bupkis 0.18.0 → 0.18.2

package/dist/assertion/impl/sync-parametric.cjs

@@ -1,812 +0,0 @@
-"use strict";
-/**
- * Parameterized assertions for comparisons, function behavior, and complex
- * validation.
- *
- * These assertions accept additional parameters to customize their behavior,
- * including numeric comparisons, string matching, object satisfaction, function
- * throwing behavior, and deep equality checks.
- *
- * @packageDocumentation
- * @groupDescription Parametric Assertions (Sync)
- * Complex assertions that accept parameters for customized validation behavior.
- *
- * @showGroups
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.satisfiesAssertion = exports.stringLengthAssertion = exports.stringMatchesAssertion = exports.stringIncludesAssertion = exports.functionThrowsTypeSatisfyingAssertion = exports.functionThrowsSatisfyingAssertion = exports.functionThrowsTypeAssertion = exports.functionThrowsAssertion = exports.deepEqualAssertion = exports.strictEqualityAssertion = exports.errorMessageMatchingAssertion = exports.errorMessageAssertion = exports.functionArityAssertion = exports.oneOfAssertion = exports.stringEndsWithAssertion = exports.stringBeginsWithAssertion = exports.stringLessThanOrEqualAssertion = exports.stringGreaterThanOrEqualAssertion = exports.stringLessThanAssertion = exports.stringGreaterThanAssertion = exports.numberCloseToAssertion = exports.numberWithinRangeAssertion = exports.numberLessThanOrEqualAssertion = exports.numberGreaterThanOrEqualAssertion = exports.numberLessThanAssertion = exports.numberGreaterThanAssertion = exports.typeOfAssertion = exports.instanceOfAssertion = void 0;
-const node_util_1 = require("node:util");
-const zod_1 = require("zod");
-const error_js_1 = require("../../error.cjs");
-const guards_js_1 = require("../../guards.cjs");
-const schema_js_1 = require("../../schema.cjs");
-const value_to_schema_js_1 = require("../../value-to-schema.cjs");
-const create_js_1 = require("../create.cjs");
-const assertion_util_js_1 = require("./assertion-util.cjs");
-const { freeze } = Object;
-const { abs } = Math;
-/**
- * For {@link typeOfAssertion}
- */
-const knownTypes = freeze(new Set([
-    'string',
-    'number',
-    'boolean',
-    'undefined',
-    'null',
-    'BigInt',
-    'Symbol',
-    'Object',
-    'Function',
-    'Array',
-    'Date',
-    'Map',
-    'Set',
-    'WeakMap',
-    'WeakSet',
-    'RegExp',
-    'Promise',
-    'Error',
-    'WeakRef',
-]));
-/**
- * Assertion for testing if a value is an instance of a specific constructor.
- *
- * @example
- *
- * ```typescript
- * expect(new Date(), 'to be an instance of', Date); // passes
- * expect('hello', 'to be a', String); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.instanceOfAssertion = (0, create_js_1.createAssertion)([['to be an instance of', 'to be a', 'to be an'], schema_js_1.ConstructibleSchema], (_, ctor) => createInstanceOfSchema(ctor));
-/**
- * Assertion for testing if a value is of a specific built-in type.
- *
- * @example
- *
- * ```typescript
- * expect('hello', 'to be a', 'string'); // passes
- * expect(42, 'to be an', 'Array'); // fails
- * expect([], 'to be a', 'array'); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.typeOfAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.UnknownSchema,
-    ['to be a', 'to be an', 'to have type'],
-    zod_1.z.enum([...knownTypes].flatMap((t) => [t, t.toLowerCase()])),
-], (_, type) => {
-    type = type.toLowerCase();
-    // these first three are names that are _not_ results of the `typeof` operator; i.e. `typeof x` will never return these strings
-    switch (type) {
-        case 'array':
-            return schema_js_1.UnknownArraySchema;
-        case 'bigint':
-            return schema_js_1.BigintSchema;
-        case 'boolean':
-            return schema_js_1.BooleanSchema;
-        case 'date':
-            return schema_js_1.DateSchema;
-        case 'error':
-            return schema_js_1.ErrorSchema;
-        case 'function':
-            return schema_js_1.FunctionSchema;
-        case 'map':
-            return schema_js_1.MapSchema;
-        case 'null':
-            return schema_js_1.NullSchema;
-        case 'number':
-            return schema_js_1.NumberSchema;
-        case 'object':
-            return schema_js_1.AnyObjectSchema;
-        case 'promise':
-            return schema_js_1.WrappedPromiseLikeSchema;
-        case 'regex': // fallthrough
-        case 'regexp':
-            return schema_js_1.RegExpSchema;
-        case 'set':
-            return schema_js_1.SetSchema;
-        case 'string':
-            return schema_js_1.StringSchema;
-        case 'symbol':
-            return schema_js_1.SymbolSchema;
-        case 'undefined':
-            return schema_js_1.UndefinedSchema;
-        case 'weakmap':
-            return schema_js_1.WeakMapSchema;
-        case 'weakref':
-            return schema_js_1.WeakRefSchema;
-        case 'weakset':
-            return schema_js_1.WeakSetSchema;
-        // c8 ignore next 2
-        default:
-            throw new error_js_1.BupkisError(`Unknown "type": "${type}"`);
-    }
-});
-/**
- * Assertion for testing if a number is greater than another number.
- *
- * @example
- *
- * ```typescript
- * expect(5, 'to be greater than', 3); // passes
- * expect(2, 'to be greater than', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.numberGreaterThanAssertion = (0, create_js_1.createAssertion)([schema_js_1.NumberSchema, 'to be greater than', schema_js_1.NumberSchema], (_, other) => schema_js_1.NumberSchema.gt(other));
-/**
- * Assertion for testing if a number is less than another number.
- *
- * @example
- *
- * ```typescript
- * expect(3, 'to be less than', 5); // passes
- * expect(5, 'to be less than', 2); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.numberLessThanAssertion = (0, create_js_1.createAssertion)([schema_js_1.NumberSchema, ['to be less than', 'to be lt'], schema_js_1.NumberSchema], (_, other) => schema_js_1.NumberSchema.lt(other));
-/**
- * Assertion for testing if a number is greater than or equal to another number.
- *
- * @example
- *
- * ```typescript
- * expect(5, 'to be greater than or equal to', 5); // passes
- * expect(5, 'to be at least', 3); // passes
- * expect(2, 'to be at least', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.numberGreaterThanOrEqualAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.NumberSchema,
-    ['to be greater than or equal to', 'to be at least', 'to be gte'],
-    schema_js_1.NumberSchema,
-], (_, other) => schema_js_1.NumberSchema.gte(other));
-/**
- * Assertion for testing if a number is less than or equal to another number.
- *
- * @example
- *
- * ```typescript
- * expect(3, 'to be less than or equal to', 5); // passes
- * expect(5, 'to be at most', 5); // passes
- * expect(7, 'to be at most', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.numberLessThanOrEqualAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.NumberSchema,
-    ['to be less than or equal to', 'to be at most', 'to be lte'],
-    schema_js_1.NumberSchema,
-], (_, other) => schema_js_1.NumberSchema.lte(other));
-/**
- * Assertion for testing if a number is within a specific range (inclusive).
- *
- * @example
- *
- * ```typescript
- * expect(5, 'to be within', 1, 10); // passes
- * expect(15, 'to be between', 1, 10); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.numberWithinRangeAssertion = (0, create_js_1.createAssertion)([schema_js_1.NumberSchema, ['to be within', 'to be between'], schema_js_1.NumberSchema, schema_js_1.NumberSchema], (subject, min, max) => {
-    if (subject < min || subject > max) {
-        return {
-            message: `Expected ${subject} to be within range [${min}, ${max}]`,
-        };
-    }
-});
-/**
- * Assertion for testing if a number is close to another number within a
- * tolerance.
- *
- * @example
- *
- * ```typescript
- * expect(1.0001, 'to be close to', 1.0, 0.001); // passes
- * expect(1.1, 'to be close to', 1.0, 0.01); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.numberCloseToAssertion = (0, create_js_1.createAssertion)([schema_js_1.NumberSchema, 'to be close to', schema_js_1.NumberSchema, schema_js_1.NumberSchema.optional()], (subject, expected, tolerance = 1e-9) => {
-    const diff = abs(subject - expected);
-    if (diff > tolerance) {
-        return {
-            actual: subject,
-            expected,
-            message: `Expected ${subject} to be close to ${expected} (within ${tolerance}), but difference was ${diff}`,
-        };
-    }
-});
-/**
- * Assertion for testing if a string is lexicographically greater than another
- * string.
- *
- * @example
- *
- * ```typescript
- * expect('b', 'to be greater than', 'a'); // passes
- * expect('apple', 'to be greater than', 'banana'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringGreaterThanAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, 'to be greater than', schema_js_1.StringSchema], (subject, other) => {
-    if (!(subject > other)) {
-        return {
-            message: `Expected "${subject}" to be greater than "${other}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if a string is lexicographically less than another
- * string.
- *
- * @example
- *
- * ```typescript
- * expect('a', 'to be less than', 'b'); // passes
- * expect('banana', 'to be less than', 'apple'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringLessThanAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, 'to be less than', schema_js_1.StringSchema], (subject, other) => {
-    if (!(subject < other)) {
-        return {
-            message: `Expected "${subject}" to be less than "${other}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if a string is lexicographically greater than or equal
- * to another string.
- *
- * @example
- *
- * ```typescript
- * expect('b', 'to be greater than or equal to', 'a'); // passes
- * expect('a', 'to be greater than or equal to', 'a'); // passes
- * expect('a', 'to be greater than or equal to', 'b'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringGreaterThanOrEqualAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, 'to be greater than or equal to', schema_js_1.StringSchema], (subject, other) => {
-    if (!(subject >= other)) {
-        return {
-            message: `Expected "${subject}" to be greater than or equal to "${other}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if a string is lexicographically less than or equal to
- * another string.
- *
- * @example
- *
- * ```typescript
- * expect('a', 'to be less than or equal to', 'b'); // passes
- * expect('a', 'to be less than or equal to', 'a'); // passes
- * expect('b', 'to be less than or equal to', 'a'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringLessThanOrEqualAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, 'to be less than or equal to', schema_js_1.StringSchema], (subject, other) => {
-    if (!(subject <= other)) {
-        return {
-            message: `Expected "${subject}" to be less than or equal to "${other}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if a string begins with a specific prefix.
- *
- * @example
- *
- * ```typescript
- * expect('hello world', 'to begin with', 'hello'); // passes
- * expect('hello world', 'to start with', 'world'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringBeginsWithAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, ['to begin with', 'to start with'], schema_js_1.StringSchema], (subject, prefix) => {
-    if (!subject.startsWith(prefix)) {
-        return {
-            message: `Expected "${subject}" to begin with "${prefix}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if a string ends with a specific suffix.
- *
- * @example
- *
- * ```typescript
- * expect('hello world', 'to end with', 'world'); // passes
- * expect('hello world', 'to end with', 'hello'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringEndsWithAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, 'to end with', schema_js_1.StringSchema], (subject, suffix) => {
-    if (!subject.endsWith(suffix)) {
-        return {
-            message: `Expected "${subject}" to end with "${suffix}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if a value is one of a specific set of values.
- *
- * @example
- *
- * ```typescript
- * expect('red', 'to be one of', ['red', 'green', 'blue']); // passes
- * expect('yellow', 'to be one of', ['red', 'green', 'blue']); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.oneOfAssertion = (0, create_js_1.createAssertion)(['to be one of', schema_js_1.UnknownArraySchema], (subject, values) => {
-    if (!values.includes(subject)) {
-        return {
-            actual: subject,
-            expected: values,
-            message: `Expected ${(0, node_util_1.inspect)(subject)} to be one of [${values.map((v) => (0, node_util_1.inspect)(v)).join(', ')}]`,
-        };
-    }
-});
-/**
- * Assertion for testing if a function has a specific arity (number of
- * parameters).
- *
- * @example
- *
- * ```typescript
- * expect((a, b) => a + b, 'to have arity', 2); // passes
- * expect((a, b, c) => a + b + c, 'to have arity', 2); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.functionArityAssertion = (0, create_js_1.createAssertion)([schema_js_1.FunctionSchema, 'to have arity', schema_js_1.NonNegativeIntegerSchema], (subject, expectedArity) => {
-    if (subject.length !== expectedArity) {
-        return {
-            actual: subject.length,
-            expected: expectedArity,
-            message: `Expected function to have arity ${expectedArity}, but it has arity ${subject.length}`,
-        };
-    }
-});
-/**
- * Assertion for testing if an Error has a specific message.
- *
- * @example
- *
- * ```typescript
- * expect(new Error('oops'), 'to have message', 'oops'); // passes
- * expect(new Error('oops'), 'to have message', 'wrong'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.errorMessageAssertion = (0, create_js_1.createAssertion)([schema_js_1.ErrorSchema, 'to have message', schema_js_1.StringSchema], (subject, expectedMessage) => {
-    if (subject.message !== expectedMessage) {
-        return {
-            actual: subject.message,
-            expected: expectedMessage,
-            message: `Expected error message "${subject.message}" to equal "${expectedMessage}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if an Error has a message matching a regular
- * expression.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   new Error('Error: something went wrong'),
- *   'to have message matching',
- *   /something/,
- * ); // passes
- * expect(new Error('All good'), 'to have message matching', /error/i); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.errorMessageMatchingAssertion = (0, create_js_1.createAssertion)([schema_js_1.ErrorSchema, 'to have message matching', schema_js_1.RegExpSchema], (subject, pattern) => {
-    if (!pattern.test(subject.message)) {
-        return {
-            message: `Expected error message "${subject.message}" to match ${pattern}`,
-        };
-    }
-});
-/**
- * Assertion for testing strict equality between two values.
- *
- * @example
- *
- * ```typescript
- * expect(42, 'to be', 42); // passes
- * expect('hello', 'to equal', 'hello'); // passes
- * expect({}, 'to be', {}); // fails (different object references)
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.strictEqualityAssertion = (0, create_js_1.createAssertion)([
-    [
-        'to be',
-        'to equal',
-        'equals',
-        'is',
-        'is equal to',
-        'to strictly equal',
-        'is strictly equal to',
-    ],
-    schema_js_1.UnknownSchema,
-], (subject, value) => {
-    if (subject !== value) {
-        return {
-            actual: subject,
-            expected: value,
-            message: `Expected ${(0, node_util_1.inspect)(subject)} to equal ${(0, node_util_1.inspect)(value)}`,
-        };
-    }
-});
-/**
- * Assertion for testing deep equality between any values.
- *
- * Works with primitives, objects, arrays, Maps, Sets, and other types.
- *
- * @example
- *
- * ```typescript
- * // Primitives
- * expect(42, 'to deep equal', 42); // passes
- * expect('hello', 'to deeply equal', 'world'); // fails
- *
- * // Objects
- * expect({ a: 1, b: 2 }, 'to deep equal', { a: 1, b: 2 }); // passes
- * expect({ a: 1 }, 'to deeply equal', { a: 1, b: 2 }); // fails
- *
- * // Arrays
- * expect([1, 2, 3], 'to deep equal', [1, 2, 3]); // passes
- *
- * // Maps and Sets
- * expect(new Map([['a', 1]]), 'to deep equal', new Map([['a', 1]])); // passes
- * expect(new Set([1, 2]), 'to deeply equal', new Set([1, 2])); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor unknown-to-deep-equal-any
- * @bupkisAssertionCategory equality
- */
-exports.deepEqualAssertion = (0, create_js_1.createAssertion)([['to deep equal', 'to deeply equal'], schema_js_1.UnknownSchema], (_, expected) => (0, value_to_schema_js_1.valueToSchema)(expected, value_to_schema_js_1.valueToSchemaOptionsForDeepEqual));
-/**
- * Assertion for testing if a function throws an error when called.
- *
- * @example
- *
- * ```typescript
- * expect(() => {
- *   throw new Error('oops');
- * }, 'to throw'); // passes
- * expect(() => 'hello', 'to throw'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor function-to-throw-any
- * @bupkisAssertionCategory function
- * @bupkisRedirect to-throw
- */
-exports.functionThrowsAssertion = (0, create_js_1.createAssertion)([schema_js_1.FunctionSchema, 'to throw'], (subject) => {
-    const { error, result } = (0, assertion_util_js_1.trapError)(subject);
-    if (error === undefined) {
-        return {
-            message: `Expected function to throw, but it fulfilled with ${(0, node_util_1.inspect)(result)}`,
-        };
-    }
-});
-/**
- * Assertion for testing if a function throws an error of a specific type.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   () => {
- *     throw new TypeError('wrong type');
- *   },
- *   'to throw a',
- *   TypeError,
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw an',
- *   TypeError,
- * ); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.functionThrowsTypeAssertion = (0, create_js_1.createAssertion)([schema_js_1.FunctionSchema, ['to throw a', 'to throw an'], schema_js_1.ConstructibleSchema], (subject, ctor) => {
-    const { error, result } = (0, assertion_util_js_1.trapError)(subject);
-    if (error === undefined) {
-        return {
-            message: `Expected function to throw, but fulfilled with ${(0, node_util_1.inspect)(result)}`,
-        };
-    }
-    if (!(0, guards_js_1.isA)(error, ctor)) {
-        if ((0, guards_js_1.isNonNullObject)(error)) {
-            const err = error;
-            return {
-                actual: err.constructor.name,
-                expected: ctor.name,
-                message: `Expected function to throw with an instance of ${ctor.name}, but it threw with a ${err.constructor.name}`,
-            };
-        }
-        return {
-            actual: typeof error,
-            expected: ctor.name,
-            message: `Expected function to throw with an instance of ${ctor.name}, but it threw a value of type ${typeof error}: ${(0, node_util_1.inspect)(error)}`,
-        };
-    }
-});
-/**
- * Assertion for testing if a function throws an error matching specific
- * criteria.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw',
- *   'oops',
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('fail');
- *   },
- *   'to throw',
- *   /error/i,
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw',
- *   { message: 'oops' },
- * ); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.functionThrowsSatisfyingAssertion = (0, create_js_1.createAssertion)([schema_js_1.FunctionSchema, ['to throw', 'to throw error satisfying'], schema_js_1.UnknownSchema], (subject, param) => {
-    const { error } = (0, assertion_util_js_1.trapError)(subject);
-    if (error === undefined) {
-        return {
-            message: 'Expected function to throw, but it did not',
-        };
-    }
-    if ((0, guards_js_1.isString)(param)) {
-        return {
-            schema: (0, schema_js_1.createErrorMessageSchema)(param),
-            subject: error,
-        };
-    }
-    else if ((0, guards_js_1.isA)(param, RegExp)) {
-        return {
-            schema: (0, schema_js_1.createErrorMessageRegexSchema)(param),
-            subject: error,
-        };
-    }
-    else if ((0, guards_js_1.isNonNullObject)(param)) {
-        const schema = (0, value_to_schema_js_1.valueToSchema)(param, value_to_schema_js_1.valueToSchemaOptionsForSatisfies);
-        return { schema, subject: error };
-    }
-    else {
-        throw new error_js_1.InvalidObjectSchemaError(`Invalid parameter schema: ${(0, node_util_1.inspect)(param, { depth: 2 })}`, { schema: param });
-    }
-});
-/**
- * Assertion for testing if a function throws an error of a specific type that
- * also matches criteria.
- *
- * @example
- *
- * ```typescript
- * expect(
- *   () => {
- *     throw new TypeError('wrong type');
- *   },
- *   'to throw a',
- *   TypeError,
- *   'satisfying',
- *   { message: 'wrong type' },
- * ); // passes
- * expect(
- *   () => {
- *     throw new Error('oops');
- *   },
- *   'to throw an',
- *   TypeError,
- *   'satisfying',
- *   /type/,
- * ); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.functionThrowsTypeSatisfyingAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.FunctionSchema,
-    ['to throw a', 'to throw an'],
-    schema_js_1.ConstructibleSchema,
-    'satisfying',
-    schema_js_1.UnknownSchema,
-], (subject, ctor, param) => {
-    const { error, result } = (0, assertion_util_js_1.trapError)(subject);
-    if (error === undefined) {
-        return {
-            message: `Expected function to throw, but it fulfilled with ${(0, node_util_1.inspect)(result)}`,
-        };
-    }
-    if (!(0, guards_js_1.isA)(error, ctor)) {
-        return {
-            message: (0, guards_js_1.isError)(error)
-                ? `Expected function to throw an instance of ${ctor.name}, but it threw ${error.constructor.name}`
-                : `Expected function to throw an instance of ${ctor.name}, but it threw a non-object value: ${(0, node_util_1.inspect)(error)}`,
-        };
-    }
-    let schema;
-    // TODO: can valueToSchema handle the first two conditional branches?
-    if ((0, guards_js_1.isString)(param)) {
-        schema = (0, schema_js_1.createErrorMessageSchema)(param);
-    }
-    else if ((0, guards_js_1.isA)(param, RegExp)) {
-        schema = (0, schema_js_1.createErrorMessageRegexSchema)(param);
-    }
-    else if ((0, guards_js_1.isNonNullObject)(param)) {
-        schema = (0, value_to_schema_js_1.valueToSchema)(param, value_to_schema_js_1.valueToSchemaOptionsForSatisfies);
-    }
-    if (!schema) {
-        throw new error_js_1.InvalidObjectSchemaError(`Invalid parameter schema: ${(0, node_util_1.inspect)(param)}`, { schema: param });
-    }
-    return {
-        schema,
-        subject: error,
-    };
-});
-/**
- * Assertion for testing if a string includes/contains another string.
- *
- * @example
- *
- * ```typescript
- * expect('hello world', 'includes', 'world'); // passes
- * expect('hello world', 'contains', 'foo'); // fails
- * expect('hello world', 'to include', 'hello'); // passes
- * expect('hello world', 'to contain', 'bar'); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringIncludesAssertion = (0, create_js_1.createAssertion)([
-    schema_js_1.StringSchema,
-    ['includes', 'contains', 'to include', 'to contain'],
-    schema_js_1.StringSchema,
-], (subject, expected) => {
-    if (!subject.includes(expected)) {
-        return {
-            message: `Expected "${subject}" to include "${expected}"`,
-        };
-    }
-});
-/**
- * Assertion for testing if a string matches a regular expression.
- *
- * @example
- *
- * ```typescript
- * expect('hello123', 'to match', /\d+/); // passes
- * expect('hello', 'to match', /\d+/); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- */
-exports.stringMatchesAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, 'to match', schema_js_1.RegExpSchema], (subject, regex) => regex.test(subject));
-/**
- * Assertion for testing if a string has a specific length.
- *
- * @example
- *
- * ```typescript
- * expect('hello', 'to have length', 5); // passes
- * expect('hi', 'to have length', 5); // fails
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor string-to-have-length
- * @bupkisAssertionCategory strings
- */
-exports.stringLengthAssertion = (0, create_js_1.createAssertion)([schema_js_1.StringSchema, 'to have length', schema_js_1.NonNegativeIntegerSchema], 
-// StringSchema.length() produces a ZodError with a string diff (e.g., "hel"
-// vs "hello") rather than comparing numeric lengths, which is confusing
-(subject, expectedLength) => {
-    if (subject.length !== expectedLength) {
-        return {
-            actual: subject.length,
-            expected: expectedLength,
-            message: `Expected string to have length ${expectedLength}, but it has length ${subject.length}`,
-        };
-    }
-});
-/**
- * Assertion for testing if a value satisfies a pattern or shape.
- *
- * Works with any value type: primitives, objects, arrays, or cross-type checks.
- * Uses partial matching semantics - extra properties are allowed in objects.
- *
- * @example
- *
- * ```typescript
- * // Primitives
- * expect(42, 'to satisfy', 42); // passes
- * expect('hello', 'satisfies', 'hello'); // passes
- *
- * // Objects (partial matching)
- * expect({ name: 'John', age: 30 }, 'to satisfy', { name: 'John' }); // passes
- * expect({ name: 'John' }, 'to be like', { name: 'John', age: 30 }); // fails
- *
- * // Arrays
- * expect([1, 2, 3], 'to satisfy', [1, 2, 3]); // passes
- *
- * // Cross-type satisfaction
- * expect([1, 2, 3], 'to satisfy', { length: 3 }); // passes
- * ```
- *
- * @group Parametric Assertions (Sync)
- * @bupkisAnchor unknown-to-satisfy-any
- * @bupkisAssertionCategory equality
- */
-exports.satisfiesAssertion = (0, create_js_1.createAssertion)([['to satisfy', 'to be like', 'satisfies'], schema_js_1.UnknownSchema], (_subject, shape) => (0, value_to_schema_js_1.valueToSchema)(shape, value_to_schema_js_1.valueToSchemaOptionsForSatisfies));
-/**
- * Memoizes {@link createInstanceOfSchema}
- */
-const createInstanceOfSchemaCache = new WeakMap();
-/**
- * @function
- */
-const createInstanceOfSchema = (ctor) => {
-    const cached = createInstanceOfSchemaCache.get(ctor);
-    if (cached) {
-        return cached;
-    }
-    const schema = zod_1.z.instanceof(ctor);
-    createInstanceOfSchemaCache.set(ctor, schema);
-    return schema;
-};
-//# sourceMappingURL=sync-parametric.js.map