bupkis 0.18.1 → 0.18.2

package/dist/guards.d.ts

@@ -1,231 +0,0 @@
-/**
- * Type guard functions and runtime type checking utilities.
- *
- * This module provides various type guard functions for runtime type checking,
- * including guards for Zod schemas, constructors, {@link PromiseLike} objects,
- * and assertion parts. These are used throughout the library for safe type
- * narrowing and validation.
- *
- * @module guards
- * @category API
- * @example
- *
- * ```ts
- * import * as guards from 'bupkis/guards';
- * ```
- */
-import { type z } from 'zod';
-import type { PhraseLiteralChoice } from "./assertion/assertion-types.js";
-import type { StandardSchemaV1 } from "./standard-schema.js";
-import type { Constructor, ExpectItExecutor, PhraseLiteral, ZodTypeMap } from "./types.js";
-/**
- * Returns `true` if the given value looks like a Zod v4 schema, determined by
- * the presence of an internal {@link z.core.$ZodTypeDef} field.
- *
- * Note: This relies on Zod's internal shape and is intended for runtime
- * discrimination within this library.
- *
- * @template T - The specific ZodType to check for (based on def.type)
- * @param value - Value to test
- * @returns Whether the value is `ZodType`-like
- */
-export declare function isZodType<T extends keyof ZodTypeMap>(value: unknown, type: T): value is ZodTypeMap[T];
-/**
- * Returns `true` if the given value looks like a Zod v4 schema, determined by
- * the presence of an internal {@link z.core.$ZodTypeDef} field.
- *
- * Note: This relies on Zod's internal shape and is intended for runtime
- * discrimination within this library.
- *
- * @param value - Value to test
- * @returns Whether the value is `ZodType`-like
- */
-export declare function isZodType(value: unknown): value is z.ZodType;
-/**
- * Returns `true` if the given value implements the Standard Schema v1
- * interface.
- *
- * This guard checks for the presence of the `~standard` property with the
- * required shape (version 1, vendor, validate function). It can detect any
- * Standard Schema compliant library including Zod v4 (which implements the
- * spec).
- *
- * @function
- * @param value - Value to test
- * @returns Whether the value is a Standard Schema v1 instance
- * @see {@link https://standardschema.dev | Standard Schema Specification}
- */
-export declare const isStandardSchema: (value: unknown) => value is StandardSchemaV1;
-/**
- * Type guard for a plain object.
- *
- * @function
- * @param value Value to test
- * @returns `true` if the value is a plain object, `false` otherwise
- */
-export declare const isObject: (value: unknown) => value is NonNullable<object>;
-/**
- * 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
- */
-export declare const isZodPromise: (value: unknown) => value is z.ZodPromise;
-/**
- * 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
- */
-export declare const isPromiseLike: (value: unknown) => value is PromiseLike<unknown>;
-/**
- * Returns `true` if the given value is a constructable function (i.e., a
- * class).
- *
- * This works by wrapping `fn` in a {@link Proxy}, attaching a no-op
- * {@link ProxyHandler.construct} trap to it, then attempting to construct the
- * proxy via `new`.
- *
- * @privateRemarks
- * 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
- */
-export declare const isConstructible: (fn: unknown) => fn is Constructor;
-/**
- * Type guard for a boolean value
- *
- * @function
- * @param value Value to check
- * @returns `true` if the value is a boolean, `false` otherwise
- */
-export declare const isBoolean: (value: unknown) => value is boolean;
-/**
- * Type guard for a function value
- *
- * @function
- * @param value Value to check
- * @returns `true` if the value is a function, `false` otherwise
- */
-export declare const isFunction: (value: unknown) => value is (...args: any[]) => any;
-/**
- * Type guard for a string value
- *
- * @function
- * @param value Value to check
- * @returns `true` if the value is a string, `false` otherwise
- */
-export declare const isString: (value: unknown) => value is 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 declare const isNonNullObject: (value: unknown) => value is object;
-/**
- * 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
- */
-export declare const isWeakKey: (value: unknown) => value is WeakKey;
-/**
- * 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 declare const isPhrase: (value: unknown) => value is PhraseLiteral | PhraseLiteralChoice;
-/**
- * Generic type guard for instanceof checks.
- *
- * This function provides a type-safe way to check if a value is an instance of
- * a given constructor, with proper type narrowing for TypeScript. It combines
- * the null/object check with instanceof to ensure the value is a valid object
- * before performing the instance check.
- *
- * @example
- *
- * ```typescript
- * const obj = new Date();
- * if (isA(obj, Date)) {
- *   // obj is now typed as Date
- *   console.log(obj.getTime());
- * }
- * ```
- *
- * @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`
- *   otherwise
- */
-export declare const isA: <T extends Constructor>(value: unknown, ctor: T) => value is InstanceType<T>;
-/**
- * Type guard for Error instances.
- *
- * This function checks if a value is an instance of the Error class or any of
- * its subclasses. It's useful for error handling and type narrowing when
- * working with unknown values that might be errors.
- *
- * @example
- *
- * ```typescript
- * try {
- *   throw new TypeError('Something went wrong');
- * } catch (err) {
- *   if (isError(err)) {
- *     // err is now typed as Error
- *     console.log(err.message);
- *   }
- * }
- * ```
- *
- * @function
- * @param value - Value to test
- * @returns `true` if the value is an Error instance, `false` otherwise
- */
-export declare const isError: (value: unknown) => value is Error;
-/**
- * Type guard for {@link ExpectItExecutor} functions.
- *
- * This function checks if a value is an {@link ExpectItExecutor} function
- * created by {@link bupkis!expect.it | expect.it()}. {@link ExpectItExecutor}
- * functions are special functions that contain assertion logic and are marked
- * with an internal symbol for identification. They are used in nested
- * assertions within "to satisfy" patterns and other complex assertion
- * scenarios.
- *
- * @example
- *
- * ```typescript
- * const executor = expect.it('to be a string');
- * if (isExpectItExecutor(executor)) {
- *   // executor is now typed as ExpectItExecutor
- *   // Can be used in satisfaction patterns
- * }
- * ```
- *
- * @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
- */
-export declare const isExpectItExecutor: <Subject extends z.ZodType = z.ZodUnknown>(value: unknown) => value is ExpectItExecutor<Subject>;
-//# sourceMappingURL=guards.d.ts.map

