bupkis 0.7.2 → 0.9.0

package/dist/commonjs/guards.js

@@ -17,35 +17,39 @@
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExpectItExecutor = exports.isError = exports.isA = exports.isPhraseLiteral = exports.isPhraseLiteralChoice = exports.isWeakKey = exports.isNullOrNonObject = exports.isNonNullObject = exports.isString = exports.isAssertionFailure = exports.isFunction = exports.isBoolean = exports.isConstructible = exports.isPromiseLike = exports.isZodPromise = exports.isObject = void 0;
+exports.isAssertionParts = exports.isAssertionPart = exports.isExpectItExecutor = exports.isError = exports.isA = exports.isPhrase = exports.isPhraseLiteral = exports.isPhraseLiteralChoice = exports.isWeakKey = exports.isNonNullObject = exports.isString = exports.isFunction = exports.isBoolean = exports.isConstructible = exports.isPromiseLike = exports.isZodPromise = exports.isObject = void 0;
 exports.isZodType = isZodType;
-const v4_1 = require("zod/v4");
 const constant_js_1 = require("./constant.js");
+const { isArray } = Array;
 function isZodType(value, type) {
     const isValid = (0, exports.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
  */
 const isObject = (value) => {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return typeof value === 'object' && value !== null && !isArray(value);
 };
 exports.isObject = isObject;
 /**
  * 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
  */
@@ -54,6 +58,7 @@ exports.isZodPromise = isZodPromise;
 /**
  * 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
  */
@@ -74,6 +79,7 @@ exports.isPromiseLike = isPromiseLike;
  * 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
  */
@@ -83,7 +89,7 @@ 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;
     }
@@ -95,6 +101,7 @@ exports.isConstructible = isConstructible;
 /**
  * Type guard for a boolean value
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is a boolean, `false` otherwise
  */
@@ -103,37 +110,16 @@ exports.isBoolean = isBoolean;
 /**
  * Type guard for a function value
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is a function, `false` otherwise
  */
 const isFunction = (value) => typeof value === 'function';
 exports.isFunction = isFunction;
-const AssertionFailureSchema = v4_1.z.object({
-    actual: v4_1.z
-        .unknown()
-        .optional()
-        .describe('The actual value or description of what actually occurred'),
-    expected: v4_1.z
-        .unknown()
-        .optional()
-        .describe('The expected value or description of what was expected to occur'),
-    message: v4_1.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
- */
-const isAssertionFailure = (value) => AssertionFailureSchema.safeParse(value).success;
-exports.isAssertionFailure = isAssertionFailure;
 /**
  * Type guard for a string value
  *
+ * @function
  * @param value Value to check
  * @returns `true` if the value is a string, `false` otherwise
  */
@@ -142,25 +128,19 @@ exports.isString = isString;
 /**
  * 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
  */
 const isNonNullObject = (value) => typeof value === 'object' && value !== null;
 exports.isNonNullObject = isNonNullObject;
-/**
- * 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
- */
-const isNullOrNonObject = (value) => typeof value !== 'object' || value === null;
-exports.isNullOrNonObject = isNullOrNonObject;
 /**
  * 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
@@ -172,22 +152,34 @@ exports.isWeakKey = isWeakKey;
 /**
  * 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
  */
-const isPhraseLiteralChoice = (value) => Array.isArray(value) && value.every(exports.isPhraseLiteral);
+const isPhraseLiteralChoice = (value) => isArray(value) && value.every(exports.isPhraseLiteral);
 exports.isPhraseLiteralChoice = isPhraseLiteralChoice;
 /**
  * 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
  */
-const isPhraseLiteral = (value) => (0, exports.isString)(value) && !value.startsWith('not ');
+const isPhraseLiteral = (value) => (0, exports.isString)(value) && !value.startsWith('not ') && value !== 'and';
 exports.isPhraseLiteral = isPhraseLiteral;
+/**
+ * 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
+ */
+const isPhrase = (value) => (0, exports.isPhraseLiteral)(value) || (0, exports.isPhraseLiteralChoice)(value);
+exports.isPhrase = isPhrase;
 /**
  * Generic type guard for instanceof checks.
  *
@@ -207,6 +199,7 @@ exports.isPhraseLiteral = isPhraseLiteral;
  * ```
  *
  * @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`
@@ -236,6 +229,7 @@ exports.isA = isA;
  * }
  * ```
  *
+ * @function
  * @param value - Value to test
  * @returns `true` if the value is an Error instance, `false` otherwise
  */
@@ -262,6 +256,7 @@ exports.isError = isError;
  * ```
  *
  * @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
@@ -270,4 +265,26 @@ const isExpectItExecutor = (value) => {
     return (0, exports.isFunction)(value) && constant_js_1.kExpectIt in value && value[constant_js_1.kExpectIt] === true;
 };
 exports.isExpectItExecutor = isExpectItExecutor;
+/**
+ * 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
+ */
+const isAssertionPart = (value) => (0, exports.isPhraseLiteral)(value) || (0, exports.isPhraseLiteralChoice)(value) || isZodType(value);
+exports.isAssertionPart = isAssertionPart;
+/**
+ * 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
+ */
+const isAssertionParts = (value) => isArray(value) && !!value.length && value.every(exports.isAssertionPart);
+exports.isAssertionParts = isAssertionParts;
 //# sourceMappingURL=guards.js.map

package/dist/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/internal-schema.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Internal schemas
+ *
+ * @internal
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMetadata = exports.CreateAssertionInputSchemaAsync = exports.CreateAssertionInputSchema = exports.isAssertionParseRequest = exports.isAssertionFailure = exports.AssertionMetadataSchema = void 0;
+const v4_1 = require("zod/v4");
+const guards_js_1 = require("./guards.js");
+/**
+ * Schema for internal assertion metadata.
+ *
+ * Used by documentation tooling.
+ */
+exports.AssertionMetadataSchema = v4_1.z
+    .looseObject({
+    anchor: v4_1.z.string().describe('Anchor ID for linking to this assertion.'),
+    category: v4_1.z
+        .enum([
+        'collections',
+        'date',
+        'equality',
+        'error',
+        'function',
+        'numeric',
+        'object',
+        'other',
+        'primitives',
+        'promise',
+        'strings',
+    ])
+        .describe('Category to map to page of logically grouped assertions'),
+    redirect: v4_1.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 = v4_1.z
+    .object({
+    actual: v4_1.z
+        .unknown()
+        .optional()
+        .describe('The actual value or description of what actually occurred'),
+    expected: v4_1.z
+        .unknown()
+        .optional()
+        .describe('The expected value or description of what was expected to occur'),
+    message: v4_1.z
+        .string()
+        .optional()
+        .describe('A human-readable message describing the failure'),
+})
+    .describe('Potential return type of an assertion implementation function');
+/**
+ * @internal
+ */
+const ZodTypeSchema = v4_1.z
+    .custom(guards_js_1.isZodType, {
+    error: 'Must be a Zod schema',
+})
+    .describe('A Zod schema within AssertionParts');
+/** @internal */
+const BaseAssertionParseRequestSchema = v4_1.z.object({
+    subject: v4_1.z.unknown().describe('The subject value to be validated'),
+});
+/**
+ * @internal
+ */
+const AssertionParseRequestSchema = v4_1.z.union([
+    v4_1.z.object({
+        ...BaseAssertionParseRequestSchema.shape,
+        schema: ZodTypeSchema.describe('The sync Zod schema to validate against'),
+    }),
+    v4_1.z.object({
+        ...BaseAssertionParseRequestSchema.shape,
+        asyncSchema: ZodTypeSchema.describe('The async Zod schema to validate against'),
+    }),
+]);
+/**
+ * @internal
+ */
+const PhraseLiteralSchema = v4_1.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 = v4_1.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 = v4_1.z
+    .union([
+    ZodTypeSchema,
+    v4_1.z.function({
+        input: v4_1.z.tuple([v4_1.z.unknown()], v4_1.z.unknown()),
+        output: v4_1.z.union([
+            v4_1.z.void(),
+            v4_1.z.boolean(),
+            ZodTypeSchema,
+            AssertionFailureSchema,
+            AssertionParseRequestSchema,
+        ]),
+    }),
+])
+    .describe('A synchronous assertion implementation function');
+const AssertionImplSchemaAsync = v4_1.z
+    .union([
+    ZodTypeSchema,
+    v4_1.z.function({
+        input: v4_1.z.tuple([v4_1.z.unknown()], v4_1.z.unknown()),
+        output: v4_1.z.union([
+            v4_1.z.void(),
+            v4_1.z.boolean(),
+            ZodTypeSchema,
+            AssertionFailureSchema,
+            AssertionParseRequestSchema,
+            v4_1.z.promise(v4_1.z.void()),
+            v4_1.z.promise(v4_1.z.boolean()),
+            v4_1.z.promise(ZodTypeSchema),
+            v4_1.z.promise(AssertionFailureSchema),
+            v4_1.z.promise(AssertionParseRequestSchema),
+        ]),
+    }),
+])
+    .describe('An async assertion implementation function');
+/**
+ * @internal
+ */
+const AssertionPartsSchema = v4_1.z
+    .array(v4_1.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 || !(0, guards_js_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
+ */
+const isAssertionFailure = (value) => {
+    return AssertionFailureSchema.safeParse(value).success;
+};
+exports.isAssertionFailure = isAssertionFailure;
+/**
+ * @function
+ */
+const isAssertionParseRequest = (value) => {
+    return AssertionParseRequestSchema.safeParse(value).success;
+};
+exports.isAssertionParseRequest = isAssertionParseRequest;
+/**
+ * @internal
+ */
+exports.CreateAssertionInputSchema = v4_1.z
+    .tuple([
+    AssertionPartsSchema,
+    AssertionImplSchemaSync,
+    v4_1.z.optional(exports.AssertionMetadataSchema),
+])
+    .describe('Parameters for createAssertion()');
+/**
+ * @internal
+ */
+exports.CreateAssertionInputSchemaAsync = v4_1.z
+    .tuple([
+    AssertionPartsSchema,
+    AssertionImplSchemaAsync,
+    v4_1.z.optional(exports.AssertionMetadataSchema),
+])
+    .describe('Parameters for createAsyncAssertion()');
+/**
+ * @function
+ * @param value
+ * @returns
+ * @knipignore
+ */
+const isMetadata = (value) => exports.AssertionMetadataSchema.safeParse(value).success;
+exports.isMetadata = isMetadata;
+//# sourceMappingURL=internal-schema.js.map