elit 3.3.3 → 3.3.4

package/dist/test-runtime.mjs

@@ -0,0 +1,1269 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/test-runtime.ts
+import { transformSync } from "esbuild";
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/fs.ts
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+var fs;
+var fsPromises;
+if (isNode) {
+  fs = __require("fs");
+  fsPromises = __require("fs/promises");
+}
+async function readFile(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.readFile(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = await file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = await Deno.readFile(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readFileSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readFileSync(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+
+// src/path.ts
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  } else if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  } else if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
+function normalizePath(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "" || part === ".") {
+      if (i === 0 && isAbsolute) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let final = result.join(separator);
+  if (final.length === 0) {
+    return isAbsolute ? separator : ".";
+  }
+  if (trailingSeparator && final[final.length - 1] !== separator) {
+    final += separator;
+  }
+  return final;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let isAbsolute = false;
+  for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!isAbsolute) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  from = resolvePaths([from], isWin);
+  to = resolvePaths([to], isWin);
+  if (from === to) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = from.split(separator).filter((p) => p.length > 0);
+  const toParts = to.split(separator).filter((p) => p.length > 0);
+  let commonLength = 0;
+  const minLength = Math.min(fromParts.length, toParts.length);
+  for (let i = 0; i < minLength; i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const result = [];
+  for (let i = 0; i < upCount; i++) {
+    result.push("..");
+  }
+  for (let i = commonLength; i < toParts.length; i++) {
+    result.push(toParts[i]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path, isWin);
+  const lastSepIndex = normalized.lastIndexOf(separator);
+  if (lastSepIndex === -1) return ".";
+  if (lastSepIndex === 0) return separator;
+  return normalized.slice(0, lastSepIndex);
+}
+function getBasename(path, ext, isWin) {
+  if (path.length === 0) return "";
+  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else {
+    if (path[0] === "/") {
+      root = "/";
+    }
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
+
+// src/test-runtime.ts
+import { SourceMapConsumer } from "source-map";
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var 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";
+  }
+};
+var currentSuite = {
+  name: "root",
+  tests: [],
+  suites: [],
+  skip: false,
+  only: false
+};
+var testResults = [];
+var hasOnly = false;
+var coveredFiles = /* @__PURE__ */ new Set();
+var describePattern = void 0;
+var testPattern = void 0;
+var currentTestFile = void 0;
+var currentSourceMapConsumer = void 0;
+var wrapperLineOffset = 0;
+async function transpileFile(filePath) {
+  const source = await readFile(filePath, "utf-8");
+  const result = transformSync(source, {
+    loader: filePath.endsWith(".ts") || filePath.endsWith(".tsx") ? "ts" : "js",
+    format: "esm",
+    sourcemap: "inline",
+    target: "es2020",
+    tsconfigRaw: {
+      compilerOptions: {
+        jsx: "react",
+        jsxFactory: "h",
+        jsxFragmentFactory: "Fragment"
+      }
+    }
+  });
+  let sourceMap;
+  const sourceMapMatch = result.code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
+  if (sourceMapMatch) {
+    const base64 = sourceMapMatch[1];
+    const json = Buffer.from(base64, "base64").toString("utf-8");
+    sourceMap = JSON.parse(json);
+  }
+  return { code: result.code, sourceMap };
+}
+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;
+}
+var 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);
+  }
+};
+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;
+}
+var 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: () => {
+  }
+};
+var beforeAllHooks = [];
+var afterAllHooks = [];
+var beforeEachHooks = [];
+var afterEachHooks = [];
+var beforeAll = (fn) => beforeAllHooks.push(fn);
+var afterAll = (fn) => afterAllHooks.push(fn);
+var beforeEach = (fn) => beforeEachHooks.push(fn);
+var afterEach = (fn) => afterEachHooks.push(fn);
+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 = 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 json = Buffer.from(base64, "base64").toString("utf-8");
+        const sourceMap = JSON.parse(json);
+        currentSourceMapConsumer = await new 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 = 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();
+  }
+}
+var globals = {
+  describe: createDescribeFunction(),
+  it: createTestFunction(5e3),
+  test: createTestFunction(5e3),
+  expect,
+  beforeAll,
+  afterAll,
+  beforeEach,
+  afterEach,
+  vi
+};
+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();
+}
+export {
+  clearGlobals,
+  getCoveredFiles,
+  globals,
+  resetCoveredFiles,
+  runTests,
+  setupGlobals,
+  transpileFile
+};
+//# sourceMappingURL=test-runtime.mjs.map