qunitx 1.2.6 → 1.2.8

package/dist/deno/module.js

@@ -1,4 +1,4 @@
-import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
+import { afterAll, beforeAll, describe } from "jsr:@std/testing/bdd";
 import ModuleContext from "../shared/module-context.js";
 function module(moduleName, runtimeOptions, moduleContent) {
   const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
@@ -8,12 +8,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) {
@@ -21,17 +21,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, {
@@ -47,7 +46,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();
   });
 }

package/dist/deno/test.d.ts

@@ -1,6 +1,4 @@
 import type Assert from '../shared/assert.d.ts';
-export type { Assert };
-export type { PushResultInfo } from '../types.d.ts';
 /**
  * Defines an individual test within a module for Deno's BDD test runner.
  *
@@ -48,3 +46,5 @@ declare namespace test {
     var todo: (testName: string, _testContent?: unknown) => void;
 }
 export default test;
+export type { Assert };
+export type { PushResultInfo } from '../types.d.ts';

package/dist/deno/test.js

@@ -1,6 +1,6 @@
 import { it } from "jsr:@std/testing/bdd";
-import TestContext from "../shared/test-context.js";
 import ModuleContext from "../shared/module-context.js";
+import TestContext from "../shared/test-context.js";
 function test(testName, runtimeOptions, testContent) {
   const moduleContext = ModuleContext.lastModule;
   if (!moduleContext) {
@@ -13,37 +13,36 @@ function test(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 module of context.module.moduleChain) {
-            for (const hook of module.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 module = context.module.moduleChain[i];
-            for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-              await module.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;
   });
 }
 test.skip = function skipTest(testName, _testContent) {

package/dist/node/index.d.ts

@@ -1,14 +1,15 @@
 import Assert from '../shared/assert.d.ts';
 import Module from './module.d.ts';
 import Test from './test.d.ts';
-export { default as module } from './module.d.ts';
-export { default as test } from './test.d.ts';
 export { Assert };
+export { default as module } from './module.d.ts';
 export declare const skip: (testName: string, _testContent?: unknown) => void;
+export { default as test } from './test.d.ts';
 export declare const todo: (testName: string, testContent?: (assert: Assert, meta: {
     testName: string;
     options: unknown;
 }) => void | Promise<void>) => void;
+export type { HookFn, HooksObject, PushResultInfo, TestFn } from '../types.d.ts';
 declare const _default: {
     AssertionError: import("../types.d.ts").AssertionErrorConstructor;
     module: typeof Module;

package/dist/node/index.js

@@ -15,8 +15,8 @@ Object.freeze(Assert);
 Object.freeze(ModuleContext);
 Object.freeze(TestContext);
 import { default as default2 } from "./module.js";
-import { default as default3 } from "./test.js";
 const skip = Test.skip;
+import { default as default3 } from "./test.js";
 const todo = Test.todo;
 var node_default = { AssertionError: Assert.AssertionError, module: Module, test: Test, config: {} };
 export {

package/dist/node/module.js

@@ -1,4 +1,4 @@
-import { describe, before as beforeAll, after as afterAll } from "node:test";
+import { after as afterAll, before as beforeAll, describe } from "node:test";
 import ModuleContext from "../shared/module-context.js";
 function module(moduleName, runtimeOptions, moduleContent) {
   const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
@@ -8,12 +8,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) {
@@ -21,17 +21,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, {
@@ -47,7 +46,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();
   });
 }

package/dist/node/test.js

@@ -1,6 +1,6 @@
 import { it } from "node:test";
-import TestContext from "../shared/test-context.js";
 import ModuleContext from "../shared/module-context.js";
+import TestContext from "../shared/test-context.js";
 function test(testName, runtimeOptions, testContent) {
   const moduleContext = ModuleContext.lastModule;
   if (!moduleContext) {
@@ -19,32 +19,31 @@ function test(testName, runtimeOptions, testContent) {
   context.userContext = userContext;
   if (todo) moduleContext.tests.pop();
   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 { 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 module = context.module.moduleChain[i];
-            for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-              await module.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;
   });
 }
 test.skip = function skipTest(testName, _testContent) {

package/dist/shared/assert.d.ts

@@ -1,5 +1,5 @@
 import '../../vendor/qunit.js';
-import type { QUnitObject, AssertionErrorConstructor, InspectFn, TestState, ModuleState, PushResultInfo } from '../types.d.ts';
+import type { AssertionErrorConstructor, InspectFn, ModuleState, PushResultInfo, QUnitObject, TestState } from '../types.d.ts';
 /**
  * The assertion object passed to every test callback and lifecycle hook.
  *
@@ -31,7 +31,7 @@ export default class Assert {
     /** @internal */
     constructor(module: ModuleState | null, test?: TestState);
     /** @internal */
