qunitx 1.2.6 → 1.2.8

package/dist/deno/index.js

@@ -244,7 +244,7 @@ var require_qunit = __commonJS({
       };
       function objectValues2(obj) {
         var allowArray = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
-        var vals = allowArray && is2("array", obj) ? [] : {};
+        var vals = allowArray && is("array", obj) ? [] : {};
         for (var key in obj) {
           if (hasOwn$1.call(obj, key)) {
             var val = obj[key];
@@ -306,7 +306,7 @@ var require_qunit = __commonJS({
             return _typeof(obj);
         }
       }
-      function is2(type, obj) {
+      function is(type, obj) {
         return objectType2(obj) === type;
       }
       function generateHash(module3, testName) {
@@ -791,11 +791,11 @@ var require_qunit = __commonJS({
               type = "null";
             } else if (typeof obj === "undefined") {
               type = "undefined";
-            } else if (is2("regexp", obj)) {
+            } else if (is("regexp", obj)) {
               type = "regexp";
-            } else if (is2("date", obj)) {
+            } else if (is("date", obj)) {
               type = "date";
-            } else if (is2("function", obj)) {
+            } else if (is("function", obj)) {
               type = "function";
             } else if (obj.setInterval !== void 0 && obj.document !== void 0 && obj.nodeType === void 0) {
               type = "window";
@@ -4297,7 +4297,7 @@ var require_qunit = __commonJS({
         equiv,
         reporters,
         hooks,
-        is: is2,
+        is,
         objectType: objectType2,
         on,
         onError: onWindowError,
@@ -5973,6 +5973,9 @@ var require_qunit = __commonJS({
   }
 });
 
+// shims/deno/index.ts
+var import_qunit2 = __toESM(require_qunit(), 1);
+
 // jsr:https://jsr.io/@std/assert/1.0.19/assertion_error.ts
 var AssertionError = class extends Error {
   /** Constructs a new instance.
@@ -6017,9 +6020,6 @@ var ANSI_PATTERN = new RegExp(
   "g"
 );
 
-// shims/deno/index.ts
-var import_qunit2 = __toESM(require_qunit(), 1);
-
 // shims/shared/assert.ts
 var import_qunit = __toESM(require_qunit(), 1);
 
@@ -6053,11 +6053,8 @@ function objectType(obj) {
       return typeof obj;
   }
 }
-function is(type, obj) {
-  return objectType(obj) === type;
-}
 function objectValues(obj, allowArray = true) {
-  const vals = allowArray && is("array", obj) ? [] : {};
+  const vals = allowArray && objectType(obj) === "array" ? [] : {};
   for (const key in obj) {
     if (hasOwn.call(obj, key)) {
       const val = obj[key];
@@ -6089,13 +6086,15 @@ function validateExpectedExceptionArgs(expected, message, assertionMethod) {
       expected = void 0;
       return [expected, message];
     } else {
-      throw new Error("assert." + assertionMethod + " does not accept a string value for the expected argument.\nUse a non-string object value (e.g. RegExp or validator function) instead if necessary.");
+      throw new Error(
+        `assert.${assertionMethod} does not accept a string value for the expected argument.
+Use a non-string object value (e.g. RegExp or validator function) instead if necessary.`
+      );
     }
   }
-  const valid = !expected || // TODO: be more explicit here
-  expectedType === "regexp" || expectedType === "function" || expectedType === "object";
+  const valid = !expected || expectedType === "regexp" || expectedType === "function" || expectedType === "object";
   if (!valid) {
-    throw new Error("Invalid expected value type (" + expectedType + ") provided to assert." + assertionMethod + ".");
+    throw new Error(`Invalid expected value type (${expectedType}) provided to assert.${assertionMethod}.`);
   }
   return [expected, message];
 }
@@ -6125,13 +6124,15 @@ function validateException(actual, expected, message) {
 function errorString(error) {
   const resultErrorString = String(error);
   if (resultErrorString.slice(0, 7) === "[object") {
-    return (error.name || "Error") + (error.message ? ": ".concat(error.message) : "");
-  } else {
-    return resultErrorString;
+    const name = error.name || "Error";
+    const msg = error.message;
+    return msg ? `${name}: ${msg}` : name;
   }
+  return resultErrorString;
 }
 
 // shims/shared/assert.ts
+var PENDING = /* @__PURE__ */ Symbol("pending");
 var Assert = class _Assert {
   /** @internal Set by each runtime shim before tests run. */
   static QUnit;
@@ -6143,7 +6144,7 @@ var Assert = class _Assert {
   test;
   /** @internal */
   constructor(module2, test3) {
-    this.test = test3 || module2.context;
+    this.test = test3 || module2.testContext;
   }
   /** @internal */
   _incrementAssertionCount() {
@@ -6185,19 +6186,10 @@ var Assert = class _Assert {
    * ```
    */
   step(message) {
-    let assertionMessage = message;
-    let result = !!message;
     this.test.steps.push(message);
-    if (typeof message === "undefined" || message === "") {
-      assertionMessage = "You must provide a message to assert.step";
-    } else if (typeof message !== "string") {
-      assertionMessage = "You must provide a string value to assert.step";
-      result = false;
-    }
-    this.pushResult({
-      result,
-      message: assertionMessage
-    });
+    const result = typeof message === "string" && message.length > 0;
+    const assertionMessage = result ? message : message === void 0 || message === "" ? "You must provide a message to assert.step" : "You must provide a string value to assert.step";
+    this.pushResult({ result, message: assertionMessage });
   }
   /**
    * Asserts that the steps recorded via {@linkcode Assert.prototype.step} match the given array,
@@ -6257,14 +6249,9 @@ var Assert = class _Assert {
    * ```
    */
   async() {
-    let resolveFn;
-    const done = new Promise((resolve) => {
-      resolveFn = resolve;
-    });
-    this.test.asyncOps.push(done);
-    return () => {
-      resolveFn();
-    };
+    const { promise, resolve } = Promise.withResolvers();
+    this.test.asyncOps.push(promise);
+    return resolve;
   }
   /** @internal Used by the test runner to wait for all async operations to complete. */
   waitForAsyncOps() {
@@ -6412,7 +6399,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected: ${defaultMessage(actual, "should equal to:", expected)}`,
+        message: message || `Values are not equal:${formatDiff(actual, expected)}`,
         operator: "==",
         stackStartFn: this.equal
       });
@@ -6437,7 +6424,7 @@ var Assert = class _Assert {
         actual,
         expected,
         operator: "!=",
-        message: message || `Expected: ${defaultMessage(actual, "should notEqual to:", expected)}`,
+        message: message || `Values are unexpectedly equal:${formatUnexpectedMatch(actual)}`,
         stackStartFn: this.notEqual
       });
     }
@@ -6466,7 +6453,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `Expected properties to be propEqual: ${defaultMessage(targetActual, "should propEqual to:", targetExpected)}`,
+        message: message || `Own properties are not equal:${formatDiff(targetActual, targetExpected)}`,
         stackStartFn: this.propEqual
       });
     }
@@ -6492,7 +6479,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `Expected properties to NOT be propEqual: ${defaultMessage(targetActual, "should notPropEqual to:", targetExpected)}`,
+        message: message || `Own properties are unexpectedly equal:${formatUnexpectedMatch(targetActual)}`,
         stackStartFn: this.notPropEqual
       });
     }
@@ -6518,7 +6505,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `propContains assertion fail on: ${defaultMessage(targetActual, "should propContains to:", targetExpected)}`,
+        message: message || `Object does not contain expected properties:${formatDiff(targetActual, targetExpected)}`,
         stackStartFn: this.propContains
       });
     }
@@ -6544,7 +6531,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual: targetActual,
         expected: targetExpected,
-        message: message || `notPropContains assertion fail on: ${defaultMessage(targetActual, "should notPropContains of:", targetExpected)}`,
+        message: message || `Object unexpectedly contains all expected properties:${formatUnexpectedMatch(targetActual)}`,
         stackStartFn: this.notPropContains
       });
     }
@@ -6568,7 +6555,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected values to be deepEqual: ${defaultMessage(actual, "should deepEqual to:", expected)}`,
+        message: message || `Values are not deeply equal:${formatDiff(actual, expected)}`,
         operator: "deepEqual",
         stackStartFn: this.deepEqual
       });
@@ -6592,7 +6579,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected values to be NOT deepEqual: ${defaultMessage(actual, "should notDeepEqual to:", expected)}`,
+        message: message || `Values are unexpectedly deeply equal:${formatUnexpectedMatch(actual)}`,
         operator: "notDeepEqual",
         stackStartFn: this.notDeepEqual
       });
@@ -6616,7 +6603,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected: ${defaultMessage(actual, "is strictEqual to:", expected)}`,
+        message: message || `Values are not strictly equal:${formatDiff(actual, expected)}`,
         operator: "strictEqual",
         stackStartFn: this.strictEqual
       });
@@ -6640,7 +6627,7 @@ var Assert = class _Assert {
       throw new _Assert.AssertionError({
         actual,
         expected,
-        message: message || `Expected: ${defaultMessage(actual, "is notStrictEqual to:", expected)}`,
+        message: message || `Values are unexpectedly strictly equal:${formatUnexpectedMatch(actual)}`,
         operator: "notStrictEqual",
         stackStartFn: this.notStrictEqual
       });
@@ -6662,7 +6649,7 @@ var Assert = class _Assert {
    * ```
    */
   throws(blockFn, expectedInput, assertionMessage) {
-    this?._incrementAssertionCount();
+    this._incrementAssertionCount();
     const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, "throws");
     if (typeof blockFn !== "function") {
       throw new _Assert.AssertionError({
@@ -6672,20 +6659,31 @@ var Assert = class _Assert {
         stackStartFn: this.throws
       });
     }
+    let returnValue;
     try {
-      blockFn();
+      returnValue = blockFn();
     } catch (error) {
-      const [result, validatedExpected, validatedMessage] = validateException(error, expected, message);
+      const [result, , validatedMessage] = validateException(error, expected, message);
       if (result === false) {
+        const expectedDesc = describeExpected(expected);
+        const receivedDesc = String(error);
         throw new _Assert.AssertionError({
-          actual: result,
-          expected: validatedExpected,
-          message: validatedMessage,
+          actual: receivedDesc,
+          expected: expectedDesc,
+          message: validatedMessage || throwsFailMessage("throws", expectedDesc, receivedDesc),
           stackStartFn: this.throws
         });
       }
       return;
     }
+    if (returnValue !== null && typeof returnValue === "object" && typeof returnValue.then === "function") {
+      throw new _Assert.AssertionError({
+        actual: returnValue,
+        expected,
+        message: "Function passed to `assert.throws` returned a Promise \u2014 did you mean to use `assert.rejects`?",
+        stackStartFn: this.throws
+      });
+    }
     throw new _Assert.AssertionError({
       actual: blockFn,
       expected,
@@ -6720,15 +6718,13 @@ var Assert = class _Assert {
         stackStartFn: this.rejects
       });
     }
-    let didReject = false;
-    let rejectionError;
+    let caught = PENDING;
     try {
       await promise;
     } catch (error) {
-      didReject = true;
-      rejectionError = error;
+      caught = error;
     }
-    if (!didReject) {
+    if (caught === PENDING) {
       throw new _Assert.AssertionError({
         actual: promise,
         expected,
@@ -6736,71 +6732,92 @@ var Assert = class _Assert {
         stackStartFn: this.rejects
       });
     }
-    const [result, validatedExpected, validatedMessage] = validateException(rejectionError, expected, message);
+    const [result, , validatedMessage] = validateException(caught, expected, message);
     if (result === false) {
+      const expectedDesc = describeExpected(expected);
+      const receivedDesc = String(caught);
       throw new _Assert.AssertionError({
-        actual: result,
-        expected: validatedExpected,
-        message: validatedMessage,
+        actual: receivedDesc,
+        expected: expectedDesc,
+        message: validatedMessage || throwsFailMessage("rejects", expectedDesc, receivedDesc),
         stackStartFn: this.rejects
       });
     }
   }
 };
-function defaultMessage(actual, description, expected) {
-  return `
+var INSPECT_OPTIONS = { depth: 10, colors: true, compact: false };
+var inspect = (value) => Assert.inspect(value, INSPECT_OPTIONS);
+function formatDiff(actual, expected) {
+  const aStr = inspect(actual), bStr = inspect(expected);
+  const aLines = aStr.split("\n"), bLines = bStr.split("\n");
+  if (aLines.length === 1 && bLines.length === 1) return `
 
-${inspect(actual)}
+Actual:   ${aStr}
+Expected: ${bStr}`;
+  const lines = lcsDiff(aLines, bLines).map(
+    ([t, line]) => t === "=" ? `  ${line}` : t === "-" ? `- ${line}` : `+ ${line}`
+  );
+  return `
 
-${description}
+- Actual  + Expected
 
-${inspect(expected)}`;
+${lines.join("\n")}`;
 }
-function inspect(value) {
-  return Assert.inspect(value, { depth: 10, colors: true, compact: false });
+var formatUnexpectedMatch = (actual) => `
+
+${inspect(actual)}`;
+var describeExpected = (expected) => expected == null ? "(no pattern)" : typeof expected === "string" ? expected : typeof expected === "function" ? expected.name || String(expected) : String(expected);
+var throwsFailMessage = (method, pattern, received) => `assert.${method}: thrown error did not match expected:
+
+Pattern:  ${pattern}
+Received: ${received}`;
+function lcsDiff(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++)
+    for (let j2 = 1; j2 <= n; j2++)
+      dp[i2][j2] = a[i2 - 1] === b[j2 - 1] ? dp[i2 - 1][j2 - 1] + 1 : Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+  const result = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+      result.push(["=", a[i - 1]]);
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.push(["+", b[j - 1]]);
+      j--;
+    } else {
+      result.push(["-", a[i - 1]]);
+      i--;
+    }
+  }
+  return result.reverse();
 }
 
 // shims/shared/test-context.ts
 var TestContext = class _TestContext {
   static Assert;
-  #name;
-  get name() {
-    return this.#name;
-  }
-  set name(value) {
-    this.#name = value;
-  }
-  #module;
-  get module() {
-    return this.#module;
-  }
-  set module(value) {
-    this.#module = value;
-  }
-  #asyncOps = [];
-  get asyncOps() {
-    return this.#asyncOps;
-  }
-  set asyncOps(value) {
-    this.#asyncOps = value;
-  }
-  #assert;
-  get assert() {
-    return this.#assert;
-  }
-  set assert(value) {
-    this.#assert = value;
-  }
-  #timeout;
-  get timeout() {
-    return this.#timeout;
-  }
-  set timeout(value) {
-    this.#timeout = value;
-  }
+  name;
+  module;
+  asyncOps = [];
+  assert;
+  timeout;
+  steps = [];
+  expectedAssertionCount;
+  totalExecutedAssertions = 0;
+  userContext = {};
   rejectTimeout;
   #timeoutHandle;
   #timedOut = false;
+  constructor(name, moduleContext) {
+    if (moduleContext) {
+      this.name = `${moduleContext.name} | ${name}`;
+      this.module = moduleContext;
+      this.module.tests.push(this);
+      this.assert = new _TestContext.Assert(moduleContext, this);
+    }
+  }
   setTimeoutDuration(ms) {
     if (this.#timeoutHandle !== void 0) {
       clearTimeout(this.#timeoutHandle);
@@ -6818,59 +6835,29 @@ var TestContext = class _TestContext {
       this.#timeoutHandle = void 0;
     }
   }
-  #steps = [];
-  get steps() {
-    return this.#steps;
-  }
-  set steps(value) {
-    this.#steps = value;
-  }
-  #expectedAssertionCount;
-  get expectedAssertionCount() {
-    return this.#expectedAssertionCount;
-  }
-  set expectedAssertionCount(value) {
-    this.#expectedAssertionCount = value;
-  }
-  #totalExecutedAssertions = 0;
-  get totalExecutedAssertions() {
-    return this.#totalExecutedAssertions;
-  }
-  set totalExecutedAssertions(value) {
-    this.#totalExecutedAssertions = value;
-  }
-  userContext = {};
-  constructor(name, moduleContext) {
-    if (moduleContext) {
-      this.name = `${moduleContext.name} | ${name}`;
-      this.module = moduleContext;
-      this.module.tests.push(this);
-      this.assert = new _TestContext.Assert(moduleContext, this);
-    }
-  }
   finish() {
     if (this.#timedOut) return;
-    if (this.totalExecutedAssertions === 0) {
-      this.assert.pushResult({
-        result: false,
-        actual: this.totalExecutedAssertions,
-        expected: "> 0",
-        message: `Expected at least one assertion to be run for test: ${this.name}`
-      });
-    } else if (this.steps.length > 0) {
+    if (this.steps.length > 0) {
       this.assert.pushResult({
         result: false,
         actual: this.steps,
         expected: [],
         message: `Expected assert.verifySteps() to be called before end of test after using assert.step(). Unverified steps: ${this.steps.join(", ")}`
       });
-    } else if (this.expectedAssertionCount && this.expectedAssertionCount !== this.totalExecutedAssertions) {
+    } else if (this.expectedAssertionCount !== void 0 && this.expectedAssertionCount !== this.totalExecutedAssertions) {
       this.assert.pushResult({
         result: false,
         actual: this.totalExecutedAssertions,
         expected: this.expectedAssertionCount,
         message: `Expected ${this.expectedAssertionCount} assertions, but ${this.totalExecutedAssertions} were run for test: ${this.name}`
       });
+    } else if (this.expectedAssertionCount === void 0 && this.totalExecutedAssertions === 0) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.totalExecutedAssertions,
+        expected: "> 0",
+        message: `Expected at least one assertion to be run for test: ${this.name}`
+      });
     }
   }
 };
@@ -6880,21 +6867,21 @@ var ModuleContext = class _ModuleContext {
   static Assert;
   static currentModuleChain = [];
   static get lastModule() {
-    return this.currentModuleChain[this.currentModuleChain.length - 1];
+    return this.currentModuleChain.at(-1);
   }
   name;
   assert;
   userContext;
   // Internal fallback assert for modules with no direct tests
-  context = new TestContext();
+  testContext = new TestContext();
   moduleChain = [];
   beforeEachHooks = [];
   afterEachHooks = [];
   tests = [];
   constructor(name) {
-    const parentModule = _ModuleContext.currentModuleChain[_ModuleContext.currentModuleChain.length - 1];
+    const parentModule = _ModuleContext.currentModuleChain.at(-1);
     _ModuleContext.currentModuleChain.push(this);
-    this.moduleChain = _ModuleContext.currentModuleChain.slice(0);
+    this.moduleChain = [..._ModuleContext.currentModuleChain];
     this.name = parentModule ? `${parentModule.name} > ${name}` : name;
     this.assert = new _ModuleContext.Assert(this);
     this.userContext = parentModule ? Object.create(parentModule.userContext) : /* @__PURE__ */ Object.create(null);
@@ -7699,12 +7686,12 @@ function module(moduleName, runtimeOptions, moduleContent) {
     });
     return;
   }
-  const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+  const targetModuleContent = moduleContent ?? runtimeOptions;
   const moduleContext = new ModuleContext(moduleName);
   describe(moduleName, { ...targetRuntimeOptions }, function() {
     const beforeHooks = [];
     const afterHooks = [];
-    beforeAll(async function() {
+    beforeAll(async () => {
       const firstTest = moduleContext.tests[0];
       const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
       for (const hook of beforeHooks) {
@@ -7712,17 +7699,16 @@ function module(moduleName, runtimeOptions, moduleContent) {
       }
     });
     afterAll(async () => {
-      for (const testContext of moduleContext.tests) {
-        await testContext.assert.waitForAsyncOps();
-      }
-      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      const allAsyncOps = moduleContext.tests.flatMap((t) => t.asyncOps);
+      if (allAsyncOps.length > 0) await Promise.all(allAsyncOps);
+      const lastTest = moduleContext.tests.at(-1);
       if (lastTest) {
-        for (let j = afterHooks.length - 1; j >= 0; j--) {
-          await afterHooks[j].call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
+        for (const hook of afterHooks.toReversed()) {
+          await hook.call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
         }
       }
-      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-        moduleContext.tests[i].finish();
+      for (const testCtx of moduleContext.tests) {
+        testCtx.finish();
       }
     });
     targetModuleContent.call(moduleContext.userContext, {
@@ -7738,7 +7724,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
+    }, { moduleName, options: targetRuntimeOptions, context: moduleContext.userContext });
     ModuleContext.currentModuleChain.pop();
   });
 }
@@ -7764,37 +7750,36 @@ function test2(testName, runtimeOptions, testContent) {
     });
     return;
   }
-  const targetTestContent = testContent ? testContent : runtimeOptions;
+  const targetTestContent = testContent ?? runtimeOptions;
   const context = new TestContext(testName, moduleContext);
   const userContext = Object.create(moduleContext.userContext);
   context.userContext = userContext;
   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 { promise, resolve, reject } = Promise.withResolvers();
+    context.rejectTimeout = reject;
+    const hookMeta = { context: userContext };
+    (async () => {
+      try {
+        for (const mod of context.module.moduleChain) {
+          for (const hook of mod.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);
-            }
+        }
+        await targetTestContent.call(userContext, context.assert, { testName, options: targetRuntimeOptions, context: userContext });
+        await context.assert.waitForAsyncOps();
+        for (const mod of context.module.moduleChain.toReversed()) {
+          for (const hook of mod.afterEachHooks.toReversed()) {
+            await hook.call(userContext, context.assert, hookMeta);
           }
-          resolve(result);
-        } catch (err) {
-          reject(err);
-        } finally {
-          context.clearTimeoutHandle();
         }
-      })();
-    });
+        resolve();
+      } catch (err) {
+        reject(err);
+      } finally {
+        context.clearTimeoutHandle();
+      }
+    })();
+    return promise;
   });
 }
 test2.skip = function skipTest(testName, _testContent) {
@@ -7810,6 +7795,7 @@ test2.todo = function todoTest(testName, _testContent) {
 var AssertionError2 = class extends AssertionError {
   constructor(object) {
     super(object.message ?? "Assertion failed");
+    if (object.stackStartFn) Error.captureStackTrace(this, object.stackStartFn);
   }
 };
 Assert.QUnit = globalThis.QUnit;

package/dist/deno/module.d.ts

@@ -1,7 +1,5 @@
 import type Assert from '../shared/assert.d.ts';
 import type { HooksObject } from '../types.d.ts';
-export type { Assert };
-export type { HookFn, HooksObject, PushResultInfo } from '../types.d.ts';
 /**
  * Defines a test module (suite) for Deno's BDD test runner.
  *
@@ -45,3 +43,5 @@ declare namespace module {
     var todo: (moduleName: string, _moduleContent?: unknown) => void;
 }
 export default module;
+export type { Assert };
+export type { HookFn, HooksObject, PushResultInfo } from '../types.d.ts';