bupkis 0.12.2 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.13.0](https://github.com/boneskull/bupkis/compare/bupkis-v0.12.2...bupkis-v0.13.0) (2025-11-13)
+
+
+### Features
+
+* **assertions:** implement snapshot testing ([fc3ebff](https://github.com/boneskull/bupkis/commit/fc3ebff8c03e190fcd293ba0859a38fde2a2343e))
+
 ## [0.12.2](https://github.com/boneskull/bupkis/compare/bupkis-v0.12.1...bupkis-v0.12.2) (2025-10-31)
 
 

package/dist/assertion/assertion.cjs

@@ -208,8 +208,8 @@ class BupkisAssertion {
         });
     }
     /**
-     * Translates a {@link z.ZodError} into an {@link AssertionError} with a
-     * human-friendly message.
+     * Translates a `ZodError` into an {@link AssertionError} with a human-friendly
+     * message.
      *
      * @remarks
      * This does not handle parameterized assertions with more than one parameter

package/dist/assertion/assertion.d.cts

@@ -37,8 +37,8 @@ export declare abstract class BupkisAssertion<Parts extends AssertionParts, Impl
      */
     protected fromStandardSchemaIssues<Values>(issues: ReadonlyArray<StandardSchemaV1.Issue>, stackStartFn: (...args: any[]) => any, values: Values): AssertionError;
     /**
-     * Translates a {@link z.ZodError} into an {@link AssertionError} with a
-     * human-friendly message.
+     * Translates a `ZodError` into an {@link AssertionError} with a human-friendly
+     * message.
      *
      * @remarks
      * This does not handle parameterized assertions with more than one parameter

package/dist/assertion/assertion.d.ts

@@ -37,8 +37,8 @@ export declare abstract class BupkisAssertion<Parts extends AssertionParts, Impl
      */
     protected fromStandardSchemaIssues<Values>(issues: ReadonlyArray<StandardSchemaV1.Issue>, stackStartFn: (...args: any[]) => any, values: Values): AssertionError;
     /**
-     * Translates a {@link z.ZodError} into an {@link AssertionError} with a
-     * human-friendly message.
+     * Translates a `ZodError` into an {@link AssertionError} with a human-friendly
+     * message.
      *
      * @remarks
      * This does not handle parameterized assertions with more than one parameter

package/dist/assertion/assertion.js

@@ -202,8 +202,8 @@ export class BupkisAssertion {
         });
     }
     /**
-     * Translates a {@link z.ZodError} into an {@link AssertionError} with a
-     * human-friendly message.
+     * Translates a `ZodError` into an {@link AssertionError} with a human-friendly
+     * message.
      *
      * @remarks
      * This does not handle parameterized assertions with more than one parameter

package/dist/assertion/impl/async-parametric.d.cts

@@ -99,8 +99,8 @@ export declare const promiseRejectAssertion: import("../assertion-types.js").Ass
  */
 export declare const functionRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
@@ -128,8 +128,8 @@ export declare const functionRejectWithTypeAssertion: import("../assertion-types
  */
 export declare const promiseRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
@@ -163,12 +163,12 @@ export declare const promiseRejectWithTypeAssertion: import("../assertion-types.
  */
 export declare const functionRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>;
 /**
  * Assertion for testing if a Promise rejects with an error satisfying specific
@@ -198,12 +198,12 @@ export declare const functionRejectWithErrorSatisfyingAssertion: import("../asse
  */
 export declare const promiseRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>;
 /**
  * Assertion for testing if a Promise fulfills with a value satisfying specific
@@ -233,12 +233,12 @@ export declare const promiseRejectWithErrorSatisfyingAssertion: import("../asser
  */
 export declare const promiseResolveWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>;
 /**
  * Assertion for testing if a function returns a Promise that fulfills with a
@@ -268,11 +268,11 @@ export declare const promiseResolveWithValueSatisfyingAssertion: import("../asse
  */
 export declare const functionFulfillWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>;
 //# sourceMappingURL=async-parametric.d.ts.map

package/dist/assertion/impl/async-parametric.d.ts

@@ -99,8 +99,8 @@ export declare const promiseRejectAssertion: import("../assertion-types.js").Ass
  */
 export declare const functionRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
@@ -128,8 +128,8 @@ export declare const functionRejectWithTypeAssertion: import("../assertion-types
  */
 export declare const promiseRejectWithTypeAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
@@ -163,12 +163,12 @@ export declare const promiseRejectWithTypeAssertion: import("../assertion-types.
  */
 export declare const functionRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>;
 /**
  * Assertion for testing if a Promise rejects with an error satisfying specific
@@ -198,12 +198,12 @@ export declare const functionRejectWithErrorSatisfyingAssertion: import("../asse
  */
 export declare const promiseRejectWithErrorSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>;
 /**
  * Assertion for testing if a Promise fulfills with a value satisfying specific
@@ -233,12 +233,12 @@ export declare const promiseRejectWithErrorSatisfyingAssertion: import("../asser
  */
 export declare const promiseResolveWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>;
 /**
  * Assertion for testing if a function returns a Promise that fulfills with a
@@ -268,11 +268,11 @@ export declare const promiseResolveWithValueSatisfyingAssertion: import("../asse
  */
 export declare const functionFulfillWithValueSatisfyingAssertion: import("../assertion-types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnknown]>;
 //# sourceMappingURL=async-parametric.d.ts.map

package/dist/assertion/impl/async.d.cts

@@ -21,52 +21,52 @@ export declare const AsyncParametricAssertions: readonly [import("../assertion-t
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>];
 /**
  * Tuple of all built-in async assertions (Promise only).
@@ -83,52 +83,52 @@ export declare const AsyncAssertions: readonly [import("../assertion-types.js").
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>];
 export * from "./async-parametric.cjs";
 //# sourceMappingURL=async.d.ts.map

package/dist/assertion/impl/async.d.ts

@@ -21,52 +21,52 @@ export declare const AsyncParametricAssertions: readonly [import("../assertion-t
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>];
 /**
  * Tuple of all built-in async assertions (Promise only).
@@ -83,52 +83,52 @@ export declare const AsyncAssertions: readonly [import("../assertion-types.js").
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("../../types.js").Constructor) => Promise<{
     message: string;
-    actual?: never;
-    expected?: never;
+    actual?: undefined;
+    expected?: undefined;
 } | {
     actual: string;
     expected: string;
     message: string;
 } | undefined>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], import("zod/v4").ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
     subject: {} | null;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
     message: string;
-    schema?: never;
-    subject?: never;
+    schema?: undefined;
+    subject?: undefined;
 } | {
     schema: import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
     subject: unknown;
-    message?: never;
+    message?: undefined;
 }>, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnknown]>];
 export * from "./async-parametric.js";
 //# sourceMappingURL=async.d.ts.map

package/dist/assertion/impl/index.cjs

@@ -27,6 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./async-parametric.cjs"), exports);
 __exportStar(require("./async.cjs"), exports);
+__exportStar(require("./snapshot.cjs"), exports);
 __exportStar(require("./sync-basic.cjs"), exports);
 __exportStar(require("./sync-collection.cjs"), exports);
 __exportStar(require("./sync-date.cjs"), exports);

package/dist/assertion/impl/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;;;;;;;;;;;;;;AAEH,yDAAsC;AACtC,8CAA2B;AAC3B,mDAAgC;AAChC,wDAAqC;AACrC,kDAA+B;AAC/B,sDAAmC;AACnC,wDAAqC;AACrC,6CAA0B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;;;;;;;;;;;;;;AAEH,yDAAsC;AACtC,8CAA2B;AAC3B,iDAA8B;AAC9B,mDAAgC;AAChC,wDAAqC;AACrC,kDAA+B;AAC/B,sDAAmC;AACnC,wDAAqC;AACrC,6CAA0B"}

package/dist/assertion/impl/index.d.cts

@@ -11,6 +11,7 @@
  */
 export * from "./async-parametric.cjs";
 export * from "./async.cjs";
+export * from "./snapshot.cjs";
 export * from "./sync-basic.cjs";
 export * from "./sync-collection.cjs";
 export * from "./sync-date.cjs";

package/dist/assertion/impl/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uCAAsC;AACtC,4BAA2B;AAC3B,iCAAgC;AAChC,sCAAqC;AACrC,gCAA+B;AAC/B,oCAAmC;AACnC,sCAAqC;AACrC,2BAA0B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uCAAsC;AACtC,4BAA2B;AAC3B,+BAA8B;AAC9B,iCAAgC;AAChC,sCAAqC;AACrC,gCAA+B;AAC/B,oCAAmC;AACnC,sCAAqC;AACrC,2BAA0B"}

package/dist/assertion/impl/index.d.ts

@@ -11,6 +11,7 @@
  */
 export * from "./async-parametric.js";
 export * from "./async.js";
+export * from "./snapshot.js";
 export * from "./sync-basic.js";
 export * from "./sync-collection.js";
 export * from "./sync-date.js";

package/dist/assertion/impl/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sCAAsC;AACtC,2BAA2B;AAC3B,gCAAgC;AAChC,qCAAqC;AACrC,+BAA+B;AAC/B,mCAAmC;AACnC,qCAAqC;AACrC,0BAA0B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sCAAsC;AACtC,2BAA2B;AAC3B,8BAA8B;AAC9B,gCAAgC;AAChC,qCAAqC;AACrC,+BAA+B;AAC/B,mCAAmC;AACnC,qCAAqC;AACrC,0BAA0B"}

package/dist/assertion/impl/index.js

@@ -11,6 +11,7 @@
  */
 export * from "./async-parametric.js";
 export * from "./async.js";
+export * from "./snapshot.js";
 export * from "./sync-basic.js";
 export * from "./sync-collection.js";
 export * from "./sync-date.js";

package/dist/assertion/impl/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sCAAsC;AACtC,2BAA2B;AAC3B,gCAAgC;AAChC,qCAAqC;AACrC,+BAA+B;AAC/B,mCAAmC;AACnC,qCAAqC;AACrC,0BAA0B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/assertion/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,sCAAsC;AACtC,2BAA2B;AAC3B,8BAA8B;AAC9B,gCAAgC;AAChC,qCAAqC;AACrC,+BAA+B;AAC/B,mCAAmC;AACnC,qCAAqC;AACrC,0BAA0B"}