-    _incrementAssertionCount(): void;
+    private _incrementAssertionCount;
     /**
      * Sets the number of milliseconds after which the current test will fail if not yet complete.
      *

package/dist/shared/assert.js

@@ -1,5 +1,6 @@
 import "../../vendor/qunit.js";
-import { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException } from "./index.js";
+import { objectValues, objectValuesSubset, validateException, validateExpectedExceptionArgs } from "./index.js";
+const PENDING = /* @__PURE__ */ Symbol("pending");
 class Assert {
   /** @internal Set by each runtime shim before tests run. */
   static QUnit;
@@ -11,7 +12,7 @@ class Assert {
   test;
   /** @internal */
   constructor(module, test) {
-    this.test = test || module.context;
+    this.test = test || module.testContext;
   }
   /** @internal */
   _incrementAssertionCount() {
@@ -53,19 +54,10 @@ 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,
@@ -125,14 +117,9 @@ 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() {
@@ -280,7 +267,7 @@ 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
       });
@@ -305,7 +292,7 @@ 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
       });
     }
@@ -334,7 +321,7 @@ 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
       });
     }
@@ -360,7 +347,7 @@ 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
       });
     }
@@ -386,7 +373,7 @@ 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
       });
     }
@@ -412,7 +399,7 @@ 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
       });
     }
@@ -436,7 +423,7 @@ 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
       });
@@ -460,7 +447,7 @@ 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
       });
@@ -484,7 +471,7 @@ 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
       });
@@ -508,7 +495,7 @@ 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
       });
@@ -530,7 +517,7 @@ 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({
@@ -540,20 +527,31 @@ 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,
@@ -588,15 +586,13 @@ 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,
@@ -604,29 +600,67 @@ 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 `
+const INSPECT_OPTIONS = { depth: 10, colors: true, compact: false };
+const 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 });
+const formatUnexpectedMatch = (actual) => `
+
+${inspect(actual)}`;
+const describeExpected = (expected) => expected == null ? "(no pattern)" : typeof expected === "string" ? expected : typeof expected === "function" ? expected.name || String(expected) : String(expected);
+const 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();
 }
 export {
   Assert as default

package/dist/shared/index.d.ts

@@ -1,21 +1,9 @@
 export declare function objectType(obj: unknown): string;
 export declare function objectValues(obj: unknown, allowArray?: boolean): unknown;
 /**
- *
  * Recursively clone an object into a plain object, taking only the
- * subset of own enumerable properties that exist a given model.
- *
- * @param {any} obj
- * @param {any} model
- * @return {Object}
+ * subset of own enumerable properties that exist in a given model.
  */
 export declare function objectValuesSubset(obj: unknown, model: unknown): unknown;
 export declare function validateExpectedExceptionArgs(expected: unknown, message: string | undefined, assertionMethod: string): [unknown, string | undefined];
 export declare function validateException(actual: unknown, expected: unknown, message: string | undefined): [boolean, unknown, string | undefined];
-declare const _default: {
-    objectValues: typeof objectValues;
-    objectValuesSubset: typeof objectValuesSubset;
-    validateExpectedExceptionArgs: typeof validateExpectedExceptionArgs;
-    validateException: typeof validateException;
-};
-export default _default;