bupkis 0.18.3 → 1.0.0

package/dist/guards.d.ts

@@ -0,0 +1,225 @@
+/**
+ * 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>;
+/**
+ * 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.
+ *
+ * Uses `Error.isError` if available.
+ *
+ * @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

@@ -0,0 +1 @@
+{"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;AAC1B;;;;;;;;;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,gBAkB1D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,MAAM,CACL,CAAC;AAEjE;;;;;;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,OACsB,CAAC;AA6B3E;;;;;;;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,CAAoD,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,OAAO,UAIN,OAAO,KAAG,KAAK,IAAI,KAC0B,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,UAAU,EACzE,OAAO,OAAO,KACb,KAAK,IAAI,gBAAgB,CAAC,OAAO,CAG+B,CAAC"}

package/dist/guards.js

@@ -0,0 +1,273 @@
+/**
+ * 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) => {
+    // Some Standard Schema compliant libraries (e.g. ArkType) implement schemas
+    // as callable objects (functions with properties), so we must accept both
+    // plain objects and functions here.
+    if (!isObject(value) && !isFunction(value)) {
+        return false;
+    }
+    const v = value;
+    const std = v['~standard'];
+    return (isObject(std) &&
+        'version' in std &&
+        std.version === 1 &&
+        'vendor' in std &&
+        typeof std.vendor === 'string' &&
+        'validate' in std &&
+        typeof std.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) => typeof value === 'object' && value !== null && !isArray(value);
+/**
+ * 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, @bupkis/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) => isNonNullObject(value) || isFunction(value) || 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) => 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.
+ *
+ * Uses `Error.isError` if available.
+ *
+ * @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 = 'isError' in Error && isFunction(Error.isError)
+    ? // @ts-expect-error - Error.isError is new
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+        (value) => Error.isError(value)
+    : (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) => isFunction(value) &&
+    kExpectIt in value &&
+    value[kExpectIt] === true;
+//# sourceMappingURL=guards.js.map

package/dist/guards.js.map

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

package/dist/index.cjs

@@ -0,0 +1,111 @@
+"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

@@ -0,0 +1 @@
+{"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"}