bupkis 0.7.2 → 0.9.0

package/dist/esm/guards.js

@@ -15,32 +15,36 @@
  *
  * @packageDocumentation
  */
-import { z } from 'zod/v4';
 import { kExpectIt } from './constant.js';
+const { isArray } = Array;
 export function isZodType(value, type) {
     const isValid = isObject(value) &&
         'def' in value &&
         !!value.def &&
         typeof value.def === 'object' &&
         'type' in value.def;
-    if (!isValid)
+    if (!isValid) {
         return false;
-    if (type === undefined)
+    }
+    if (type === undefined) {
         return true;
+    }
     return value.def.type === type;
 }
 /**
  * Type guard for a plain object.
  *
+ * @function
  * @param value Value to test
  * @returns `true` if the value is a plain object, `false` otherwise
  */
 export const isObject = (value) => {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return typeof value === 'object' && value !== null && !isArray(value);
 };
 /**
  * Returns `true` if the given value is a {@link z.ZodPromise} schema.
  *
+ * @function
  * @param value - Value to test
  * @returns `true` if the value is a `ZodPromise` schema; `false` otherwise
  */
@@ -48,6 +52,7 @@ export const isZodPromise = (value) => isZodType(value, 'promise');
 /**
  * Checks if a value is "promise-like", meaning it is a "thenable" object.
  *
+ * @function
  * @param value - Value to test
  * @returns `true` if the value is promise-like, `false` otherwise
  */
@@ -67,6 +72,7 @@ export const isPromiseLike = (value) => isObject(value) &&
  * This may be the only way we can determine, at runtime, if a function is a
  * constructor without actually calling it. I am unsure if this only works for
  * classes.
+ * @function
  * @param fn - Function to test
  * @returns Whether the function is constructable
  */
@@ -76,7 +82,7 @@ export const isConstructible = (fn) => {
     }
     try {
         // this will throw if there is no `[[construct]]` slot.. or so I've heard.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, custom/require-function-tag-in-arrow-functions
         new new Proxy(fn, { construct: () => ({}) })();
         return true;
     }
