@aljazmc/testero 0.1.6 → 0.2.0

package/bin/main.js

@@ -1,12 +1,2140 @@
 #!/usr/bin/env node
 
+// shared/config/src/config.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// shared/config/src/pattern.ts
+var Pattern = class _Pattern {
+  #anchored;
+  #regex;
+  constructor(source) {
+    const glob = source.replace(/^\.?\/+|\/+$/g, "");
+    this.#anchored = glob.includes("/");
+    this.#regex = new RegExp(`^${_Pattern.#toRegex(glob)}$`);
+  }
+  matches(path) {
+    const segments = path.split("/");
+    return segments.some(
+      (segment, index) => this.#regex.test(
+        this.#anchored ? segments.slice(0, index + 1).join("/") : segment
+      )
+    );
+  }
+  /** Translates `**`, `*`, `?` and `{a,b}` alternatives, other characters match themselves. */
+  static #toRegex(glob) {
+    const tokens = {
+      "**/": "(?:.*/)?",
+      "**": ".*",
+      "*": "[^/]*",
+      "?": "[^/]"
+    };
+    let regex = "";
+    let braces = 0;
+    for (const [token] of glob.matchAll(/\*\*\/|\*\*|[\s\S]/g)) {
+      if (token in tokens) regex += tokens[token] ?? token;
+      else if (token === "{") {
+        braces++;
+        regex += "(?:";
+      } else if (token === "}" && braces > 0) {
+        braces--;
+        regex += ")";
+      } else if (token === "," && braces > 0) regex += "|";
+      else regex += token.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return regex;
+  }
+};
+
+// shared/config/src/ignore.ts
+var Ignore = class {
+  #patterns;
+  constructor(sources) {
+    this.#patterns = sources.map((source) => new Pattern(source));
+  }
+  matches(path) {
+    const normalized = path.replaceAll("\\", "/").replace(/^\.\//, "");
+    return this.#patterns.some((pattern) => pattern.matches(normalized));
+  }
+};
+
+// shared/config/src/config.ts
+var Config = class _Config {
+  static extensions = ["ts", "js"];
+  root;
+  ignore;
+  rules;
+  /** What the config file set, before the defaults were merged in. */
+  custom;
+  constructor(options, root = process.cwd(), custom = {}) {
+    this.root = root;
+    this.ignore = new Ignore(options.ignore);
+    this.rules = options.rules;
+    this.custom = custom;
+  }
+  static async load(name, defaults, root = process.cwd()) {
+    for (const extension of _Config.extensions) {
+      const file = join(root, `${name}.config.${extension}`);
+      if (existsSync(file)) {
+        const { default: options } = await import(pathToFileURL(file).href);
+        return new _Config(
+          _Config.merge(defaults, options),
+          root,
+          options
+        );
+      }
+    }
+    return new _Config(defaults, root);
+  }
+  /** Deep merges plain objects, anything else in override replaces base. */
+  static merge(base, override) {
+    const plain = (value) => value?.constructor === Object;
+    if (!plain(base) || !plain(override)) return override ?? base;
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override))
+      merged[key] = _Config.merge(base[key], value);
+    return merged;
+  }
+  *files(directory = "") {
+    const entries = readdirSync(join(this.root, directory), {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const path = directory ? `${directory}/${entry.name}` : entry.name;
+      if (this.ignore.matches(path)) continue;
+      if (entry.isDirectory()) yield* this.files(path);
+      else yield path;
+    }
+  }
+  /** Text files that are not ignored and that accepts takes, binaries are skipped. */
+  *sources(accepts = () => true) {
+    for (const file of this.files()) {
+      if (!accepts(file)) continue;
+      const path = join(this.root, file);
+      const text = readFileSync(path, "utf8");
+      if (!text.includes("\0")) yield { file, path, text };
+    }
+  }
+};
+
+// shared/config/src/includes.ts
+var Includes = class {
+  #globs;
+  constructor(globs) {
+    this.#globs = globs.map((glob) => ({
+      pattern: new Pattern(glob.replace(/^!/, "")),
+      included: !glob.startsWith("!")
+    }));
+  }
+  matches(file) {
+    let included = false;
+    for (const { pattern, included: positive } of this.#globs)
+      if (pattern.matches(file)) included = positive;
+    return included;
+  }
+};
+
+// packages/testero/src/arguments.ts
+var Arguments = class {
+  static usage = `Usage: testero [patterns...] [options]
+
+Runs the test files whose paths match a pattern, every test file without patterns.
+
+Options:
+  -t, --testNamePattern <regex>  run only tests whose name matches
+  --bail                         stop after the first failing test file
+  --verbose                      list every test
+  --listTests                    print the test files instead of running them
+  --passWithNoTests              succeed when there are no test files
+  --testTimeout <ms>             milliseconds a test or hook may take
+  -h, --help                     show this help
+`;
+  patterns = [];
+  rules = {};
+  namePattern;
+  listTests = false;
+  help = false;
+  constructor(argv) {
+    for (let index = 0; index < argv.length; index++) {
+      const argument = argv[index];
+      const [name, inline] = argument.split(/=(.*)/s);
+      const value = () => {
+        const next = inline ?? argv[++index];
+        if (next === void 0)
+          throw new Error(`${name} needs a value.`);
+        return next;
+      };
+      switch (name) {
+        case "-t":
+        case "--testNamePattern":
+          this.namePattern = new RegExp(value());
+          break;
+        case "--testTimeout":
+          this.rules.testTimeout = Number(value());
+          break;
+        case "--bail":
+        case "--verbose":
+        case "--passWithNoTests":
+          this.rules[name.slice(2)] = true;
+          break;
+        case "--listTests":
+          this.listTests = true;
+          break;
+        case "-h":
+        case "--help":
+          this.help = true;
+          break;
+        default:
+          if (name.startsWith("-"))
+            throw new Error(`Unknown option ${name}.`);
+          this.patterns.push(argument);
+      }
+    }
+  }
+  /** The configured rules, with the ones given on the command line instead. */
+  options(rules2) {
+    return {
+      ...rules2,
+      ...this.rules,
+      patterns: this.patterns,
+      namePattern: this.namePattern
+    };
+  }
+};
+
+// packages/testero/src/config.ts
+var extensions = "{js,jsx,ts,tsx,mjs,cjs,mts,cts}";
+var rules = {
+  testMatch: [
+    `**/__tests__/**/*.${extensions}`,
+    `**/*.{spec,test}.${extensions}`
+  ],
+  testTimeout: 5e3,
+  bail: false,
+  verbose: false,
+  passWithNoTests: false,
+  clearMocks: false,
+  resetMocks: false,
+  restoreMocks: false
+};
+var config_default = {
+  ignore: [".git", "node_modules"],
+  rules
+};
+
 // packages/testero/src/testero.ts
