qunitx-cli 0.9.3 → 0.9.7

package/dist/cli.js

@@ -0,0 +1,2009 @@
+#!/usr/bin/env -S node --experimental-strip-types
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// lib/utils/find-chrome.ts
+import { accessSync, constants } from "node:fs";
+import { join } from "node:path";
+function findChromeSync() {
+  if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
+  for (const dir of PATH_DIRS) {
+    for (const name of CANDIDATES) {
+      const fullPath = join(dir, name);
+      try {
+        accessSync(fullPath, constants.X_OK);
+        return fullPath;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function findChrome() {
+  return Promise.resolve(findChromeSync());
+}
+var CANDIDATES, PATH_DIRS;
+var init_find_chrome = __esm({
+  "lib/utils/find-chrome.ts"() {
+    CANDIDATES = ["google-chrome-stable", "google-chrome", "chromium", "chromium-browser"];
+    PATH_DIRS = (process.env.PATH || "").split(":").filter(Boolean);
+  }
+});
+
+// lib/utils/pre-launch-chrome.ts
+import { spawn } from "node:child_process";
+function preLaunchChrome(chromePath, args) {
+  if (!chromePath) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const proc = spawn(chromePath, ["--remote-debugging-port=0", "--headless=new", ...args], {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    let buffer = "";
+    proc.stderr.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const match = buffer.match(CDP_URL_REGEX);
+      if (match) {
+        proc.unref();
+        proc.stderr.unref();
+        resolve({ proc, cdpEndpoint: match[1] });
+      }
+    });
+    proc.on("error", () => resolve(null));
+    proc.on("close", () => resolve(null));
+  });
+}
+var CDP_URL_REGEX;
+var init_pre_launch_chrome = __esm({
+  "lib/utils/pre-launch-chrome.ts"() {
+    CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
+  }
+});
+
+// lib/utils/chromium-args.ts
+var chromium_args_default;
+var init_chromium_args = __esm({
+  "lib/utils/chromium-args.ts"() {
+    chromium_args_default = [
+      "--no-sandbox",
+      "--disable-gpu",
+      "--window-size=1440,900",
+      "--disable-extensions",
+      "--disable-sync",
+      "--no-first-run",
+      "--disable-default-apps",
+      "--mute-audio",
+      "--disable-background-networking",
+      "--disable-background-timer-throttling",
+      "--disable-renderer-backgrounding",
+      "--disable-dev-shm-usage",
+      "--disable-translate",
+      "--metrics-recording-only",
+      "--disable-hang-monitor"
+    ];
+  }
+});
+
+// lib/utils/perf-logger.ts
+function perfLog(label, ...details) {
+  if (!isPerfTracing) return;
+  const elapsed = Date.now() - processStart;
+  const suffix = details.length ? " " + details.join(" ") : "";
+  process.stderr.write(`[perf +${elapsed}ms] ${label}${suffix}
+`);
+}
+var isPerfTracing, processStart;
+var init_perf_logger = __esm({
+  "lib/utils/perf-logger.ts"() {
+    isPerfTracing = process.argv.includes("--trace-perf");
+    processStart = isPerfTracing ? Date.now() : 0;
+  }
+});
+
+// lib/utils/early-chrome.ts
+var NON_RUN_COMMANDS, isRunCommand, browserFromArgv, earlyChromeProcRef, earlyBrowserPromise;
+var init_early_chrome = __esm({
+  "lib/utils/early-chrome.ts"() {
+    init_find_chrome();
+    init_pre_launch_chrome();
+    init_chromium_args();
+    init_perf_logger();
+    NON_RUN_COMMANDS = /* @__PURE__ */ new Set(["help", "h", "p", "print", "new", "n", "g", "generate", "init"]);
+    isRunCommand = Boolean(process.argv[2]) && !NON_RUN_COMMANDS.has(process.argv[2]);
+    browserFromArgv = process.argv.find((arg) => arg.startsWith("--browser="))?.split("=")[1] || "chromium";
+    earlyChromeProcRef = null;
+    process.on("exit", () => earlyChromeProcRef?.kill());
+    perfLog("early-chrome.js: module evaluated");
+    earlyBrowserPromise = isRunCommand && browserFromArgv === "chromium" ? findChrome().then((chromePath) => {
+      perfLog("early-chrome.js: findChrome resolved", chromePath);
+      return preLaunchChrome(chromePath, chromium_args_default);
+    }).then((info) => {
+      perfLog("early-chrome.js: Chrome CDP ready", info?.cdpEndpoint ?? null);
+      if (info) earlyChromeProcRef = info.proc;
+      return info;
+    }) : Promise.resolve(null);
+  }
+});
+
+// lib/utils/color.ts
+function createColors(enabled2) {
+  const c = (open, close) => (text) => enabled2 ? `\x1B[${open}m${text}\x1B[${close}m` : String(text);
+  const red2 = c(31, 39);
+  const green2 = c(32, 39);
+  const yellow2 = c(33, 39);
+  const blue2 = c(34, 39);
+  const magenta2 = ((text) => {
+    if (text !== void 0) return enabled2 ? `\x1B[35m${text}\x1B[39m` : String(text);
+    return { bold: (t) => enabled2 ? `\x1B[35m\x1B[1m${t}\x1B[22m\x1B[39m` : String(t) };
+  });
+  return { red: red2, green: green2, yellow: yellow2, blue: blue2, magenta: magenta2 };
+}
+function red(text) {
+  return _c.red(text);
+}
+function green(text) {
+  return _c.green(text);
+}
+function yellow(text) {
+  return _c.yellow(text);
+}
+function blue(text) {
+  return _c.blue(text);
+}
+function magenta(text) {
+  return _c.magenta(text);
+}
+var enabled, _c;
+var init_color = __esm({
+  "lib/utils/color.ts"() {
+    enabled = !process.env.NODE_DISABLE_COLORS && process.env.NO_COLOR == null && process.env.TERM !== "dumb" && (process.env.FORCE_COLOR != null && process.env.FORCE_COLOR !== "0" || !!process.stdout?.isTTY);
+    _c = createColors(enabled);
+  }
+});
+
+// lib/utils/path-exists.ts
+import fs from "node:fs/promises";
+async function pathExists(path5) {
+  try {
+    await fs.access(path5);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_path_exists = __esm({
+  "lib/utils/path-exists.ts"() {
+  }
+});
+
+// lib/utils/read-boilerplate.ts
+import fs2 from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+async function readBoilerplate(relativePath) {
+  const sea = await import("node:sea").catch(() => null);
+  if (sea?.isSea()) return sea.getAsset(relativePath, "utf8");
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return (await fs2.readFile(join2(__dirname, "../../templates", relativePath))).toString();
+}
+var init_read_boilerplate = __esm({
+  "lib/utils/read-boilerplate.ts"() {
+  }
+});
+
+// lib/utils/find-internal-assets-from-html.ts
+function findInternalAssetsFromHTML(htmlContent) {
+  const links = [...htmlContent.matchAll(LINK_HREF_REGEX)].map((m) => m[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  const scripts = [...htmlContent.matchAll(SCRIPT_SRC_REGEX)].map((m) => m[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  return links.concat(scripts);
+}
+var ABSOLUTE_URL_REGEX, SCRIPT_SRC_REGEX, LINK_HREF_REGEX;
+var init_find_internal_assets_from_html = __esm({
+  "lib/utils/find-internal-assets-from-html.ts"() {
+    ABSOLUTE_URL_REGEX = /^(?:[a-z]+:)?\/\//i;
+    SCRIPT_SRC_REGEX = /<script[^>]+\bsrc=['"]([^'"]+)['"]/gi;
+    LINK_HREF_REGEX = /<link[^>]+\bhref=['"]([^'"]+)['"]/gi;
+  }
+});
+
+// lib/tap/dump-yaml.ts
+function needsQuoting(str) {
+  return NEEDS_QUOTING.test(str);
+}
+function dumpString(str, indent) {
+  if (str === "") return "''";
+  if (str.includes("\n")) {
+    return "|-\n" + str.replace(/^/gm, `${indent}  `);
+  }
+  if (needsQuoting(str)) return `'${str.replace(/'/g, "''")}'`;
+  return str;
+}
+function dumpValue(value, indent) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") return dumpString(value, indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const next2 = `${indent}  `;
+    return "\n" + value.map((v) => `${next2}- ${dumpValue(v, next2)}`).join("\n");
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "{}";
+  const next = `${indent}  `;
+  return "\n" + entries.map(([k, v]) => `${next}${k}: ${dumpValue(v, next)}`).join("\n");
+}
+function yamlLine(key, value) {
+  const v = dumpValue(value, "");
+  return v[0] === "\n" ? `${key}:${v}
+` : `${key}: ${v}
+`;
+}
+function dumpYaml({
+  name,
+  actual,
+  expected,
+  message,
+  stack,
+  at
+}) {
+  return `name: ${dumpString(name, "")}
+` + yamlLine("actual", actual) + yamlLine("expected", expected) + yamlLine("message", message) + yamlLine("stack", stack) + yamlLine("at", at);
+}
+var NEEDS_QUOTING;
+var init_dump_yaml = __esm({
+  "lib/tap/dump-yaml.ts"() {
+    NEEDS_QUOTING = /^$|^(null|true|false|~|yes|no|on|off|y|n)$|^[{[!|>'"#%@`]|^[-?:](\s|$)|^---|^[-+]?(\d|\.\d)|^\d{4}-\d{2}-\d{2}|: |#/i;
+  }
+});
+
+// lib/utils/indent-string.ts
+function indentString(string, count = 1, options = {}) {
+  const { indent = " ", includeEmptyLines = false } = options;
+  if (count <= 0) {
+    return string;
+  }
+  const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+  return string.replace(regex, indent.repeat(count));
+}
+var init_indent_string = __esm({
+  "lib/utils/indent-string.ts"() {
+  }
+});
+
+// lib/tap/display-test-result.ts
+function TAPDisplayTestResult(COUNTER, details) {
+  COUNTER.testCount++;
+  if (details.status === "skipped") {
+    COUNTER.skipCount++;
+    console.log(`ok ${COUNTER.testCount}`, details.fullName.join(" | "), "# skip");
+  } else if (details.status === "todo") {
+    console.log(`not ok ${COUNTER.testCount}`, details.fullName.join(" | "), "# skip");
+  } else if (details.status === "failed") {
+    COUNTER.failCount++;
+    console.log(
+      `not ok ${COUNTER.testCount}`,
+      details.fullName.join(" | "),
+      `# (${details.runtime.toFixed(0)} ms)`
+    );
+    details.assertions.forEach((assertion, index) => {
+      if (!assertion.passed && assertion.todo === false) {
+        COUNTER.errorCount = (COUNTER.errorCount ?? 0) + 1;
+        const stack = assertion.stack?.match(/\(.+\)/g);
+        console.log("  ---");
+        console.log(
+          indentString(
+            dumpYaml({
+              name: `Assertion #${index + 1}`,
+              actual: assertion.actual ? JSON.parse(JSON.stringify(assertion.actual, getCircularReplacer())) : assertion.actual,
+              expected: assertion.expected ? JSON.parse(JSON.stringify(assertion.expected, getCircularReplacer())) : assertion.expected,
+              message: assertion.message || null,
+              stack: assertion.stack || null,
+              at: stack ? stack[0].replace("(file://", "").replace(")", "") : null
+            }),
+            4
+          )
+        );
+        console.log("  ...");
+      }
+    });
+  } else if (details.status === "passed") {
+    COUNTER.passCount++;
+    console.log(
+      `ok ${COUNTER.testCount}`,
+      details.fullName.join(" | "),
+      `# (${details.runtime.toFixed(0)} ms)`
+    );
+  }
+}
+function getCircularReplacer() {
+  const ancestors = [];
+  return function(_key, value) {
+    if (typeof value !== "object" || value === null) {
+      return value;
+    }
+    while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+      ancestors.pop();
+    }
+    if (ancestors.includes(value)) {
+      return "[Circular]";
+    }
+    ancestors.push(value);
+    return value;
+  };
+}
+var init_display_test_result = __esm({
+  "lib/tap/display-test-result.ts"() {
+    init_dump_yaml();
+    init_indent_string();
+  }
+});
+
+// lib/setup/bind-server-to-port.ts
+async function bindServerToPort(server, config) {
+  await server.listen(0);
+  config.port = server._server.address().port;
+  return server;
+}
+var init_bind_server_to_port = __esm({
+  "lib/setup/bind-server-to-port.ts"() {
+  }
+});
+
+// lib/servers/http.ts
+import http from "node:http";
+import WebSocket, { WebSocketServer } from "ws";
+var MIME_TYPES, HTTPServer;
+var init_http = __esm({
+  "lib/servers/http.ts"() {
+    init_bind_server_to_port();
+    MIME_TYPES = {
+      html: "text/html; charset=UTF-8",
+      js: "application/javascript",
+      css: "text/css",
+      png: "image/png",
+      jpg: "image/jpg",
+      gif: "image/gif",
+      ico: "image/x-icon",
+      svg: "image/svg+xml"
+    };
+    HTTPServer = class {
+      /** Registered routes keyed by HTTP method then path. */
+      routes;
+      /** Registered middleware functions, applied in order before each route handler. */
+      middleware;
+      /** Underlying Node.js HTTP server instance. */
+      _server;
+      /** WebSocket server attached to the HTTP server for live-reload broadcasts. */
+      wss;
+      /**
+       * Creates and starts a plain `http.createServer` instance on the given port.
+       * @returns {Promise<object>}
+       */
+      static serve(config = {
+        port: 1234
+      }, handler) {
+        const onListen = config.onListen || ((_server) => {
+        });
+        const onError = config.onError || ((_error) => {
+        });
+        return new Promise((resolve, reject) => {
+          const server = http.createServer((req, res) => {
+            return handler(req, res);
+          });
+          server.on("error", (error) => {
+            onError(error);
+            reject(error);
+          }).once("listening", () => {
+            onListen(Object.assign({ hostname: "127.0.0.1", server }, config));
+            resolve(server);
+          });
+          server.wss = new WebSocketServer({ server });
+          server.wss.on("error", (error) => {
+            console.log("# [WebSocketServer] Error:");
+            console.trace(error);
+          });
+          bindServerToPort(server, config);
+        });
+      }
+      constructor() {
+        this.routes = {
+          GET: {},
+          POST: {},
+          DELETE: {},
+          PUT: {}
+        };
+        this.middleware = [];
+        this._server = http.createServer((req, res) => {
+          req.send = (data) => {
+            res.setHeader("Content-Type", "text/plain");
+            res.end(data);
+          };
+          res.json = (data) => {
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(data));
+          };
+          return this.#handleRequest(req, res);
+        });
+        this.wss = new WebSocketServer({ server: this._server });
+        this.wss.on("error", (error) => {
+          console.log("# [WebSocketServer] Error:");
+          console.log(error);
+        });
+      }
+      /**
+       * Closes the underlying HTTP server and all active connections, returning a
+       * Promise that resolves once the server is fully closed.
+       * @returns {Promise<void>}
+       */
+      close() {
+        this._server.closeAllConnections?.();
+        return new Promise((resolve) => this._server.close(resolve));
+      }
+      /** Registers a GET route handler. */
+      get(path5, handler) {
+        this.#registerRouteHandler("GET", path5, handler);
+      }
+      /**
+       * Starts listening on the given port (0 = OS-assigned).
+       * @returns {Promise<void>}
+       */
+      listen(port = 0, callback = () => {
+      }) {
+        return new Promise((resolve, reject) => {
+          const onError = (err) => {
+            this._server.off("listening", onListening);
+            reject(err);
+          };
+          const onListening = () => {
+            this._server.off("error", onError);
+            resolve(callback());
+          };
+          this._server.once("error", onError);
+          this._server.once("listening", onListening);
+          this._server.listen(port);
+        });
+      }
+      /** Broadcasts a message to all connected WebSocket clients. */
+      publish(data) {
+        this.wss.clients.forEach((client) => {
+          if (client.readyState === WebSocket.OPEN) {
+            client.send(data);
+          }
+        });
+      }
+      /** Registers a POST route handler. */
+      post(path5, handler) {
+        this.#registerRouteHandler("POST", path5, handler);
+      }
+      /** Registers a DELETE route handler. */
+      delete(path5, handler) {
+        this.#registerRouteHandler("DELETE", path5, handler);
+      }
+      /** Registers a PUT route handler. */
+      put(path5, handler) {
+        this.#registerRouteHandler("PUT", path5, handler);
+      }
+      /** Adds a middleware function to the chain. */
+      use(middleware) {
+        this.middleware.push(middleware);
+      }
+      #registerRouteHandler(method, path5, handler) {
+        if (!this.routes[method]) {
+          this.routes[method] = {};
+        }
+        this.routes[method][path5] = {
+          path: path5,
+          handler,
+          paramNames: this.#extractParamNames(path5),
+          isWildcard: path5 === "/*"
+        };
+      }
+      #handleRequest(req, res) {
+        const { method, url } = req;
+        const urlObj = new URL(url, "http://localhost");
+        const pathname = urlObj.pathname;
+        req.path = pathname;
+        req.query = Object.fromEntries(urlObj.searchParams);
+        const matchingRoute = this.#findRouteHandler(method, pathname);
+        if (matchingRoute) {
+          req.params = this.#extractParams(matchingRoute, pathname);
+          this.#runMiddleware(req, res, matchingRoute.handler);
+        } else {
+          res.statusCode = 404;
+          res.setHeader("Content-Type", "text/plain");
+          res.end("Not found");
+        }
+      }
+      #runMiddleware(req, res, callback) {
+        let index = 0;
+        const next = () => {
+          if (index >= this.middleware.length) {
+            callback(req, res);
+          } else {
+            const middleware = this.middleware[index];
+            index++;
+            middleware(req, res, next);
+          }
+        };
+        next();
+      }
+      #findRouteHandler(method, url) {
+        const routes = this.routes[method];
+        if (!routes) {
+          return null;
+        }
+        return routes[url] || Object.values(routes).find((route) => {
+          const { path: path5, isWildcard } = route;
+          if (!isWildcard && !path5.includes(":")) {
+            return false;
+          }
+          if (isWildcard || this.#matchPathSegments(path5, url)) {
+            if (route.paramNames.length > 0) {
+              const regexPattern = this.#buildRegexPattern(path5, route.paramNames);
+              const regex = new RegExp(`^${regexPattern}$`);
+              const regexMatches = regex.exec(url);
+              if (regexMatches) {
+                route.paramValues = regexMatches.slice(1);
+              }
+            }
+            return true;
+          }
+          return false;
+        }) || routes["/*"] || null;
+      }
+      #matchPathSegments(path5, url) {
+        const pathSegments = path5.split("/");
+        const urlSegments = url.split("/");
+        if (pathSegments.length !== urlSegments.length) {
+          return false;
+        }
+        for (let i = 0; i < pathSegments.length; i++) {
+          const pathSegment = pathSegments[i];
+          const urlSegment = urlSegments[i];
+          if (pathSegment.startsWith(":")) {
+            continue;
+          }
+          if (pathSegment !== urlSegment) {
+            return false;
+          }
+        }
+        return true;
+      }
+      #buildRegexPattern(path5, _paramNames) {
+        let regexPattern = path5.replace(/:[^/]+/g, "([^/]+)");
+        regexPattern = regexPattern.replace(/\//g, "\\/");
+        return regexPattern;
+      }
+      #extractParamNames(path5) {
+        const paramRegex = /:(\w+)/g;
+        const paramMatches = path5.match(paramRegex);
+        return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
+      }
+      #extractParams(route, _url) {
+        const { paramNames, paramValues } = route;
+        const params = {};
+        for (let i = 0; i < paramNames.length; i++) {
+          params[paramNames[i]] = paramValues[i];
+        }
+        return params;
+      }
+    };
+  }
+});
+
+// lib/setup/web-server.ts
+import fs7 from "node:fs";
+import path3 from "node:path";
+function setupWebServer(config, cachedContent) {
+  const STATIC_FILES_PATH = path3.join(config.projectRoot, config.output);
+  const server = new HTTPServer();
+  server.wss.on("connection", function connection(socket) {
+    socket.on("message", function message(data) {
+      const { event, details, abort } = JSON.parse(data);
+      if (event === "connection") {
+        if (!config._groupMode) console.log("TAP version 13");
+        config._resetTestTimeout?.();
+      } else if (event === "testEnd" && !abort) {
+        if (details.status === "failed") {
+          config.lastFailedTestFiles = config.lastRanTestFiles;
+        }
+        config._resetTestTimeout?.();
+        TAPDisplayTestResult(config.COUNTER, details);
+      } else if (event === "done") {
+        if (typeof config._testRunDone === "function") {
+          config._testRunDone();
+          config._testRunDone = null;
+        }
+      }
+    });
+  });
+  server.get("/", async (_req, res) => {
+    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    const htmlContent = escapeAndInjectTestsToHTML(
+      replaceAssetPaths(
+        cachedContent.mainHTML.html,
+        cachedContent.mainHTML.filePath,
+        config.projectRoot
+      ),
+      TEST_RUNTIME_TO_INJECT,
+      cachedContent.allTestCode
+    );
+    res.write(htmlContent);
+    res.end();
+    return await fsPromise.writeFile(
+      `${config.projectRoot}/${config.output}/index.html`,
+      htmlContent
+    );
+  });
+  server.get("/qunitx.html", async (_req, res) => {
+    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    const htmlContent = escapeAndInjectTestsToHTML(
+      replaceAssetPaths(
+        cachedContent.mainHTML.html,
+        cachedContent.mainHTML.filePath,
+        config.projectRoot
+      ),
+      TEST_RUNTIME_TO_INJECT,
+      cachedContent.filteredTestCode
+    );
+    res.write(htmlContent);
+    res.end();
+    return await fsPromise.writeFile(
+      `${config.projectRoot}/${config.output}/qunitx.html`,
+      htmlContent
+    );
+  });
+  server.get("/*", async (req, res) => {
+    const possibleDynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
+    if (possibleDynamicHTML) {
+      const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+      const htmlContent = escapeAndInjectTestsToHTML(
+        possibleDynamicHTML,
+        TEST_RUNTIME_TO_INJECT,
+        cachedContent.allTestCode
+      );
+      res.write(htmlContent);
+      res.end();
+      return await fsPromise.writeFile(
+        `${config.projectRoot}/${config.output}${req.path}`,
+        htmlContent
+      );
+    }
+    const url = req.url;
+    const requestStartedAt = /* @__PURE__ */ new Date();
+    const filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join("");
+    const statusCode = await pathExists(filePath) ? 200 : 404;
+    res.writeHead(statusCode, {
+      "Content-Type": req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path3.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html
+    });
+    if (statusCode === 404) {
+      res.end();
+    } else {
+      fs7.createReadStream(filePath).pipe(res);
+    }
+    console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${/* @__PURE__ */ new Date() - requestStartedAt}ms`);
+  });
+  return server;
+}
+function replaceAssetPaths(html, htmlPath, projectRoot) {
+  const assetPaths = findInternalAssetsFromHTML(html);
+  const htmlDirectory = htmlPath.split("/").slice(0, -1).join("/");
+  return assetPaths.reduce((result, assetPath) => {
+    const normalizedFullAbsolutePath = path3.normalize(`${htmlDirectory}/${assetPath}`);
+    return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
+  }, html);
+}
+function testRuntimeToInject(port, config) {
+  return `<script>
+    window.testTimeout = 0;
+    setInterval(() => {
+      window.testTimeout = window.testTimeout + 1000;
+    }, 1000);
+
+    (function() {
+      let wsRetryCount = 0;
+      const WS_MAX_RETRIES = 50; // 500ms total before giving up
+
+      function setupWebSocket() {
+        try {
+          window.socket = new WebSocket('ws://localhost:${port}');
+        } catch (error) {
+          console.log(error);
+          retryOrFail();
+          return;
+        }
+
+        window.socket.addEventListener('open', function() {
+          setupQUnit();
+        });
+        window.socket.addEventListener('error', function() {
+          retryOrFail();
+        });
+        window.socket.addEventListener('message', function(messageEvent) {
+          if (!window.IS_PLAYWRIGHT && messageEvent.data === 'refresh') {
+            window.location.reload(true);
+          } else if (window.IS_PLAYWRIGHT && messageEvent.data === 'abort') {
+            window.abortQUnit = true;
+            window.QUnit.config.queue.length = 0;
+            window.socket.send(JSON.stringify({ event: 'abort' }));
+          }
+        });
+      }
+
+      function retryOrFail() {
+        wsRetryCount++;
+        if (wsRetryCount > WS_MAX_RETRIES) {
+          console.log('WebSocket connection failed after ' + WS_MAX_RETRIES + ' retries');
+          window.testTimeout = ${config.timeout};
+          return;
+        }
+        window.setTimeout(setupWebSocket, 10);
+      }
+
+      setupWebSocket();
+    })();
+
+    {{allTestCode}}
+
+    function getCircularReplacer() {
+      const ancestors = [];
+      return function (key, value) {
+        if (typeof value !== "object" || value === null) {
+          return value;
+        }
+        while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+          ancestors.pop();
+        }
+        if (ancestors.includes(value)) {
+          return "[Circular]";
+        }
+        ancestors.push(value);
+        return value;
+      };
+    }
+
+    function setupQUnit() {
+      window.QUNIT_RESULT = { totalTests: 0, finishedTests: 0, failedTests: 0, currentTest: '' };
+
+      if (!window.QUnit) {
+        console.log('QUnit not found after WebSocket connected');
+        window.testTimeout = ${config.timeout};
+        return;
+      }
+
+      window.QUnit.begin(() => { // NOTE: might be useful in future for hanged module tracking
+        if (window.IS_PLAYWRIGHT) {
+          window.socket.send(JSON.stringify({ event: 'connection' }));
+        }
+      });
+      window.QUnit.moduleStart((details) => { // NOTE: might be useful in future for hanged module tracking
+        if (window.IS_PLAYWRIGHT) {
+          window.socket.send(JSON.stringify({ event: 'moduleStart', details: details }, getCircularReplacer()));
+        }
+      });
+      window.QUnit.on('testStart', (details) => {
+        window.QUNIT_RESULT.totalTests++;
+        window.QUNIT_RESULT.currentTest = details.fullName.join(' | ');
+      });
+      window.QUnit.on('testEnd', (details) => { // NOTE: https://github.com/qunitjs/qunit/blob/master/src/html-reporter/diff.js
+        window.testTimeout = 0;
+        window.QUNIT_RESULT.finishedTests++;
+        if (details.status === 'failed') window.QUNIT_RESULT.failedTests++;
+        window.QUNIT_RESULT.currentTest = null;
+        if (window.IS_PLAYWRIGHT) {
+          window.socket.send(JSON.stringify({ event: 'testEnd', details: details, abort: window.abortQUnit }, getCircularReplacer()));
+
+          if (${config.failFast} && details.status === 'failed') {
+            window.QUnit.config.queue.length = 0;
+          }
+        }
+      });
+      window.QUnit.done((details) => {
+        if (window.IS_PLAYWRIGHT) {
+          window.socket.send(JSON.stringify({ event: 'done', details: details, abort: window.abortQUnit }, getCircularReplacer()));
+          // Do NOT set testTimeout here. The WS 'done' event (testsDone promise) is the
+          // canonical completion signal for Playwright runs. waitForFunction is reserved
+          // for true timeouts (test hangs) where testTimeout increments naturally via setInterval.
+          // Setting testTimeout after done caused a race: under CI load, waitForFunction could
+          // win before Node.js processed the WS done message, dropping all testEnd events.
+        } else {
+          window.testTimeout = ${config.timeout};
+        }
+      });
+
+      window.QUnit.start();
+    }
+  </script>`;
+}
+function escapeAndInjectTestsToHTML(html, testRuntimeCode, testContentCode) {
+  return html.replace(
+    "{{content}}",
+    testRuntimeCode.replace("{{allTestCode}}", testContentCode).replace("</script>", "</script>")
+    // NOTE: remove this when simple-html-tokenizer PR gets merged
+  );
+}
+var fsPromise;
+var init_web_server = __esm({
+  "lib/setup/web-server.ts"() {
+    init_find_internal_assets_from_html();
+    init_display_test_result();
+    init_path_exists();
+    init_http();
+    fsPromise = fs7.promises;
+  }
+});
+
+// lib/setup/browser.ts
+async function launchBrowser(config) {
+  const browserName = config.browser || "chromium";
+  if (browserName === "chromium") {
+    const waitStart = Date.now();
+    const [playwrightCore2, earlyChrome] = await Promise.all([
+      playwrightCorePromise,
+      earlyBrowserPromise
+    ]);
+    perfLog(
+      `browser.js: playwright-core + earlyChrome resolved in ${Date.now() - waitStart}ms, earlyChrome:`,
+      earlyChrome?.cdpEndpoint ?? null
+    );
+    if (earlyChrome) {
+      const connectStart = Date.now();
+      const browser = await playwrightCore2.chromium.connectOverCDP({
+        endpointURL: earlyChrome.cdpEndpoint
+      });
+      perfLog(`browser.js: connectOverCDP took ${Date.now() - connectStart}ms`);
+      return browser;
+    }
+    const executablePath = await findChrome();
+    const launchOptions = { args: chromium_args_default, headless: true };
+    if (executablePath) launchOptions.executablePath = executablePath;
+    return playwrightCore2.chromium.launch(launchOptions);
+  }
+  const playwrightCore = await playwrightCorePromise;
+  return playwrightCore[browserName].launch({ headless: true });
+}
+async function setupBrowser(config, cachedContent, existingBrowser = null) {
+  const setupStart = Date.now();
+  const [server, resolvedExistingBrowser] = await Promise.all([
+    setupWebServer(config, cachedContent),
+    Promise.resolve(existingBrowser)
+  ]);
+  perfLog(`browser.js: setupWebServer took ${Date.now() - setupStart}ms`);
+  const browser = resolvedExistingBrowser || await launchBrowser(config);
+  const pageStart = Date.now();
+  const [page] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
+  perfLog(`browser.js: newPage + bindServerToPort took ${Date.now() - pageStart}ms`);
+  await page.addInitScript(() => {
+    window.IS_PLAYWRIGHT = true;
+  });
+  page.on("console", async (msg) => {
+    if (!config.debug) return;
+    try {
+      const values = await Promise.all(msg.args().map((arg) => arg.jsonValue()));
+      console.log(...values);
+    } catch {
+      console.log(msg.text());
+    }
+  });
+  page.on("pageerror", (error) => {
+    console.log(error.toString());
+    console.error(error.toString());
+  });
+  return { server, browser, page };
+}
+var playwrightCorePromise;
+var init_browser = __esm({
+  "lib/setup/browser.ts"() {
+    init_web_server();
+    init_bind_server_to_port();
+    init_find_chrome();
+    init_chromium_args();
+    init_early_chrome();
+    init_perf_logger();
+    playwrightCorePromise = import("playwright-core");
+    perfLog("browser.js: playwright-core import started");
+  }
+});
+
+// lib/utils/time-counter.ts
+function timeCounter() {
+  const startTime = /* @__PURE__ */ new Date();
+  return {
+    startTime,
+    stop: () => +/* @__PURE__ */ new Date() - +startTime
+  };
+}
+var init_time_counter = __esm({
+  "lib/utils/time-counter.ts"() {
+  }
+});
+
+// lib/utils/run-user-module.ts
+async function runUserModule(modulePath, params, scriptPosition) {
+  try {
+    const func = await import(modulePath);
+    if (func) {
+      func.default ? await func.default(params) : typeof func === "function" ? await func(params) : null;
+    }
+  } catch (error) {
+    console.log("#", red(`QUnitX ${scriptPosition} script failed:`));
+    console.trace(error);
+    console.error(error);
+    return process.exit(1);
+  }
+}
+var init_run_user_module = __esm({
+  "lib/utils/run-user-module.ts"() {
+    init_color();
+  }
+});
+
+// lib/tap/display-final-result.ts
+function TAPDisplayFinalResult({ testCount, passCount, skipCount, failCount }, timeTaken) {
+  console.log("");
+  console.log(`1..${testCount}`);
+  console.log(`# tests ${testCount}`);
+  console.log(`# pass ${passCount}`);
+  console.log(`# skip ${skipCount}`);
+  console.log(`# fail ${failCount}`);
+  console.log(`# duration ${timeTaken}`);
+  console.log("");
+}
+var init_display_final_result = __esm({
+  "lib/tap/display-final-result.ts"() {
+  }
+});
+
+// lib/commands/run/tests-in-browser.ts
+import fs8 from "node:fs/promises";
+import esbuild from "esbuild";
+async function buildTestBundle(config, cachedContent) {
+  const { projectRoot, output } = config;
+  const allTestFilePaths = Object.keys(config.fsTree);
+  await Promise.all([
+    esbuild.build({
+      stdin: {
+        contents: allTestFilePaths.map((f) => `import "${f}";`).join(""),
+        resolveDir: process.cwd()
+      },
+      bundle: true,
+      logLevel: "error",
+      outfile: `${projectRoot}/${output}/tests.js`,
+      keepNames: true,
+      sourcemap: config.debug || config.watch ? "inline" : false
+    }),
+    Promise.all(
+      cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
+        const targetPath = `${config.projectRoot}/${config.output}${htmlPath}`;
+        if (htmlPath !== "/") {
+          await fs8.rm(targetPath, { force: true, recursive: true });
+          await fs8.mkdir(targetPath.split("/").slice(0, -1).join("/"), { recursive: true });
+        }
+      })
+    )
+  ]);
+  cachedContent.allTestCode = await fs8.readFile(`${projectRoot}/${output}/tests.js`);
+}
+async function runTestsInBrowser(config, cachedContent = {}, connections, targetTestFilesToFilter) {
+  const { projectRoot, output } = config;
+  const allTestFilePaths = Object.keys(config.fsTree);
+  const runHasFilter = !!targetTestFilesToFilter;
+  if (!config._groupMode) {
+    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 };
+  }
+  config.lastRanTestFiles = targetTestFilesToFilter || allTestFilePaths;
+  try {
+    if (!cachedContent.allTestCode) {
+      await buildTestBundle(config, cachedContent);
+    }
+    if (runHasFilter) {
+      const outputPath = `${projectRoot}/${output}/filtered-tests.js`;
+      await buildFilteredTests(targetTestFilesToFilter, outputPath, config);
+      cachedContent.filteredTestCode = (await fs8.readFile(outputPath)).toString();
+    }
+    const TIME_COUNTER = timeCounter();
+    if (runHasFilter) {
+      await runTestInsideHTMLFile("/qunitx.html", connections, config);
+    } else {
+      await Promise.all(
+        cachedContent.htmlPathsToRunTests.map(
+          (htmlPath) => runTestInsideHTMLFile(htmlPath, connections, config)
+        )
+      );
+    }
+    const TIME_TAKEN = TIME_COUNTER.stop();
+    if (!config._groupMode) {
+      TAPDisplayFinalResult(config.COUNTER, TIME_TAKEN);
+      if (config.after) {
+        await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, "after");
+      }
+      if (!config.watch) {
+        await Promise.all([
+          connections.server && connections.server.close(),
+          connections.browser && connections.browser.close()
+        ]);
+        return process.exit(config.COUNTER.failCount > 0 ? 1 : 0);
+      }
+    }
+  } catch (error) {
+    config.lastFailedTestFiles = config.lastRanTestFiles;
+    console.log(error);
+    const exception = new BundleError(error);
+    if (config.watch) {
+      console.log(`# ${exception}`);
+    } else {
+      throw exception;
+    }
+  }
+  return connections;
+}
+function buildFilteredTests(filteredTests, outputPath, config) {
+  return esbuild.build({
+    stdin: {
+      contents: filteredTests.map((f) => `import "${f}";`).join(""),
+      resolveDir: process.cwd()
+    },
+    bundle: true,
+    logLevel: "error",
+    outfile: outputPath,
+    sourcemap: config.debug || config.watch ? "inline" : false
+  });
+}
+async function runTestInsideHTMLFile(filePath, { page, server, browser }, config) {
+  let QUNIT_RESULT;
+  let targetError;
+  let timeoutHandle;
+  try {
+    console.log("#", blue(`QUnitX running: http://localhost:${config.port}${filePath}`));
+    const testRaceResult = new Promise((resolve) => {
+      config._testRunDone = () => resolve(false);
+      config._resetTestTimeout = () => {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = setTimeout(() => resolve(true), config.timeout);
+      };
+    });
+    await page.goto(`http://localhost:${config.port}${filePath}`, {
+      timeout: config.timeout + 1e4
+    });
+    config._resetTestTimeout();
+    await testRaceResult;
+    QUNIT_RESULT = await page.evaluate(() => window.QUNIT_RESULT);
+  } catch (error) {
+    targetError = error;
+    console.log(error);
+    console.error(error);
+  } finally {
+    clearTimeout(timeoutHandle);
+    config._resetTestTimeout = null;
+  }
+  if (!QUNIT_RESULT || QUNIT_RESULT.totalTests === 0) {
+    console.log(targetError);
+    console.log("BROWSER: runtime error thrown during executing tests");
+    console.error("BROWSER: runtime error thrown during executing tests");
+    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
+  } else if (QUNIT_RESULT.totalTests > QUNIT_RESULT.finishedTests) {
+    console.log(targetError);
+    console.log(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
+    console.error(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
+    await failOnNonWatchMode(config.watch, { server, browser }, config._groupMode);
+  } else if (QUNIT_RESULT.failedTests > config.COUNTER.failCount) {
+    config.COUNTER.failCount = QUNIT_RESULT.failedTests;
+  }
+}
+async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode = false) {
+  if (!watchMode) {
+    if (groupMode) {
+      throw new Error("Browser test run failed");
+    }
+    await Promise.all([
+      connections.server && connections.server.close(),
+      connections.browser && connections.browser.close()
+    ]);
+    process.exit(1);
+  }
+}
+var BundleError;
+var init_tests_in_browser = __esm({
+  "lib/commands/run/tests-in-browser.ts"() {
+    init_color();
+    init_time_counter();
+    init_run_user_module();
+    init_display_final_result();
+    BundleError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "BundleError";
+        this.message = `esbuild Bundle Error: ${message}`.split("\n").join("\n# ");
+      }
+    };
+  }
+});
+
+// lib/setup/file-watcher.ts
+import fs9 from "node:fs";
+import { stat } from "node:fs/promises";
+import path4 from "node:path";
+function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
+  const extensions = config.extensions || ["js", "ts"];
+  const fileWatchers = testFileLookupPaths.reduce((watchers, watchPath) => {
+    let ready = false;
+    const watcher = fs9.watch(watchPath, { recursive: true }, async (eventType, filename) => {
+      if (!ready || !filename) return;
+      const fullPath = path4.join(watchPath, filename);
+      if (eventType === "change") {
+        return handleWatchEvent(config, extensions, "change", fullPath, onEventFunc, onFinishFunc);
+      }
+      try {
+        const s = await stat(fullPath);
+        handleWatchEvent(
+          config,
+          extensions,
+          s.isDirectory() ? "addDir" : "add",
+          fullPath,
+          onEventFunc,
+          onFinishFunc
+        );
+      } catch {
+        const event = config.fsTree && fullPath in config.fsTree ? "unlink" : "unlinkDir";
+        handleWatchEvent(config, extensions, event, fullPath, onEventFunc, onFinishFunc);
+      }
+    });
+    setImmediate(() => {
+      ready = true;
+    });
+    return Object.assign(watchers, { [watchPath]: watcher });
+  }, {});
+  return {
+    fileWatchers,
+    killFileWatchers() {
+      Object.keys(fileWatchers).forEach((watcherKey) => fileWatchers[watcherKey].close());
+      return fileWatchers;
+    }
+  };
+}
+function handleWatchEvent(config, extensions, event, filePath, onEventFunc, onFinishFunc) {
+  const isFileEvent = extensions.some((ext) => filePath.endsWith(`.${ext}`));
+  if (!isFileEvent && event !== "unlinkDir") return;
+  mutateFSTree(config.fsTree, event, filePath);
+  console.log(
+    "#",
+    magenta().bold("==================================================================")
+  );
+  console.log("#", getEventColor(event), filePath.split(config.projectRoot)[1]);
+  console.log(
+    "#",
+    magenta().bold("==================================================================")
+  );
+  if (!config._building) {
+    config._building = true;
+    const result = onEventFunc(event, filePath);
+    if (!(result instanceof Promise)) {
+      config._building = false;
+      return result;
+    }
+    result.then(() => {
+      onFinishFunc ? onFinishFunc(event, filePath) : null;
+    }).catch((error) => {
+      console.error("#", red("Build error:"), error.message || error);
+    }).finally(() => config._building = false);
+  }
+}
+function mutateFSTree(fsTree, event, path5) {
+  if (event === "add") {
+    fsTree[path5] = null;
+  } else if (event === "unlink") {
+    delete fsTree[path5];
+  } else if (event === "unlinkDir") {
+    for (const treePath of Object.keys(fsTree)) {
+      if (treePath.startsWith(path5)) delete fsTree[treePath];
+    }
+  }
+}
+function getEventColor(event) {
+  if (event === "change") {
+    return yellow("CHANGED:");
+  } else if (event === "add" || event === "addDir") {
+    return green("ADDED:");
+  } else if (event === "unlink" || event === "unlinkDir") {
+    return red("REMOVED:");
+  }
+}
+var init_file_watcher = __esm({
+  "lib/setup/file-watcher.ts"() {
+    init_color();
+  }
+});
+
+// lib/utils/listen-to-keyboard-key.ts
+import process3 from "node:process";
+function listenToKeyboardKey(inputString, closure, options = { caseSensitive: false }) {
+  if (!stdin.isTTY) return;
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  if (!listenerAdded) {
+    stdin.on("data", function(key) {
+      if (key === "") {
+        process3.exit();
+      }
+      inputs.shift();
+      inputs.push(key);
+      const currentInput = inputs.join("");
+      const targetListener = targetInputs[currentInput.toUpperCase()];
+      if (targetListener && targetListenerConformsToCase(targetListener, currentInput)) {
+        targetListener.closure(currentInput);
+        inputs.fill(void 0);
+      }
+    });
+    listenerAdded = true;
+  }
+  if (inputString.length > inputs.length) {
+    inputs.length = inputString.length;
+  }
+  targetInputs[inputString.toUpperCase()] = Object.assign(options, { closure });
+}
+function targetListenerConformsToCase(targetListener, inputString) {
+  if (targetListener.caseSensitive) {
+    return inputString === inputString.toUpperCase();
+  }
+  return true;
+}
+var stdin, targetInputs, inputs, listenerAdded;
+var init_listen_to_keyboard_key = __esm({
+  "lib/utils/listen-to-keyboard-key.ts"() {
+    stdin = process3.stdin;
+    targetInputs = {};
+    inputs = [];
+    listenerAdded = false;
+  }
+});
+
+// lib/setup/keyboard-events.ts
+function setupKeyboardEvents(config, cachedContent, connections) {
+  listenToKeyboardKey("qq", () => abortBrowserQUnit(config, connections));
+  listenToKeyboardKey("qa", () => {
+    abortBrowserQUnit(config, connections);
+    runTestsInBrowser(config, cachedContent, connections);
+  });
+  listenToKeyboardKey("qf", () => {
+    abortBrowserQUnit(config, connections);
+    if (!config.lastFailedTestFiles) {
+      console.log("#", blue(`QUnitX: No tests failed so far, so repeating the last test run`));
+      return runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles);
+    }
+    runTestsInBrowser(config, cachedContent, connections, config.lastFailedTestFiles);
+  });
+  listenToKeyboardKey("ql", () => {
+    abortBrowserQUnit(config, connections);
+    runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles);
+  });
+}
+function abortBrowserQUnit(_config, connections) {
+  connections.server.publish("abort", "abort");
+}
+var init_keyboard_events = __esm({
+  "lib/setup/keyboard-events.ts"() {
+    init_color();
+    init_listen_to_keyboard_key();
+    init_tests_in_browser();
+  }
+});
+
+// lib/setup/write-output-static-files.ts
+import fs10 from "node:fs/promises";
+async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
+  const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
+    const htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, "");
+    await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
+    await fs10.writeFile(
+      `${projectRoot}/${output}/${htmlRelativePath}`,
+      cachedContent.staticHTMLs[staticHTMLKey]
+    );
+  });
+  const assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
+    const assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, "");
+    await ensureFolderExists(`${projectRoot}/${output}/${assetRelativePath}`);
+    await fs10.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);
+  });
+  await Promise.all(staticHTMLPromises.concat(assetPromises));
+}
+async function ensureFolderExists(assetPath) {
+  await fs10.mkdir(assetPath.split("/").slice(0, -1).join("/"), { recursive: true });
+}
+var init_write_output_static_files = __esm({
+  "lib/setup/write-output-static-files.ts"() {
+  }
+});
+
+// lib/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  default: () => run
+});
+import fs11 from "node:fs/promises";
+import { normalize } from "node:path";
+import { availableParallelism } from "node:os";
+async function run(config) {
+  const cachedContent = await buildCachedContent(config, config.htmlPaths);
+  if (config.watch) {
+    const [connections] = await Promise.all([
+      setupBrowser(config, cachedContent),
+      writeOutputStaticFiles(config, cachedContent)
+    ]);
+    config.expressApp = connections.server;
+    setupKeyboardEvents(config, cachedContent, connections);
+    if (config.before) {
+      await runUserModule(`${process.cwd()}/${config.before}`, config, "before");
+    }
+    try {
+      await runTestsInBrowser(config, cachedContent, connections);
+    } catch (error) {
+      await Promise.all([
+        connections.server && connections.server.close(),
+        connections.browser && connections.browser.close()
+      ]);
+      throw error;
+    }
+    logWatcherAndKeyboardShortcutInfo(config, connections.server);
+    await setupFileWatchers(
+      config.testFileLookupPaths,
+      config,
+      async (event, file) => {
+        if (event === "addDir") return;
+        if (["unlink", "unlinkDir"].includes(event)) {
+          return await runTestsInBrowser(config, cachedContent, connections);
+        }
+        await runTestsInBrowser(config, cachedContent, connections, [file]);
+      },
+      (_path, _event) => connections.server.publish("refresh", "refresh")
+    );
+  } else {
+    const allFiles = Object.keys(config.fsTree);
+    const groupCount = Math.min(allFiles.length, availableParallelism());
+    const groups = splitIntoGroups(allFiles, groupCount);
+    config.COUNTER = { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 };
+    config.lastRanTestFiles = allFiles;
+    const groupConfigs = groups.map((groupFiles, i) => ({
+      ...config,
+      fsTree: Object.fromEntries(groupFiles.map((f) => [f, config.fsTree[f]])),
+      // Single group keeps the root output dir for backward-compatible file paths.
+      output: groupCount === 1 ? config.output : `${config.output}/group-${i}`,
+      _groupMode: true
+    }));
+    const groupCachedContents = groups.map(() => ({ ...cachedContent }));
+    console.log("TAP version 13");
+    const [browser] = await Promise.all([
+      launchBrowser(config),
+      Promise.all(
+        groupConfigs.map(
+          (groupConfig, i) => Promise.all([
+            buildTestBundle(groupConfig, groupCachedContents[i]),
+            writeOutputStaticFiles(groupConfig, groupCachedContents[i])
+          ])
+        )
+      )
+    ]);
+    const TIME_COUNTER = timeCounter();
+    const GROUP_TIMEOUT_MS = 3 * 60 * 1e3;
+    const keepAlive = setInterval(() => {
+    }, 1e3);
+    const groupResults = await Promise.allSettled(
+      groupConfigs.map((groupConfig, i) => {
+        const groupTimeout = new Promise((_, reject) => {
+          const t = setTimeout(
+            () => reject(new Error(`Group ${i} timed out after ${GROUP_TIMEOUT_MS}ms`)),
+            GROUP_TIMEOUT_MS
+          );
+          t.unref();
+        });
+        return Promise.race([
+          (async () => {
+            const connections = await setupBrowser(groupConfig, groupCachedContents[i], browser);
+            groupConfig.expressApp = connections.server;
+            if (config.before) {
+              await runUserModule(`${process.cwd()}/${config.before}`, groupConfig, "before");
+            }
+            try {
+              await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
+            } finally {
+              await Promise.all([
+                connections.server && connections.server.close(),
+                connections.page && // Unref'd: the keepAlive interval above holds the event loop open, so this
+                // timer still fires if page.close() hangs, without preventing process exit later.
+                Promise.race([
+                  connections.page.close(),
+                  new Promise((resolve) => {
+                    const t = setTimeout(resolve, 1e4);
+                    t.unref();
+                  })
+                ]).catch(() => {
+                })
+              ]);
+            }
+          })(),
+          groupTimeout
+        ]);
+      })
+    );
+    const exitCode = groupResults.reduce(
+      (code, { status, reason }) => {
+        if (status !== "rejected") return code;
+        console.error(reason);
+        return 1;
+      },
+      config.COUNTER.failCount > 0 ? 1 : 0
+    );
+    process.exitCode = exitCode;
+    TAPDisplayFinalResult(config.COUNTER, TIME_COUNTER.stop());
+    if (config.after) {
+      await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, "after");
+    }
+    const exitTimer = setTimeout(() => process.exit(exitCode), 5e3);
+    exitTimer.unref();
+    process.stdout.write("\n", () => {
+      clearTimeout(exitTimer);
+      clearInterval(keepAlive);
+      browser.close().catch(() => {
+      });
+      process.exit(exitCode);
+    });
+  }
+}
+async function buildCachedContent(config, htmlPaths) {
+  const htmlBuffers = await Promise.all(config.htmlPaths.map((htmlPath) => fs11.readFile(htmlPath)));
+  const cachedContent = htmlPaths.reduce(
+    (result, _htmlPath, index) => {
+      const filePath = config.htmlPaths[index];
+      const html = htmlBuffers[index].toString();
+      if (html.includes("{{content}}")) {
+        result.dynamicContentHTMLs[filePath] = html;
+        result.htmlPathsToRunTests.push(filePath.replace(config.projectRoot, ""));
+      } else {
+        console.log(
+          "#",
+          yellow(
+            `WARNING: Static html file with no {{content}} detected. Therefore ignoring ${filePath}`
+          )
+        );
+        result.staticHTMLs[filePath] = html;
+      }
+      findInternalAssetsFromHTML(html).forEach((key) => {
+        result.assets.add(normalizeInternalAssetPathFromHTML(config.projectRoot, key, filePath));
+      });
+      return result;
+    },
+    {
+      allTestCode: null,
+      assets: /* @__PURE__ */ new Set(),
+      htmlPathsToRunTests: [],
+      mainHTML: { filePath: null, html: null },
+      staticHTMLs: {},
+      dynamicContentHTMLs: {}
+    }
+  );
+  if (cachedContent.htmlPathsToRunTests.length === 0) {
+    cachedContent.htmlPathsToRunTests = ["/"];
+  }
+  return addCachedContentMainHTML(config.projectRoot, cachedContent);
+}
+async function addCachedContentMainHTML(projectRoot, cachedContent) {
+  const mainHTMLPath = Object.keys(cachedContent.dynamicContentHTMLs)[0];
+  if (mainHTMLPath) {
+    cachedContent.mainHTML = {
+      filePath: mainHTMLPath,
+      html: cachedContent.dynamicContentHTMLs[mainHTMLPath]
+    };
+  } else {
+    const html = await readBoilerplate("setup/tests.hbs");
+    cachedContent.mainHTML = { filePath: `${projectRoot}/test/tests.html`, html };
+    cachedContent.assets.add(`${projectRoot}/node_modules/qunitx/vendor/qunit.css`);
+  }
+  return cachedContent;
+}
+function splitIntoGroups(files, groupCount) {
+  const groups = Array.from({ length: groupCount }, () => []);
+  files.forEach((file, i) => groups[i % groupCount].push(file));
+  return groups.filter((g) => g.length > 0);
+}
+function logWatcherAndKeyboardShortcutInfo(config, _server) {
+  console.log(
+    "#",
+    blue(`Watching files... You can browse the tests on http://localhost:${config.port} ...`)
+  );
+  console.log(
+    "#",
+    blue(
+      `Shortcuts: Press "qq" to abort running tests, "qa" to run all the tests, "qf" to run last failing test, "ql" to repeat last test`
+    )
+  );
+}
+function normalizeInternalAssetPathFromHTML(projectRoot, assetPath, htmlPath) {
+  const currentDirectory = htmlPath ? htmlPath.split("/").slice(0, -1).join("/") : projectRoot;
+  return assetPath.startsWith("./") ? normalize(`${currentDirectory}/${assetPath.slice(2)}`) : normalize(`${currentDirectory}/${assetPath}`);
+}
+var init_run = __esm({
+  "lib/commands/run.ts"() {
+    init_browser();
+    init_color();
+    init_tests_in_browser();
+    init_file_watcher();
+    init_find_internal_assets_from_html();
+    init_run_user_module();
+    init_keyboard_events();
+    init_write_output_static_files();
+    init_time_counter();
+    init_display_final_result();
+    init_read_boilerplate();
+  }
+});
+
+// cli.ts
+init_early_chrome();
+import process4 from "node:process";
+
+// lib/commands/help.ts
+init_color();
+
+// package.json
+var package_default = {
+  name: "qunitx-cli",
+  type: "module",
+  version: "0.9.7",
+  description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
+  author: "Izel Nakri",
+  license: "MIT",
+  keywords: [
+    "test runner",
+    "testing",
+    "browser",
+    "ci",
+    "qunit",
+    "qunitx"
+  ],
+  files: [
+    "bin/",
+    "dist/",
+    "templates/"
+  ],
+  scripts: {
+    build: "node scripts/build-cli.js",
+    bin: "chmod +x cli.ts && ./cli.ts",
+    prepublishOnly: "npm run build",
+    format: 'prettier --check "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
+    "format:fix": 'prettier --write "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
+    lint: "deno lint lib/ cli.ts",
+    "lint:docs": "node scripts/lint-docs.js",
+    docs: `deno doc --html --name="qunitx-cli" --output=docs/lib 'lib/**/*.ts' README.md`,
+    "changelog:unreleased": "git-cliff --unreleased --strip all",
+    "changelog:preview": "git-cliff",
+    "changelog:update": "git-cliff --output CHANGELOG.md",
+    postinstall: "deno install --allow-scripts=npm:playwright-core || true",
+    test: `node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require("os").availableParallelism()') test/**/*-test.ts`,
+    "test:browser": `node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require("os").availableParallelism()') test/flags/*-test.ts test/inputs/*-test.ts`,
+    "test:sanity-first": "./cli.ts test/helpers/failing-tests.js test/helpers/failing-tests.ts",
+    "test:sanity-second": "./cli.ts test/helpers/passing-tests.js test/helpers/passing-tests.ts"
+  },
+  engines: {
+    node: ">=24.0.0",
+    deno: ">=2.7.0"
+  },
+  bin: {
+    qunitx: "bin/qunitx.js"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/izelnakri/qunitx-cli.git"
+  },
+  dependencies: {
+    esbuild: "^0.27.3",
+    "playwright-core": "^1.58.2",
+    ws: "^8.20.0"
+  },
+  devDependencies: {
+    cors: "^2.8.6",
+    express: "^5.2.1",
+    "js-yaml": "^4.1.1",
+    prettier: "^3.8.1",
+    qunitx: "^1.1.2",
+    typescript: "^6.0.2"
+  },
+  volta: {
+    node: "24.14.0"
+  },
+  prettier: {
+    printWidth: 100,
+    singleQuote: true,
+    arrowParens: "always"
+  },
+  optionalDependencies: {
+    "qunitx-cli-linux-x64": "*"
+  }
+};
+
+// lib/commands/help.ts
+var highlight = (text) => magenta().bold(text);
+var color = (text) => blue(text);
+function displayHelpOutput() {
+  const config = package_default;
+  console.log(`${highlight("[qunitx v" + config.version + "] Usage:")} qunitx ${color("[targets] --$flags")}
+
+${highlight("Input options:")}
+- File: $ ${color("qunitx test/foo.js")}
+- Folder: $ ${color("qunitx test/login")}
+- Globs: $ ${color("qunitx test/**/*-test.js")}
+- Combination: $ ${color("qunitx test/foo.js test/bar.js test/*-test.js test/logout")}
+
+${highlight("Optional flags:")}
+${color("--debug")} : print console output when tests run in browser
+${color("--watch")} : run the target file or folders, watch them for continuous run and expose http server under localhost
+${color("--timeout")} : change default timeout per test case
+${color("--output")} : folder to distribute built qunitx html and js that a webservers can run[default: tmp]
+${color("--failFast")} : run the target file or folders with immediate abort if a single test fails
+${color("--port")} : HTTP server port (auto-selects a free port if the given port is taken)[default: 1234]
+${color("--extensions")} : comma-separated file extensions to track for discovery and watch-mode rebuilds[default: js,ts]
+${color("--browser")} : browser engine to run tests in: chromium, firefox, webkit[default: chromium]
+${color("--before")} : run a script before the tests(i.e start a new web server before tests)
+${color("--after")} : run a script after the tests(i.e save test results to a file)
+
+${highlight("Example:")} $ ${color("qunitx test/foo.ts app/e2e --debug --watch --before=scripts/start-new-webserver.js --after=scripts/write-test-results.js")}
+
+${highlight("Commands:")}
+${color("$ qunitx init")}               # Bootstraps qunitx base html and add qunitx config to package.json if needed
+${color("$ qunitx new $testFileName")}  # Creates a qunitx test file
+`);
+}
+
+// lib/commands/init.ts
+import fs3 from "node:fs/promises";
+import path from "node:path";
+
+// lib/utils/find-project-root.ts
+import process2 from "node:process";
+
+// lib/utils/search-in-parent-directories.ts
+init_path_exists();
+async function searchInParentDirectories(directory, targetEntry) {
+  const resolvedDirectory = directory === "." ? process.cwd() : directory;
+  if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {
+    return `${resolvedDirectory}/${targetEntry}`;
+  } else if (resolvedDirectory === "") {
+    return;
+  }
+  return await searchInParentDirectories(
+    resolvedDirectory.slice(0, resolvedDirectory.lastIndexOf("/")),
+    targetEntry
+  );
+}
+var search_in_parent_directories_default = searchInParentDirectories;
+
+// lib/utils/find-project-root.ts
+async function findProjectRoot() {
+  try {
+    const absolutePath = await search_in_parent_directories_default(".", "package.json");
+    if (!absolutePath.includes("package.json")) {
+      throw new Error("package.json mising");
+    }
+    return absolutePath.replace("/package.json", "");
+  } catch (_error) {
+    console.log("couldnt find projects package.json, did you run $ npm init ??");
+    process2.exit(1);
+  }
+}
+
+// lib/commands/init.ts
+init_path_exists();
+
+// lib/setup/default-project-config-values.ts
+var default_project_config_values_default = {
+  output: "tmp",
+  timeout: 2e4,
+  failFast: false,
+  port: 1234,
+  extensions: ["js", "ts"],
+  browser: "chromium"
+};
+
+// lib/commands/init.ts
+init_read_boilerplate();
+async function initializeProject() {
+  const projectRoot = await findProjectRoot();
+  const oldPackageJSON = JSON.parse(await fs3.readFile(`${projectRoot}/package.json`));
+  const existingQunitx = oldPackageJSON.qunitx || {};
+  const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith(".html"));
+  const config = Object.assign({}, default_project_config_values_default, existingQunitx, {
+    htmlPaths: cliHtmlPaths.length > 0 ? cliHtmlPaths : existingQunitx.htmlPaths || ["test/tests.html"]
+  });
+  await Promise.all([
+    writeTestsHTML(projectRoot, config, oldPackageJSON),
+    rewritePackageJSON(projectRoot, config, oldPackageJSON),
+    writeTSConfigIfNeeded(projectRoot)
+  ]);
+}
+async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
+  const testHTMLTemplateBuffer = await readBoilerplate("setup/tests.hbs");
+  return await Promise.all(
+    config.htmlPaths.map(async (htmlPath) => {
+      const targetPath = `${projectRoot}/${htmlPath}`;
+      if (await pathExists(targetPath)) {
+        return console.log(`${htmlPath} already exists`);
+      } else {
+        const targetDirectory = path.dirname(targetPath);
+        const _targetOutputPath = path.relative(
+          targetDirectory,
+          `${projectRoot}/${config.output}/tests.js`
+        );
+        const testHTMLTemplate = testHTMLTemplateBuffer.replace(
+          "{{applicationName}}",
+          oldPackageJSON.name
+        );
+        await fs3.mkdir(targetDirectory, { recursive: true });
+        await fs3.writeFile(targetPath, testHTMLTemplate);
+        console.log(`${targetPath} written`);
+      }
+    })
+  );
+}
+async function rewritePackageJSON(projectRoot, config, oldPackageJSON) {
+  const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: config });
+  await fs3.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
+}
+async function writeTSConfigIfNeeded(projectRoot) {
+  const targetPath = `${projectRoot}/tsconfig.json`;
+  if (!await pathExists(targetPath)) {
+    const tsConfigTemplate = await readBoilerplate("setup/tsconfig.json");
+    await fs3.writeFile(targetPath, tsConfigTemplate);
+    console.log(`${targetPath} written`);
+  }
+}
+
+// lib/commands/generate.ts
+init_color();
+import fs4 from "node:fs/promises";
+init_path_exists();
+init_read_boilerplate();
+async function generateTestFiles() {
+  const projectRoot = await findProjectRoot();
+  const moduleName = process.argv[3];
+  const path5 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
+  if (await pathExists(path5)) {
+    console.log(`${path5} already exists!`);
+    return;
+  }
+  const testJSContent = await readBoilerplate("test.js");
+  const targetFolderPaths = path5.split("/");
+  targetFolderPaths.pop();
+  await fs4.mkdir(targetFolderPaths.join("/"), { recursive: true });
+  await fs4.writeFile(path5, testJSContent.replace("{{moduleName}}", moduleName));
+  console.log(green(`${path5} written`));
+}
+
+// lib/setup/config.ts
+import fs6 from "node:fs/promises";
+
+// lib/setup/fs-tree.ts
+import fs5, { glob as fsGlob } from "node:fs/promises";
+import path2 from "node:path";
+function isGlob(str) {
+  return /[*?{[]/.test(str);
+}
+async function readDirRecursive(dir, filter) {
+  const entries = await fs5.readdir(dir, { recursive: true, withFileTypes: true });
+  return entries.filter((e) => e.isFile() && filter(e.name)).map((e) => path2.join(e.parentPath, e.name));
+}
+async function buildFSTree(fileAbsolutePaths, config = {}) {
+  const targetExtensions = config.extensions || ["js", "ts"];
+  const fsTree = {};
+  await Promise.all(
+    fileAbsolutePaths.map(async (fileAbsolutePath) => {
+      try {
+        if (isGlob(fileAbsolutePath)) {
+          for await (const fileName of fsGlob(fileAbsolutePath)) {
+            if (targetExtensions.some((ext) => fileName.endsWith(`.${ext}`))) {
+              fsTree[fileName] = null;
+            }
+          }
+        } else {
+          const entry = await fs5.stat(fileAbsolutePath);
+          if (entry.isFile()) {
+            fsTree[fileAbsolutePath] = null;
+          } else if (entry.isDirectory()) {
+            const fileNames = await readDirRecursive(fileAbsolutePath, (name) => {
+              return targetExtensions.some((extension) => name.endsWith(`.${extension}`));
+            });
+            fileNames.forEach((fileName) => {
+              fsTree[fileName] = null;
+            });
+          }
+        }
+      } catch (error) {
+        console.error(error);
+        return process.exit(1);
+      }
+    })
+  );
+  return fsTree;
+}
+
+// lib/setup/test-file-paths.ts
+import { matchesGlob } from "node:path";
+function isGlob2(str) {
+  return /[*?{[]/.test(str);
+}
+function setupTestFilePaths(_projectRoot, inputs2) {
+  const [folders, filesWithGlob, filesWithoutGlob] = inputs2.reduce(
+    (result2, input) => {
+      const glob = isGlob2(input);
+      if (!pathIsFile(input)) {
+        result2[0].push({ input, isFile: false, isGlob: glob });
+      } else {
+        result2[glob ? 1 : 2].push({ input, isFile: true, isGlob: glob });
+      }
+      return result2;
+    },
+    [[], [], []]
+  );
+  const result = folders.reduce((folderResult, folder) => {
+    if (!pathIsIncludedInPaths(folders, folder)) {
+      folderResult.push(folder);
+    }
+    return folderResult;
+  }, []);
+  filesWithGlob.forEach((file) => {
+    if (!pathIsIncludedInPaths(result, file) && !pathIsIncludedInPaths(filesWithGlob, file)) {
+      result.push(file);
+    }
+  });
+  filesWithoutGlob.forEach((file) => {
+    if (!pathIsIncludedInPaths(result, file)) {
+      result.push(file);
+    }
+  });
+  return result.map((metaItem) => metaItem.input);
+}
+function pathIsFile(path5) {
+  const inputs2 = path5.split("/");
+  return inputs2[inputs2.length - 1].includes(".");
+}
+function pathIsIncludedInPaths(paths, targetPath) {
+  return paths.some((path5) => {
+    if (path5 === targetPath) {
+      return false;
+    }
+    return matchesGlob(targetPath.input, buildGlobFormat(path5));
+  });
+}
+function buildGlobFormat(path5) {
+  return path5.isFile ? path5.input : `${path5.input}/**`;
+}
+
+// lib/utils/parse-cli-flags.ts
+function parseCliFlags(projectRoot) {
+  const providedFlags = process.argv.slice(2).reduce(
+    (result, arg) => {
+      if (arg.startsWith("--debug")) {
+        return Object.assign(result, { debug: parseBoolean(arg.split("=")[1]) });
+      } else if (arg.startsWith("--watch")) {
+        return Object.assign(result, { watch: parseBoolean(arg.split("=")[1]) });
+      } else if (arg.startsWith("--failfast") || arg.startsWith("--failFast")) {
+        return Object.assign(result, { failFast: parseBoolean(arg.split("=")[1]) });
+      } else if (arg.startsWith("--timeout")) {
+        return Object.assign(result, { timeout: Number(arg.split("=")[1]) || 1e4 });
+      } else if (arg.startsWith("--output")) {
+        return Object.assign(result, { output: arg.split("=")[1] });
+      } else if (arg.endsWith(".html")) {
+        if (result.htmlPaths) {
+          result.htmlPaths.push(arg);
+        } else {
+          result.htmlPaths = [arg];
+        }
+        return result;
+      } else if (arg.startsWith("--port")) {
+        return Object.assign(result, { port: Number(arg.split("=")[1]) });
+      } else if (arg.startsWith("--extensions")) {
+        return Object.assign(result, {
+          extensions: arg.split("=")[1].split(",").map((e) => e.trim())
+        });
+      } else if (arg.startsWith("--browser")) {
+        const value = arg.split("=")[1];
+        if (!["chromium", "firefox", "webkit"].includes(value)) {
+          console.error(
+            `Invalid --browser value: "${value}". Must be one of: chromium, firefox, webkit`
+          );
+          process.exit(1);
+        }
+        return Object.assign(result, { browser: value });
+      } else if (arg.startsWith("--before")) {
+        return Object.assign(result, { before: parseModule(arg.split("=")[1]) });
+      } else if (arg.startsWith("--after")) {
+        return Object.assign(result, { after: parseModule(arg.split("=")[1]) });
+      } else if (arg === "--trace-perf") {
+        return result;
+      }
+      result.inputs.add(arg.startsWith(projectRoot) ? arg : `${process.cwd()}/${arg}`);
+      return result;
+    },
+    { inputs: /* @__PURE__ */ new Set([]) }
+  );
+  return { ...providedFlags, inputs: Array.from(providedFlags.inputs) };
+}
+function parseBoolean(result, defaultValue = true) {
+  if (result === "true") {
+    return true;
+  } else if (result === "false") {
+    return false;
+  }
+  return defaultValue;
+}
+function parseModule(value) {
+  if (["false", "'false'", '"false"', ""].includes(value)) {
+    return false;
+  }
+  return value;
+}
+
+// lib/setup/config.ts
+async function setupConfig() {
+  const projectRoot = await findProjectRoot();
+  const cliConfigFlags = parseCliFlags(projectRoot);
+  const projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
+  const inputs2 = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
+  const config = {
+    ...default_project_config_values_default,
+    htmlPaths: [],
+    ...projectPackageJSON.qunitx || {},
+    ...cliConfigFlags,
+    projectRoot,
+    inputs: inputs2,
+    testFileLookupPaths: setupTestFilePaths(projectRoot, inputs2),
+    lastFailedTestFiles: null,
+    lastRanTestFiles: null,
+    COUNTER: { testCount: 0, failCount: 0, skipCount: 0, passCount: 0, errorCount: 0 },
+    _testRunDone: null,
+    _resetTestTimeout: null
+  };
+  config.htmlPaths = normalizeHTMLPaths(config.projectRoot, config.htmlPaths);
+  config.fsTree = await buildFSTree(config.testFileLookupPaths, config);
+  return config;
+}
+async function readConfigFromPackageJSON(projectRoot) {
+  const packageJSON = await fs6.readFile(`${projectRoot}/package.json`);
+  return JSON.parse(packageJSON.toString());
+}
+function normalizeHTMLPaths(projectRoot, htmlPaths) {
+  return Array.from(new Set(htmlPaths.map((htmlPath) => `${projectRoot}/${htmlPath}`)));
+}
+function readInputsFromPackageJSON(packageJSON) {
+  const qunitx = packageJSON.qunitx;
+  return qunitx && qunitx.inputs ? qunitx.inputs : [];
+}
+
+// cli.ts
+process4.title = "qunitx";
+(async () => {
+  if (!process4.argv[2]) {
+    return await displayHelpOutput();
+  } else if (["help", "h", "p", "print"].includes(process4.argv[2])) {
+    return await displayHelpOutput();
+  } else if (["new", "n", "g", "generate"].includes(process4.argv[2])) {
+    return await generateTestFiles();
+  } else if (["init"].includes(process4.argv[2])) {
+    return await initializeProject();
+  }
+  const [config, { default: run2 }] = await Promise.all([
+    setupConfig(),
+    Promise.resolve().then(() => (init_run(), run_exports))
+  ]);
+  try {
+    return await run2(config);
+  } catch (error) {
+    console.error(error);
+    process4.exitCode = 1;
+    process4.stdout.write("\n", () => process4.exit(1));
+  }
+})();