@gjsify/unit 0.3.13 → 0.3.14

package/lib/esm/index.js

@@ -1,7 +1,9 @@
+import { spy } from "./spy.js";
 import "@girs/gjs";
-export * from "./spy.js";
 import nodeAssert from "node:assert";
 import { quitMainLoop } from "@gjsify/utils/main-loop";
+
+//#region src/index.ts
 const mainloop = globalThis?.imports?.mainloop;
 let countTestsOverall = 0;
 let countTestsFailed = 0;
@@ -11,47 +13,48 @@ let runStartTime = 0;
 let currentSuite = "";
 let testErrors = [];
 const DEFAULT_TIMEOUT_CONFIG = {
-  testTimeout: 5e3,
-  suiteTimeout: 3e4,
-  runTimeout: 12e4
+	testTimeout: 5e3,
+	suiteTimeout: 3e4,
+	runTimeout: 12e4
 };
 let timeoutConfig = { ...DEFAULT_TIMEOUT_CONFIG };
-class TimeoutError extends Error {
-  constructor(label, timeoutMs) {
-    super(`Timeout: "${label}" exceeded ${timeoutMs}ms`);
-    this.name = "TimeoutError";
-  }
-}
+var TimeoutError = class extends Error {
+	constructor(label, timeoutMs) {
+		super(`Timeout: "${label}" exceeded ${timeoutMs}ms`);
+		this.name = "TimeoutError";
+	}
+};
 async function withTimeout(fn, timeoutMs, label) {
-  if (timeoutMs <= 0) return fn();
-  let timeoutId;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(() => reject(new TimeoutError(label, timeoutMs)), timeoutMs);
-  });
-  const fnPromise = Promise.resolve(fn());
-  fnPromise.catch(() => {
-  });
-  try {
-    return await Promise.race([fnPromise, timeoutPromise]);
-  } finally {
-    clearTimeout(timeoutId);
-  }
+	if (timeoutMs <= 0) return fn();
+	let timeoutId;
+	const timeoutPromise = new Promise((_, reject) => {
+		timeoutId = setTimeout(() => reject(new TimeoutError(label, timeoutMs)), timeoutMs);
+	});
+	const fnPromise = Promise.resolve(fn());
+	fnPromise.catch(() => {});
+	try {
+		return await Promise.race([fnPromise, timeoutPromise]);
+	} finally {
+		clearTimeout(timeoutId);
+	}
 }
 const configure = (overrides) => {
-  timeoutConfig = { ...timeoutConfig, ...overrides };
+	timeoutConfig = {
+		...timeoutConfig,
+		...overrides
+	};
 };
 function applyEnvOverrides() {
-  try {
-    const env = globalThis.process?.env;
-    if (!env) return;
-    const t = parseInt(env.GJSIFY_TEST_TIMEOUT, 10);
-    if (!isNaN(t) && t >= 0) timeoutConfig.testTimeout = t;
-    const s = parseInt(env.GJSIFY_SUITE_TIMEOUT, 10);
-    if (!isNaN(s) && s >= 0) timeoutConfig.suiteTimeout = s;
-    const r = parseInt(env.GJSIFY_RUN_TIMEOUT, 10);
-    if (!isNaN(r) && r >= 0) timeoutConfig.runTimeout = r;
-  } catch (_e) {
-  }
+	try {
+		const env = globalThis.process?.env;
+		if (!env) return;
+		const t = parseInt(env.GJSIFY_TEST_TIMEOUT, 10);
+		if (!isNaN(t) && t >= 0) timeoutConfig.testTimeout = t;
+		const s = parseInt(env.GJSIFY_SUITE_TIMEOUT, 10);
+		if (!isNaN(s) && s >= 0) timeoutConfig.suiteTimeout = s;
+		const r = parseInt(env.GJSIFY_RUN_TIMEOUT, 10);
+		if (!isNaN(r) && r >= 0) timeoutConfig.runTimeout = r;
+	} catch (_e) {}
 }
 const RED = "\x1B[31m";
 const GREEN = "\x1B[32m";
@@ -60,585 +63,472 @@ const GRAY = "\x1B[90m";
 const RESET = "\x1B[39m";
 const now = () => globalThis.performance?.now?.() ?? Date.now();
 const formatDuration = (ms) => {
-  if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
-  if (ms >= 100) return `${Math.round(ms)}ms`;
-  return `${ms.toFixed(1)}ms`;
+	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+	if (ms >= 100) return `${Math.round(ms)}ms`;
+	return `${ms.toFixed(1)}ms`;
 };
 const _isGjsProcess = typeof globalThis.process?.versions?.gjs === "string";
 const print = !_isGjsProcess && typeof globalThis.document !== "undefined" ? console.log : globalThis.print || console.log;
