qunitx 1.2.17 → 1.2.19

package/dist/deno/index.js

@@ -6,7 +6,11 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -150,7 +154,7 @@ var require_qunit = __commonJS({
       var g = getGlobalThis();
       var console$1 = g.console;
       var setTimeout$1 = g.setTimeout;
-      var clearTimeout2 = g.clearTimeout;
+      var clearTimeout = g.clearTimeout;
       var process$1 = g.process;
       var window$1 = g.window;
       var document = window$1 && window$1.document;
@@ -168,22 +172,22 @@ var require_qunit = __commonJS({
       var StringMap = typeof g.Map === "function" && typeof g.Map.prototype.keys === "function" && typeof g.Symbol === "function" && _typeof(g.Symbol.iterator) === "symbol" ? g.Map : function StringMap2(input) {
         var _this = this;
         var store = /* @__PURE__ */ Object.create(null);
-        var hasOwn3 = Object.prototype.hasOwnProperty;
+        var hasOwn2 = Object.prototype.hasOwnProperty;
         this.has = function(strKey) {
-          return hasOwn3.call(store, strKey);
+          return hasOwn2.call(store, strKey);
         };
         this.get = function(strKey) {
           return store[strKey];
         };
         this.set = function(strKey, val) {
-          if (!hasOwn3.call(store, strKey)) {
+          if (!hasOwn2.call(store, strKey)) {
             this.size++;
           }
           store[strKey] = val;
           return this;
         };
         this.delete = function(strKey) {
-          if (hasOwn3.call(store, strKey)) {
+          if (hasOwn2.call(store, strKey)) {
             delete store[strKey];
             this.size--;
           }
@@ -242,25 +246,25 @@ var require_qunit = __commonJS({
       } : function(elem, array) {
         return array.indexOf(elem) !== -1;
       };
-      function objectValues2(obj) {
+      function objectValues(obj) {
         var allowArray = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
         var vals = allowArray && is("array", obj) ? [] : {};
         for (var key in obj) {
           if (hasOwn$1.call(obj, key)) {
             var val = obj[key];
-            vals[key] = val === Object(val) ? objectValues2(val, allowArray) : val;
+            vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
           }
         }
         return vals;
       }
-      function objectValuesSubset2(obj, model) {
+      function objectValuesSubset(obj, model) {
         if (obj !== Object(obj)) {
           return obj;
         }
         var subset = {};
         for (var key in model) {
           if (hasOwn$1.call(model, key) && hasOwn$1.call(obj, key)) {
-            subset[key] = objectValuesSubset2(obj[key], model[key]);
+            subset[key] = objectValuesSubset(obj[key], model[key]);
           }
         }
         return subset;
@@ -277,7 +281,7 @@ var require_qunit = __commonJS({
         }
         return a;
       }
-      function objectType2(obj) {
+      function objectType(obj) {
         if (typeof obj === "undefined") {
           return "undefined";
         }
@@ -307,7 +311,7 @@ var require_qunit = __commonJS({
         }
       }
       function is(type, obj) {
-        return objectType2(obj) === type;
+        return objectType(obj) === type;
       }
       function generateHash(module3, testName) {
         var str = module3 + "" + testName;
@@ -322,7 +326,7 @@ var require_qunit = __commonJS({
         }
         return hex.slice(-8);
       }
-      function errorString2(error) {
+      function errorString(error) {
         var resultErrorString = String(error);
         if (resultErrorString.slice(0, 7) === "[object") {
           return (error.name || "Error") + (error.message ? ": ".concat(error.message) : "");
@@ -485,8 +489,8 @@ var require_qunit = __commonJS({
             a,
             b
           });
-          var aObjType = objectType2(a);
-          var bObjType = objectType2(b);
+          var aObjType = objectType(a);
+          var bObjType = objectType(b);
           if (aObjType !== "object" || bObjType !== "object") {
             return aObjType === bObjType && objTypeCallbacks[aObjType](a, b);
           }
@@ -517,7 +521,7 @@ var require_qunit = __commonJS({
         var aType = _typeof(a);
         var bType = _typeof(b);
         if (aType !== bType) {
-          return (aType === "object" && BOXABLE_TYPES.has(objectType2(a)) ? a.valueOf() : a) === (bType === "object" && BOXABLE_TYPES.has(objectType2(b)) ? b.valueOf() : b);
+          return (aType === "object" && BOXABLE_TYPES.has(objectType(a)) ? a.valueOf() : a) === (bType === "object" && BOXABLE_TYPES.has(objectType(b)) ? b.valueOf() : b);
         }
         return entryTypeCallbacks[aType](a, b);
       }
@@ -555,6 +559,7 @@ var require_qunit = __commonJS({
         failOnZeroTests: true,
         // Select by pattern or case-insensitive substring match against "moduleName: testName"
         filter: void 0,
+        ignoreUnhandledRejections: false,
         testFilter: null,
         // TODO: Make explicit in QUnit 3.
         // fixture: undefined,
@@ -1317,7 +1322,7 @@ var require_qunit = __commonJS({
             }
             this.test.timeout = duration;
             if (config.timeout) {
-              clearTimeout2(config.timeout);
+              clearTimeout(config.timeout);
               config.timeout = null;
               if (config.timeoutHandler && this.test.timeout > 0) {
                 this.test.internalResetTimeout(this.test.timeout);
@@ -1484,8 +1489,8 @@ var require_qunit = __commonJS({
         }, {
           key: "propEqual",
           value: function propEqual(actual, expected, message) {
-            actual = objectValues2(actual);
-            expected = objectValues2(expected);
+            actual = objectValues(actual);
+            expected = objectValues(expected);
             this.pushResult({
               result: equiv(actual, expected),
               actual,
@@ -1496,8 +1501,8 @@ var require_qunit = __commonJS({
         }, {
           key: "notPropEqual",
           value: function notPropEqual(actual, expected, message) {
-            actual = objectValues2(actual);
-            expected = objectValues2(expected);
+            actual = objectValues(actual);
+            expected = objectValues(expected);
             this.pushResult({
               result: !equiv(actual, expected),
               actual,
@@ -1509,8 +1514,8 @@ var require_qunit = __commonJS({
         }, {
           key: "propContains",
           value: function propContains(actual, expected, message) {
-            actual = objectValuesSubset2(actual, expected);
-            expected = objectValues2(expected, false);
+            actual = objectValuesSubset(actual, expected);
+            expected = objectValues(expected, false);
             this.pushResult({
               result: equiv(actual, expected),
               actual,
@@ -1521,8 +1526,8 @@ var require_qunit = __commonJS({
         }, {
           key: "notPropContains",
           value: function notPropContains(actual, expected, message) {
-            actual = objectValuesSubset2(actual, expected);
-            expected = objectValues2(expected);
+            actual = objectValuesSubset(actual, expected);
+            expected = objectValues(expected);
             this.pushResult({
               result: !equiv(actual, expected),
               actual,
@@ -1576,7 +1581,7 @@ var require_qunit = __commonJS({
         }, {
           key: "throws",
           value: function throws(block, expected, message) {
-            var _validateExpectedExce = validateExpectedExceptionArgs2(expected, message, "throws");
+            var _validateExpectedExce = validateExpectedExceptionArgs(expected, message, "throws");
             var _validateExpectedExce2 = _slicedToArray(_validateExpectedExce, 2);
             expected = _validateExpectedExce2[0];
             message = _validateExpectedExce2[1];
@@ -1599,7 +1604,7 @@ var require_qunit = __commonJS({
             }
             currentTest.ignoreGlobalErrors = false;
             if (actual) {
-              var _validateException = validateException2(actual, expected, message);
+              var _validateException = validateException(actual, expected, message);
               var _validateException2 = _slicedToArray(_validateException, 3);
               result = _validateException2[0];
               expected = _validateException2[1];
@@ -1608,15 +1613,16 @@ var require_qunit = __commonJS({
             currentTest.assert.pushResult({
               result,
               // undefined if it didn't throw
-              actual: actual && errorString2(actual),
+              actual: actual && errorString(actual),
               expected,
               message
             });
+            return actual;
           }
         }, {
           key: "rejects",
           value: function rejects(promise, expected, message) {
-            var _validateExpectedExce3 = validateExpectedExceptionArgs2(expected, message, "rejects");
+            var _validateExpectedExce3 = validateExpectedExceptionArgs(expected, message, "rejects");
             var _validateExpectedExce4 = _slicedToArray(_validateExpectedExce3, 2);
             expected = _validateExpectedExce4[0];
             message = _validateExpectedExce4[1];
@@ -1640,7 +1646,7 @@ var require_qunit = __commonJS({
               done();
             }, function handleRejection(actual) {
               var result;
-              var _validateException3 = validateException2(actual, expected, message);
+              var _validateException3 = validateException(actual, expected, message);
               var _validateException4 = _slicedToArray(_validateException3, 3);
               result = _validateException4[0];
               expected = _validateException4[1];
@@ -1648,17 +1654,18 @@ var require_qunit = __commonJS({
               currentTest.assert.pushResult({
                 result,
                 // leave rejection value of undefined as-is
-                actual: actual && errorString2(actual),
+                actual: actual && errorString(actual),
                 expected,
                 message
               });
               done();
+              return actual;
             });
           }
         }]);
       })();
-      function validateExpectedExceptionArgs2(expected, message, assertionMethod) {
-        var expectedType = objectType2(expected);
+      function validateExpectedExceptionArgs(expected, message, assertionMethod) {
+        var expectedType = objectType(expected);
         if (expectedType === "string") {
           if (message === void 0) {
             message = expected;
@@ -1675,25 +1682,25 @@ var require_qunit = __commonJS({
         }
         return [expected, message];
       }
-      function validateException2(actual, expected, message) {
+      function validateException(actual, expected, message) {
         var result = false;
-        var expectedType = objectType2(expected);
+        var expectedType = objectType(expected);
         if (!expected) {
           result = true;
         } else if (expectedType === "regexp") {
-          result = expected.test(errorString2(actual));
+          result = expected.test(errorString(actual));
           expected = String(expected);
         } else if (expectedType === "function" && expected.prototype !== void 0 && actual instanceof expected) {
           result = true;
         } else if (expectedType === "object") {
           result = actual instanceof expected.constructor && actual.name === expected.name && actual.message === expected.message;
-          expected = errorString2(expected);
+          expected = errorString(expected);
         } else if (expectedType === "function") {
           try {
             result = expected.call({}, actual) === true;
             expected = null;
           } catch (e) {
-            expected = errorString2(e);
+            expected = errorString(e);
           }
         }
         return [result, expected, message];
@@ -2275,7 +2282,7 @@ var require_qunit = __commonJS({
               try {
                 promise = hook.call(_this2.testEnvironment, _this2.assert);
               } catch (error) {
-                _this2.pushFailure("Global " + hookName + " failed on " + _this2.testName + ": " + errorString2(error), extractStacktrace(error, 0));
+                _this2.pushFailure("Global " + hookName + " failed on " + _this2.testName + ": " + errorString(error), extractStacktrace(error, 0));
                 return;
               }
             }
@@ -2341,7 +2348,7 @@ var require_qunit = __commonJS({
         finish: function finish() {
           config.current = this;
           if (setTimeout$1) {
-            clearTimeout2(this.timeout);
+            clearTimeout(this.timeout);
             config.timeoutHandler = null;
           }
           this.callback = void 0;
@@ -2554,7 +2561,7 @@ var require_qunit = __commonJS({
          * @param {number} timeoutDuration
          */
         internalResetTimeout: function internalResetTimeout(timeoutDuration) {
-          clearTimeout2(config.timeout);
+          clearTimeout(config.timeout);
           config.timeout = setTimeout$1(config.timeoutHandler(timeoutDuration), timeoutDuration);
         },
         /**
@@ -2662,10 +2669,10 @@ var require_qunit = __commonJS({
                   internalRecover(test4);
                 };
               };
-              clearTimeout2(config.timeout);
+              clearTimeout(config.timeout);
               config.timeout = setTimeout$1(config.timeoutHandler(timeoutDuration), timeoutDuration);
             } else {
-              clearTimeout2(config.timeout);
+              clearTimeout(config.timeout);
               config.timeout = setTimeout$1(function() {
                 config.timeout = null;
                 if (!config._deprecated_timeout_shown) {
@@ -2960,12 +2967,12 @@ var require_qunit = __commonJS({
           return;
         }
         if (setTimeout$1) {
-          clearTimeout2(config.timeout);
+          clearTimeout(config.timeout);
           config.timeout = setTimeout$1(function() {
             if (test4.pauses.size > 0) {
               return;
             }
-            clearTimeout2(config.timeout);
+            clearTimeout(config.timeout);
             config.timeout = null;
             config.blocking = false;
             config.pq.advance();
@@ -3355,7 +3362,7 @@ var require_qunit = __commonJS({
               this.log("not ok ".concat(this.testCount, " ").concat($.red("global failure")));
               this.logError(error);
             }
-            this.log("Bail out! " + errorString2(error).split("\n")[0]);
+            this.log("Bail out! " + errorString(error).split("\n")[0]);
             if (this.ended) {
               this.logError(error);
             }
@@ -3415,7 +3422,7 @@ var require_qunit = __commonJS({
           key: "logError",
           value: function logError(error) {
             var out = "  ---";
-            out += "\n  message: ".concat(prettyYamlValue(errorString2(error)));
+            out += "\n  message: ".concat(prettyYamlValue(errorString(error)));
             out += "\n  severity: ".concat(prettyYamlValue("failed"));
             if (error && error.stack) {
               var fmtStack = annotateStacktrace(error.stack, $.grey, error.toString());
@@ -3634,7 +3641,7 @@ var require_qunit = __commonJS({
         if (config.current) {
           config.current.assert.pushResult({
             result: false,
-            message: "global failure: ".concat(errorString2(error)),
+            message: "global failure: ".concat(errorString(error)),
             // We could let callers specify an offset to subtract a number of frames via
             // sourceFromStacktrace, in case they are a wrapper further away from the error
             // handler, and thus reduce some noise in the stack trace. However, we're not
@@ -3665,7 +3672,7 @@ var require_qunit = __commonJS({
       var DIFF_DELETE = -1;
       var DIFF_INSERT = 1;
       var DIFF_EQUAL = 0;
-      var hasOwn2 = Object.prototype.hasOwnProperty;
+      var hasOwn = Object.prototype.hasOwnProperty;
       DiffMatchPatch.prototype.DiffMain = function(text1, text2, optChecklines) {
         var deadline = Date.now() + 1e3;
         if (text1 === null || text2 === null) {
@@ -4159,7 +4166,7 @@ var require_qunit = __commonJS({
             }
             var line = text.substring(lineStart, lineEnd + 1);
             lineStart = lineEnd + 1;
-            if (hasOwn2.call(lineHash, line)) {
+            if (hasOwn.call(lineHash, line)) {
               chars += String.fromCharCode(lineHash[line]);
             } else {
               chars += String.fromCharCode(lineArrayLength);
@@ -4289,7 +4296,7 @@ var require_qunit = __commonJS({
       var globalStartCalled = false;
       var runStarted = false;
       QUnit.isLocal = window$1 && window$1.location && window$1.location.protocol === "file:";
-      QUnit.version = "2.25.0";
+      QUnit.version = "2.26.0";
       extend(QUnit, {
         config,
         diff: diff2,
@@ -4298,7 +4305,7 @@ var require_qunit = __commonJS({
         reporters,
         hooks,
         is,
-        objectType: objectType2,
+        objectType,
         on,
         onError: onWindowError,
         onUncaughtException,
@@ -4453,9 +4460,9 @@ var require_qunit = __commonJS({
           return;
         }
         var config2 = QUnit.config;
-        var hasOwn3 = Object.prototype.hasOwnProperty;
+        var hasOwn2 = Object.prototype.hasOwnProperty;
         function storeFixture() {
-          if (hasOwn3.call(config2, "fixture")) {
+          if (hasOwn2.call(config2, "fixture")) {
             return;
           }
           var fixture = document.getElementById("qunit-fixture");
@@ -5237,7 +5244,7 @@ var require_qunit = __commonJS({
         var config2 = QUnit.config;
         var hiddenTests = [];
         var collapseNext = false;
-        var hasOwn3 = Object.prototype.hasOwnProperty;
+        var hasOwn2 = Object.prototype.hasOwnProperty;
         var unfilteredUrl = setUrl({
           filter: void 0,
           module: void 0,
@@ -5332,7 +5339,7 @@ var require_qunit = __commonJS({
                 }
               } else {
                 for (var _j in val.value) {
-                  if (hasOwn3.call(val.value, _j)) {
+                  if (hasOwn2.call(val.value, _j)) {
                     urlConfigHtml += "<option value='" + escapeText(_j) + "'" + (config2[val.id] === _j ? (selection = true) && " selected='selected'" : "") + ">" + escapeText(val.value[_j]) + "</option>";
                   }
                 }
@@ -5394,7 +5401,7 @@ var require_qunit = __commonJS({
           var location = window$1.location;
           params = extend(extend({}, QUnit.urlParams), params);
           for (var key in params) {
-            if (hasOwn3.call(params, key) && params[key] !== void 0) {
+            if (hasOwn2.call(params, key) && params[key] !== void 0) {
               var arrValue = [].concat(params[key]);
               for (var i = 0; i < arrValue.length; i++) {
                 querystring += encodeURIComponent(key);
@@ -5918,7 +5925,7 @@ var require_qunit = __commonJS({
           if (!testItem) {
             return;
           }
-          var message = escapeText(errorString2(error));
+          var message = escapeText(errorString(error));
           message = "<span class='test-message'>" + message + "</span>";
           if (error && error.stack) {
             message += "<table><tr class='test-source'><th>Source: </th><td><pre>" + escapeText(error.stack) + "</pre></td></tr></table>";
@@ -5963,7 +5970,9 @@ var require_qunit = __commonJS({
           return ret;
         };
         window$1.addEventListener("unhandledrejection", function(event) {
-          QUnit.onUncaughtException(event.reason);
+          if (!QUnit.config.ignoreUnhandledRejections) {
+            QUnit.onUncaughtException(event.reason);
+          }
         });
       })();
     })();
@@ -5974,7 +5983,7 @@ var require_qunit = __commonJS({
 });
 
 // shims/deno/index.ts
-var import_qunit2 = __toESM(require_qunit(), 1);
+var import_qunit = __toESM(require_qunit(), 1);
 
 // jsr:https://jsr.io/@std/assert/1.0.19/assertion_error.ts
 var AssertionError = class extends Error {
@@ -6020,899 +6029,11 @@ var ANSI_PATTERN = new RegExp(
   "g"
 );
 
-// shims/shared/assert.ts
-var import_qunit = __toESM(require_qunit(), 1);
-
-// shims/shared/index.ts
-var hasOwn = Object.prototype.hasOwnProperty;
-var objToString = Object.prototype.toString;
-function objectType(obj) {
-  if (obj === null) return "null";
-  const t = typeof obj;
-  switch (t) {
-    case "undefined":
-    case "string":
-    case "boolean":
-    case "function":
-    case "symbol":
-    case "bigint":
-      return t;
-    case "number":
-      return obj !== obj ? "nan" : "number";
-  }
-  const type = objToString.call(obj).slice(8, -1);
-  switch (type) {
-    case "Number":
-      return isNaN(obj) ? "nan" : "number";
-    case "String":
-    case "Boolean":
-    case "Array":
-    case "Set":
-    case "Map":
-    case "Date":
-    case "RegExp":
-    case "Function":
-    case "Symbol":
-      return type.toLowerCase();
-    default:
-      return "object";
-  }
-}
-function objectValues(obj, allowArray = true) {
-  const vals = allowArray && Array.isArray(obj) ? [] : {};
-  for (const key in obj) {
-    if (hasOwn.call(obj, key)) {
-      const val = obj[key];
-      const t = typeof val;
-      const isObjectish = val !== null && (t === "object" || t === "function");
-      vals[key] = isObjectish ? objectValues(val, allowArray) : val;
-    }
-  }
-  return vals;
-}
-function objectValuesSubset(obj, model) {
-  if (obj === null) return obj;
-  const objT = typeof obj;
-  if (objT !== "object" && objT !== "function") return obj;
-  const subset = {};
-  for (const key in model) {
-    if (hasOwn.call(model, key) && hasOwn.call(obj, key)) {
-      subset[key] = objectValuesSubset(
-        obj[key],
-        model[key]
-      );
-    }
-  }
-  return subset;
-}
-function validateExpectedExceptionArgs(expected, message, assertionMethod) {
-  const expectedType = objectType(expected);
-  if (expectedType === "string") {
-    if (message === void 0) {
-      message = expected;
-      expected = void 0;
-      return [expected, message];
-    } else {
-      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 || expectedType === "regexp" || expectedType === "function" || expectedType === "object";
-  if (!valid) {
-    throw new Error(`Invalid expected value type (${expectedType}) provided to assert.${assertionMethod}.`);
-  }
-  return [expected, message];
-}
-function validateException(actual, expected, message) {
-  let result = false;
-  const expectedType = objectType(expected);
-  if (!expected) {
-    result = true;
-  } else if (expectedType === "regexp") {
-    result = expected.test(errorString(actual));
-    expected = String(expected);
-  } else if (expectedType === "function" && expected.prototype !== void 0 && actual instanceof expected) {
-    result = true;
-  } else if (expectedType === "object") {
-    result = actual instanceof expected.constructor && actual.name === expected.name && actual.message === expected.message;
-    expected = errorString(expected);
-  } else if (expectedType === "function") {
-    try {
-      result = expected.call({}, actual) === true;
-      expected = null;
-    } catch (e) {
-      expected = errorString(e);
-    }
-  }
-  return [result, expected, message];
-}
-function errorString(error) {
-  const resultErrorString = String(error);
-  if (resultErrorString.slice(0, 7) === "[object") {
-    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;
-  /** @internal Set by each runtime shim before tests run. */
-  static AssertionError;
-  /** @internal Set by each runtime shim before tests run. */
-  static inspect;
-  /** @internal Mutable test state written during the test run. */
-  test;
-  /** @internal */
-  constructor(module2, test3) {
-    this.test = test3 || module2.testContext;
-  }
-  /**
-   * Sets the number of milliseconds after which the current test will fail if not yet complete.
-   *
-   * @param {number} number - Timeout in milliseconds (positive integer).
-   * @example
-   * ```js
-   * test("slow async operation", async (assert) => {
-   *   assert.timeout(500);
-   *   await somethingAsync();
-   *   assert.ok(true);
-   * });
-   * ```
-   */
-  timeout(number) {
-    if (!Number.isInteger(number) || number < 0) {
-      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
-   * a sequence of steps occurred in the right order.
-   *
-   * @param {string} message - The step label to record.
-   * @example
-   * ```js
-   * test("event order", (assert) => {
-   *   assert.expect(3);
-   *   assert.step("step one");
-   *   assert.step("step two");
-   *   assert.verifySteps(["step one", "step two"]);
-   * });
-   * ```
-   */
-  step(message) {
-    this.test.steps.push(message);
-    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,
-   * then clears the recorded steps.
-   *
-   * @param {string[]} steps - Expected array of step labels in order.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * test("lifecycle order", (assert) => {
-   *   assert.step("init");
-   *   assert.step("run");
-   *   assert.verifySteps(["init", "run"]);
-   * });
-   * ```
-   */
-  verifySteps(steps, message = "Verify steps failed!") {
-    this.deepEqual(this.test.steps, steps, message);
-    this.test.steps.length = 0;
-  }
-  /**
-   * Sets the number of assertions expected to run in the current test.
-   * The test fails if a different number of assertions actually ran.
-   *
-   * @param {number} number - Expected assertion count (non-negative integer).
-   * @example
-   * ```js
-   * test("exactly two assertions", (assert) => {
-   *   assert.expect(2);
-   *   assert.ok(true);
-   *   assert.ok(true);
-   * });
-   * ```
-   */
-  expect(number) {
-    if (!Number.isInteger(number) || number < 0) {
-      throw new Error("assert.expect() expects a positive integer.");
-    }
-    this.test.expectedAssertionCount = number;
-  }
-  /**
-   * Returns a `done` callback for callback-style async tests. The test will not
-   * finish until every `done` callback returned by `async()` has been called.
-   *
-   * For `async/await` tests prefer `async (assert) => { ... }` directly.
-   *
-   * @returns {function} A callback to invoke when the async work finishes.
-   * @example
-   * ```js
-   * test("async callback style", (assert) => {
-   *   const done = assert.async();
-   *   setTimeout(() => {
-   *     assert.ok(true, "async callback ran");
-   *     done();
-   *   }, 10);
-   * });
-   * ```
-   */
-  async() {
-    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() {
-    return Promise.all(this.test.asyncOps);
-  }
-  /**
-   * Pushes a custom assertion result. Fails the test if `resultInfo.result` is falsy.
-   * Throws an {@linkcode AssertionError} on failure.
-   *
-   * Useful for building custom assertion helpers.
-   *
-   * @param {{ result: boolean, actual?: unknown, expected?: unknown, message?: string }} resultInfo
-   * @example
-   * ```js
-   * test("custom assertion", (assert) => {
-   *   assert.pushResult({
-   *     result: 1 + 1 === 2,
-   *     actual: 2,
-   *     expected: 2,
-   *     message: "custom math check",
-   *   });
-   * });
-   * ```
-   */
-  pushResult(resultInfo = {}) {
-    this.test.totalExecutedAssertions++;
-    if (!resultInfo.result) {
-      throw new _Assert.AssertionError({
-        actual: resultInfo.actual,
-        expected: resultInfo.expected,
-        message: resultInfo.message || "Custom assertion failed!",
-        stackStartFn: this.pushResult
-      });
-    }
-    return this;
-  }
-  /**
-   * Asserts that `state` is truthy.
-   *
-   * @param {unknown} state - The value to test.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.ok(true);
-   * assert.ok(1, "non-zero is truthy");
-   * assert.ok("hello");
-   * ```
-   */
-  ok(state, message) {
-    this.test.totalExecutedAssertions++;
-    if (!state) {
-      throw new _Assert.AssertionError({
-        actual: state,
-        expected: true,
-        message: message || `Expected argument to be truthy, it was: ${inspect(state)}`,
-        stackStartFn: this.ok
-      });
-    }
-  }
-  /**
-   * Asserts that `state` is falsy.
-   *
-   * @param {unknown} state - The value to test.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.notOk(false);
-   * assert.notOk(0, "zero is falsy");
-   * assert.notOk(null);
-   * ```
-   */
-  notOk(state, message) {
-    this.test.totalExecutedAssertions++;
-    if (state) {
-      throw new _Assert.AssertionError({
-        actual: state,
-        expected: false,
-        message: message || `Expected argument to be falsy, it was: ${inspect(state)}`,
-        stackStartFn: this.notOk
-      });
-    }
-  }
-  /**
-   * Asserts that `state === true` (strict boolean true).
-   *
-   * @param {unknown} state - The value to test.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.true(1 === 1);
-   * assert.true(Array.isArray([]), "arrays are arrays");
-   * ```
-   */
-  true(state, message) {
-    this.test.totalExecutedAssertions++;
-    if (state !== true) {
-      throw new _Assert.AssertionError({
-        actual: state,
-        expected: true,
-        message: message || `Expected argument to be true, it was: ${inspect(state)}`,
-        stackStartFn: this.true
-      });
-    }
-  }
-  /**
-   * Asserts that `state === false` (strict boolean false).
-   *
-   * @param {unknown} state - The value to test.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.false(1 === 2);
-   * assert.false(Number.isNaN(42), "42 is not NaN");
-   * ```
-   */
-  false(state, message) {
-    this.test.totalExecutedAssertions++;
-    if (state !== false) {
-      throw new _Assert.AssertionError({
-        actual: state,
-        expected: false,
-        message: message || `Expected argument to be false, it was: ${inspect(state)}`,
-        stackStartFn: this.false
-      });
-    }
-  }
-  /**
-   * Asserts that `actual == expected` (loose equality, allows type coercion).
-   *
-   * Prefer {@linkcode Assert.prototype.strictEqual} for most comparisons. Use {@linkcode Assert.prototype.notEqual}
-   * for the inverse.
-   *
-   * @param {unknown} actual - The value produced by the code under test.
-   * @param {unknown} expected - The expected value.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.equal(1, 1);
-   * assert.equal("1", 1, "loose equality allows coercion");
-   * ```
-   */
-  equal(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    if (actual != expected) {
-      throw new _Assert.AssertionError({
-        actual,
-        expected,
-        message: message || `Values are not equal:${formatDiff(actual, expected)}`,
-        operator: "==",
-        stackStartFn: this.equal
-      });
-    }
-  }
-  /**
-   * Asserts that `actual != expected` (loose inequality). Inverse of {@linkcode Assert.prototype.equal}.
-   *
-   * @param {unknown} actual - The actual value.
-   * @param {unknown} expected - The value it should not loosely equal.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.notEqual(1, 2);
-   * assert.notEqual("hello", "world");
-   * ```
-   */
-  notEqual(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    if (actual == expected) {
-      throw new _Assert.AssertionError({
-        actual,
-        expected,
-        operator: "!=",
-        message: message || `Values are unexpectedly equal:${formatUnexpectedMatch(actual)}`,
-        stackStartFn: this.notEqual
-      });
-    }
-  }
-  /**
-   * Asserts that `actual` and `expected` have the same own enumerable properties
-   * and values. Prototype methods are ignored; only own properties are compared.
-   *
-   * @param {object} actual - The actual object.
-   * @param {object} expected - The expected object.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.propEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
-   *
-   * // Ignores prototype methods — only own properties matter:
-   * function Point(x, y) { this.x = x; this.y = y; }
-   * assert.propEqual(new Point(1, 2), { x: 1, y: 2 });
-   * ```
-   */
-  propEqual(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    const targetActual = objectValues(actual);
-    const targetExpected = objectValues(expected);
-    if (!_Assert.QUnit.equiv(targetActual, targetExpected)) {
-      throw new _Assert.AssertionError({
-        actual: targetActual,
-        expected: targetExpected,
-        message: message || `Own properties are not equal:${formatDiff(targetActual, targetExpected)}`,
-        stackStartFn: this.propEqual
-      });
-    }
-  }
-  /**
-   * Asserts that `actual` and `expected` do NOT have the same own enumerable
-   * properties and values. Inverse of {@linkcode Assert.prototype.propEqual}.
-   *
-   * @param {object} actual - The actual object.
-   * @param {object} expected - The value it should not propEqual.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.notPropEqual({ a: 1 }, { a: 2 });
-   * assert.notPropEqual({ a: 1, b: 2 }, { a: 1 }); // extra key makes them unequal
-   * ```
-   */
-  notPropEqual(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    const targetActual = objectValues(actual);
-    const targetExpected = objectValues(expected);
-    if (_Assert.QUnit.equiv(targetActual, targetExpected)) {
-      throw new _Assert.AssertionError({
-        actual: targetActual,
-        expected: targetExpected,
-        message: message || `Own properties are unexpectedly equal:${formatUnexpectedMatch(targetActual)}`,
-        stackStartFn: this.notPropEqual
-      });
-    }
-  }
-  /**
-   * Asserts that `actual` contains all own enumerable properties from `expected`
-   * with matching values. Extra properties on `actual` are allowed and ignored.
-   *
-   * @param {object} actual - The actual object (may have extra keys).
-   * @param {object} expected - The subset of key/value pairs that must be present.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.propContains({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 });
-   * assert.propContains(user, { role: "admin" });
-   * ```
-   */
-  propContains(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    const targetActual = objectValuesSubset(actual, expected);
-    const targetExpected = objectValues(expected, false);
-    if (!_Assert.QUnit.equiv(targetActual, targetExpected)) {
-      throw new _Assert.AssertionError({
-        actual: targetActual,
-        expected: targetExpected,
-        message: message || `Object does not contain expected properties:${formatDiff(targetActual, targetExpected)}`,
-        stackStartFn: this.propContains
-      });
-    }
-  }
-  /**
-   * Asserts that `actual` does NOT contain all own enumerable properties
-   * from `expected` with matching values. Inverse of {@linkcode Assert.prototype.propContains}.
-   *
-   * @param {object} actual - The actual object.
-   * @param {object} expected - The subset of properties that must NOT all match.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.notPropContains({ a: 1, b: 2 }, { a: 9 });
-   * assert.notPropContains(user, { role: "banned" });
-   * ```
-   */
-  notPropContains(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    const targetActual = objectValuesSubset(actual, expected);
-    const targetExpected = objectValues(expected);
-    if (_Assert.QUnit.equiv(targetActual, targetExpected)) {
-      throw new _Assert.AssertionError({
-        actual: targetActual,
-        expected: targetExpected,
-        message: message || `Object unexpectedly contains all expected properties:${formatUnexpectedMatch(targetActual)}`,
-        stackStartFn: this.notPropContains
-      });
-    }
-  }
-  /**
-   * Asserts deep equality between `actual` and `expected` using recursive structural
-   * comparison. Handles nested objects, arrays, `Date`, `RegExp`, and more.
-   *
-   * @param {unknown} actual - The actual value.
-   * @param {unknown} expected - The expected value.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.deepEqual([1, { a: 2 }], [1, { a: 2 }]);
-   * assert.deepEqual(new Date("2024-01-01"), new Date("2024-01-01"));
-   * ```
-   */
-  deepEqual(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    if (!_Assert.QUnit.equiv(actual, expected)) {
-      throw new _Assert.AssertionError({
-        actual,
-        expected,
-        message: message || `Values are not deeply equal:${formatDiff(actual, expected)}`,
-        operator: "deepEqual",
-        stackStartFn: this.deepEqual
-      });
-    }
-  }
-  /**
-   * Asserts that `actual` and `expected` are NOT deeply equal. Inverse of {@linkcode Assert.prototype.deepEqual}.
-   *
-   * @param {unknown} actual - The actual value.
-   * @param {unknown} expected - The value it should not deepEqual.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.notDeepEqual([1, 2], [1, 3]);
-   * assert.notDeepEqual({ a: 1 }, { a: 2 });
-   * ```
-   */
-  notDeepEqual(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    if (_Assert.QUnit.equiv(actual, expected)) {
-      throw new _Assert.AssertionError({
-        actual,
-        expected,
-        message: message || `Values are unexpectedly deeply equal:${formatUnexpectedMatch(actual)}`,
-        operator: "notDeepEqual",
-        stackStartFn: this.notDeepEqual
-      });
-    }
-  }
-  /**
-   * Asserts that `actual === expected` (strict equality, no type coercion).
-   *
-   * @param {unknown} actual - The actual value.
-   * @param {unknown} expected - The expected value.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.strictEqual(1 + 1, 2);
-   * assert.strictEqual(typeof "hello", "string");
-   * ```
-   */
-  strictEqual(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    if (actual !== expected) {
-      throw new _Assert.AssertionError({
-        actual,
-        expected,
-        message: message || `Values are not strictly equal:${formatDiff(actual, expected)}`,
-        operator: "strictEqual",
-        stackStartFn: this.strictEqual
-      });
-    }
-  }
-  /**
-   * Asserts that `actual !== expected` (strict inequality). Inverse of {@linkcode Assert.prototype.strictEqual}.
-   *
-   * @param {unknown} actual - The actual value.
-   * @param {unknown} expected - The value it should not strictly equal.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.notStrictEqual(1, "1", "different types");
-   * assert.notStrictEqual({}, {}, "different object references");
-   * ```
-   */
-  notStrictEqual(actual, expected, message) {
-    this.test.totalExecutedAssertions++;
-    if (actual === expected) {
-      throw new _Assert.AssertionError({
-        actual,
-        expected,
-        message: message || `Values are unexpectedly strictly equal:${formatUnexpectedMatch(actual)}`,
-        operator: "notStrictEqual",
-        stackStartFn: this.notStrictEqual
-      });
-    }
-  }
-  /**
-   * Asserts that `blockFn` throws an exception. Optionally validates the thrown
-   * error against a string (message substring), RegExp (message pattern),
-   * or constructor (`instanceof` check). For async functions use {@linkcode Assert.prototype.rejects}.
-   *
-   * @param {function} blockFn - A synchronous function expected to throw.
-   * @param {string|RegExp|function} [expected] - Optional matcher for the thrown error.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * assert.throws(() => { throw new Error("boom"); });
-   * assert.throws(() => JSON.parse("{bad}"), SyntaxError);
-   * assert.throws(() => { throw new Error("bad input"); }, /bad input/);
-   * ```
-   */
-  throws(blockFn, expectedInput, assertionMessage) {
-    this.test.totalExecutedAssertions++;
-    const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, "throws");
-    if (typeof blockFn !== "function") {
-      throw new _Assert.AssertionError({
-        actual: blockFn,
-        expected: Function,
-        message: "The value provided to `assert.throws` was not a function.",
-        stackStartFn: this.throws
-      });
-    }
-    let returnValue;
-    try {
-      returnValue = blockFn();
-    } catch (error) {
-      const [result, , validatedMessage] = validateException(error, expected, message);
-      if (result === false) {
-        const expectedDesc = describeExpected(expected);
-        const receivedDesc = String(error);
-        throw new _Assert.AssertionError({
-          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,
-      message: "Function passed to `assert.throws` did not throw an exception!",
-      stackStartFn: this.throws
-    });
-  }
-  /**
-   * Asserts that a promise rejects. Optionally validates the rejection reason
-   * against a string (message substring), RegExp (message pattern),
-   * or constructor (`instanceof` check). For synchronous throws use {@linkcode Assert.prototype.throws}.
-   *
-   * @param {Promise<unknown>} promise - A promise expected to reject.
-   * @param {string|RegExp|function} [expected] - Optional matcher for the rejection reason.
-   * @param {string} [message] - Optional failure message.
-   * @example
-   * ```js
-   * await assert.rejects(Promise.reject(new Error("oops")));
-   * await assert.rejects(fetch("/bad-url"), TypeError);
-   * await assert.rejects(Promise.reject(new Error("timeout")), /timeout/);
-   * ```
-   */
-  async rejects(promise, expectedInput, assertionMessage) {
-    this.test.totalExecutedAssertions++;
-    const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, "rejects");
-    const then = promise && promise.then;
-    if (typeof then !== "function") {
-      throw new _Assert.AssertionError({
-        actual: promise,
-        expected,
-        message: "The value provided to `assert.rejects` was not a promise!",
-        stackStartFn: this.rejects
-      });
-    }
-    let caught = PENDING;
-    try {
-      await promise;
-    } catch (error) {
-      caught = error;
-    }
-    if (caught === PENDING) {
-      throw new _Assert.AssertionError({
-        actual: promise,
-        expected,
-        message: "The promise returned by the `assert.rejects` callback did not reject!",
-        stackStartFn: this.rejects
-      });
-    }
-    const [result, , validatedMessage] = validateException(caught, expected, message);
-    if (result === false) {
-      const expectedDesc = describeExpected(expected);
-      const receivedDesc = String(caught);
-      throw new _Assert.AssertionError({
-        actual: receivedDesc,
-        expected: expectedDesc,
-        message: validatedMessage || throwsFailMessage("rejects", expectedDesc, receivedDesc),
-        stackStartFn: this.rejects
-      });
-    }
-  }
-};
-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 `
-
-Actual:   ${aStr}
-Expected: ${bStr}`;
-  const lines = lcsDiff(aLines, bLines).map(
-    ([t, line]) => t === "=" ? `  ${line}` : t === "-" ? `- ${line}` : `+ ${line}`
-  );
-  return `
-
-- Actual  + Expected
-
-${lines.join("\n")}`;
-}
-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/filter-stack.ts
-var FILTER_PATTERNS = [
-  /\bnode:internal\/test_runner\//,
-  /\bnode:async_hooks\b/
-];
-function isDebugEnabled() {
-  try {
-    const proc = globalThis.process;
-    if (proc?.env?.QUNITX_DEBUG === "1") return true;
-    const deno = globalThis.Deno;
-    if (deno?.env?.get?.("QUNITX_DEBUG") === "1") return true;
-  } catch {
-  }
-  return false;
-}
-function filterStack(stack) {
-  if (!stack || isDebugEnabled()) return stack;
-  return stack.split("\n").filter((line) => !FILTER_PATTERNS.some((p) => p.test(line))).join("\n");
-}
-
-// shims/shared/test-context.ts
-var TestContext = class _TestContext {
-  static Assert;
-  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);
-      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;
-    }
-  }
-  finish() {
-    if (this.#timedOut) return;
-    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 !== 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}`
-      });
-    }
-  }
-};
-
-// shims/shared/module-context.ts
-var ModuleContext = class _ModuleContext {
-  static Assert;
-  static currentModuleChain = [];
-  static get lastModule() {
-    const chain = this.currentModuleChain;
-    return chain[chain.length - 1];
-  }
-  name;
-  assert;
-  userContext;
-  // Internal fallback assert for modules with no direct tests
-  testContext = new TestContext();
-  moduleChain = [];
-  beforeEachHooks = [];
-  afterEachHooks = [];
-  tests = [];
-  constructor(name) {
-    const chain = _ModuleContext.currentModuleChain;
-    const parentModule = chain[chain.length - 1];
-    chain.push(this);
-    this.moduleChain = chain.slice();
-    this.name = parentModule ? `${parentModule.name} > ${name}` : name;
-    this.assert = new _ModuleContext.Assert(this);
-    this.userContext = parentModule ? Object.create(parentModule.userContext) : /* @__PURE__ */ Object.create(null);
-    return Object.freeze(this);
-  }
-};
+// shims/deno/index.ts
+import Assert from "../shared/assert.js";
+import { filterStack } from "../shared/filter-stack.js";
+import ModuleContext3 from "../shared/module-context.js";
+import TestContext2 from "../shared/test-context.js";
 
 // jsr:https://jsr.io/@std/internal/1.0.12/assertion_state.ts
 var AssertionState = class {
@@ -7703,6 +6824,7 @@ describe.skip = function describeSkip(...args) {
 };
 
 // shims/deno/module.ts
+import ModuleContext from "../shared/module-context.js";
 function module(moduleName, runtimeOptions, moduleContent) {
   const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
   const { skip: skip2 } = targetRuntimeOptions;
@@ -7762,10 +6884,13 @@ module.todo = function todoModule(moduleName, _moduleContent) {
   describe(moduleName, { ignore: true }, function() {
   });
 };
+var module_default = module;
 
 // shims/deno/test.ts
+import ModuleContext2 from "../shared/module-context.js";
+import TestContext from "../shared/test-context.js";
 function test2(testName, runtimeOptions, testContent) {
-  const moduleContext = ModuleContext.lastModule;
+  const moduleContext = ModuleContext2.lastModule;
   if (!moduleContext) {
     throw new Error(`Test '${testName}' called outside of module context.`);
   }
@@ -7818,9 +6943,19 @@ test2.todo = function todoTest(testName, _testContent) {
   it(testName, { ignore: true }, async function() {
   });
 };
+var test_default = test2;
 
 // shims/deno/index.ts
 var AssertionError2 = class extends AssertionError {
+  /**
+   * Builds an assertion failure, trimming the stack to the caller's frame.
+   *
+   * @param {object} object - Failure details.
+   * @param {string} [object.message] - Failure message; defaults to `"Assertion failed"`.
+   * @param {Function} [object.stackStartFn] - Frames at and above this function are cut
+   *   from the stack, so the trace starts at the caller's assertion rather than inside
+   *   QUnitX.
+   */
   constructor(object) {
     super(object.message ?? "Assertion failed");
     if (object.stackStartFn) Error.captureStackTrace(this, object.stackStartFn);
@@ -7830,25 +6965,25 @@ var AssertionError2 = class extends AssertionError {
 Assert.QUnit = globalThis.QUnit;
 Assert.AssertionError = AssertionError2;
 Assert.inspect = Deno.inspect;
-ModuleContext.Assert = Assert;
-TestContext.Assert = Assert;
+ModuleContext3.Assert = Assert;
+TestContext2.Assert = Assert;
 Object.freeze(Assert);
-Object.freeze(ModuleContext);
-Object.freeze(TestContext);
-var skip = test2.skip;
-var todo = test2.todo;
-var index_default = { AssertionError: Assert.AssertionError, module, test: test2, config: {} };
+Object.freeze(ModuleContext3);
+Object.freeze(TestContext2);
+var skip = test_default.skip;
+var todo = test_default.todo;
+var index_default = { AssertionError: Assert.AssertionError, module: module_default, test: test_default, config: {} };
 export {
   Assert,
   AssertionError2 as AssertionError,
   index_default as default,
-  module,
+  module_default as module,
   skip,
-  test2 as test,
+  test_default as test,
   todo
 };
 /*!
- * QUnit 2.25.0
+ * QUnit 2.26.0
  * https://qunitjs.com/
  *
  * Copyright OpenJS Foundation and other contributors