-var testero_default = new class Testero {
-  greeting;
+import { join as join3 } from "node:path";
+
+// packages/testero/src/expect/format.ts
+var Format = class _Format {
+  /** A value with one property or item per line. */
+  static value(value) {
+    return _Format.#print(value, "", true, []);
+  }
+  /** A value on one line. */
+  static inline(value) {
+    return _Format.#print(value, "", false, []);
+  }
+  /** A line diff of two values, `-` for expected lines and `+` for received ones. */
+  static diff(expected, received) {
+    const a = _Format.value(expected).split("\n");
+    const b = _Format.value(received).split("\n");
+    if (a.length * b.length > 4e6)
+      return `Expected: ${_Format.inline(expected)}
+Received: ${_Format.inline(received)}`;
+    return ["- Expected", "+ Received", "", ..._Format.#lines(a, b)].join(
+      "\n"
+    );
+  }
+  /** Lines of a longest common subsequence diff. */
+  static #lines(a, b) {
+    const lengths = Array.from(
+      { length: a.length + 1 },
+      () => new Array(b.length + 1).fill(0)
+    );
+    for (let i2 = a.length - 1; i2 >= 0; i2--)
+      for (let j2 = b.length - 1; j2 >= 0; j2--)
+        lengths[i2][j2] = a[i2] === b[j2] ? lengths[i2 + 1][j2 + 1] + 1 : Math.max(
+          lengths[i2 + 1][j2],
+          lengths[i2][j2 + 1]
+        );
+    const lines = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+      if (i < a.length && j < b.length && a[i] === b[j]) {
+        lines.push(`  ${a[i++]}`);
+        j++;
+      } else if (j >= b.length || i < a.length && lengths[i + 1][j] >= lengths[i][j + 1])
+        lines.push(`- ${a[i++]}`);
+      else lines.push(`+ ${b[j++]}`);
+    }
+    return lines;
+  }
+  static #print(value, indent, multiline, seen) {
+    switch (typeof value) {
+      case "string":
+        return JSON.stringify(value);
+      case "number":
+        return Object.is(value, -0) ? "-0" : String(value);
+      case "bigint":
+        return `${value}n`;
+      case "symbol":
+        return value.toString();
+      case "function":
+        return `[Function ${value.name || "anonymous"}]`;
+      case "undefined":
+        return "undefined";
+      case "boolean":
+        return String(value);
+    }
+    if (value === null) return "null";
+    const object = value;
+    if (typeof object.asymmetricMatch === "function") return String(object);
+    if (value instanceof Date)
+      return Number.isNaN(value.getTime()) ? "Date { NaN }" : value.toISOString();
+    if (value instanceof RegExp) return String(value);
+    if (value instanceof Error) return `[${value.name}: ${value.message}]`;
+    if (seen.includes(value)) return "[Circular]";
+    const inner = [...seen, value];
+    const print = (item) => _Format.#print(item, `${indent}  `, multiline, inner);
+    const name = object.constructor?.name;
+    if (value instanceof Map)
+      return _Format.#block(
+        `Map {`,
+        "}",
+        [...value].map(
+          ([key, item]) => `${print(key)} => ${print(item)}`
+        ),
+        indent,
+        multiline
+      );
+    if (value instanceof Set)
+      return _Format.#block(
+        "Set {",
+        "}",
+        [...value].map(print),
+        indent,
+        multiline
+      );
+    if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+      const items = Array.from(value, print);
+      const prefix2 = name && name !== "Array" ? `${name} [` : "[";
+      return _Format.#block(prefix2, "]", items, indent, multiline);
+    }
+    const keys = [
+      ...Object.keys(object),
+      ...Object.getOwnPropertySymbols(object).filter(
+        (symbol) => Object.getOwnPropertyDescriptor(object, symbol)?.enumerable
+      )
+    ];
+    const entries = keys.map(
+      (key) => `${typeof key === "symbol" ? key.toString() : JSON.stringify(key)}: ${print(object[key])}`
+    );
+    const prefix = name && name !== "Object" ? `${name} {` : "{";
+    return _Format.#block(prefix, "}", entries, indent, multiline);
+  }
+  static #block(open, close, entries, indent, multiline) {
+    if (entries.length === 0) return `${open}${close}`;
+    if (!multiline) return `${open}${entries.join(", ")}${close}`;
+    return `${open}
+${entries.map((entry) => `${indent}  ${entry},
+`).join("")}${indent}${close}`;
+  }
+};
+
+// packages/testero/src/each.ts
+var Each = class _Each {
+  /**
+   * The argument lists of a table: rows of arrays are spread, other rows
+   * are one argument, and a tagged template gives one object per row.
+   */
+  static rows(table, values) {
+    if (_Each.#template(table)) {
+      const names = table.join("").trim().split(/\s*\|\s*/);
+      const rows = [];
+      for (let index = 0; index < values.length; index += names.length)
+        rows.push([
+          Object.fromEntries(
+            names.map((name, offset) => [
+              name,
+              values[index + offset]
+            ])
+          )
+        ]);
+      return rows;
+    }
+    if (!Array.isArray(table))
+      throw new TypeError(
+        "each needs an array or a tagged template table"
+      );
+    return table.map((row) => Array.isArray(row) ? row : [row]);
+  }
+  /** A title with `$name` properties of an object row, or printf placeholders. */
+  static title(title, args, index) {
+    const [first] = args;
+    if (args.length === 1 && _Each.#plain(first) && title.includes("$"))
+      return title.replace(
+        /\$([\w$]+(?:\.[\w$]+)*)/g,
+        (match, path) => path === "#" ? String(index) : _Each.#show(_Each.#at(first, path.split("."), match))
+      );
+    const rest = [...args];
+    return title.replace(/%([sdifjoOp#$%])/g, (match, flag) => {
+      if (flag === "%") return "%";
+      if (flag === "#") return String(index);
+      if (flag === "$") return String(index + 1);
+      if (rest.length === 0) return match;
+      const value = rest.shift();
+      switch (flag) {
+        case "d":
+        case "i":
+          return String(
+            flag === "i" ? Math.trunc(Number(value)) : Number(value)
+          );
+        case "f":
+          return String(Number(value));
+        case "j":
+          return JSON.stringify(value);
+        case "s":
+          return _Each.#show(value);
+        default:
+          return Format.inline(value);
+      }
+    });
+  }
+  static #template(table) {
+    return Array.isArray(table) && "raw" in table;
+  }
+  static #plain(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  static #at(value, path, fallback) {
+    let current = value;
+    for (const key of path) {
+      if (typeof current !== "object" || current === null || !(key in current))
+        return fallback;
+      current = current[key];
+    }
+    return current;
+  }
+  /** Strings as they are, other values like Jest prints them. */
+  static #show(value) {
+    return typeof value === "string" ? value : Format.inline(value);
+  }
+};
+
+// packages/testero/src/suite.ts
+var Suite = class {
+  name;
+  mode;
+  parent;
+  children = [];
+  hooks = {
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: []
+  };
+  constructor(name, mode = "run", parent) {
+    this.name = name;
+    this.mode = mode;
+    this.parent = parent;
+  }
+  /** The names of the suites from the file down to this one, the file has none. */
+  get titles() {
+    return this.parent ? [...this.parent.titles, this.name] : [];
+  }
+  /** This suite and the ones around it, from the file down. */
+  get path() {
+    return this.parent ? [...this.parent.path, this] : [this];
+  }
+  /** Every test, of nested suites too, in order. */
+  *tests() {
+    for (const child of this.children)
+      if (child instanceof Test) yield child;
+      else yield* child.tests();
+  }
+};
+var Test = class {
+  name;
+  body;
+  mode;
+  timeout;
+  suite;
+  constructor(name, body, mode, timeout, suite) {
+    this.name = name;
+    this.body = body;
+    this.mode = mode;
+    this.timeout = timeout;
+    this.suite = suite;
+  }
+  /** The names of the suites around the test, and its own. */
+  get titles() {
+    return [...this.suite.titles, this.name];
+  }
+  /** The titles joined like Jest does for `-t`. */
+  get fullName() {
+    return this.titles.join(" ");
+  }
+  /** Whether the test, or a suite around it, is marked with `only`. */
+  get focused() {
+    return this.mode === "only" || this.suite.path.some((suite) => suite.mode === "only");
+  }
+  /** Whether the test, or a suite around it, is skipped or todo. */
+  get skipped() {
+    return this.mode === "skip" || this.mode === "todo" || this.suite.path.some((suite) => suite.mode === "skip");
+  }
+};
+
+// packages/testero/src/collector.ts
+var Collector = class {
+  root = new Suite("");
+  #current = this.root;
+  #closed = false;
+  describe = this.#describes();
+  test = this.#tests();
+  /** Ends collection, tests cannot be declared while tests run. */
+  close() {
+    this.#closed = true;
+  }
+  /** `beforeAll`, `afterAll`, `beforeEach` or `afterEach`. */
+  hook = (kind) => (body, timeout) => {
+    this.#open(kind);
+    this.#current.hooks[kind].push({ body, timeout });
+  };
+  #describes() {
+    const describe = (mode) => (name, body) => this.#describe(name, body, mode);
+    const each = (mode) => (table, ...values) => (name, body) => {
+      for (const [index, row] of Each.rows(table, values).entries())
+        this.#describe(
+          Each.title(String(name), row, index),
+          () => body(...row),
+          mode
+        );
+    };
+    return Object.assign(describe("run"), {
+      only: Object.assign(describe("only"), { each: each("only") }),
+      skip: Object.assign(describe("skip"), { each: each("skip") }),
+      each: each("run")
+    });
+  }
+  #tests() {
+    const test = (mode) => (name, body, timeout) => this.#test(name, body, mode, timeout);
+    const each = (mode) => (table, ...values) => (name, body, timeout) => {
+      for (const [index, row] of Each.rows(table, values).entries())
+        this.#test(
+          Each.title(String(name), row, index),
+          () => body(...row),
+          mode,
+          timeout
+        );
+    };
+    return Object.assign(test("run"), {
+      only: Object.assign(test("only"), { each: each("only") }),
+      skip: Object.assign(test("skip"), { each: each("skip") }),
+      todo: (name) => this.#test(name, void 0, "todo", void 0),
+      each: each("run")
+    });
+  }
+  #describe(name, body, mode) {
+    this.#open("describe");
+    const suite = new Suite(String(name), mode, this.#current);
+    this.#current.children.push(suite);
+    const outer = this.#current;
+    this.#current = suite;
+    try {
+      const result = body();
+      if (result instanceof Promise)
+        throw new Error(
+          `describe "${suite.name}" returned a promise, its tests must be declared synchronously.`
+        );
+    } finally {
+      this.#current = outer;
+    }
+  }
+  #test(name, body, mode, timeout) {
+    this.#open("test");
+    if (mode !== "todo" && typeof body !== "function")
+      throw new TypeError(`test "${name}" needs a function.`);
+    this.#current.children.push(
+      new Test(String(name), body, mode, timeout, this.#current)
+    );
+  }
+  #open(what) {
+    if (this.#closed)
+      throw new Error(
+        `Cannot declare ${what} while tests run, declare it at the top level or in describe.`
+      );
+  }
+};
+
+// packages/testero/src/mock.ts
+var Mock = class _Mock {
+  function;
+  state = _Mock.#empty();
+  /** What the mock does after a reset, a spy calls its original. */
+  #original;
+  #restore;
+  #implementation;
+  #once = [];
+  #name = "testero.fn()";
+  constructor(implementation, restore) {
+    this.#original = implementation;
+    this.#implementation = implementation;
+    this.#restore = restore;
+    const mock = this;
+    const fn = function(...args) {
+      return mock.#call(this, args, new.target);
+    };
+    Object.defineProperty(fn, "mock", { get: () => mock.state });
+    this.function = Object.assign(fn, this.#methods(fn));
+  }
+  #methods(fn) {
+    const set = (change) => {
+      change();
+      return fn;
+    };
+    return {
+      _isMockFunction: true,
+      mockImplementation: (implementation) => set(() => {
+        this.#implementation = implementation;
+      }),
+      mockImplementationOnce: (implementation) => set(() => this.#once.push(implementation)),
+      mockReturnValue: (value) => fn.mockImplementation(() => value),
+      mockReturnValueOnce: (value) => fn.mockImplementationOnce(() => value),
+      mockResolvedValue: (value) => fn.mockImplementation(() => Promise.resolve(value)),
+      mockResolvedValueOnce: (value) => fn.mockImplementationOnce(() => Promise.resolve(value)),
+      mockRejectedValue: (value) => fn.mockImplementation(() => Promise.reject(value)),
+      mockRejectedValueOnce: (value) => fn.mockImplementationOnce(() => Promise.reject(value)),
+      mockReturnThis: () => fn.mockImplementation(function() {
+        return this;
+      }),
+      mockName: (name) => set(() => {
+        this.#name = name;
+      }),
+      getMockName: () => this.#name,
+      getMockImplementation: () => this.#implementation,
+      mockClear: () => set(() => this.clear()),
+      mockReset: () => set(() => this.reset()),
+      mockRestore: () => this.restore()
+    };
+  }
+  /** Forgets the calls. */
+  clear() {
+    this.state = _Mock.#empty();
+  }
+  /** Forgets the calls and the implementations given since. */
+  reset() {
+    this.clear();
+    this.#implementation = this.#original;
+    this.#once = [];
+  }
+  /** Resets, and puts a spied method back. */
+  restore() {
+    this.reset();
+    this.#restore?.();
+  }
+  #call(context, args, target) {
+    const result = { type: "incomplete", value: void 0 };
+    this.state.calls.push(args);
+    this.state.contexts.push(context);
+    this.state.instances.push(context);
+    this.state.results.push(result);
+    this.state.lastCall = args;
+    const implementation = this.#once.shift() ?? this.#implementation;
+    try {
+      result.value = !implementation ? void 0 : target ? Reflect.construct(implementation, args, target) : implementation.apply(context, args);
+      result.type = "return";
+      return result.value;
+    } catch (error) {
+      result.type = "throw";
+      result.value = error;
+      throw error;
+    }
+  }
+  static #empty() {
+    return {
+      calls: [],
+      results: [],
+      instances: [],
+      contexts: [],
+      lastCall: void 0
+    };
+  }
+};
+var Mocks = class _Mocks {
+  static #all = /* @__PURE__ */ new Map();
+  /** A mock function, doing what an implementation does, if given. */
+  static fn(implementation) {
+    const mock = new Mock(implementation);
+    _Mocks.#all.set(mock.function, mock);
+    return mock.function;
+  }
+  /** Replaces a method with a mock that calls it, until restored. */
+  static spyOn(object, method) {
+    const original = object[method];
+    if (_Mocks.isMockFunction(original)) return original;
+    if (typeof original !== "function")
+      throw new TypeError(
+        `Cannot spy on ${String(method)}, it is ${typeof original}, not a function.`
+      );
+    const own = Object.hasOwn(object, method);
+    const mock = new Mock(
+      function(...args) {
+        return original.apply(this, args);
+      },
+      () => {
+        if (own) object[method] = original;
+        else delete object[method];
+      }
+    );
+    object[method] = mock.function;
+    _Mocks.#all.set(mock.function, mock);
+    return mock.function;
+  }
+  static isMockFunction(value) {
+    return typeof value === "function" && value._isMockFunction === true;
+  }
+  static clearAll() {
+    for (const mock of _Mocks.#all.values()) mock.clear();
+  }
+  static resetAll() {
+    for (const mock of _Mocks.#all.values()) mock.reset();
+  }
+  static restoreAll() {
+    for (const mock of _Mocks.#all.values()) mock.restore();
+  }
+  /** Forgets every mock, between test files. */
+  static forget() {
+    _Mocks.#all.clear();
+  }
+};
+
+// packages/testero/src/expect/equality.ts
+var Equality = class _Equality {
+  /** Whether a value matches by its own rule, like `expect.any(Number)`. */
+  static asymmetric(value) {
+    return typeof value === "object" && value !== null && typeof value.asymmetricMatch === "function";
+  }
+  /**
+   * Whether two values are deeply equal. Loosely, properties set to
+   * undefined count as missing; strictly, types and holes in arrays count.
+   */
+  static equals(a, b, strict = false) {
+    return _Equality.#equals(a, b, strict, [], []);
+  }
+  /** Whether received has every property expected has, recursively, like `toMatchObject`. */
+  static matches(received, expected) {
+    if (_Equality.asymmetric(expected))
+      return expected.asymmetricMatch(received);
+    if (!_Equality.#plainish(expected) || typeof received !== "object" || received === null)
+      return _Equality.equals(received, expected);
+    if (Array.isArray(expected))
+      return Array.isArray(received) && received.length === expected.length && expected.every(
+        (item, index) => _Equality.matches(received[index], item)
+      );
+    return _Equality.#keys(expected, true).every(
+      (key) => key in received && _Equality.matches(
+        received[key],
+        expected[key]
+      )
+    );
+  }
+  /** Objects and arrays that `toMatchObject` compares by their properties. */
+  static #plainish(value) {
+    return typeof value === "object" && value !== null && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof Error);
+  }
+  static #equals(a, b, strict, aSeen, bSeen) {
+    if (_Equality.asymmetric(a)) return a.asymmetricMatch(b);
+    if (_Equality.asymmetric(b)) return b.asymmetricMatch(a);
+    if (Object.is(a, b)) return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+      return false;
+    const tag = Object.prototype.toString.call(a);
+    if (tag !== Object.prototype.toString.call(b)) return false;
+    if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+      return false;
+    if (a instanceof Date)
+      return Object.is(a.getTime(), b.getTime());
+    if (a instanceof RegExp) return String(a) === String(b);
+    if (a instanceof Error && b instanceof Error)
+      return a.name === b.name && a.message === b.message;
+    if (a instanceof Number || a instanceof String || a instanceof Boolean)
+      return Object.is(
+        a.valueOf(),
+        b.valueOf()
+      );
+    const index = aSeen.indexOf(a);
+    if (index >= 0) return bSeen[index] === b;
+    aSeen.push(a);
+    bSeen.push(b);
+    try {
+      return _Equality.#structures(a, b, strict, aSeen, bSeen);
+    } finally {
+      aSeen.pop();
+      bSeen.pop();
+    }
+  }
+  static #structures(a, b, strict, aSeen, bSeen) {
+    const equal = (x, y) => _Equality.#equals(x, y, strict, aSeen, bSeen);
+    if (a instanceof Map && b instanceof Map)
+      return a.size === b.size && [...a].every(
+        ([key, value]) => b.has(key) ? equal(value, b.get(key)) : [...b].some(
+          ([other, item]) => equal(key, other) && equal(value, item)
+        )
+      );
+    if (a instanceof Set && b instanceof Set)
+      return a.size === b.size && [...a].every(
+        (value) => b.has(value) || [...b].some((other) => equal(value, other))
+      );
+    if (Array.isArray(a) || ArrayBuffer.isView(a)) {
+      const left = a;
+      const right = b;
+      if (left.length !== right.length) return false;
+      for (let index = 0; index < left.length; index++) {
+        if (strict && index in left !== index in right) return false;
+        if (!equal(left[index], right[index])) return false;
+      }
+    }
+    const indexed = Array.isArray(a) || ArrayBuffer.isView(a);
+    const keysOf = (object) => _Equality.#keys(object, strict).filter(
+      (key) => !(indexed && typeof key === "string" && /^\d+$/.test(key))
+    );
+    const aKeys = keysOf(a);
+    const bKeys = keysOf(b);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every(
+      (key) => Object.hasOwn(b, key) && equal(
+        a[key],
+        b[key]
+      )
+    );
+  }
+  /** Own enumerable keys, without the ones set to undefined unless strict. */
+  static #keys(object, strict) {
+    const record = object;
+    const keys = [
+      ...Object.keys(object),
+      ...Object.getOwnPropertySymbols(object).filter(
+        (symbol) => Object.getOwnPropertyDescriptor(object, symbol)?.enumerable
+      )
+    ];
+    return strict ? keys : keys.filter((key) => record[key] !== void 0);
+  }
+};
+
+// packages/testero/src/expect/matchers.ts
+var show = (value) => Format.inline(value);
+var hint = (context, name, expected = "expected") => `expect(received)${context.promise ? `.${context.promise}` : ""}${context.isNot ? ".not" : ""}.${name}(${expected})`;
+var difference = (expected, received) => {
+  const multiline = Format.value(expected).includes("\n") || Format.value(received).includes("\n");
+  return multiline ? Format.diff(expected, received) : `Expected: ${show(expected)}
+Received: ${show(received)}`;
+};
+var callsOf = (context, name, received) => {
+  if (!Mocks.isMockFunction(received))
+    throw new Error(
+      `${hint(context, name)}
+
+Matcher error: received value must be a mock or spy function
+
+Received: ${show(received)}`
+    );
+  return received.mock;
+};
+var listCalls = (calls) => calls.length === 0 ? "Number of calls: 0" : `Received
+${calls.map(
+  (call, index) => `  ${index + 1}: ${call.map(show).join(", ")}`
+).join("\n")}
+
+Number of calls: ${calls.length}`;
+var comparison = (name, operator, test) => function(received, expected) {
+  if (typeof received !== "number" && typeof received !== "bigint")
+    throw new Error(
+      `${hint(this, name)}
+
+Matcher error: received value must be a number or bigint
+
+Received: ${show(received)}`
+    );
+  return {
+    pass: test(received, expected),
+    message: () => `${hint(this, name)}
+
+Expected:${this.isNot ? " not" : ""} ${operator} ${show(expected)}
+Received:${" ".repeat(operator.length + (this.isNot ? 6 : 2))}${show(received)}`
+  };
+};
+var predicate = (name, test) => function(received) {
+  return {
+    pass: test(received),
+    message: () => `${hint(this, name, "")}
+
+Received: ${show(received)}`
+  };
+};
+var thrownMatch = (expected, thrown) => {
+  const message = thrown instanceof Error ? thrown.message : String(thrown);
+  const received = `Received message: ${JSON.stringify(message)}`;
+  if (expected === void 0) return { pass: true, expected: "", received };
+  if (typeof expected === "string")
+    return {
+      pass: message.includes(expected),
+      expected: `Expected substring: ${JSON.stringify(expected)}`,
+      received
+    };
+  if (expected instanceof RegExp)
+    return {
+      pass: expected.test(message),
+      expected: `Expected pattern: ${expected}`,
+      received
+    };
+  if (typeof expected === "function")
+    return {
+      pass: thrown instanceof expected,
+      expected: `Expected constructor: ${expected.name}`,
+      received: `Received constructor: ${thrown?.constructor?.name ?? show(thrown)}
+${received}`
+    };
+  if (Equality.asymmetric(expected))
+    return {
+      pass: expected.asymmetricMatch(thrown),
+      expected: `Expected asymmetric matcher: ${String(expected)}`,
+      received: `Received value: ${show(thrown)}`
+    };
+  if (expected instanceof Error)
+    return {
+      pass: message === expected.message,
+      expected: `Expected message: ${JSON.stringify(expected.message)}`,
+      received
+    };
+  throw new Error(
+    `Matcher error: expected value must be a string, regular expression, class, error or asymmetric matcher
+
+Expected: ${show(expected)}`
+  );
+};
+var property = (object, path) => {
+  const keys = typeof path === "string" ? path.split(/[.[\]]/).filter((key) => key !== "") : path;
+  let current = object;
+  const found = [];
+  for (const key of keys) {
+    if (current === null || current === void 0 || !(key in Object(current)))
+      return { has: false, value: current, found };
+    current = current[key];
+    found.push(key);
+  }
+  return { has: true, value: current, found };
+};
+var matchers = {
+  toBe(received, expected) {
+    const pass = Object.is(received, expected);
+    return {
+      pass,
+      message: () => {
+        const header = `${hint(this, "toBe")} // Object.is equality
+
+`;
+        if (this.isNot)
+          return `${header}Expected: not ${show(expected)}`;
+        const deep = Equality.equals(received, expected, true) ? '\n\nIf it should pass with deep equality, replace "toBe" with "toStrictEqual"' : "";
+        return `${header}${difference(expected, received)}${deep}`;
+      }
+    };
+  },
+  toEqual(received, expected) {
+    return {
+      pass: Equality.equals(received, expected),
+      message: () => `${hint(this, "toEqual")} // deep equality
+
+${this.isNot ? `Expected: not ${show(expected)}` : difference(expected, received)}`
+    };
+  },
+  toStrictEqual(received, expected) {
+    return {
+      pass: Equality.equals(received, expected, true),
+      message: () => `${hint(this, "toStrictEqual")} // deep equality
+
+${this.isNot ? `Expected: not ${show(expected)}` : difference(expected, received)}`
+    };
+  },
+  toMatchObject(received, expected) {
+    if (typeof received !== "object" || received === null)
+      throw new Error(
+        `${hint(this, "toMatchObject")}
+
+Matcher error: received value must be a non-null object
+
+Received: ${show(received)}`
+      );
+    return {
+      pass: Equality.matches(received, expected),
+      message: () => `${hint(this, "toMatchObject")}
+
+${this.isNot ? `Expected: not ${show(expected)}` : difference(expected, received)}`
+    };
+  },
+  toBeDefined: predicate("toBeDefined", (value) => value !== void 0),
+  toBeUndefined: predicate("toBeUndefined", (value) => value === void 0),
+  toBeNull: predicate("toBeNull", (value) => value === null),
+  toBeNaN: predicate("toBeNaN", (value) => Number.isNaN(value)),
+  toBeTruthy: predicate("toBeTruthy", (value) => Boolean(value)),
+  toBeFalsy: predicate("toBeFalsy", (value) => !value),
+  toBeGreaterThan: comparison("toBeGreaterThan", ">", (a, b) => a > b),
+  toBeGreaterThanOrEqual: comparison(
+    "toBeGreaterThanOrEqual",
+    ">=",
+    (a, b) => a >= b
+  ),
+  toBeLessThan: comparison("toBeLessThan", "<", (a, b) => a < b),
+  toBeLessThanOrEqual: comparison(
+    "toBeLessThanOrEqual",
+    "<=",
+    (a, b) => a <= b
+  ),
+  toBeCloseTo(received, expected, digits = 2) {
+    const value = received;
+    const pass = value === expected || Math.abs(expected - value) < 10 ** -digits / 2;
+    return {
+      pass,
+      message: () => `${hint(this, "toBeCloseTo", "expected, precision")}
+
+Expected: ${this.isNot ? "not " : ""}${show(expected)}
+Received: ${show(received)}
+
+Expected precision:    ${digits}
+Expected difference: < ${10 ** -digits / 2}
+Received difference:   ${Math.abs(expected - value)}`
+    };
+  },
+  toBeInstanceOf(received, expected) {
+    return {
+      pass: received instanceof expected,
+      message: () => `${hint(this, "toBeInstanceOf")}
+
+Expected constructor: ${this.isNot ? "not " : ""}${expected.name}
+Received constructor: ${received?.constructor?.name ?? show(received)}`
+    };
+  },
+  toContain(received, expected) {
+    const text = typeof received === "string";
+    if (!text && (received === null || typeof received?.[Symbol.iterator] !== "function"))
+      throw new Error(
+        `${hint(this, "toContain")}
+
+Matcher error: received value must not be null nor undefined, and must be iterable
+
+Received: ${show(received)}`
+      );
+    const pass = text ? received.includes(String(expected)) : [...received].includes(expected);
+    return {
+      pass,
+      message: () => `${hint(this, "toContain")}
+
+Expected ${text ? "substring" : "value"}: ${this.isNot ? "not " : ""}${show(expected)}
+Received ${text ? "string" : "value"}:${text ? "    " : "     "}${show(received)}`
+    };
+  },
+  toContainEqual(received, expected) {
+    const items = [...received];
+    return {
+      pass: items.some((item) => Equality.equals(item, expected)),
+      message: () => `${hint(this, "toContainEqual")}
+
+Expected value: ${this.isNot ? "not " : ""}${show(expected)}
+Received value: ${show(received)}`
+    };
+  },
+  toHaveLength(received, expected) {
+    const length = received?.length;
+    if (typeof length !== "number")
+      throw new Error(
+        `${hint(this, "toHaveLength")}
+
+Matcher error: received value must have a length property whose value must be a number
+
+Received: ${show(received)}`
+      );
+    return {
+      pass: length === expected,
+      message: () => `${hint(this, "toHaveLength")}
+
+Expected length: ${this.isNot ? "not " : ""}${expected}
+Received length: ${length}
+Received value:  ${show(received)}`
+    };
+  },
+  toHaveProperty(received, path, ...value) {
+    const { has, value: actual, found } = property(received, path);
+    const checksValue = value.length > 0;
+    const pass = has && (!checksValue || Equality.equals(actual, value[0]));
+    const shown = typeof path === "string" ? path : path.map(String).join(".");
+    return {
+      pass,
+      message: () => {
+        const header = `${hint(this, "toHaveProperty", checksValue ? "path, value" : "path")}
+
+Expected path: ${JSON.stringify(shown)}
+`;
+        if (!has)
+          return `${header}Received path: ${JSON.stringify(found.map(String).join("."))}
+
+Received value: ${show(actual)}`;
+        return checksValue ? `${header}
+${this.isNot ? `Expected value: not ${show(value[0])}` : difference(value[0], actual)}` : `${header}
+Received value: ${show(actual)}`;
+      }
+    };
+  },
+  toMatch(received, expected) {
+    if (typeof received !== "string")
+      throw new Error(
+        `${hint(this, "toMatch")}
+
+Matcher error: received value must be a string
+
+Received: ${show(received)}`
+      );
+    const pattern = typeof expected === "string";
+    return {
+      pass: pattern ? received.includes(expected) : expected.test(received),
+      message: () => `${hint(this, "toMatch")}
+
+Expected ${pattern ? "substring" : "pattern"}: ${this.isNot ? "not " : ""}${pattern ? show(expected) : String(expected)}
+Received string:${pattern ? "    " : "  "}${show(received)}`
+    };
+  },
+  toThrow(received, expected) {
+    let thrown;
+    if (this.promise === "rejects") thrown = { value: received };
+    else if (typeof received !== "function")
+      throw new Error(
+        `${hint(this, "toThrow")}
+
+Matcher error: received value must be a function
+
+Received: ${show(received)}`
+      );
+    else
+      try {
+        received();
+      } catch (error) {
+        thrown = { value: error };
+      }
+    const match = thrown ? thrownMatch(expected, thrown.value) : void 0;
+    const name = expected === void 0 ? "" : "expected";
+    return {
+      pass: match?.pass ?? false,
+      message: () => {
+        const header = `${hint(this, "toThrow", name)}
+
+`;
+        if (!thrown || !match)
+          return `${header}${expected === void 0 ? "" : `${thrownMatch(expected, void 0).expected}
+
+`}Received function did not throw`;
+        if (this.isNot && expected === void 0)
+          return `${header}Error name:    ${thrown.value?.name ?? "thrown"}
+${match.received}`;
+        return `${header}${match.expected.replace(": ", this.isNot ? ": not " : ": ")}
+${match.received}`;
+      }
+    };
+  },
+  toHaveBeenCalled(received) {
+    const { calls } = callsOf(this, "toHaveBeenCalled", received);
+    return {
+      pass: calls.length > 0,
+      message: () => `${hint(this, "toHaveBeenCalled", "")}
+
+Expected number of calls: ${this.isNot ? "0" : ">= 1"}
+${listCalls(calls)}`
+    };
+  },
+  toHaveBeenCalledTimes(received, expected) {
+    const { calls } = callsOf(this, "toHaveBeenCalledTimes", received);
+    return {
+      pass: calls.length === expected,
+      message: () => `${hint(this, "toHaveBeenCalledTimes")}
+
+Expected number of calls: ${this.isNot ? "not " : ""}${expected}
+Received number of calls: ${calls.length}`
+    };
+  },
+  toHaveBeenCalledWith(received, ...expected) {
+    const { calls } = callsOf(this, "toHaveBeenCalledWith", received);
+    return {
+      pass: calls.some((call) => Equality.equals(call, expected)),
+      message: () => `${hint(this, "toHaveBeenCalledWith", "...expected")}
+
+Expected: ${this.isNot ? "not " : ""}${expected.map(show).join(", ")}
+${listCalls(calls)}`
+    };
+  },
+  toHaveBeenLastCalledWith(received, ...expected) {
+    const { calls } = callsOf(this, "toHaveBeenLastCalledWith", received);
+    const last = calls.at(-1);
+    return {
+      pass: last !== void 0 && Equality.equals(last, expected),
+      message: () => `${hint(this, "toHaveBeenLastCalledWith", "...expected")}
+
+Expected: ${this.isNot ? "not " : ""}${expected.map(show).join(", ")}
+${listCalls(calls)}`
+    };
+  },
+  toHaveBeenNthCalledWith(received, nth, ...expected) {
+    const { calls } = callsOf(this, "toHaveBeenNthCalledWith", received);
+    const call = calls[nth - 1];
+    return {
+      pass: call !== void 0 && Equality.equals(call, expected),
+      message: () => `${hint(this, "toHaveBeenNthCalledWith", "n, ...expected")}
+
+n: ${nth}
+Expected: ${this.isNot ? "not " : ""}${expected.map(show).join(", ")}
+${listCalls(calls)}`
+    };
+  },
+  toHaveReturned(received) {
+    const { results } = callsOf(this, "toHaveReturned", received);
+    const returns = results.filter((result) => result.type === "return");
+    return {
+      pass: returns.length > 0,
+      message: () => `${hint(this, "toHaveReturned", "")}
+
+Expected number of returns: ${this.isNot ? "0" : ">= 1"}
+Received number of returns: ${returns.length}`
+    };
+  },
+  toHaveReturnedTimes(received, expected) {
+    const { results } = callsOf(this, "toHaveReturnedTimes", received);
+    const returns = results.filter((result) => result.type === "return");
+    return {
+      pass: returns.length === expected,
+      message: () => `${hint(this, "toHaveReturnedTimes")}
+
+Expected number of returns: ${this.isNot ? "not " : ""}${expected}
+Received number of returns: ${returns.length}`
+    };
+  },
+  toHaveReturnedWith(received, expected) {
+    const { results } = callsOf(this, "toHaveReturnedWith", received);
+    return {
+      pass: results.some(
+        (result) => result.type === "return" && Equality.equals(result.value, expected)
+      ),
+      message: () => `${hint(this, "toHaveReturnedWith")}
+
+Expected: ${this.isNot ? "not " : ""}${show(expected)}
+Received: ${results.map((result) => show(result.value)).join(", ")}`
+    };
+  },
+  toHaveLastReturnedWith(received, expected) {
+    const { results } = callsOf(this, "toHaveLastReturnedWith", received);
+    const last = results.at(-1);
+    return {
+      pass: last?.type === "return" && Equality.equals(last.value, expected),
+      message: () => `${hint(this, "toHaveLastReturnedWith")}
+
+Expected: ${this.isNot ? "not " : ""}${show(expected)}
+Received: ${last ? show(last.value) : "no calls"}`
+    };
+  },
+  toHaveNthReturnedWith(received, nth, expected) {
+    const { results } = callsOf(this, "toHaveNthReturnedWith", received);
+    const result = results[nth - 1];
+    return {
+      pass: result?.type === "return" && Equality.equals(result.value, expected),
+      message: () => `${hint(this, "toHaveNthReturnedWith", "n, expected")}
+
+n: ${nth}
+Expected: ${this.isNot ? "not " : ""}${show(expected)}
+Received: ${result ? show(result.value) : "no call"}`
+    };
+  }
+};
+
+// packages/testero/src/expect/assertion.ts
+var AssertionError = class extends Error {
+  name = "AssertionError";
+};
+var Assertion = class _Assertion {
+  /** Assertions made since the last reset, for `expect.assertions(n)`. */
+  static count = 0;
+  #received;
+  #context;
+  constructor(received, context = { isNot: false, promise: "" }) {
+    this.#received = received;
+    this.#context = context;
+  }
+  /** The same assertion, expecting the opposite. */
+  get not() {
+    return new _Assertion(this.#received, {
+      ...this.#context,
+      isNot: !this.#context.isNot
+    });
+  }
+  /** The assertion on what a promise resolves to, its matchers return promises. */
+  get resolves() {
+    return new _Assertion(this.#received, {
+      ...this.#context,
+      promise: "resolves"
+    });
+  }
+  /** The assertion on why a promise rejects, its matchers return promises. */
+  get rejects() {
+    return new _Assertion(this.#received, {
+      ...this.#context,
+      promise: "rejects"
+    });
+  }
+  /** Adds a matcher to every assertion, like `expect.extend`. */
+  static define(name, matcher) {
+    matchers[name] = matcher;
+    Object.defineProperty(_Assertion.prototype, name, {
+      configurable: true,
+      writable: true,
+      value: function check(...args) {
+        return this.#run(name, args, check);
+      }
+    });
+  }
+  /** Runs a matcher now, or once the promise settles for `.resolves` and `.rejects`. */
+  #run(name, args, caller) {
+    _Assertion.count++;
+    const origin = {};
+    Error.captureStackTrace(origin, caller);
+    const { promise } = this.#context;
+    if (!promise) return this.#check(name, this.#received, args, origin);
+    const settled = (value, resolved) => {
+      if (resolved === (promise === "resolves"))
+        return this.#check(name, value, args, origin);
+      throw _Assertion.#error(
+        `expect(received).${promise}.${name}()
+
+Received promise ${resolved ? "resolved" : "rejected"} instead of ${resolved ? "rejected" : "resolved"}
+${resolved ? "Resolved" : "Rejected"} to value: ${String(value)}`,
+        origin
+      );
+    };
+    if (!(this.#received instanceof Promise) && typeof this.#received?.then !== "function")
+      throw _Assertion.#error(
+        `expect(received).${promise}.${name}()
+
+Matcher error: received value must be a promise`,
+        origin
+      );
+    return Promise.resolve(this.#received).then(
+      (value) => settled(value, true),
+      (reason) => settled(reason, false)
+    );
+  }
+  #check(name, received, args, origin) {
+    const matcher = matchers[name];
+    let result;
+    try {
+      result = matcher.call(this.#context, received, ...args);
+    } catch (error) {
+      throw _Assertion.#error(
+        error instanceof Error ? error.message : String(error),
+        origin
+      );
+    }
+    if (result.pass === this.#context.isNot)
+      throw _Assertion.#error(result.message(), origin);
+  }
+  static #error(message, origin) {
+    const error = new AssertionError(message);
+    const frames = origin.stack?.split("\n").slice(1).join("\n");
+    error.stack = `${error.name}: ${message}${frames ? `
+${frames}` : ""}`;
+    return error;
+  }
+};
+for (const [name, matcher] of Object.entries(matchers))
+  Assertion.define(name, matcher);
+
+// packages/testero/src/expect/asymmetric.ts
+var Asymmetric = class {
+  sample;
+  /** Set for the `expect.not` variants, which match what the rule does not. */
+  inverse;
+  constructor(sample, inverse = false) {
+    this.sample = sample;
+    this.inverse = inverse;
+  }
+  asymmetricMatch(other) {
+    return this.matches(other) !== this.inverse;
+  }
+  get prefix() {
+    return this.inverse ? "Not" : "";
+  }
+};
+var Any = class extends Asymmetric {
+  matches(other) {
+    const primitives = /* @__PURE__ */ new Map([
+      [String, "string"],
+      [Number, "number"],
+      [Boolean, "boolean"],
+      [BigInt, "bigint"],
+      [Symbol, "symbol"],
+      [Function, "function"]
+    ]);
+    const type = primitives.get(this.sample);
+    if (type && typeof other === type) return true;
+    if (this.sample === Object)
+      return typeof other === "object" && other !== null;
+    return other instanceof this.sample;
+  }
+  toString() {
+    return `Any<${this.sample.name}>`;
+  }
+};
+var Anything = class extends Asymmetric {
+  matches(other) {
+    return other !== null && other !== void 0;
+  }
+  toString() {
+    return "Anything";
+  }
+};
+var ObjectContaining = class extends Asymmetric {
+  matches(other) {
+    if (typeof other !== "object" || other === null) return false;
+    return Reflect.ownKeys(this.sample).every(
+      (key) => key in other && Equality.equals(
+        this.sample[key],
+        other[key]
+      )
+    );
+  }
+  toString() {
+    return `Object${this.prefix}Containing ${Format.inline(this.sample)}`;
+  }
+};
+var ArrayContaining = class extends Asymmetric {
+  matches(other) {
+    return Array.isArray(other) && this.sample.every(
+      (item) => other.some((value) => Equality.equals(item, value))
+    );
+  }
+  toString() {
+    return `Array${this.prefix}Containing ${Format.inline(this.sample)}`;
+  }
+};
+var StringContaining = class extends Asymmetric {
+  matches(other) {
+    return typeof other === "string" && other.includes(this.sample);
+  }
+  toString() {
+    return `String${this.prefix}Containing ${JSON.stringify(this.sample)}`;
+  }
+};
+var StringMatching = class extends Asymmetric {
+  matches(other) {
+    return typeof other === "string" && this.sample.test(other);
+  }
+  toString() {
+    return `String${this.prefix}Matching ${this.sample}`;
+  }
+};
+var CloseTo = class extends Asymmetric {
+  #digits;
+  constructor(sample, digits = 2, inverse = false) {
+    super(sample, inverse);
+    this.#digits = digits;
+  }
+  matches(other) {
+    if (typeof other !== "number") return false;
+    if (other === this.sample) return true;
+    return Math.abs(this.sample - other) < 10 ** -this.#digits / 2;
+  }
+  toString() {
+    return `Number${this.prefix}CloseTo ${this.sample} (${this.#digits} digits)`;
+  }
+};
+
+// packages/testero/src/expect/expect.ts
+var negatable = (inverse) => ({
+  objectContaining: (object) => new ObjectContaining(object, inverse),
+  arrayContaining: (array) => new ArrayContaining(array, inverse),
+  stringContaining: (text) => new StringContaining(text, inverse),
+  stringMatching: (pattern) => new StringMatching(new RegExp(pattern), inverse),
+  closeTo: (number, digits) => new CloseTo(number, digits, inverse)
+});
+var Expect = class {
+  #expected;
+  #needed = false;
+  /** Starts the counts of a new test. */
+  reset() {
+    Assertion.count = 0;
+    this.#expected = void 0;
+    this.#needed = false;
+  }
+  /** Failures of `expect.assertions(n)` and `expect.hasAssertions()` after a test. */
+  verify() {
+    const count = Assertion.count;
+    if (this.#expected !== void 0 && count !== this.#expected)
+      return [
+        new AssertionError(
+          `expect.assertions(${this.#expected})
+
+Expected ${this.#expected} assertion${this.#expected === 1 ? "" : "s"} to be called but received ${count} assertion call${count === 1 ? "" : "s"}.`
+        )
+      ];
+    if (this.#needed && count === 0)
+      return [
+        new AssertionError(
+          "expect.hasAssertions()\n\nExpected at least one assertion to be called but received none."
+        )
+      ];
+    return [];
+  }
+  /** The function test files call as `expect`. */
+  create() {
+    const expect = (received) => new Assertion(received);
+    return Object.assign(expect, {
+      ...negatable(false),
+      not: negatable(true),
+      any: (type) => new Any(type),
+      anything: () => new Anything(void 0),
+      assertions: (count) => {
+        this.#expected = count;
+      },
+      hasAssertions: () => {
+        this.#needed = true;
+      },
+      extend: (added) => {
+        for (const [name, matcher] of Object.entries(added))
+          Assertion.define(name, matcher);
+      }
+    });
+  }
+};
+
+// packages/testero/src/globals.ts
+var Globals = class _Globals {
+  static key = /* @__PURE__ */ Symbol.for("testero");
+  static names = [
+    "describe",
+    "fdescribe",
+    "xdescribe",
+    "test",
+    "it",
+    "fit",
+    "xit",
+    "xtest",
+    "beforeAll",
+    "afterAll",
+    "beforeEach",
+    "afterEach",
+    "expect",
+    "testero",
+    "jest"
+  ];
+  /** The module the transformer injects, it reads the globals of the file being run. */
+  static source() {
+    return [
+      'const globals = globalThis[Symbol.for("testero")];',
+      ..._Globals.names.map(
+        (name) => `export const ${name} = globals.${name};`
+      )
+    ].join("\n");
+  }
+  /** Sets the globals for the next test file to import. */
+  static install(collector, expect, settings) {
+    const { describe, test } = collector;
+    const testero = {
+      fn: Mocks.fn,
+      spyOn: Mocks.spyOn,
+      isMockFunction: Mocks.isMockFunction,
+      clearAllMocks: () => {
+        Mocks.clearAll();
+        return testero;
+      },
+      resetAllMocks: () => {
+        Mocks.resetAll();
+        return testero;
+      },
+      restoreAllMocks: () => {
+        Mocks.restoreAll();
+        return testero;
+      },
+      /** Sets the timeout of the tests and hooks of this file. */
+      setTimeout: (timeout) => {
+        settings.timeout = timeout;
+        return testero;
+      }
+    };
+    globalThis[_Globals.key] = {
+      describe,
+      fdescribe: describe.only,
+      xdescribe: describe.skip,
+      test,
+      it: test,
+      fit: test.only,
+      xit: test.skip,
+      xtest: test.skip,
+      beforeAll: collector.hook("beforeAll"),
+      afterAll: collector.hook("afterAll"),
+      beforeEach: collector.hook("beforeEach"),
+      afterEach: collector.hook("afterEach"),
+      expect: expect.create(),
+      testero,
+      jest: testero
+    };
+  }
+};
+
+// packages/testero/src/reporter.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname2, isAbsolute, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/testero/src/transformer.ts
+import { mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, extname, join as join2, sep } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { build } from "esbuild";
+var Transformer = class _Transformer {
+  /** Packages test files import the globals from, like with Jest. */
+  static modules = ["@jest/globals", "@aljazmc/testero"];
+  static #loaders = {
+    ".js": "js",
+    ".cjs": "js",
+    ".mjs": "js",
+    ".jsx": "jsx",
+    ".ts": "ts",
+    ".cts": "ts",
+    ".mts": "ts",
+    ".tsx": "tsx"
+  };
+  /** Marks the resolutions the plugin asks esbuild for itself. */
+  static #own = /* @__PURE__ */ Symbol("testero");
+  /** Where compiled test files go, stack frames there are testero's own. */
+  static prefix = join2(tmpdir(), "testero-build-");
+  #directory = mkdtempSync(_Transformer.prefix);
+  #globals = join2(this.#directory, "globals.mjs");
+  #count = 0;
   constructor() {
-    this.greeting = "Hello, test runner!";
+    writeFileSync(this.#globals, Globals.source());
+  }
+  /** Bundles a test file, returns the URL of the module to import. */
+  async compile(file) {
+    const outfile = join2(this.#directory, `${++this.#count}.mjs`);
+    const { outputFiles } = await build({
+      entryPoints: [file],
+      outfile,
+      write: false,
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      target: `node${process.versions.node.split(".")[0]}`,
+      sourcemap: "inline",
+      sourcesContent: false,
+      inject: [this.#globals],
+      // CommonJS code in the bundle may require installed packages
+      banner: {
+        js: 'import { createRequire as __testeroRequire } from "node:module";\nconst require = __testeroRequire(import.meta.url);'
+      },
+      logLevel: "silent",
+      plugins: [this.#plugin()]
+    });
+    writeFileSync(outfile, outputFiles[0]?.text ?? "");
+    return pathToFileURL2(outfile).href;
+  }
+  /** Removes the compiled files. */
+  dispose() {
+    rmSync(this.#directory, { recursive: true, force: true });
   }
-}();
+  #plugin() {
+    return {
+      name: "testero",
+      setup: (build2) => {
+        build2.onResolve({ filter: /^[^./]/ }, async (args) => {
+          if (args.pluginData === _Transformer.#own) return void 0;
+          if (_Transformer.modules.includes(args.path))
+            return { path: this.#globals };
+          const resolved = await build2.resolve(args.path, {
+            kind: args.kind,
+            resolveDir: args.resolveDir,
+            pluginData: _Transformer.#own
+          });
+          if (resolved.errors.length > 0)
+            return { errors: resolved.errors };
+          if (resolved.external)
+            return { path: args.path, external: true };
+          if (!_Transformer.#installed(resolved.path))
+            return { path: resolved.path };
+          return {
+            path: args.kind === "require-call" ? resolved.path : pathToFileURL2(resolved.path).href,
+            external: true
+          };
+        });
+        build2.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+          if (_Transformer.#installed(args.path)) return void 0;
+          const values = {
+            url: pathToFileURL2(args.path).href,
+            filename: args.path,
+            dirname: dirname(args.path)
+          };
+          const contents = readFileSync2(args.path, "utf8").replace(
+            /\bimport\.meta\.(url|filename|dirname)\b/g,
+            (_, name) => JSON.stringify(values[name])
+          );
+          return {
+            contents,
+            loader: _Transformer.#loaders[extname(args.path)] ?? "js",
+            resolveDir: dirname(args.path)
+          };
+        });
+      }
+    };
+  }
+  static #installed(path) {
+    return path.split(sep).includes("node_modules");
+  }
+};
+
+// packages/testero/src/reporter.ts
+var Reporter = class _Reporter {
+  static #codes = {
+    bold: 1,
+    dim: 2,
+    inverse: 7,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    magenta: 35,
+    gray: 90
+  };
+  /** Stack frames from testero itself are left out of failures. */
+  static #own = dirname2(fileURLToPath(import.meta.url));
+  #root;
+  #verbose;
+  #color;
+  #write;
+  constructor(root, options = {}) {
+    this.#root = root;
+    this.#verbose = options.verbose ?? false;
+    this.#color = options.color ?? (process.stdout.isTTY === true && !process.env.NO_COLOR);
+    this.#write = options.write ?? ((text) => process.stdout.write(text));
+  }
+  static failed(result) {
+    return result.errors.length > 0 || result.results.some((test) => test.status === "failed");
+  }
+  /** The results of a test file, with the failures in detail. */
+  file(result) {
+    const failed = _Reporter.failed(result);
+    const status = failed ? this.#paint(" FAIL ", "inverse", "bold", "red") : this.#paint(" PASS ", "inverse", "bold", "green");
+    const slow = result.duration > 1e3 ? ` (${(result.duration / 1e3).toFixed(2)} s)` : "";
+    const lines = [`${status} ${result.file}${slow}`];
+    if (this.#verbose || failed) lines.push(...this.#tree(result.results));
+    for (const error of result.errors)
+      lines.push(
+        "",
+        this.#paint("  \u25CF Test suite failed to run", "bold", "red"),
+        "",
+        this.#error(error)
+      );
+    for (const test of result.results)
+      for (const error of test.errors)
+        lines.push(
+          "",
+          this.#paint(
+            `  \u25CF ${test.test.titles.join(" \u203A ")}`,
+            "bold",
+            "red"
+          ),
+          "",
+          this.#error(error)
+        );
+    this.#write(`${lines.join("\n")}
+${failed ? "\n" : ""}`);
+  }
+  /** Counts of test files and tests, and the time they took. */
+  summary(files, duration) {
+    const results = files.flatMap((file) => file.results);
+    const count = (status) => results.filter((result) => result.status === status).length;
+    const failedFiles = files.filter(_Reporter.failed).length;
+    const parts = (counts, total) => [
+      ...counts.filter(([amount]) => amount > 0).map(
+        ([amount, label, color]) => this.#paint(`${amount} ${label}`, "bold", color)
+      ),
+      `${total} total`
+    ].join(", ");
+    this.#write(
+      [
+        "",
+        `${this.#paint("Test Suites:", "bold")} ${parts(
+          [
+            [failedFiles, "failed", "red"],
+            [files.length - failedFiles, "passed", "green"]
+          ],
+          files.length
+        )}`,
+        `${this.#paint("Tests:", "bold")}       ${parts(
+          [
+            [count("failed"), "failed", "red"],
+            [count("skipped"), "skipped", "yellow"],
+            [count("todo"), "todo", "magenta"],
+            [count("passed"), "passed", "green"]
+          ],
+          results.length
+        )}`,
+        `${this.#paint("Time:", "bold")}        ${(duration / 1e3).toFixed(3)} s`,
+        ""
+      ].join("\n")
+    );
+  }
+  /** Explains that no test files were found. */
+  none(patterns) {
+    this.#write(
+      `No tests found${patterns.length > 0 ? `, no files match ${patterns.map((pattern) => JSON.stringify(pattern)).join(", ")}` : ""}.
+`
+    );
+  }
+  /** Tests indented under their suites, with a mark for how each went. */
+  #tree(results) {
+    const lines = [];
+    let previous = [];
+    for (const { test, status, duration } of results) {
+      const titles = test.suite.titles;
+      let shared = 0;
+      while (shared < titles.length && titles[shared] === previous[shared])
+        shared++;
+      for (const [depth, title] of titles.slice(shared).entries())
+        lines.push(`${"  ".repeat(shared + depth + 1)}${title}`);
+      previous = titles;
+      const marks = {
+        passed: this.#paint("\u2713", "green"),
+        failed: this.#paint("\u2715", "red"),
+        skipped: this.#paint("\u25CB skipped", "yellow"),
+        todo: this.#paint("\u270E todo", "magenta")
+      };
+      const time = duration >= 1 ? this.#paint(` (${Math.round(duration)} ms)`, "gray") : "";
+      lines.push(
+        `${"  ".repeat(titles.length + 1)}${marks[status]} ${test.name}${status === "passed" || status === "failed" ? time : ""}`
+      );
+    }
+    return lines;
+  }
+  /** The message of an error, the code where it happened and its stack. */
+  #error(error) {
+    const message = error instanceof AssertionError ? error.message : error instanceof Error ? `${error.name}: ${error.message}` : `thrown: ${Format.inline(error)}`;
+    const frames = error instanceof Error ? this.#frames(error.stack ?? "") : [];
+    const [first] = frames;
+    const sections = [this.#highlight(message)];
+    const code = first ? this.#code(first) : "";
+    if (code) sections.push(code);
+    if (frames.length > 0)
+      sections.push(
+        frames.map(
+          (frame) => this.#paint(
+            `at ${this.#path(frame.file)}:${frame.line}:${frame.column}`,
+            "gray"
+          )
+        ).join("\n")
+      );
+    return _Reporter.#indent(sections.join("\n\n"), "    ");
+  }
+  /** Colors expected values green and received values red, like Jest. */
+  #highlight(message) {
+    return message.split("\n").map((line) => {
+      if (/^(?:Expected|- )/.test(line))
+        return this.#paint(line, "green");
+      if (/^(?:Received|\+ )/.test(line))
+        return this.#paint(line, "red");
+      return line;
+    }).join("\n");
+  }
+  /** Stack frames of the code under test, without Node's and testero's own. */
+  #frames(stack) {
+    const frames = [];
+    for (const line of stack.split("\n")) {
+      const match = /^\s+at (?:.*?\()?(.+?):(\d+):(\d+)\)?$/.exec(line);
+      if (!match) continue;
+      let file = match[1];
+      if (file.startsWith("file://")) file = fileURLToPath(file);
+      if (!isAbsolute(file) || file.includes("node_modules") || file.startsWith(_Reporter.#own) || file.startsWith(Transformer.prefix))
+        continue;
+      frames.push({
+        file,
+        line: Number(match[2]),
+        column: Number(match[3])
+      });
+    }
+    return frames;
+  }
+  /** The lines around a position, with a mark under it. */
+  #code({ file, line, column }) {
+    if (!existsSync2(file)) return "";
+    const lines = readFileSync3(file, "utf8").split(/\r?\n/);
+    const first = Math.max(1, line - 2);
+    const last = Math.min(lines.length, line + 2);
+    const width = String(last).length;
+    const out = [];
+    for (let number = first; number <= last; number++) {
+      const gutter = `${String(number).padStart(width)} |`;
+      const text = lines[number - 1] ?? "";
+      if (number === line) {
+        out.push(
+          `${this.#paint(">", "red", "bold")} ${gutter} ${text}`
+        );
+        out.push(
+          `  ${" ".repeat(width)} | ${" ".repeat(column - 1)}${this.#paint("^", "red", "bold")}`
+        );
+      } else out.push(this.#paint(`  ${gutter} ${text}`, "dim"));
+    }
+    return out.join("\n");
+  }
+  #path(file) {
+    const path = relative(this.#root, file);
+    return path.startsWith("..") ? file : path;
+  }
+  #paint(text, ...styles) {
+    if (!this.#color) return text;
+    const codes = styles.map((style) => _Reporter.#codes[style]).join(";");
+    return `\x1B[${codes}m${text}\x1B[0m`;
+  }
+  static #indent(text, indent) {
+    return text.split("\n").map((line) => line ? indent + line : line).join("\n");
+  }
+};
+
+// packages/testero/src/runner.ts
+var Runner = class _Runner {
+  #settings;
+  #focused = false;
+  constructor(settings) {
+    this.#settings = settings;
+  }
+  /** Results of every test, and errors of `afterAll` hooks that belong to no test. */
+  async run(root) {
+    this.#focused = [...root.tests()].some((test) => test.focused);
+    const results = [];
+    const errors = [];
+    await this.#suite(root, [], results, errors);
+    return { results, errors };
+  }
+  /** Whether a test runs: not skipped, focused when others are, matching the name pattern. */
+  runs(test) {
+    return !test.skipped && (!this.#focused || test.focused) && (this.#settings.namePattern?.test(test.fullName) ?? true);
+  }
+  async #suite(suite, failed, results, errors) {
+    if (![...suite.tests()].some((test) => this.runs(test))) {
+      for (const test of suite.tests()) results.push(_Runner.#skip(test));
+      return;
+    }
+    const setup = [...failed];
+    if (setup.length === 0)
+      for (const hook of suite.hooks.beforeAll) {
+        const error = await this.#call(hook.body, hook.timeout);
+        if (error !== void 0) {
+          setup.push(error);
+          break;
+        }
+      }
+    for (const child of suite.children)
+      if (child instanceof Suite)
+        await this.#suite(child, setup, results, errors);
+      else await this.#test(child, setup, results);
+    if (failed.length === 0)
+      for (const hook of suite.hooks.afterAll) {
+        const error = await this.#call(hook.body, hook.timeout);
+        if (error !== void 0) errors.push(error);
+      }
+  }
+  async #test(test, failed, results) {
+    if (!this.runs(test)) {
+      results.push(_Runner.#skip(test));
+      return;
+    }
+    const start = performance.now();
+    const errors = [...failed];
+    if (errors.length === 0) {
+      this.#settings.beforeTest?.(test);
+      for (const hook of _Runner.#hooks(test, "beforeEach")) {
+        const error = await this.#call(hook.body, hook.timeout);
+        if (error !== void 0) {
+          errors.push(error);
+          break;
+        }
+      }
+      if (errors.length === 0 && test.body) {
+        const error = await this.#call(test.body, test.timeout);
+        if (error !== void 0) errors.push(error);
+      }
+      for (const hook of _Runner.#hooks(test, "afterEach").reverse()) {
+        const error = await this.#call(hook.body, hook.timeout);
+        if (error !== void 0) errors.push(error);
+      }
+      errors.push(...this.#settings.afterTest?.(test) ?? []);
+    }
+    results.push({
+      test,
+      status: errors.length > 0 ? "failed" : "passed",
+      duration: performance.now() - start,
+      errors
+    });
+  }
+  /** Hooks of a kind from the outermost suite to the test's own. */
+  static #hooks(test, kind) {
+    return test.suite.path.flatMap((suite) => suite.hooks[kind]);
+  }
+  static #skip(test) {
+    return {
+      test,
+      status: test.mode === "todo" ? "todo" : "skipped",
+      duration: 0,
+      errors: []
+    };
+  }
+  /** Calls a body within its timeout, returning what it threw, or undefined. */
+  async #call(body, timeout = this.#settings.timeout) {
+    let timer;
+    const expired = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(
+          new Error(
+            `Exceeded timeout of ${timeout} ms for a test or hook.`
+          )
+        ),
+        timeout
+      );
+    });
+    try {
+      await Promise.race([_Runner.#invoke(body), expired]);
+      return void 0;
+    } catch (error) {
+      return error ?? new Error(`${String(error)} was thrown`);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Runs a body as a promise, with a `done` callback when it takes one. */
+  static #invoke(body) {
+    if (body.length === 0)
+      return new Promise((resolve) => resolve(body(() => {
+      })));
+    return new Promise((resolve, reject) => {
+      body(
+        (error) => error === void 0 ? resolve(void 0) : reject(error)
+      );
+    });
+  }
+};
+
+// packages/testero/src/testero.ts
+var Testero = class {
+  #config;
+  #options;
+  #reporter;
+  /** Errors thrown outside of tests, like from a forgotten timer. */
+  #stray = [];
+  constructor(config, options, reporter = new Reporter(config.root, { verbose: options.verbose })) {
+    this.#config = config;
+    this.#options = options;
+    this.#reporter = reporter;
+  }
+  /** The test files to run, relative to the root. */
+  files() {
+    const includes = new Includes(this.#options.testMatch);
+    const patterns = this.#options.patterns.map(
+      (pattern) => new RegExp(pattern)
+    );
+    return [...this.#config.files()].filter(
+      (file) => includes.matches(file) && (patterns.length === 0 || patterns.some((pattern) => pattern.test(file)))
+    ).sort();
+  }
+  /** Runs every test file, returns whether all of them passed. */
+  async run() {
+    const start = performance.now();
+    const files = this.files();
+    if (files.length === 0) {
+      this.#reporter.none(this.#options.patterns);
+      return this.#options.passWithNoTests;
+    }
+    process.setSourceMapsEnabled(true);
+    const stray = (error) => this.#stray.push(error);
+    process.on("uncaughtException", stray);
+    process.on("unhandledRejection", stray);
+    const transformer = new Transformer();
+    const results = [];
+    try {
+      for (const file of files) {
+        const result = await this.#file(file, transformer);
+        results.push(result);
+        this.#reporter.file(result);
+        if (this.#options.bail && Reporter.failed(result)) break;
+      }
+    } finally {
+      transformer.dispose();
+      process.off("uncaughtException", stray);
+      process.off("unhandledRejection", stray);
+    }
+    this.#reporter.summary(results, performance.now() - start);
+    return !results.some(Reporter.failed);
+  }
+  async #file(file, transformer) {
+    const start = performance.now();
+    const finish = (results2, errors2) => {
+      errors2.push(...this.#stray.splice(0));
+      Mocks.restoreAll();
+      Mocks.forget();
+      return {
+        file,
+        results: results2,
+        errors: errors2,
+        duration: performance.now() - start
+      };
+    };
+    const collector = new Collector();
+    const expect = new Expect();
+    const settings = {
+      timeout: this.#options.testTimeout,
+      namePattern: this.#options.namePattern,
+      beforeTest: () => {
+        expect.reset();
+        if (this.#options.restoreMocks) Mocks.restoreAll();
+        else if (this.#options.resetMocks) Mocks.resetAll();
+        else if (this.#options.clearMocks) Mocks.clearAll();
+      },
+      afterTest: () => expect.verify()
+    };
+    Globals.install(collector, expect, settings);
+    try {
+      await import(await transformer.compile(join3(this.#config.root, file)));
+    } catch (error) {
+      return finish([], [error]);
+    } finally {
+      collector.close();
+    }
+    if ([...collector.root.tests()].length === 0)
+      return finish(
+        [],
+        [new Error("Your test suite must contain at least one test.")]
+      );
+    const { results, errors } = await new Runner(settings).run(
+      collector.root
+    );
+    return finish(results, errors);
+  }
+};
 
 // packages/testero/src/index.ts
-console.log(testero_default.greeting);
+try {
+  const args = new Arguments(process.argv.slice(2));
+  if (args.help) process.stdout.write(Arguments.usage);
+  else {
+    const config = await Config.load("testero", config_default);
+    const testero = new Testero(config, args.options(config.rules));
+    if (args.listTests)
+      for (const file of testero.files()) console.log(file);
+    else if (!await testero.run()) process.exitCode = 1;
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+}