-class MatcherFactory {
-  constructor(actualValue, positive, negated) {
-    this.actualValue = actualValue;
-    this.positive = positive;
-    if (negated) {
-      this.not = negated;
-    } else {
-      this.not = new MatcherFactory(actualValue, !positive, this);
-    }
-  }
-  actualValue;
-  positive;
-  not;
-  triggerResult(success, msg) {
-    if (success && !this.positive || !success && this.positive) {
-      const error = new Error(msg);
-      error.__testFailureCounted = true;
-      ++countTestsFailed;
-      throw error;
-    }
-  }
-  to(callback) {
-    this.triggerResult(
-      callback(this.actualValue),
-      `      Expected callback to validate`
-    );
-  }
-  toBe(expectedValue) {
-    this.triggerResult(
-      this.actualValue === expectedValue,
-      `      Expected values to match using ===
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toEqual(expectedValue) {
-    this.triggerResult(
-      this.actualValue == expectedValue,
-      `      Expected values to match using ==
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toStrictEqual(expectedValue) {
-    let success = true;
-    let errorMessage = "";
-    try {
-      nodeAssert.deepStrictEqual(this.actualValue, expectedValue);
-    } catch (e) {
-      success = false;
-      errorMessage = e.message || "";
-    }
-    this.triggerResult(
-      success,
-      `      Expected values to be deeply strictly equal
-      Expected: ${JSON.stringify(expectedValue)}
-      Actual: ${JSON.stringify(this.actualValue)}` + (errorMessage ? `
-      ${errorMessage}` : "")
-    );
-  }
-  toEqualArray(expectedValue) {
-    let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
-    for (let i = 0; i < this.actualValue.length; i++) {
-      const actualVal = this.actualValue[i];
-      const expectedVal = expectedValue[i];
-      success = actualVal == expectedVal;
-      if (!success) break;
-    }
-    this.triggerResult(
-      success,
-      `      Expected array items to match using ==
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toBeInstanceOf(expectedType) {
-    this.triggerResult(
-      this.actualValue instanceof expectedType,
-      `      Expected value to be instance of ${expectedType.name || expectedType}
-      Actual: ${this.actualValue?.constructor?.name || typeof this.actualValue}`
-    );
-  }
-  toHaveLength(expectedLength) {
-    const actualLength = this.actualValue?.length;
-    this.triggerResult(
-      actualLength === expectedLength,
-      `      Expected length: ${expectedLength}
-      Actual length: ${actualLength}`
-    );
-  }
-  toMatch(expectedValue) {
-    if (typeof this.actualValue.match !== "function") {
-      throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
-    }
-    this.triggerResult(
-      !!this.actualValue.match(expectedValue),
-      "      Expected values to match using regular expression\n      Expression: " + expectedValue + "\n      Actual: " + this.actualValue
-    );
-  }
-  toBeDefined() {
-    this.triggerResult(
-      typeof this.actualValue !== "undefined",
-      `      Expected value to be defined`
-    );
-  }
-  toBeUndefined() {
-    this.triggerResult(
-      typeof this.actualValue === "undefined",
-      `      Expected value to be undefined`
-    );
-  }
-  toBeNull() {
-    this.triggerResult(
-      this.actualValue === null,
-      `      Expected value to be null`
-    );
-  }
-  toBeTruthy() {
-    this.triggerResult(
-      this.actualValue,
-      `      Expected value to be truthy`
-    );
-  }
-  toBeFalsy() {
-    this.triggerResult(
-      !this.actualValue,
-      `      Expected value to be falsy`
-    );
-  }
-  toContain(needle) {
-    const value = this.actualValue;
-    let contains;
-    if (typeof value === "string") {
-      contains = value.includes(String(needle));
-    } else if (value instanceof Array) {
-      contains = value.indexOf(needle) !== -1;
-    } else {
-      contains = false;
-    }
-    this.triggerResult(
-      contains,
-      `      Expected ` + value + ` to contain ` + needle
-    );
-  }
-  toBeLessThan(greaterValue) {
-    this.triggerResult(
-      this.actualValue < greaterValue,
-      `      Expected ` + this.actualValue + ` to be less than ` + greaterValue
-    );
-  }
-  toBeGreaterThan(smallerValue) {
-    this.triggerResult(
-      this.actualValue > smallerValue,
-      `      Expected ` + this.actualValue + ` to be greater than ` + smallerValue
-    );
-  }
-  toBeGreaterThanOrEqual(value) {
-    this.triggerResult(
-      this.actualValue >= value,
-      `      Expected ${this.actualValue} to be greater than or equal to ${value}`
-    );
-  }
-  toBeLessThanOrEqual(value) {
-    this.triggerResult(
-      this.actualValue <= value,
-      `      Expected ${this.actualValue} to be less than or equal to ${value}`
-    );
-  }
-  toBeCloseTo(expectedValue, precision) {
-    const shiftHelper = Math.pow(10, precision);
-    this.triggerResult(
-      Math.round(this.actualValue * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper,
-      `      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue
-    );
-  }
-  toThrow(expected) {
-    let errorMessage = "";
-    let didThrow = false;
-    let typeMatch = true;
-    let messageMatch = true;
-    try {
-      this.actualValue();
-      didThrow = false;
-    } catch (e) {
-      errorMessage = e.message || "";
-      didThrow = true;
-      if (typeof expected === "function") {
-        typeMatch = e instanceof expected;
-      } else if (typeof expected === "string") {
-        messageMatch = errorMessage.includes(expected);
-      } else if (expected instanceof RegExp) {
-        messageMatch = expected.test(errorMessage);
-      }
-    }
-    const functionName = this.actualValue.name || typeof this.actualValue === "function" ? "[anonymous function]" : this.actualValue.toString();
-    this.triggerResult(
-      didThrow,
-      `      Expected ${functionName} to ${this.positive ? "throw" : "not throw"} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ""}`
-    );
-    if (typeof expected === "function") {
-      this.triggerResult(
-        typeMatch,
-        `      Expected Error type '${expected.name}', but the error is not an instance of it`
-      );
-    } else if (expected !== void 0) {
-      this.triggerResult(
-        messageMatch,
-        `      Expected error message to match ${expected}
-      Actual message: "${errorMessage}"`
-      );
-    }
-  }
-  async toReject(expected) {
-    let didReject = false;
-    let errorMessage = "";
-    let typeMatch = true;
-    let messageMatch = true;
-    try {
-      await this.actualValue;
-      didReject = false;
-    } catch (e) {
-      didReject = true;
-      errorMessage = e?.message || String(e);
-      if (typeof expected === "function") {
-        typeMatch = e instanceof expected;
-      } else if (typeof expected === "string") {
-        messageMatch = errorMessage.includes(expected);
-      } else if (expected instanceof RegExp) {
-        messageMatch = expected.test(errorMessage);
-      }
-    }
-    this.triggerResult(
-      didReject,
-      `      Expected promise to ${this.positive ? "reject" : "resolve"}${!this.positive && errorMessage ? `, but it rejected with "${errorMessage}"` : ""}`
-    );
-    if (didReject && typeof expected === "function") {
-      this.triggerResult(
-        typeMatch,
-        `      Expected rejection type '${expected.name}', but the error is not an instance of it`
-      );
-    } else if (didReject && expected !== void 0) {
-      this.triggerResult(
-        messageMatch,
-        `      Expected rejection message to match ${expected}
-      Actual message: "${errorMessage}"`
-      );
-    }
-  }
-  async toResolve() {
-    let didResolve = false;
-    let errorMessage = "";
-    try {
-      await this.actualValue;
-      didResolve = true;
-    } catch (e) {
-      didResolve = false;
-      errorMessage = e?.message || String(e);
-    }
-    this.triggerResult(
-      didResolve,
-      `      Expected promise to ${this.positive ? "resolve" : "reject"}${!didResolve ? `, but it rejected with "${errorMessage}"` : ""}`
-    );
-  }
-}
+var MatcherFactory = class MatcherFactory {
+	not;
+	constructor(actualValue, positive, negated) {
+		this.actualValue = actualValue;
+		this.positive = positive;
+		if (negated) {
+			this.not = negated;
+		} else {
+			this.not = new MatcherFactory(actualValue, !positive, this);
+		}
+	}
+	triggerResult(success, msg) {
+		if (success && !this.positive || !success && this.positive) {
+			const error = new Error(msg);
+			error.__testFailureCounted = true;
+			++countTestsFailed;
+			throw error;
+		}
+	}
+	to(callback) {
+		this.triggerResult(callback(this.actualValue), `      Expected callback to validate`);
+	}
+	toBe(expectedValue) {
+		this.triggerResult(this.actualValue === expectedValue, `      Expected values to match using ===\n` + `      Expected: ${expectedValue} (${typeof expectedValue})\n` + `      Actual: ${this.actualValue} (${typeof this.actualValue})`);
+	}
+	toEqual(expectedValue) {
+		this.triggerResult(this.actualValue == expectedValue, `      Expected values to match using ==\n` + `      Expected: ${expectedValue} (${typeof expectedValue})\n` + `      Actual: ${this.actualValue} (${typeof this.actualValue})`);
+	}
+	toStrictEqual(expectedValue) {
+		let success = true;
+		let errorMessage = "";
+		try {
+			nodeAssert.deepStrictEqual(this.actualValue, expectedValue);
+		} catch (e) {
+			success = false;
+			errorMessage = e.message || "";
+		}
+		this.triggerResult(success, `      Expected values to be deeply strictly equal\n` + `      Expected: ${JSON.stringify(expectedValue)}\n` + `      Actual: ${JSON.stringify(this.actualValue)}` + (errorMessage ? `\n      ${errorMessage}` : ""));
+	}
+	toEqualArray(expectedValue) {
+		let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
+		for (let i = 0; i < this.actualValue.length; i++) {
+			const actualVal = this.actualValue[i];
+			const expectedVal = expectedValue[i];
+			success = actualVal == expectedVal;
+			if (!success) break;
+		}
+		this.triggerResult(success, `      Expected array items to match using ==\n` + `      Expected: ${expectedValue} (${typeof expectedValue})\n` + `      Actual: ${this.actualValue} (${typeof this.actualValue})`);
+	}
+	toBeInstanceOf(expectedType) {
+		this.triggerResult(this.actualValue instanceof expectedType, `      Expected value to be instance of ${expectedType.name || expectedType}\n` + `      Actual: ${this.actualValue?.constructor?.name || typeof this.actualValue}`);
+	}
+	toHaveLength(expectedLength) {
+		const actualLength = this.actualValue?.length;
+		this.triggerResult(actualLength === expectedLength, `      Expected length: ${expectedLength}\n` + `      Actual length: ${actualLength}`);
+	}
+	toMatch(expectedValue) {
+		if (typeof this.actualValue.match !== "function") {
+			throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
+		}
+		this.triggerResult(!!this.actualValue.match(expectedValue), "      Expected values to match using regular expression\n" + "      Expression: " + expectedValue + "\n" + "      Actual: " + this.actualValue);
+	}
+	toBeDefined() {
+		this.triggerResult(typeof this.actualValue !== "undefined", `      Expected value to be defined`);
+	}
+	toBeUndefined() {
+		this.triggerResult(typeof this.actualValue === "undefined", `      Expected value to be undefined`);
+	}
+	toBeNull() {
+		this.triggerResult(this.actualValue === null, `      Expected value to be null`);
+	}
+	toBeTruthy() {
+		this.triggerResult(this.actualValue, `      Expected value to be truthy`);
+	}
+	toBeFalsy() {
+		this.triggerResult(!this.actualValue, `      Expected value to be falsy`);
+	}
+	toContain(needle) {
+		const value = this.actualValue;
+		let contains;
+		if (typeof value === "string") {
+			contains = value.includes(String(needle));
+		} else if (value instanceof Array) {
+			contains = value.indexOf(needle) !== -1;
+		} else {
+			contains = false;
+		}
+		this.triggerResult(contains, `      Expected ` + value + ` to contain ` + needle);
+	}
+	toBeLessThan(greaterValue) {
+		this.triggerResult(this.actualValue < greaterValue, `      Expected ` + this.actualValue + ` to be less than ` + greaterValue);
+	}
+	toBeGreaterThan(smallerValue) {
+		this.triggerResult(this.actualValue > smallerValue, `      Expected ` + this.actualValue + ` to be greater than ` + smallerValue);
+	}
+	toBeGreaterThanOrEqual(value) {
+		this.triggerResult(this.actualValue >= value, `      Expected ${this.actualValue} to be greater than or equal to ${value}`);
+	}
+	toBeLessThanOrEqual(value) {
+		this.triggerResult(this.actualValue <= value, `      Expected ${this.actualValue} to be less than or equal to ${value}`);
+	}
+	toBeCloseTo(expectedValue, precision) {
+		const shiftHelper = Math.pow(10, precision);
+		this.triggerResult(Math.round(this.actualValue * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper, `      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue);
+	}
+	toThrow(expected) {
+		let errorMessage = "";
+		let didThrow = false;
+		let typeMatch = true;
+		let messageMatch = true;
+		try {
+			this.actualValue();
+			didThrow = false;
+		} catch (e) {
+			errorMessage = e.message || "";
+			didThrow = true;
+			if (typeof expected === "function") {
+				typeMatch = e instanceof expected;
+			} else if (typeof expected === "string") {
+				messageMatch = errorMessage.includes(expected);
+			} else if (expected instanceof RegExp) {
+				messageMatch = expected.test(errorMessage);
+			}
+		}
+		const functionName = this.actualValue.name || typeof this.actualValue === "function" ? "[anonymous function]" : this.actualValue.toString();
+		this.triggerResult(didThrow, `      Expected ${functionName} to ${this.positive ? "throw" : "not throw"} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ""}`);
+		if (typeof expected === "function") {
+			this.triggerResult(typeMatch, `      Expected Error type '${expected.name}', but the error is not an instance of it`);
+		} else if (expected !== undefined) {
+			this.triggerResult(messageMatch, `      Expected error message to match ${expected}\n` + `      Actual message: "${errorMessage}"`);
+		}
+	}
+	async toReject(expected) {
+		let didReject = false;
+		let errorMessage = "";
+		let typeMatch = true;
+		let messageMatch = true;
+		try {
+			await this.actualValue;
+			didReject = false;
+		} catch (e) {
+			didReject = true;
+			errorMessage = e?.message || String(e);
+			if (typeof expected === "function") {
+				typeMatch = e instanceof expected;
+			} else if (typeof expected === "string") {
+				messageMatch = errorMessage.includes(expected);
+			} else if (expected instanceof RegExp) {
+				messageMatch = expected.test(errorMessage);
+			}
+		}
+		this.triggerResult(didReject, `      Expected promise to ${this.positive ? "reject" : "resolve"}${!this.positive && errorMessage ? `, but it rejected with "${errorMessage}"` : ""}`);
+		if (didReject && typeof expected === "function") {
+			this.triggerResult(typeMatch, `      Expected rejection type '${expected.name}', but the error is not an instance of it`);
+		} else if (didReject && expected !== undefined) {
+			this.triggerResult(messageMatch, `      Expected rejection message to match ${expected}\n` + `      Actual message: "${errorMessage}"`);
+		}
+	}
+	async toResolve() {
+		let didResolve = false;
+		let errorMessage = "";
+		try {
+			await this.actualValue;
+			didResolve = true;
+		} catch (e) {
+			didResolve = false;
+			errorMessage = e?.message || String(e);
+		}
+		this.triggerResult(didResolve, `      Expected promise to ${this.positive ? "resolve" : "reject"}${!didResolve ? `, but it rejected with "${errorMessage}"` : ""}`);
+	}
+};
 const describe = async function(moduleName, callback, options) {
-  const suiteTimeoutMs = typeof options === "number" ? options : options?.timeout ?? timeoutConfig.suiteTimeout;
-  print("\n" + moduleName);
-  const prevSuite = currentSuite;
-  currentSuite = moduleName;
-  const t0 = now();
-  try {
-    await withTimeout(callback, suiteTimeoutMs, `describe: ${moduleName}`);
-  } catch (e) {
-    if (e instanceof TimeoutError) {
-      ++countTestsFailed;
-      print(`  ${RED}\u23F1 Suite timed out: ${e.message}${RESET}`);
-    } else {
-      throw e;
-    }
-  }
-  currentSuite = prevSuite;
-  const duration = now() - t0;
-  print(`  ${GRAY}\u21B3 ${formatDuration(duration)}${RESET}`);
-  beforeEachCb = null;
-  afterEachCb = null;
+	const suiteTimeoutMs = typeof options === "number" ? options : options?.timeout ?? timeoutConfig.suiteTimeout;
+	print("\n" + moduleName);
+	const prevSuite = currentSuite;
+	currentSuite = moduleName;
+	const t0 = now();
+	try {
+		await withTimeout(callback, suiteTimeoutMs, `describe: ${moduleName}`);
+	} catch (e) {
+		if (e instanceof TimeoutError) {
+			++countTestsFailed;
+			print(`  ${RED}⏱ Suite timed out: ${e.message}${RESET}`);
+		} else {
+			throw e;
+		}
+	}
+	currentSuite = prevSuite;
+	const duration = now() - t0;
+	print(`  ${GRAY}↳ ${formatDuration(duration)}${RESET}`);
+	beforeEachCb = null;
+	afterEachCb = null;
 };
 describe.skip = async function(moduleName, _callback) {
-  ++countTestsIgnored;
-  print(`
-${BLUE}- ${moduleName} (skipped)${RESET}`);
+	++countTestsIgnored;
+	print(`\n${BLUE}- ${moduleName} (skipped)${RESET}`);
 };
 const hasDisplay = () => {
-  const env = globalThis.process?.env;
-  if (env) {
-    return !!(env.DISPLAY || env.WAYLAND_DISPLAY);
-  }
-  try {
-    const GLib = globalThis?.imports?.gi?.GLib;
-    if (GLib) {
-      return !!(GLib.getenv("DISPLAY") || GLib.getenv("WAYLAND_DISPLAY"));
-    }
-  } catch (_) {
-  }
-  return false;
+	const env = globalThis.process?.env;
+	if (env) {
+		return !!(env.DISPLAY || env.WAYLAND_DISPLAY);
+	}
+	try {
+		const GLib = globalThis?.imports?.gi?.GLib;
+		if (GLib) {
+			return !!(GLib.getenv("DISPLAY") || GLib.getenv("WAYLAND_DISPLAY"));
+		}
+	} catch (_) {}
+	return false;
 };
 const runtimeMatch = async function(onRuntime, version) {
-  if (onRuntime.includes("Display")) {
-    return { matched: hasDisplay() };
-  }
-  const currRuntime = await getRuntime();
-  const foundRuntime = onRuntime.find((r) => currRuntime.includes(r));
-  if (!foundRuntime) {
-    return {
-      matched: false
-    };
-  }
-  if (typeof version === "string") {
-    if (!currRuntime.includes(version)) {
-      return {
-        matched: false
-      };
-    }
-  }
-  return {
-    matched: true,
-    runtime: foundRuntime,
-    version
-  };
+	if (onRuntime.includes("Display")) {
+		return { matched: hasDisplay() };
+	}
+	const currRuntime = await getRuntime();
+	const foundRuntime = onRuntime.find((r) => currRuntime.includes(r));
+	if (!foundRuntime) {
+		return { matched: false };
+	}
+	if (typeof version === "string") {
+		if (!currRuntime.includes(version)) {
+			return { matched: false };
+		}
+	}
+	return {
+		matched: true,
+		runtime: foundRuntime,
+		version
+	};
 };
+/** E.g on('Deno', () {  it(...) }) */
 const on = async function(onRuntime, version, callback) {
-  if (typeof onRuntime === "string") {
-    onRuntime = [onRuntime];
-  }
-  if (typeof version === "function") {
-    callback = version;
-    version = void 0;
-  }
-  const { matched } = await runtimeMatch(onRuntime, version);
-  if (!matched) {
-    ++countTestsIgnored;
-    return;
-  }
-  print(`
-On ${onRuntime.join(", ")}${version ? " " + version : ""}`);
-  await callback();
+	if (typeof onRuntime === "string") {
+		onRuntime = [onRuntime];
+	}
+	if (typeof version === "function") {
+		callback = version;
+		version = undefined;
+	}
+	const { matched } = await runtimeMatch(onRuntime, version);
+	if (!matched) {
+		++countTestsIgnored;
+		return;
+	}
+	print(`\nOn ${onRuntime.join(", ")}${version ? " " + version : ""}`);
+	await callback();
 };
 let beforeEachCb;
 let afterEachCb;
 const beforeEach = function(callback) {
-  beforeEachCb = callback;
+	beforeEachCb = callback;
 };
 const afterEach = function(callback) {
-  afterEachCb = callback;
+	afterEachCb = callback;
 };
 const it = async function(expectation, callback, options) {
-  const timeoutMs = typeof options === "number" ? options : options?.timeout ?? timeoutConfig.testTimeout;
-  const t0 = now();
-  try {
-    if (typeof beforeEachCb === "function") {
-      await beforeEachCb();
-    }
-    await withTimeout(callback, timeoutMs, expectation);
-    if (typeof afterEachCb === "function") {
-      await afterEachCb();
-    }
-    const duration = now() - t0;
-    print(`  ${GREEN}\u2714${RESET} ${GRAY}${expectation}  (${formatDuration(duration)})${RESET}`);
-  } catch (e) {
-    const duration = now() - t0;
-    if (!e.__testFailureCounted) {
-      ++countTestsFailed;
-    }
-    testErrors.push({ suite: currentSuite, test: expectation, message: e.message ?? String(e) });
-    const icon = e instanceof TimeoutError ? "\u23F1" : "\u274C";
-    print(`  ${RED}${icon}${RESET} ${GRAY}${expectation}  (${formatDuration(duration)})${RESET}`);
-    print(`${RED}${e.message}${RESET}`);
-    if (e.stack) print(e.stack);
-  }
+	const timeoutMs = typeof options === "number" ? options : options?.timeout ?? timeoutConfig.testTimeout;
+	const t0 = now();
+	try {
+		if (typeof beforeEachCb === "function") {
+			await beforeEachCb();
+		}
+		await withTimeout(callback, timeoutMs, expectation);
+		if (typeof afterEachCb === "function") {
+			await afterEachCb();
+		}
+		const duration = now() - t0;
+		print(`  ${GREEN}✔${RESET} ${GRAY}${expectation}  (${formatDuration(duration)})${RESET}`);
+	} catch (e) {
+		const duration = now() - t0;
+		if (!e.__testFailureCounted) {
+			++countTestsFailed;
+		}
+		testErrors.push({
+			suite: currentSuite,
+			test: expectation,
+			message: e.message ?? String(e)
+		});
+		const icon = e instanceof TimeoutError ? "⏱" : "❌";
+		print(`  ${RED}${icon}${RESET} ${GRAY}${expectation}  (${formatDuration(duration)})${RESET}`);
+		print(`${RED}${e.message}${RESET}`);
+		if (e.stack) print(e.stack);
+	}
 };
 it.skip = async function(expectation, _callback) {
-  ++countTestsIgnored;
-  print(`  ${BLUE}-${RESET} ${GRAY}${expectation} (skipped)${RESET}`);
+	++countTestsIgnored;
+	print(`  ${BLUE}-${RESET} ${GRAY}${expectation} (skipped)${RESET}`);
 };
 const expect = function(actualValue) {
-  ++countTestsOverall;
-  const expecter = new MatcherFactory(actualValue, true);
-  return expecter;
+	++countTestsOverall;
+	const expecter = new MatcherFactory(actualValue, true);
+	return expecter;
 };
 const assert = function(success, message) {
-  ++countTestsOverall;
-  if (!success) {
-    ++countTestsFailed;
-  }
-  try {
-    nodeAssert(success, message);
-  } catch (error) {
-    error.__testFailureCounted = true;
-    throw error;
-  }
+	++countTestsOverall;
+	if (!success) {
+		++countTestsFailed;
+	}
+	try {
+		nodeAssert(success, message);
+	} catch (error) {
+		error.__testFailureCounted = true;
+		throw error;
+	}
 };
 assert.strictEqual = function(actual, expected, message) {
-  ++countTestsOverall;
-  try {
-    nodeAssert.strictEqual(actual, expected, message);
-  } catch (error) {
-    ++countTestsFailed;
-    error.__testFailureCounted = true;
-    throw error;
-  }
+	++countTestsOverall;
+	try {
+		nodeAssert.strictEqual(actual, expected, message);
+	} catch (error) {
+		++countTestsFailed;
+		error.__testFailureCounted = true;
+		throw error;
+	}
 };
 assert.throws = function(promiseFn, ...args) {
-  ++countTestsOverall;
-  let error;
-  try {
-    promiseFn();
-  } catch (e) {
-    error = e;
-  }
-  if (!error) ++countTestsFailed;
-  nodeAssert.throws(() => {
-    if (error) throw error;
-  }, args[0], args[1]);
+	++countTestsOverall;
+	let error;
+	try {
+		promiseFn();
+	} catch (e) {
+		error = e;
+	}
+	if (!error) ++countTestsFailed;
+	nodeAssert.throws(() => {
+		if (error) throw error;
+	}, args[0], args[1]);
 };
 assert.deepStrictEqual = function(actual, expected, message) {
-  ++countTestsOverall;
-  try {
-    nodeAssert.deepStrictEqual(actual, expected, message);
-  } catch (error) {
-    ++countTestsFailed;
-    error.__testFailureCounted = true;
-    throw error;
-  }
+	++countTestsOverall;
+	try {
+		nodeAssert.deepStrictEqual(actual, expected, message);
+	} catch (error) {
+		++countTestsFailed;
+		error.__testFailureCounted = true;
+		throw error;
+	}
 };
 const runTests = async function(namespaces) {
-  for (const subNamespace in namespaces) {
-    const namespace = namespaces[subNamespace];
-    if (typeof namespace === "function") {
-      await namespace();
-    } else if (typeof namespace === "object") {
-      await runTests(namespace);
-    }
-  }
+	for (const subNamespace in namespaces) {
+		const namespace = namespaces[subNamespace];
+		if (typeof namespace === "function") {
+			await namespace();
+		} else if (typeof namespace === "object") {
+			await runTests(namespace);
+		}
+	}
 };
 const browserSignalDone = () => {
-  const doc = globalThis.document;
-  if (!doc) return;
-  globalThis.__gjsify_test_results = {
-    passed: countTestsOverall - countTestsFailed,
-    failed: countTestsFailed,
-    total: countTestsOverall,
-    errors: testErrors
-  };
-  doc.documentElement.dataset.testsDone = "true";
+	const doc = globalThis.document;
+	if (!doc) return;
+	globalThis.__gjsify_test_results = {
+		passed: countTestsOverall - countTestsFailed,
+		failed: countTestsFailed,
+		total: countTestsOverall,
+		errors: testErrors
+	};
+	doc.documentElement.dataset.testsDone = "true";
 };
 const printResult = () => {
-  const totalMs = runStartTime > 0 ? now() - runStartTime : 0;
-  const durationStr = totalMs > 0 ? `  ${GRAY}(${formatDuration(totalMs)})` : "";
-  if (countTestsIgnored) {
-    print(`
-${BLUE}\u2714 ${countTestsIgnored} ignored test${countTestsIgnored > 1 ? "s" : ""}${RESET}`);
-  }
-  if (countTestsFailed) {
-    print(`
-${RED}\u274C ${countTestsFailed} of ${countTestsOverall} tests failed${durationStr}${RESET}`);
-  } else {
-    print(`
-${GREEN}\u2714 ${countTestsOverall} completed${durationStr}${RESET}`);
-  }
+	const totalMs = runStartTime > 0 ? now() - runStartTime : 0;
+	const durationStr = totalMs > 0 ? `  ${GRAY}(${formatDuration(totalMs)})` : "";
+	if (countTestsIgnored) {
+		print(`\n${BLUE}✔ ${countTestsIgnored} ignored test${countTestsIgnored > 1 ? "s" : ""}${RESET}`);
+	}
+	if (countTestsFailed) {
+		print(`\n${RED}❌ ${countTestsFailed} of ${countTestsOverall} tests failed${durationStr}${RESET}`);
+	} else {
+		print(`\n${GREEN}✔ ${countTestsOverall} completed${durationStr}${RESET}`);
+	}
 };
 const getRuntime = async () => {
-  if (runtime && runtime !== "Unknown") {
-    return runtime;
-  }
-  if (globalThis.Deno?.version?.deno) {
-    return "Deno " + globalThis.Deno?.version?.deno;
-  }
-  {
-    let process = globalThis.process;
-    if (!process) {
-      try {
-        process = await import("process");
-      } catch (_e) {
-      }
-    }
-    if (process?.versions?.gjs) {
-      runtime = "Gjs " + process.versions.gjs;
-      return runtime;
-    } else if (process?.versions?.node) {
-      runtime = "Node.js " + process.versions.node;
-      return runtime;
-    }
-  }
-  if (typeof globalThis.document !== "undefined") {
-    runtime = "Browser";
-    return runtime;
-  }
-  return runtime || "Unknown";
+	if (runtime && runtime !== "Unknown") {
+		return runtime;
+	}
+	if (globalThis.Deno?.version?.deno) {
+		return "Deno " + globalThis.Deno?.version?.deno;
+	}
+	{
+		let process = globalThis.process;
+		if (!process) {
+			try {
+				process = await import("process");
+			} catch (_e) {}
+		}
+		if (process?.versions?.gjs) {
+			runtime = "Gjs " + process.versions.gjs;
+			return runtime;
+		} else if (process?.versions?.node) {
+			runtime = "Node.js " + process.versions.node;
+			return runtime;
+		}
+	}
+	if (typeof globalThis.document !== "undefined") {
+		runtime = "Browser";
+		return runtime;
+	}
+	return runtime || "Unknown";
 };
 const printRuntime = async () => {
-  const runtime2 = await getRuntime();
-  print(`
-Running on ${runtime2}`);
+	const runtime = await getRuntime();
+	print(`\nRunning on ${runtime}`);
 };
 const run = async (namespaces, options) => {
-  applyEnvOverrides();
-  runStartTime = now();
-  if (options) {
-    if (typeof options === "number") {
-      timeoutConfig.runTimeout = options;
-    } else {
-      if (options.timeout !== void 0) timeoutConfig.runTimeout = options.timeout;
-      if (options.testTimeout !== void 0) timeoutConfig.testTimeout = options.testTimeout;
-      if (options.suiteTimeout !== void 0) timeoutConfig.suiteTimeout = options.suiteTimeout;
-    }
-  }
-  printRuntime().then(async () => {
-    try {
-      await withTimeout(() => runTests(namespaces), timeoutConfig.runTimeout, "entire test run");
-    } catch (e) {
-      if (e instanceof TimeoutError) {
-        print(`
-${RED}\u23F1 ${e.message}${RESET}`);
-        ++countTestsFailed;
-      } else {
-        throw e;
-      }
-    }
-  }).then(async () => {
-    printResult();
-    browserSignalDone();
-    print();
-    quitMainLoop();
-    mainloop?.quit();
-    if (!mainloop) {
-      const exitCode = countTestsFailed > 0 ? 1 : 0;
-      try {
-        const process = globalThis.process || await import("process");
-        process.exit(exitCode);
-      } catch (_e) {
-      }
-    }
-  });
-  mainloop?.run();
-  if (mainloop) {
-    const exitCode = countTestsFailed > 0 ? 1 : 0;
-    try {
-      globalThis.imports.system.exit(exitCode);
-    } catch (_e) {
-    }
-  }
-};
-var index_default = {
-  run,
-  assert,
-  expect,
-  it,
-  afterEach,
-  beforeEach,
-  on,
-  describe,
-  configure,
-  print
+	applyEnvOverrides();
+	runStartTime = now();
+	if (options) {
+		if (typeof options === "number") {
+			timeoutConfig.runTimeout = options;
+		} else {
+			if (options.timeout !== undefined) timeoutConfig.runTimeout = options.timeout;
+			if (options.testTimeout !== undefined) timeoutConfig.testTimeout = options.testTimeout;
+			if (options.suiteTimeout !== undefined) timeoutConfig.suiteTimeout = options.suiteTimeout;
+		}
+	}
+	printRuntime().then(async () => {
+		try {
+			await withTimeout(() => runTests(namespaces), timeoutConfig.runTimeout, "entire test run");
+		} catch (e) {
+			if (e instanceof TimeoutError) {
+				print(`\n${RED}⏱ ${e.message}${RESET}`);
+				++countTestsFailed;
+			} else {
+				throw e;
+			}
+		}
+	}).then(async () => {
+		printResult();
+		browserSignalDone();
+		print();
+		quitMainLoop();
+		mainloop?.quit();
+		if (!mainloop) {
+			const exitCode = countTestsFailed > 0 ? 1 : 0;
+			try {
+				const process = globalThis.process || await import("process");
+				process.exit(exitCode);
+			} catch (_e) {}
+		}
+	});
+	mainloop?.run();
+	if (mainloop) {
+		const exitCode = countTestsFailed > 0 ? 1 : 0;
+		try {
+			globalThis.imports.system.exit(exitCode);
+		} catch (_e) {}
+	}
 };
-export {
-  afterEach,
-  assert,
-  beforeEach,
-  configure,
-  index_default as default,
-  describe,
-  expect,
-  it,
-  on,
-  print,
-  run
+var src_default = {
+	run,
+	assert,
+	expect,
+	it,
+	afterEach,
+	beforeEach,
+	on,
+	describe,
+	configure,
+	print
 };
+
+//#endregion
+export { afterEach, assert, beforeEach, configure, src_default as default, describe, expect, it, on, print, run, spy };