qunitx 1.2.4 → 1.2.6

package/dist/deno/index.js

@@ -150,7 +150,7 @@ var require_qunit = __commonJS({
       var g = getGlobalThis();
       var console$1 = g.console;
       var setTimeout$1 = g.setTimeout;
-      var clearTimeout = g.clearTimeout;
+      var clearTimeout2 = g.clearTimeout;
       var process$1 = g.process;
       var window$1 = g.window;
       var document = window$1 && window$1.document;
@@ -1317,7 +1317,7 @@ var require_qunit = __commonJS({
             }
             this.test.timeout = duration;
             if (config.timeout) {
-              clearTimeout(config.timeout);
+              clearTimeout2(config.timeout);
               config.timeout = null;
               if (config.timeoutHandler && this.test.timeout > 0) {
                 this.test.internalResetTimeout(this.test.timeout);
@@ -2341,7 +2341,7 @@ var require_qunit = __commonJS({
         finish: function finish() {
           config.current = this;
           if (setTimeout$1) {
-            clearTimeout(this.timeout);
+            clearTimeout2(this.timeout);
             config.timeoutHandler = null;
           }
           this.callback = void 0;
@@ -2554,7 +2554,7 @@ var require_qunit = __commonJS({
          * @param {number} timeoutDuration
          */
         internalResetTimeout: function internalResetTimeout(timeoutDuration) {
-          clearTimeout(config.timeout);
+          clearTimeout2(config.timeout);
           config.timeout = setTimeout$1(config.timeoutHandler(timeoutDuration), timeoutDuration);
         },
         /**
@@ -2662,10 +2662,10 @@ var require_qunit = __commonJS({
                   internalRecover(test4);
                 };
               };
-              clearTimeout(config.timeout);
+              clearTimeout2(config.timeout);
               config.timeout = setTimeout$1(config.timeoutHandler(timeoutDuration), timeoutDuration);
             } else {
-              clearTimeout(config.timeout);
+              clearTimeout2(config.timeout);
               config.timeout = setTimeout$1(function() {
                 config.timeout = null;
                 if (!config._deprecated_timeout_shown) {
@@ -2960,12 +2960,12 @@ var require_qunit = __commonJS({
           return;
         }
         if (setTimeout$1) {
-          clearTimeout(config.timeout);
+          clearTimeout2(config.timeout);
           config.timeout = setTimeout$1(function() {
             if (test4.pauses.size > 0) {
               return;
             }
-            clearTimeout(config.timeout);
+            clearTimeout2(config.timeout);
             config.timeout = null;
             config.blocking = false;
             config.pq.advance();
@@ -6167,6 +6167,7 @@ var Assert = class _Assert {
       throw new Error("assert.timeout() expects a positive integer.");
     }
     this.test.timeout = number;
+    this.test.setTimeoutDuration(number);
   }
   /**
    * Records a named step. Use with {@linkcode Assert.prototype.verifySteps} to assert that
@@ -6797,6 +6798,26 @@ var TestContext = class _TestContext {
   set timeout(value) {
     this.#timeout = value;
   }
+  rejectTimeout;
+  #timeoutHandle;
+  #timedOut = false;
+  setTimeoutDuration(ms) {
+    if (this.#timeoutHandle !== void 0) {
+      clearTimeout(this.#timeoutHandle);
+      this.#timeoutHandle = void 0;
+    }
+    if (!this.rejectTimeout) return;
+    this.#timeoutHandle = setTimeout(() => {
+      this.#timedOut = true;
+      this.rejectTimeout(new Error(`Test timed out after ${ms}ms`));
+    }, ms);
+  }
+  clearTimeoutHandle() {
+    if (this.#timeoutHandle !== void 0) {
+      clearTimeout(this.#timeoutHandle);
+      this.#timeoutHandle = void 0;
+    }
+  }
   #steps = [];
   get steps() {
     return this.#steps;
@@ -6828,6 +6849,7 @@ var TestContext = class _TestContext {
     }
   }
   finish() {
+    if (this.#timedOut) return;
     if (this.totalExecutedAssertions === 0) {
       this.assert.pushResult({
         result: false,
@@ -7686,7 +7708,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const firstTest = moduleContext.tests[0];
       const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
     afterAll(async () => {
@@ -7696,7 +7718,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
       if (lastTest) {
         for (let j = afterHooks.length - 1; j >= 0; j--) {
-          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
         }
       }
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -7716,7 +7738,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
     ModuleContext.currentModuleChain.pop();
   });
 }
@@ -7724,6 +7746,10 @@ module.skip = function skipModule(moduleName, _moduleContent) {
   describe(moduleName, { ignore: true }, function() {
   });
 };
+module.todo = function todoModule(moduleName, _moduleContent) {
+  describe(moduleName, { ignore: true }, function() {
+  });
+};
 
 // shims/deno/test.ts
 function test2(testName, runtimeOptions, testContent) {
@@ -7742,21 +7768,33 @@ function test2(testName, runtimeOptions, testContent) {
   const context = new TestContext(testName, moduleContext);
   const userContext = Object.create(moduleContext.userContext);
   context.userContext = userContext;
-  it(testName, { ...targetRuntimeOptions }, async function() {
-    for (const module2 of context.module.moduleChain) {
-      for (const hook of module2.beforeEachHooks) {
-        await hook.call(userContext, context.assert);
-      }
-    }
-    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
-    await context.assert.waitForAsyncOps();
-    for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
-      const module2 = context.module.moduleChain[i];
-      for (let j = module2.afterEachHooks.length - 1; j >= 0; j--) {
-        await module2.afterEachHooks[j].call(userContext, context.assert);
-      }
-    }
-    return result;
+  it(testName, { ...targetRuntimeOptions }, function() {
+    return new Promise((resolve, reject) => {
+      context.rejectTimeout = reject;
+      (async () => {
+        const hookMeta = { context: userContext };
+        try {
+          for (const module2 of context.module.moduleChain) {
+            for (const hook of module2.beforeEachHooks) {
+              await hook.call(userContext, context.assert, hookMeta);
+            }
+          }
+          const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions, context: userContext });
+          await context.assert.waitForAsyncOps();
+          for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
+            const module2 = context.module.moduleChain[i];
+            for (let j = module2.afterEachHooks.length - 1; j >= 0; j--) {
+              await module2.afterEachHooks[j].call(userContext, context.assert, hookMeta);
+            }
+          }
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        } finally {
+          context.clearTimeoutHandle();
+        }
+      })();
+    });
   });
 }
 test2.skip = function skipTest(testName, _testContent) {

package/dist/deno/module.d.ts

@@ -32,13 +32,16 @@ export type { HookFn, HooksObject, PushResultInfo } from '../types.d.ts';
 export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
 /** Defines a test module (suite) with optional Deno BDD runtime options forwarded to `describe()`. */
 declare function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
 declare namespace module {
     var skip: (moduleName: string, _moduleContent?: unknown) => void;
+    var todo: (moduleName: string, _moduleContent?: unknown) => void;
 }
 export default module;

package/dist/deno/module.js

@@ -17,7 +17,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const firstTest = moduleContext.tests[0];
       const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
     afterAll(async () => {
@@ -27,7 +27,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
       if (lastTest) {
         for (let j = afterHooks.length - 1; j >= 0; j--) {
-          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
         }
       }
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -47,7 +47,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
     ModuleContext.currentModuleChain.pop();
   });
 }
@@ -55,6 +55,10 @@ module.skip = function skipModule(moduleName, _moduleContent) {
   describe(moduleName, { ignore: true }, function() {
   });
 };
+module.todo = function todoModule(moduleName, _moduleContent) {
+  describe(moduleName, { ignore: true }, function() {
+  });
+};
 export {
   module as default
 };

package/dist/deno/test.d.ts

@@ -35,11 +35,13 @@ export type { PushResultInfo } from '../types.d.ts';
 export default function test(testName: string, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
 /** Defines an individual test with optional Deno BDD runtime options forwarded to `it()`. */
 declare function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
 declare namespace test {
     var skip: (testName: string, _testContent?: unknown) => void;

package/dist/deno/test.js

@@ -17,21 +17,33 @@ function test(testName, runtimeOptions, testContent) {
   const context = new TestContext(testName, moduleContext);
   const userContext = Object.create(moduleContext.userContext);
   context.userContext = userContext;
-  it(testName, { ...targetRuntimeOptions }, async function() {
-    for (const module of context.module.moduleChain) {
-      for (const hook of module.beforeEachHooks) {
-        await hook.call(userContext, context.assert);
-      }
-    }
-    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
-    await context.assert.waitForAsyncOps();
-    for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
-      const module = context.module.moduleChain[i];
-      for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-        await module.afterEachHooks[j].call(userContext, context.assert);
-      }
-    }
-    return result;
+  it(testName, { ...targetRuntimeOptions }, function() {
+    return new Promise((resolve, reject) => {
+      context.rejectTimeout = reject;
+      (async () => {
+        const hookMeta = { context: userContext };
+        try {
+          for (const module of context.module.moduleChain) {
+            for (const hook of module.beforeEachHooks) {
+              await hook.call(userContext, context.assert, hookMeta);
+            }
+          }
+          const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions, context: userContext });
+          await context.assert.waitForAsyncOps();
+          for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
+            const module = context.module.moduleChain[i];
+            for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
+              await module.afterEachHooks[j].call(userContext, context.assert, hookMeta);
+            }
+          }
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        } finally {
+          context.clearTimeoutHandle();
+        }
+      })();
+    });
   });
 }
 test.skip = function skipTest(testName, _testContent) {

package/dist/node/module.d.ts

@@ -1,14 +1,51 @@
 import type Assert from '../shared/assert.d.ts';
 import type { HooksObject } from '../types.d.ts';
+/**
+ * Defines a test module (suite) for Node's built-in test runner.
+ *
+ * Wraps `describe()` from `node:test` and sets up the QUnit lifecycle
+ * (before/beforeEach/afterEach/after hooks, assertion counting, steps tracking).
+ *
+ * @param {string} moduleName - Name of the test suite.
+ * @param {object} [runtimeOptions] - Optional Node test runner options forwarded to `describe()`
+ *   (e.g. `{ concurrency: true }`, `{ timeout: 5000 }`). Use `{ skip: true | string }` to skip
+ *   the entire module.
+ * @param {function} moduleContent - Callback that defines tests and hooks via `hooks.before`,
+ *   `hooks.beforeEach`, `hooks.afterEach`, `hooks.after`.
+ *   Receives `(hooks, { moduleName, options, context })`.
+ *   `context` is the shared module environment — the same object as `this` in
+ *   regular-function callbacks, useful when using arrow functions.
+ * @returns {void}
+ * @example
+ * ```js
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", (hooks, { context }) => {
+ *   context.multiplier = 2;
+ *
+ *   hooks.beforeEach((assert, { context }) => {
+ *     context.value = 21;
+ *   });
+ *
+ *   test("multiplication", (assert, { context }) => {
+ *     assert.equal(context.value * context.multiplier, 42);
+ *   });
+ * });
+ * ```
+ */
 export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
+/** Defines a test module (suite) with optional Node test runner options forwarded to `describe()`. */
 declare function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
 declare namespace module {
     var skip: (moduleName: string, _moduleContent?: unknown) => void;
+    var todo: (moduleName: string, _moduleContent?: unknown) => void;
 }
 export default module;

package/dist/node/module.js

@@ -17,7 +17,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const firstTest = moduleContext.tests[0];
       const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
     afterAll(async () => {
@@ -27,7 +27,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
       if (lastTest) {
         for (let j = afterHooks.length - 1; j >= 0; j--) {
-          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
         }
       }
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -47,7 +47,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
     ModuleContext.currentModuleChain.pop();
   });
 }
@@ -55,6 +55,10 @@ module.skip = function skipModule(moduleName, _moduleContent) {
   describe(moduleName, { skip: true }, function() {
   });
 };
+module.todo = function todoModule(moduleName, _moduleContent) {
+  describe(moduleName, { skip: true }, function() {
+  });
+};
 export {
   module as default
 };

package/dist/node/test.d.ts

@@ -1,11 +1,46 @@
 import type Assert from '../shared/assert.d.ts';
+/**
+ * Defines an individual test within a module for Node's built-in test runner.
+ *
+ * Wraps `it()` from `node:test` and handles the full QUnit lifecycle:
+ * beforeEach/afterEach hooks, async assertion waiting, and step verification.
+ *
+ * Must be called inside a `module()` callback.
+ *
+ * @param {string} testName - Name of the test.
+ * @param {object} [runtimeOptions] - Optional Node test runner options forwarded to `it()`.
+ *   Use `{ skip: true | string }` to skip the test, `{ todo: true | string }` to mark it as todo.
+ *   Other Node options like `{ concurrency: true }` or `{ timeout: 5000 }` are forwarded as-is.
+ * @param {function} testContent - Test callback receiving `(assert, { testName, options, context })`.
+ *   `context` is the per-test environment — inherits properties set by `before`/`beforeEach` hooks,
+ *   and is the same object as `this` in regular-function callbacks. Useful when using arrow functions.
+ * @returns {void}
+ * @example
+ * ```js
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", () => {
+ *   test("addition", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ *
+ *   test("async resolves correctly", async (assert) => {
+ *     const result = await Promise.resolve(42);
+ *     assert.strictEqual(result, 42);
+ *   });
+ * });
+ * ```
+ */
 export default function test(testName: string, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
+/** Defines an individual test with optional Node test runner options forwarded to `it()`. */
 declare function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
 declare namespace test {
     var skip: (testName: string, _testContent?: unknown) => void;

package/dist/node/test.js

@@ -18,21 +18,33 @@ function test(testName, runtimeOptions, testContent) {
   const userContext = Object.create(moduleContext.userContext);
   context.userContext = userContext;
   if (todo) moduleContext.tests.pop();
-  it(testName, { ...targetRuntimeOptions }, async function() {
-    for (const module of context.module.moduleChain) {
-      for (const hook of module.beforeEachHooks) {
-        await hook.call(userContext, context.assert);
-      }
-    }
-    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
-    await context.assert.waitForAsyncOps();
-    for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
-      const module = context.module.moduleChain[i];
-      for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-        await module.afterEachHooks[j].call(userContext, context.assert);
-      }
-    }
-    return result;
+  it(testName, { ...targetRuntimeOptions }, function() {
+    return new Promise((resolve, reject) => {
+      context.rejectTimeout = reject;
+      (async () => {
+        const hookMeta = { context: userContext };
+        try {
+          for (const module of context.module.moduleChain) {
+            for (const hook of module.beforeEachHooks) {
+              await hook.call(userContext, context.assert, hookMeta);
+            }
+          }
+          const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions, context: userContext });
+          await context.assert.waitForAsyncOps();
+          for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
+            const module = context.module.moduleChain[i];
+            for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
+              await module.afterEachHooks[j].call(userContext, context.assert, hookMeta);
+            }
+          }
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        } finally {
+          context.clearTimeoutHandle();
+        }
+      })();
+    });
   });
 }
 test.skip = function skipTest(testName, _testContent) {

package/dist/shared/assert.js

@@ -35,6 +35,7 @@ class Assert {
       throw new Error("assert.timeout() expects a positive integer.");
     }
     this.test.timeout = number;
+    this.test.setTimeoutDuration(number);
   }
   /**
    * Records a named step. Use with {@linkcode Assert.prototype.verifySteps} to assert that

package/dist/shared/module-context.d.ts

@@ -7,7 +7,7 @@ export default class ModuleContext {
     static get lastModule(): ModuleContext;
     name: string;
     assert: Assert;
-    userContext: object;
+    userContext: Record<string, unknown>;
     context: TestContext;
     moduleChain: ModuleContext[];
     beforeEachHooks: HookFn<Assert>[];

package/dist/shared/test-context.d.ts

@@ -13,13 +13,16 @@ export default class TestContext {
     set assert(value: Assert | undefined);
     get timeout(): number | undefined;
     set timeout(value: number | undefined);
+    rejectTimeout: ((err: Error) => void) | undefined;
+    setTimeoutDuration(ms: number): void;
+    clearTimeoutHandle(): void;
     get steps(): string[];
     set steps(value: string[]);
     get expectedAssertionCount(): number | undefined;
     set expectedAssertionCount(value: number | undefined);
     get totalExecutedAssertions(): number;
     set totalExecutedAssertions(value: number);
-    userContext: object;
+    userContext: Record<string, unknown>;
     constructor(name?: string, moduleContext?: ModuleContext);
     finish(): void;
 }

package/dist/shared/test-context.js

@@ -35,6 +35,26 @@ class TestContext {
   set timeout(value) {
     this.#timeout = value;
   }
+  rejectTimeout;
+  #timeoutHandle;
+  #timedOut = false;
+  setTimeoutDuration(ms) {
+    if (this.#timeoutHandle !== void 0) {
+      clearTimeout(this.#timeoutHandle);
+      this.#timeoutHandle = void 0;
+    }
+    if (!this.rejectTimeout) return;
+    this.#timeoutHandle = setTimeout(() => {
+      this.#timedOut = true;
+      this.rejectTimeout(new Error(`Test timed out after ${ms}ms`));
+    }, ms);
+  }
+  clearTimeoutHandle() {
+    if (this.#timeoutHandle !== void 0) {
+      clearTimeout(this.#timeoutHandle);
+      this.#timeoutHandle = void 0;
+    }
+  }
   #steps = [];
   get steps() {
     return this.#steps;
@@ -66,6 +86,7 @@ class TestContext {
     }
   }
   finish() {
+    if (this.#timedOut) return;
     if (this.totalExecutedAssertions === 0) {
       this.assert.pushResult({
         result: false,

package/dist/types.d.ts

@@ -36,20 +36,24 @@ export interface TestState {
     asyncOps: Promise<void>[];
     timeout?: number;
     expectedAssertionCount?: number;
-    userContext?: object;
+    userContext?: Record<string, unknown>;
     module?: {
         name: string;
     };
+    setTimeoutDuration(ms: number): void;
 }
 /** Minimal module shape that Assert needs to resolve a fallback test context. */
 export interface ModuleState {
     context: TestState;
 }
-/** A lifecycle hook callback that receives an {@linkcode Assert} instance. */
-export type HookFn<A = unknown> = (assert: A) => void | Promise<void>;
+/** A lifecycle hook callback that receives an {@linkcode Assert} instance and a meta object with the shared context. */
+export type HookFn<A = unknown> = (assert: A, meta: {
+    context: Record<string, unknown>;
+}) => void | Promise<void>;
 export type TestFn<A = unknown> = (assert: A, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<unknown>;
 /** Lifecycle hooks available inside a `module()` callback. */
 export interface HooksObject<A = unknown> {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -83,11 +83,11 @@
     "format:fix": "prettier --write \"test/**/*.ts\" \"*.ts\" \"package.json\"",
     "lint": "deno lint shims/",
     "lint:docs": "deno doc --lint shims/deno/module.ts shims/deno/test.ts",
-    "build": "node --experimental-strip-types build.ts",
-    "build:cold": "rm -rf dist && node --experimental-strip-types build.ts",
-    "pretest": "node --experimental-strip-types build.ts && node --input-type=module -e \"import{symlinkSync}from'fs';try{symlinkSync('..','node_modules/qunitx','junction')}catch(_){}\"",
+    "build": "node build.ts",
+    "build:cold": "rm -rf dist && node build.ts",
+    "pretest": "node build.ts && node --input-type=module -e \"import{symlinkSync}from'fs';try{symlinkSync('..','node_modules/qunitx','junction')}catch(_){}\"",
     "run:all": "npm run run:node && npm run run:deno",
-    "run:node": "node --experimental-strip-types --test test/helpers/passing-tests.ts && node --experimental-strip-types --test test/helpers/failing-tests.ts",
+    "run:node": "node --test test/helpers/passing-tests.ts && node --test test/helpers/failing-tests.ts",
     "run:deno": "deno test test/helpers/passing-tests.ts && deno test test/helpers/failing-tests.ts",
     "changelog:unreleased": "git-cliff --unreleased --strip all",
     "changelog:preview": "git-cliff",
@@ -99,8 +99,8 @@
     "test:browser": "qunitx test/index.ts --debug",
     "test:deno": "deno test --allow-read --allow-run test/index.ts",
     "test:doctests": "deno test --doc --allow-read shims/deno/module.ts shims/deno/test.ts",
-    "test:node": "node --experimental-strip-types --test test/index.ts",
-    "coverage": "deno test --coverage=tmp/coverage --allow-read --allow-env --allow-run test/index.ts && deno coverage --lcov --output=tmp/coverage/lcov.info --include='shims/' tmp/coverage && node --experimental-strip-types scripts/check-coverage.ts",
+    "test:node": "node --test test/index.ts",
+    "coverage": "deno test --coverage=tmp/coverage --allow-read --allow-env --allow-run test/index.ts && deno coverage --lcov --output=tmp/coverage/lcov.info --include='shims/' tmp/coverage && node scripts/check-coverage.ts",
     "coverage:report": "npm run coverage && deno coverage --html --include='shims/' tmp/coverage",
     "bench": "deno task bench",
     "bench:check": "deno task bench:check",
@@ -109,6 +109,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "playwright-core": "^1.59.1",
     "prettier": "^3.8.1",
     "qunit": "^2.25.0",
     "qunitx-cli": "^0.9.10",