package/dist/guards.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../src/guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,uCAAuC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,6BAA6B;AAC7D,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,aAAa,EACb,UAAU,EACX,mBAAmB;AAMpB;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,UAAU,EAClD,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,CAAC,GACN,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAE1B;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,OAAO,CAAC;AAsB9D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,gBAY1D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,MAAM,CAEpE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,CAAC,UAC5B,CAAC;AAE9B;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CAIpD,CAAC;AAExB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,GAAI,IAAI,OAAO,KAAG,EAAE,IAAI,WAYnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OACxB,CAAC;AAE7B;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAC5C,CAAC;AAE9B;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACxB,CAAC;AAE5B;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACb,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OAGzB,CAAC;AA6B5B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GACnB,OAAO,OAAO,KACb,KAAK,IAAI,aAAa,GAAG,mBAC4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,WAAW,EACvC,OAAO,OAAO,EACd,MAAM,CAAC,KACN,KAAK,IAAI,YAAY,CAAC,CAAC,CAEzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,KAA0B,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,UAAU,EACzE,OAAO,OAAO,KACb,KAAK,IAAI,gBAAgB,CAAC,OAAO,CAMnC,CAAC"}

package/dist/guards.js

@@ -1,277 +0,0 @@
-/**
- * Type guard functions and runtime type checking utilities.
- *
- * This module provides various type guard functions for runtime type checking,
- * including guards for Zod schemas, constructors, {@link PromiseLike} objects,
- * and assertion parts. These are used throughout the library for safe type
- * narrowing and validation.
- *
- * @module guards
- * @category API
- * @example
- *
- * ```ts
- * import * as guards from 'bupkis/guards';
- * ```
- */
-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) {
-        return false;
-    }
-    if (type === undefined) {
-        return true;
-    }
-    return value.def.type === type;
-}
-/**
- * Returns `true` if the given value implements the Standard Schema v1
- * interface.
- *
- * This guard checks for the presence of the `~standard` property with the
- * required shape (version 1, vendor, validate function). It can detect any
- * Standard Schema compliant library including Zod v4 (which implements the
- * spec).
- *
- * @function
- * @param value - Value to test
- * @returns Whether the value is a Standard Schema v1 instance
- * @see {@link https://standardschema.dev | Standard Schema Specification}
- */
-export const isStandardSchema = (value) => {
-    return (isObject(value) &&
-        '~standard' in value &&
-        isObject(value['~standard']) &&
-        'version' in value['~standard'] &&
-        value['~standard'].version === 1 &&
-        'vendor' in value['~standard'] &&
-        typeof value['~standard'].vendor === 'string' &&
-        'validate' in value['~standard'] &&
-        typeof value['~standard'].validate === 'function');
-};
-/**
- * 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 && !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
- */
-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
- */
-export const isPromiseLike = (value) => isObject(value) &&
-    'then' in value &&
-    isFunction(value.then) &&
-    value.then.length > 0;
-/**
- * Returns `true` if the given value is a constructable function (i.e., a
- * class).
- *
- * This works by wrapping `fn` in a {@link Proxy}, attaching a no-op
- * {@link ProxyHandler.construct} trap to it, then attempting to construct the
- * proxy via `new`.
- *
- * @privateRemarks
- * 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
- */
-export const isConstructible = (fn) => {
-    if (fn === Symbol || fn === BigInt) {
-        return false;
-    }
-    try {
-        // this will throw if there is no `[[construct]]` slot.. or so I've heard.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, custom/require-function-tag-in-arrow-functions
-        new new Proxy(fn, { construct: () => ({}) })();
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-/**
- * Type guard for a boolean value
- *
- * @function
- * @param value Value to check
- * @returns `true` if the value is a boolean, `false` otherwise
- */
-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';
-/**
- * Type guard for a string value
- *
- * @function
- * @param value Value to check
- * @returns `true` if the value is a string, `false` otherwise
- */
-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 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
- */
-export const isWeakKey = (value) => (typeof value === 'object' && value !== null) ||
-    typeof value === 'function' ||
-    typeof value === 'symbol';
-/**
- * Type guard for a {@link PhraseLiteral}, which is just a string that does not
- * begin with `not `.
- *
- * @function
- * @param value Value to check
- * @returns `true` if the value is a `PhraseLiteral`, `false` otherwise
- * @internal
- */
-export const isPhraseLiteral = (value) => isString(value) && value !== 'and';
-/**
- * Type guard for a {@link PhraseLiteralChoice}, which is a tuple of strings.
- *
- * @function
- * @param value Value to check
- * @returns `true` if the value is a `PhraseLiteralChoice`, `false` otherwise
- * @internal
- */
-export const isPhraseLiteralChoice = (value) => isArray(value) &&
-    value.length >= 1 &&
-    value.every((item) => isPhraseLiteral(item));
-/**
- * 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.
- *
- * This function provides a type-safe way to check if a value is an instance of
- * a given constructor, with proper type narrowing for TypeScript. It combines
- * the null/object check with instanceof to ensure the value is a valid object
- * before performing the instance check.
- *
- * @example
- *
- * ```typescript
- * const obj = new Date();
- * if (isA(obj, Date)) {
- *   // obj is now typed as Date
- *   console.log(obj.getTime());
- * }
- * ```
- *
- * @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`
- *   otherwise
- */
-export const isA = (value, ctor) => {
-    return isNonNullObject(value) && value instanceof ctor;
-};
-/**
- * Type guard for Error instances.
- *
- * This function checks if a value is an instance of the Error class or any of
- * its subclasses. It's useful for error handling and type narrowing when
- * working with unknown values that might be errors.
- *
- * @example
- *
- * ```typescript
- * try {
- *   throw new TypeError('Something went wrong');
- * } catch (err) {
- *   if (isError(err)) {
- *     // err is now typed as Error
- *     console.log(err.message);
- *   }
- * }
- * ```
- *
- * @function
- * @param value - Value to test
- * @returns `true` if the value is an Error instance, `false` otherwise
- */
-export const isError = (value) => isA(value, Error);
-/**
- * Type guard for {@link ExpectItExecutor} functions.
- *
- * This function checks if a value is an {@link ExpectItExecutor} function
- * created by {@link bupkis!expect.it | expect.it()}. {@link ExpectItExecutor}
- * functions are special functions that contain assertion logic and are marked
- * with an internal symbol for identification. They are used in nested
- * assertions within "to satisfy" patterns and other complex assertion
- * scenarios.
- *
- * @example
- *
- * ```typescript
- * const executor = expect.it('to be a string');
- * if (isExpectItExecutor(executor)) {
- *   // executor is now typed as ExpectItExecutor
- *   // Can be used in satisfaction patterns
- * }
- * ```
- *
- * @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
- */
-export const isExpectItExecutor = (value) => {
-    return (isFunction(value) &&
-        kExpectIt in value &&
-        value[kExpectIt] === true);
-};
-//# sourceMappingURL=guards.js.map

package/dist/guards.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"guards.js","sourceRoot":"","sources":["../src/guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAaH,OAAO,EAAE,SAAS,EAAE,sBAAsB;AAE1C,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;AA6B1B,MAAM,UAAU,SAAS,CACvB,KAAc,EACd,IAAQ;IAER,MAAM,OAAO,GACX,QAAQ,CAAC,KAAK,CAAC;QACf,KAAK,IAAI,KAAK;QACd,CAAC,CAAC,KAAK,CAAC,GAAG;QACX,OAAO,KAAK,CAAC,GAAG,KAAK,QAAQ;QAC7B,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC;IAEtB,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAQ,KAAmB,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAA6B,EAAE;IAC5E,OAAO,CACL,QAAQ,CAAC,KAAK,CAAC;QACf,WAAW,IAAI,KAAK;QACpB,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC5B,SAAS,IAAI,KAAK,CAAC,WAAW,CAAC;QAC/B,KAAK,CAAC,WAAW,CAAC,CAAC,OAAO,KAAK,CAAC;QAChC,QAAQ,IAAI,KAAK,CAAC,WAAW,CAAC;QAC9B,OAAO,KAAK,CAAC,WAAW,CAAC,CAAC,MAAM,KAAK,QAAQ;QAC7C,UAAU,IAAI,KAAK,CAAC,WAAW,CAAC;QAChC,OAAO,KAAK,CAAC,WAAW,CAAC,CAAC,QAAQ,KAAK,UAAU,CAClD,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAgC,EAAE;IACvE,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AACxE,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAc,EAAyB,EAAE,CACpE,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAc,EAAiC,EAAE,CAC7E,QAAQ,CAAC,KAAK,CAAC;IACf,MAAM,IAAI,KAAK;IACf,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC;IACtB,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;AAExB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,EAAW,EAAqB,EAAE;IAChE,IAAI,EAAE,KAAK,MAAM,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC;QACH,0EAA0E;QAC1E,6GAA6G;QAC7G,IAAI,IAAI,KAAK,CAAC,EAAS,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QACtD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAc,EAAoB,EAAE,CAC5D,OAAO,KAAK,KAAK,SAAS,CAAC;AAE7B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAc,EAAoC,EAAE,CAC7E,OAAO,KAAK,KAAK,UAAU,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAmB,EAAE,CAC1D,OAAO,KAAK,KAAK,QAAQ,CAAC;AAE5B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAc,EAAmB,EAAE,CACjE,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAc,EAAoB,EAAE,CAC5D,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;IAC7C,OAAO,KAAK,KAAK,UAAU;IAC3B,OAAO,KAAK,KAAK,QAAQ,CAAC;AAE5B;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAc,EAA0B,EAAE,CACxE,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,KAAK,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,KAAc,EACgB,EAAE,CAChC,OAAO,CAAC,KAAK,CAAC;IACd,KAAK,CAAC,MAAM,IAAI,CAAC;IACjB,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAyB,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;AAEtE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,KAAc,EACgC,EAAE,CAChD,eAAe,CAAC,KAAK,CAAC,IAAI,qBAAqB,CAAC,KAAK,CAAC,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CACjB,KAAc,EACd,IAAO,EACmB,EAAE;IAC5B,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY,IAAI,CAAC;AACzD,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,KAAc,EAAkB,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,KAAc,EACsB,EAAE;IACtC,OAAO,CACL,UAAU,CAAC,KAAK,CAAC;QACjB,SAAS,IAAI,KAAK;QACjB,KAA4C,CAAC,SAAS,CAAC,KAAK,IAAI,CAClE,CAAC;AACJ,CAAC,CAAC"}

package/dist/index.cjs

@@ -1,111 +0,0 @@
-"use strict";
-/**
- * Main entry point for the Bupkis assertion library.
- *
- * This module exports all public APIs including the main `expect` function,
- * asynchronous `expectAsync` function, assertion creation utilities, type
- * guards, schema definitions, utility functions, and error types.
- *
- * @module bupkis
- * @category API
- * @example
- *
- * ```ts
- * import { expect, expectAsync, z, createAssertion } from 'bupkis';
- * ```
- *
- * {@link https://zod.dev | Zod v4} is exported as `z` if you aren't already
- * using a {@link https://standardschema.dev | Standard Schema V1}-compatible
- * validation library.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.use = exports.fail = exports.createAsyncAssertion = exports.createAssertion = exports.z = exports.schema = exports.expectAsync = exports.expect = exports.assertions = void 0;
-const zod_1 = require("zod");
-Object.defineProperty(exports, "z", { enumerable: true, get: function () { return zod_1.z; } });
-const bootstrap_js_1 = require("./bootstrap.cjs");
-exports.assertions = __importStar(require("./assertion/impl/index.cjs"));
-var bootstrap_js_2 = require("./bootstrap.cjs");
-Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return bootstrap_js_2.expect; } });
-Object.defineProperty(exports, "expectAsync", { enumerable: true, get: function () { return bootstrap_js_2.expectAsync; } });
-__exportStar(require("./error.cjs"), exports);
-exports.schema = __importStar(require("./schema.cjs"));
-const { 
-/**
- * The main factory function for creating asynchronous assertions.
- *
- * Exported from the entry point; is also a property of {@link Expect} and
- * {@link ExpectAsync}.
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-createAssertion, 
-/**
- * The main factory function for creating asynchronous assertions.
- *
- * Exported from the entry point; is also a property of {@link Expect} and
- * {@link ExpectAsync}.
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-createAsyncAssertion, 
-/**
- * {@inheritDoc FailFn}
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-fail, 
-/**
- * {@inheritDoc UseFn}
- *
- * @function
- * @primaryExport
- * @group Core API
- */
-use, ..._rest } = bootstrap_js_1.expect;
-exports.createAssertion = createAssertion;
-exports.createAsyncAssertion = createAsyncAssertion;
-exports.fail = fail;
-exports.use = use;
-//# sourceMappingURL=index.js.map

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,6BAAwB;AAgCf,kFAhCA,OAAC,OAgCA;AA9BV,kDAA6D;AAC7D,yEAAwD;AACxD,gDAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAQ5B,8CAA2B;AAE3B,uDAAsC;AA2DtC,MAAM;AACJ;;;;;;;;;GASG;AACH,eAAe;AACf;;;;;;;;;GASG;AACH,oBAAoB;AACpB;;;;;;GAMG;AACH,IAAI;AACJ;;;;;;GAMG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAzCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}