@@ -87,6 +93,7 @@ export const isConstructible = (fn) => {
 /**
  * Type guard for a boolean value
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is a boolean, `false` otherwise
  */
@@ -94,35 +101,15 @@ export const isBoolean = (value) => typeof value === 'boolean';
 /**
  * Type guard for a function value
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is a function, `false` otherwise
  */
 export const isFunction = (value) => typeof value === 'function';
-const AssertionFailureSchema = z.object({
-    actual: z
-        .unknown()
-        .optional()
-        .describe('The actual value or description of what actually occurred'),
-    expected: z
-        .unknown()
-        .optional()
-        .describe('The expected value or description of what was expected to occur'),
-    message: z
-        .string()
-        .optional()
-        .describe('A human-readable message describing the failure'),
-});
-/**
- * Type guard for a {@link AssertionFailure} object
- *
- * @param value Value to check
- * @returns `true` if the value is an `AssertionFailure`, `false` otherwise
- * @internal
- */
-export const isAssertionFailure = (value) => AssertionFailureSchema.safeParse(value).success;
 /**
  * Type guard for a string value
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is a string, `false` otherwise
  */
@@ -130,23 +117,18 @@ export const isString = (value) => typeof value === 'string';
 /**
  * Type guard for a non-null object value
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is an object and not null, `false` otherwise
  */
 export const isNonNullObject = (value) => typeof value === 'object' && value !== null;
-/**
- * Type guard for a null or non-object value
- *
- * @param value Value to check
- * @returns `true` if the value is null or not an object, `false` otherwise
- */
-export const isNullOrNonObject = (value) => typeof value !== 'object' || value === null;
 /**
  * Type guard for a valid WeakKey (object, function, or symbol).
  *
  * WeakMaps and WeakSets can only use objects (including functions) or symbols
  * as keys, not primitives like strings, numbers, booleans, null, or undefined.
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is a valid WeakKey (object, function, or
  *   symbol), `false` otherwise
@@ -157,20 +139,31 @@ export const isWeakKey = (value) => (typeof value === 'object' && value !== null
 /**
  * Type guard for a {@link PhraseLiteralChoice}, which is a tuple of strings.
  *
+ * @function
  * @param value Assertion part to check
  * @returns `true` if the part is a `PhraseLiteralChoice`, `false` otherwise
  * @internal
  */
-export const isPhraseLiteralChoice = (value) => Array.isArray(value) && value.every(isPhraseLiteral);
+export const isPhraseLiteralChoice = (value) => isArray(value) && value.every(isPhraseLiteral);
 /**
  * Type guard for a {@link PhraseLiteral}, which is just a string that does not
  * begin with `not `.
  *
+ * @function
  * @param value Assertion part to check
  * @returns `true` if the part is a `PhraseLiteral`, `false` otherwise
  * @internal
  */
-export const isPhraseLiteral = (value) => isString(value) && !value.startsWith('not ');
+export const isPhraseLiteral = (value) => isString(value) && !value.startsWith('not ') && value !== 'and';
+/**
+ * Type guard for a {@link PhraseLiteral} or {@link PhraseLiteralChoice}.
+ *
+ * @function
+ * @param value Value to check
+ * @returns `true` if the value is a `PhraseLiteral` or `PhraseLiteralChoice`,
+ *   `false` otherwise
+ */
+export const isPhrase = (value) => isPhraseLiteral(value) || isPhraseLiteralChoice(value);
 /**
  * Generic type guard for instanceof checks.
  *
@@ -190,6 +183,7 @@ export const isPhraseLiteral = (value) => isString(value) && !value.startsWith('
  * ```
  *
  * @template T - The constructor type to check against
+ * @function
  * @param value - Value to test
  * @param ctor - Constructor function to check instanceof
  * @returns `true` if the value is an instance of the constructor, `false`
@@ -218,6 +212,7 @@ export const isA = (value, ctor) => {
  * }
  * ```
  *
+ * @function
  * @param value - Value to test
  * @returns `true` if the value is an Error instance, `false` otherwise
  */
@@ -243,6 +238,7 @@ export const isError = (value) => isA(value, Error);
  * ```
  *
  * @template Subject - The subject type that the executor function operates on
+ * @function
  * @param value - Value to test
  * @returns `true` if the value is an ExpectItExecutor function, `false`
  *   otherwise
@@ -250,4 +246,24 @@ export const isError = (value) => isA(value, Error);
 export const isExpectItExecutor = (value) => {
     return isFunction(value) && kExpectIt in value && value[kExpectIt] === true;
 };
+/**
+ * Type guard for an {@link AssertionPart}, which can be a {@link PhraseLiteral},
+ * {@link PhraseLiteralChoice}, or a Zod schema.
+ *
+ * @function
+ * @param value Value to check
+ * @returns `true` if the value is an `AssertionPart`, `false` otherwise
+ * @internal
+ */
+export const isAssertionPart = (value) => isPhraseLiteral(value) || isPhraseLiteralChoice(value) || isZodType(value);
+/**
+ * Type guard for {@link AssertionParts}, which is an array of
+ * {@link AssertionPart}.
+ *
+ * @function
+ * @param value Value to check
+ * @returns `true` if the value is an `AssertionParts`, `false` otherwise
+ * @internal
+ */
+export const isAssertionParts = (value) => isArray(value) && !!value.length && value.every(isAssertionPart);
 //# sourceMappingURL=guards.js.map

package/dist/esm/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/guards.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/guards.ts"],"names":[],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -182,15 +182,35 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
 }, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to throw"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => {
     actual: unknown;
     message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to throw">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => false | {
-    actual: {};
-    expected: import("./types.js").Constructor;
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to throw">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => {
+    actual: unknown;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], z.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => {
+    actual: unknown;
+    expected: string;
     message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw", "to throw error satisfying"], z.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => boolean, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", z.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: any) => z.ZodError<unknown> | {
-    actual: never;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expected?: never;
+    message?: never;
+}, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw", "to throw error satisfying"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to throw an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", z.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: any) => {
+    actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => {
+    schema?: never;
+    subject?: never;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expected?: never;
+    message?: never;
+}, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => {
     actual: string;
     expected: string;
     message: string;
@@ -211,11 +231,7 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: boolean;
     expected: boolean;
     message: string;
-} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (subject: unknown, key: string | number | symbol) => {
-    actual: boolean;
-    expected: boolean;
-    message: string;
-} | undefined, readonly [z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>], readonly [import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => z.ZodCustom<unknown, unknown>, readonly [z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>], readonly [import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
     actual: string;
     expected: string;
     message: string;
@@ -231,21 +247,73 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: string;
     expected: string;
     message: string;
-} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./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"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./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"], z.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<z.ZodError<unknown> | {
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./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"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<{
     actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, z.ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying"], z.ZodAny], (subject: PromiseLike<unknown>, param: any) => Promise<z.ZodError<unknown> | {
+    expected?: never;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+    expect?: never;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<{
     actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, z.ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodAny], (promise: PromiseLike<unknown>, param: any) => Promise<z.ZodError<any> | {
-    actual: unknown;
+    expected?: never;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+    expect?: never;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./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"], z.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<{
+    actual: string;
+    expect: string;
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, z.ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying"], z.ZodAny], (subject: PromiseLike<unknown>, param: any) => Promise<{
+    actual: string;
+    expect: string;
+    message: string;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, z.ZodAny]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodAny], (promise: PromiseLike<unknown>, param: any) => Promise<{
+    actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodAny]>, import("./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.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<z.ZodError<any> | {
+    schema?: never;
+    subject?: never;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodAny]>, import("./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.ZodAny], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: any) => Promise<{
     actual: string;
     expect: string;
     message: string;
-} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodAny]>]>;
+    schema?: never;
+    subject?: never;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    actual?: never;
+    expect?: never;
+    message?: never;
+}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodAny]>]>;
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,KAAK,UAAU,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACrD,cAAc,YAAY,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,gBAAgB,EAChB,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,QAAQ,EACR,aAAa,EACb,MAAM,EACN,OAAO,EACP,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sUAEgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,KAAK,UAAU,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACrD,cAAc,YAAY,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,gBAAgB,EAChB,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,QAAQ,EACR,aAAa,EACb,MAAM,EACN,OAAO,EACP,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0TAEgB,CAAC"}

package/dist/esm/internal-schema.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Internal schemas
+ *
+ * @internal
+ * @packageDocumentation
+ */
+import type { AssertionMetadata, AssertionParseRequest } from './types.js';
+/**
+ * Schema for internal assertion metadata.
+ *
+ * Used by documentation tooling.
+ */
+export declare const AssertionMetadataSchema: z.ZodType<AssertionMetadata>;
+/**
+ * @function
+ */
+export declare const isAssertionParseRequest: (value: unknown) => value is AssertionParseRequest;
+/**
+ * @function
+ * @param value
+ * @returns
+ * @knipignore
+ */
+export declare const isMetadata: (value: unknown) => value is AssertionMetadata;
+//# sourceMappingURL=internal-schema.d.ts.map

package/dist/esm/internal-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-schema.d.ts","sourceRoot":"","sources":["../../src/internal-schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAEV,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAIpB;;;;GAIG;AAEH,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CA2B9D,CAAC;AA6JJ;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,OAAO,KACb,KAAK,IAAI,qBAEX,CAAC;AAwBF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,iBACH,CAAC"}

package/dist/esm/internal-schema.js

@@ -0,0 +1,203 @@
+/**
+ * Internal schemas
+ *
+ * @internal
+ * @packageDocumentation
+ */
+import { z } from 'zod/v4';
+import { isZodType } from './guards.js';
+/**
+ * Schema for internal assertion metadata.
+ *
+ * Used by documentation tooling.
+ */
+export const AssertionMetadataSchema = z
+    .looseObject({
+    anchor: z.string().describe('Anchor ID for linking to this assertion.'),
+    category: z
+        .enum([
+        'collections',
+        'date',
+        'equality',
+        'error',
+        'function',
+        'numeric',
+        'object',
+        'other',
+        'primitives',
+        'promise',
+        'strings',
+    ])
+        .describe('Category to map to page of logically grouped assertions'),
+    redirect: z
+        .string()
+        .optional()
+        .describe('Redirect for assertion to its documentation page, including anchor'),
+})
+    .describe('Metadata associated with an assertion, for internal use by documentation tooling.');
+/**
+ * Schema for {@link AssertionFailure}.
+ *
+ * @internal
+ */
+const AssertionFailureSchema = z
+    .object({
+    actual: z
+        .unknown()
+        .optional()
+        .describe('The actual value or description of what actually occurred'),
+    expected: z
+        .unknown()
+        .optional()
+        .describe('The expected value or description of what was expected to occur'),
+    message: z
+        .string()
+        .optional()
+        .describe('A human-readable message describing the failure'),
+})
+    .describe('Potential return type of an assertion implementation function');
+/**
+ * @internal
+ */
+const ZodTypeSchema = z
+    .custom(isZodType, {
+    error: 'Must be a Zod schema',
+})
+    .describe('A Zod schema within AssertionParts');
+/** @internal */
+const BaseAssertionParseRequestSchema = z.object({
+    subject: z.unknown().describe('The subject value to be validated'),
+});
+/**
+ * @internal
+ */
+const AssertionParseRequestSchema = z.union([
+    z.object({
+        ...BaseAssertionParseRequestSchema.shape,
+        schema: ZodTypeSchema.describe('The sync Zod schema to validate against'),
+    }),
+    z.object({
+        ...BaseAssertionParseRequestSchema.shape,
+        asyncSchema: ZodTypeSchema.describe('The async Zod schema to validate against'),
+    }),
+]);
+/**
+ * @internal
+ */
+const PhraseLiteralSchema = z
+    .stringFormat('PhraseLiteral', (value) => !value.startsWith('not '), {
+    error: 'Phrase literals may not begin with "not "',
+})
+    .min(1, { error: 'Phrase literals must be at least 1 character long' })
+    .describe('A phrase literal within AssertionParts');
+/**
+ * @internal
+ */
+const PhraseLiteralChoiceSchema = z
+    .array(PhraseLiteralSchema)
+    .min(1, { error: 'Phrase literal choices must have at least one option' })
+    .describe('A choice of phrase literals, represented as an array of strings, within AssertionParts');
+/**
+ * @internal
+ */
+const AssertionImplSchemaSync = z
+    .union([
+    ZodTypeSchema,
+    z.function({
+        input: z.tuple([z.unknown()], z.unknown()),
+        output: z.union([
+            z.void(),
+            z.boolean(),
+            ZodTypeSchema,
+            AssertionFailureSchema,
+            AssertionParseRequestSchema,
+        ]),
+    }),
+])
+    .describe('A synchronous assertion implementation function');
+const AssertionImplSchemaAsync = z
+    .union([
+    ZodTypeSchema,
+    z.function({
+        input: z.tuple([z.unknown()], z.unknown()),
+        output: z.union([
+            z.void(),
+            z.boolean(),
+            ZodTypeSchema,
+            AssertionFailureSchema,
+            AssertionParseRequestSchema,
+            z.promise(z.void()),
+            z.promise(z.boolean()),
+            z.promise(ZodTypeSchema),
+            z.promise(AssertionFailureSchema),
+            z.promise(AssertionParseRequestSchema),
+        ]),
+    }),
+])
+    .describe('An async assertion implementation function');
+/**
+ * @internal
+ */
+const AssertionPartsSchema = z
+    .array(z.union([PhraseLiteralSchema, PhraseLiteralChoiceSchema, ZodTypeSchema]))
+    .min(1, { error: 'At least one part is required for an assertion' })
+    .refine((parts) => {
+    // Special validation for 'and': it can only appear if followed by a ZodType
+    for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === 'and') {
+            // 'and' must be followed by another part, and that part must be a ZodType
+            if (i === parts.length - 1 || !isZodType(parts[i + 1])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}, { error: '"and" can only appear when followed by a Zod schema' })
+    .describe('Assertion "parts" which define the input of an assertion');
+/**
+ * Type guard for a {@link AssertionFailure}.
+ *
+ * This cannot live in `guards.ts` because it would create a cycle.
+ *
+ * @function
+ * @param value Value to check
+ * @returns `true` if value is an AssertionFailure
+ * @internal
+ */
+export const isAssertionFailure = (value) => {
+    return AssertionFailureSchema.safeParse(value).success;
+};
+/**
+ * @function
+ */
+export const isAssertionParseRequest = (value) => {
+    return AssertionParseRequestSchema.safeParse(value).success;
+};
+/**
+ * @internal
+ */
+export const CreateAssertionInputSchema = z
+    .tuple([
+    AssertionPartsSchema,
+    AssertionImplSchemaSync,
+    z.optional(AssertionMetadataSchema),
+])
+    .describe('Parameters for createAssertion()');
+/**
+ * @internal
+ */
+export const CreateAssertionInputSchemaAsync = z
+    .tuple([
+    AssertionPartsSchema,
+    AssertionImplSchemaAsync,
+    z.optional(AssertionMetadataSchema),
+])
+    .describe('Parameters for createAsyncAssertion()');
+/**
+ * @function
+ * @param value
+ * @returns
+ * @knipignore
+ */
+export const isMetadata = (value) => AssertionMetadataSchema.safeParse(value).success;
+//# sourceMappingURL=internal-schema.js.map

package/dist/esm/internal-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-schema.js","sourceRoot":"","sources":["../../src/internal-schema.ts"],"names":[],"mappings":"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"}