@modulify/validator 0.2.0 → 0.3.0

package/dist/assertions.d.cts

@@ -0,0 +1,56 @@
+import { AssertionConstraint, Guard, Refinement, Extractor, Checker } from './types/index.cjs';
+import { assert, refine } from './assert.cjs';
+export { assert, refine, };
+type Defined = {} | null;
+type EmptyOptions = Record<never, never>;
+type BoundedAssertionOptions = {
+    exact?: number | null;
+    max?: number | null;
+    min?: number | null;
+    range?: readonly [number, number] | null;
+    bail?: boolean;
+};
+type OptionNumber<O, K extends PropertyKey> = K extends keyof O ? Extract<O[K], number> : never;
+type OptionRange<O, K extends PropertyKey> = K extends keyof O ? Extract<O[K], readonly [number, number] | [number, number]> extends infer R ? R extends readonly [infer Min extends number, infer Max extends number] ? readonly [Min, Max] : never : never : never;
+type IncludeConstraint<Value, C extends AssertionConstraint> = [Value] extends [never] ? [] : [C];
+export declare const isBoolean: Guard<boolean, [], "type.boolean", [], "isBoolean">;
+export declare const isBigInt: Guard<bigint, [], "type.bigint", [], "isBigInt">;
+export declare const isBlob: Guard<Blob, [], "type.blob", [], "isBlob">;
+export declare const isDate: Guard<Date, [], "type.date", [], "isDate">;
+export declare const isDefined: Guard<Defined, [], "value.defined", [], "isDefined">;
+export declare const isEmail: Guard<string, [], "string.email", [], "isEmail">;
+export declare const isError: Guard<Error, [], "type.error", [], "isError">;
+export declare const isFiniteNumber: Guard<number, [], "number.finite", [], "isFiniteNumber">;
+export declare const isFile: Guard<File, [], "type.file", [], "isFile">;
+export declare const isFunction: Guard<(...args: never[]) => unknown, [], "type.function", [], "isFunction">;
+export declare const isInteger: Guard<number, [], "number.integer", [], "isInteger">;
+export declare const isMap: Guard<Map<unknown, unknown>, [], "type.map", [], "isMap">;
+export declare const isNaN: Guard<number, [], "number.nan", [], "isNaN">;
+export declare const isNull: Guard<null, [], "type.null", [], "isNull">;
+export declare const isNumber: Guard<number, [], "type.number", [], "isNumber">;
+export declare const isPromiseLike: Guard<PromiseLike<unknown>, [], "type.promise-like", [], "isPromiseLike">;
+export declare const isRegExp: Guard<RegExp, [], "type.regexp", [], "isRegExp">;
+export declare const isSafeInteger: Guard<number, [], "number.safe-integer", [], "isSafeInteger">;
+export declare const isSet: Guard<Set<unknown>, [], "type.set", [], "isSet">;
+export declare const isString: Guard<string, [], "type.string", [], "isString">;
+export declare const isSymbol: Guard<symbol, [], "type.symbol", [], "isSymbol">;
+export declare const isValidDate: Guard<Date, [], "date.valid", [], "isValidDate">;
+export declare const hasLength: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>], "length.unsupported-type", [], "hasLength">;
+export declare const hasSize: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>], "size.unsupported-type", [], "hasSize">;
+export declare const hasPattern: (pattern: RegExp, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, pattern: RegExp) => boolean, "string.pattern", RegExp]], "string.unsupported-type", [], "hasPattern">;
+export declare const startsWith: (prefix: string, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, prefix: string) => boolean, "string.starts-with", string]], "string.unsupported-type", [], "startsWith">;
+export declare const endsWith: (suffix: string, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, suffix: string) => boolean, "string.ends-with", string]], "string.unsupported-type", [], "endsWith">;
+export declare const hasValue: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>], "number.unsupported-type", [], "hasValue">;
+export declare const multipleOf: <const Step extends number>(step: Step, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<number, readonly [readonly [(value: number) => number, (value: number, step: number) => boolean, "number.multiple-of", Step]], "number.unsupported-type", [], "multipleOf">;
+export declare const oneOf: <Actual = unknown>(values: Actual[] | Record<string, Actual>, { equalTo, bail, }?: {
+    equalTo?: (a: Actual, b: unknown) => boolean;
+    bail?: boolean;
+}) => Guard<Actual, [], "value.one-of", readonly [Actual[]], "oneOf">;

package/dist/assertions.d.mts

@@ -0,0 +1,56 @@
+import { AssertionConstraint, Guard, Refinement, Extractor, Checker } from './types/index.mjs';
+import { assert, refine } from './assert.mjs';
+export { assert, refine, };
+type Defined = {} | null;
+type EmptyOptions = Record<never, never>;
+type BoundedAssertionOptions = {
+    exact?: number | null;
+    max?: number | null;
+    min?: number | null;
+    range?: readonly [number, number] | null;
+    bail?: boolean;
+};
+type OptionNumber<O, K extends PropertyKey> = K extends keyof O ? Extract<O[K], number> : never;
+type OptionRange<O, K extends PropertyKey> = K extends keyof O ? Extract<O[K], readonly [number, number] | [number, number]> extends infer R ? R extends readonly [infer Min extends number, infer Max extends number] ? readonly [Min, Max] : never : never : never;
+type IncludeConstraint<Value, C extends AssertionConstraint> = [Value] extends [never] ? [] : [C];
+export declare const isBoolean: Guard<boolean, [], "type.boolean", [], "isBoolean">;
+export declare const isBigInt: Guard<bigint, [], "type.bigint", [], "isBigInt">;
+export declare const isBlob: Guard<Blob, [], "type.blob", [], "isBlob">;
+export declare const isDate: Guard<Date, [], "type.date", [], "isDate">;
+export declare const isDefined: Guard<Defined, [], "value.defined", [], "isDefined">;
+export declare const isEmail: Guard<string, [], "string.email", [], "isEmail">;
+export declare const isError: Guard<Error, [], "type.error", [], "isError">;
+export declare const isFiniteNumber: Guard<number, [], "number.finite", [], "isFiniteNumber">;
+export declare const isFile: Guard<File, [], "type.file", [], "isFile">;
+export declare const isFunction: Guard<(...args: never[]) => unknown, [], "type.function", [], "isFunction">;
+export declare const isInteger: Guard<number, [], "number.integer", [], "isInteger">;
+export declare const isMap: Guard<Map<unknown, unknown>, [], "type.map", [], "isMap">;
+export declare const isNaN: Guard<number, [], "number.nan", [], "isNaN">;
+export declare const isNull: Guard<null, [], "type.null", [], "isNull">;
+export declare const isNumber: Guard<number, [], "type.number", [], "isNumber">;
+export declare const isPromiseLike: Guard<PromiseLike<unknown>, [], "type.promise-like", [], "isPromiseLike">;
+export declare const isRegExp: Guard<RegExp, [], "type.regexp", [], "isRegExp">;
+export declare const isSafeInteger: Guard<number, [], "number.safe-integer", [], "isSafeInteger">;
+export declare const isSet: Guard<Set<unknown>, [], "type.set", [], "isSet">;
+export declare const isString: Guard<string, [], "type.string", [], "isString">;
+export declare const isSymbol: Guard<symbol, [], "type.symbol", [], "isSymbol">;
+export declare const isValidDate: Guard<Date, [], "date.valid", [], "isValidDate">;
+export declare const hasLength: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>], "length.unsupported-type", [], "hasLength">;
+export declare const hasSize: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>], "size.unsupported-type", [], "hasSize">;
+export declare const hasPattern: (pattern: RegExp, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, pattern: RegExp) => boolean, "string.pattern", RegExp]], "string.unsupported-type", [], "hasPattern">;
+export declare const startsWith: (prefix: string, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, prefix: string) => boolean, "string.starts-with", string]], "string.unsupported-type", [], "startsWith">;
+export declare const endsWith: (suffix: string, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, suffix: string) => boolean, "string.ends-with", string]], "string.unsupported-type", [], "endsWith">;
+export declare const hasValue: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>], "number.unsupported-type", [], "hasValue">;
+export declare const multipleOf: <const Step extends number>(step: Step, { bail, }?: {
+    bail?: boolean;
+}) => Refinement<number, readonly [readonly [(value: number) => number, (value: number, step: number) => boolean, "number.multiple-of", Step]], "number.unsupported-type", [], "multipleOf">;
+export declare const oneOf: <Actual = unknown>(values: Actual[] | Record<string, Actual>, { equalTo, bail, }?: {
+    equalTo?: (a: Actual, b: unknown) => boolean;
+    bail?: boolean;
+}) => Guard<Actual, [], "value.one-of", readonly [Actual[]], "oneOf">;

package/dist/assertions.d.ts

@@ -1,58 +1,56 @@
-import { AssertionConstraint, Assertion } from '../types';
-import { assert } from './assert';
-export { assert };
-type LengthAssertionConstraint = AssertionConstraint<string | unknown[], number, [exact: number], 'length.exact'> | AssertionConstraint<string | unknown[], number, [max: number], 'length.max'> | AssertionConstraint<string | unknown[], number, [min: number], 'length.min'> | AssertionConstraint<string | unknown[], number, [range: [number, number]], 'length.range'>;
-type SizeAssertionConstraint = AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [exact: number], 'size.exact'> | AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [max: number], 'size.max'> | AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [min: number], 'size.min'> | AssertionConstraint<Map<unknown, unknown> | Set<unknown>, number, [range: [number, number]], 'size.range'>;
-type ValueAssertionConstraint = AssertionConstraint<number, number, [exact: number], 'number.exact'> | AssertionConstraint<number, number, [max: number], 'number.max'> | AssertionConstraint<number, number, [min: number], 'number.min'> | AssertionConstraint<number, number, [range: [number, number]], 'number.range'>;
-export declare const isBoolean: Assertion<boolean, [], "type.boolean", undefined, "isBoolean">;
-export declare const isBigInt: Assertion<bigint, [], "type.bigint", undefined, "isBigInt">;
-export declare const isBlob: Assertion<Blob, [], "type.blob", undefined, "isBlob">;
-export declare const isDate: Assertion<Date, [], "type.date", undefined, "isDate">;
-export declare const isDefined: Assertion<{}, [], "value.defined", undefined, "isDefined">;
-export declare const isEmail: Assertion<string, [], "string.email", undefined, "isEmail">;
-export declare const isFile: Assertion<File, [], "type.file", undefined, "isFile">;
-export declare const isFunction: Assertion<(...args: never[]) => unknown, [], "type.function", undefined, "isFunction">;
-export declare const isMap: Assertion<Map<unknown, unknown>, [], "type.map", undefined, "isMap">;
-export declare const isNaN: Assertion<number, [], "number.nan", undefined, "isNaN">;
-export declare const isNull: Assertion<null, [], "type.null", undefined, "isNull">;
-export declare const isNumber: Assertion<number, [], "type.number", undefined, "isNumber">;
-export declare const isSet: Assertion<Set<unknown>, [], "type.set", undefined, "isSet">;
-export declare const isString: Assertion<string, [], "type.string", undefined, "isString">;
-export declare const isSymbol: Assertion<symbol, [], "type.symbol", undefined, "isSymbol">;
-export declare const hasLength: ({ exact, max, min, range, bail, }?: {
+import { AssertionConstraint, Guard, Refinement, Extractor, Checker } from './types/index.js';
+import { assert, refine } from './assert.js';
+export { assert, refine, };
+type Defined = {} | null;
+type EmptyOptions = Record<never, never>;
+type BoundedAssertionOptions = {
     exact?: number | null;
     max?: number | null;
     min?: number | null;
-    range?: [number, number] | null;
-    bail?: boolean;
-}) => Assertion<string | unknown[], LengthAssertionConstraint[], "length.unsupported-type", undefined, "hasLength">;
-export declare const hasSize: ({ exact, max, min, range, bail, }?: {
-    exact?: number | null;
-    max?: number | null;
-    min?: number | null;
-    range?: [number, number] | null;
-    bail?: boolean;
-}) => Assertion<Map<unknown, unknown> | Set<unknown>, SizeAssertionConstraint[], "size.unsupported-type", undefined, "hasSize">;
+    range?: readonly [number, number] | null;
+    bail?: boolean;
+};
+type OptionNumber<O, K extends PropertyKey> = K extends keyof O ? Extract<O[K], number> : never;
+type OptionRange<O, K extends PropertyKey> = K extends keyof O ? Extract<O[K], readonly [number, number] | [number, number]> extends infer R ? R extends readonly [infer Min extends number, infer Max extends number] ? readonly [Min, Max] : never : never : never;
+type IncludeConstraint<Value, C extends AssertionConstraint> = [Value] extends [never] ? [] : [C];
+export declare const isBoolean: Guard<boolean, [], "type.boolean", [], "isBoolean">;
+export declare const isBigInt: Guard<bigint, [], "type.bigint", [], "isBigInt">;
+export declare const isBlob: Guard<Blob, [], "type.blob", [], "isBlob">;
+export declare const isDate: Guard<Date, [], "type.date", [], "isDate">;
+export declare const isDefined: Guard<Defined, [], "value.defined", [], "isDefined">;
+export declare const isEmail: Guard<string, [], "string.email", [], "isEmail">;
+export declare const isError: Guard<Error, [], "type.error", [], "isError">;
+export declare const isFiniteNumber: Guard<number, [], "number.finite", [], "isFiniteNumber">;
+export declare const isFile: Guard<File, [], "type.file", [], "isFile">;
+export declare const isFunction: Guard<(...args: never[]) => unknown, [], "type.function", [], "isFunction">;
+export declare const isInteger: Guard<number, [], "number.integer", [], "isInteger">;
+export declare const isMap: Guard<Map<unknown, unknown>, [], "type.map", [], "isMap">;
+export declare const isNaN: Guard<number, [], "number.nan", [], "isNaN">;
+export declare const isNull: Guard<null, [], "type.null", [], "isNull">;
+export declare const isNumber: Guard<number, [], "type.number", [], "isNumber">;
+export declare const isPromiseLike: Guard<PromiseLike<unknown>, [], "type.promise-like", [], "isPromiseLike">;
+export declare const isRegExp: Guard<RegExp, [], "type.regexp", [], "isRegExp">;
+export declare const isSafeInteger: Guard<number, [], "number.safe-integer", [], "isSafeInteger">;
+export declare const isSet: Guard<Set<unknown>, [], "type.set", [], "isSet">;
+export declare const isString: Guard<string, [], "type.string", [], "isString">;
+export declare const isSymbol: Guard<symbol, [], "type.symbol", [], "isSymbol">;
+export declare const isValidDate: Guard<Date, [], "date.valid", [], "isValidDate">;
+export declare const hasLength: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<string | unknown[], number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "length.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<string | unknown[], number>, Checker<number, [max: OptionNumber<O, "max">]>, "length.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<string | unknown[], number>, Checker<number, [min: OptionNumber<O, "min">]>, "length.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<string | unknown[], number>, Checker<number, [range: OptionRange<O, "range">]>, "length.range", range: OptionRange<O, "range">]>], "length.unsupported-type", [], "hasLength">;
+export declare const hasSize: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "size.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [max: OptionNumber<O, "max">]>, "size.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [min: OptionNumber<O, "min">]>, "size.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<Map<unknown, unknown> | Set<unknown>, number>, Checker<number, [range: OptionRange<O, "range">]>, "size.range", range: OptionRange<O, "range">]>], "size.unsupported-type", [], "hasSize">;
 export declare const hasPattern: (pattern: RegExp, { bail, }?: {
     bail?: boolean;
-}) => Assertion<string, readonly [readonly [(value: string) => string, (value: string, pattern: RegExp) => boolean, "string.pattern", RegExp]], "string.unsupported-type", undefined, "hasPattern">;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, pattern: RegExp) => boolean, "string.pattern", RegExp]], "string.unsupported-type", [], "hasPattern">;
 export declare const startsWith: (prefix: string, { bail, }?: {
     bail?: boolean;
-}) => Assertion<string, readonly [readonly [(value: string) => string, (value: string, prefix: string) => boolean, "string.starts-with", string]], "string.unsupported-type", undefined, "startsWith">;
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, prefix: string) => boolean, "string.starts-with", string]], "string.unsupported-type", [], "startsWith">;
 export declare const endsWith: (suffix: string, { bail, }?: {
     bail?: boolean;
-}) => Assertion<string, readonly [readonly [(value: string) => string, (value: string, suffix: string) => boolean, "string.ends-with", string]], "string.unsupported-type", undefined, "endsWith">;
-export declare const hasValue: ({ exact, max, min, range, bail, }?: {
-    exact?: number | null;
-    max?: number | null;
-    min?: number | null;
-    range?: [number, number] | null;
-    bail?: boolean;
-}) => Assertion<number, ValueAssertionConstraint[], "number.unsupported-type", undefined, "hasValue">;
-export declare const multipleOf: (step: number, { bail, }?: {
+}) => Refinement<string, readonly [readonly [(value: string) => string, (value: string, suffix: string) => boolean, "string.ends-with", string]], "string.unsupported-type", [], "endsWith">;
+export declare const hasValue: <const O extends BoundedAssertionOptions = EmptyOptions>(options?: O) => Refinement<[...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>] extends infer T ? T extends [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>] ? T extends readonly [] ? unknown : (T[number] extends infer T_1 ? T_1 extends T[number] ? T_1 extends unknown ? (value: Parameters<T_1[0]>[0]) => void : never : never : never) extends (value: infer Input) => void ? Input : never : never : never, [...IncludeConstraint<OptionNumber<O, "exact">, readonly [ Extractor<number, number>, Checker<number, [exact: OptionNumber<O, "exact">]>, "number.exact", exact: OptionNumber<O, "exact">]>, ...IncludeConstraint<OptionNumber<O, "max">, readonly [ Extractor<number, number>, Checker<number, [max: OptionNumber<O, "max">]>, "number.max", max: OptionNumber<O, "max">]>, ...IncludeConstraint<OptionNumber<O, "min">, readonly [ Extractor<number, number>, Checker<number, [min: OptionNumber<O, "min">]>, "number.min", min: OptionNumber<O, "min">]>, ...IncludeConstraint<OptionRange<O, "range">, readonly [ Extractor<number, number>, Checker<number, [range: OptionRange<O, "range">]>, "number.range", range: OptionRange<O, "range">]>], "number.unsupported-type", [], "hasValue">;
+export declare const multipleOf: <const Step extends number>(step: Step, { bail, }?: {
     bail?: boolean;
-}) => Assertion<number, readonly [readonly [(value: number) => number, (value: number, step: number) => boolean, "number.multiple-of", number]], "number.unsupported-type", undefined, "multipleOf">;
+}) => Refinement<number, readonly [readonly [(value: number) => number, (value: number, step: number) => boolean, "number.multiple-of", Step]], "number.unsupported-type", [], "multipleOf">;
 export declare const oneOf: <Actual = unknown>(values: Actual[] | Record<string, Actual>, { equalTo, bail, }?: {
     equalTo?: (a: Actual, b: unknown) => boolean;
     bail?: boolean;
-}) => Assertion<Actual, [], "value.one-of", readonly [Actual[]], "oneOf">;
+}) => Guard<Actual, [], "value.one-of", readonly [Actual[]], "oneOf">;

package/dist/assertions.mjs

@@ -1,207 +1,3 @@
-import { assert } from "./assert.mjs";
-import { isString as isString$1, isArray, isMap as isMap$1, isSet as isSet$1, isNumber as isNumber$1, isBigInt as isBigInt$1, isBlob as isBlob$1, isBoolean as isBoolean$1, isDate as isDate$1, isEmail as isEmail$1, isFile as isFile$1, isFunction as isFunction$1, isNaN as isNaN$1, isNull as isNull$1, isSymbol as isSymbol$1 } from "./predicates.mjs";
-const isEqual = (value, exact) => value === exact;
-const isGte = (value, min) => value >= min;
-const isLte = (value, max) => value <= max;
-const inRange = (value, [min, max]) => value >= min && value <= max;
-const startsWith$1 = (value, prefix) => value.startsWith(prefix);
-const endsWith$1 = (value, suffix) => value.endsWith(suffix);
-const matchesPattern = (value, pattern) => new RegExp(pattern.source, pattern.flags).test(value);
-const isMultipleOf = (value, step) => {
-  if (step === 0) {
-    return false;
-  }
-  const quotient = value / step;
-  const nearestInteger = Math.round(quotient);
-  const delta = Math.abs(quotient - nearestInteger);
-  return Number.isFinite(quotient) && delta <= Number.EPSILON * Math.max(1, Math.abs(quotient)) * 16;
-};
-const length = (value) => value.length;
-const size = (value) => value.size;
-const isBoolean = assert(isBoolean$1, { name: "isBoolean", bail: true, code: "type.boolean" });
-const isBigInt = assert(isBigInt$1, { name: "isBigInt", bail: true, code: "type.bigint" });
-const isBlob = assert(isBlob$1, { name: "isBlob", bail: true, code: "type.blob" });
-const isDate = assert(isDate$1, { name: "isDate", bail: true, code: "type.date" });
-const isDefined = assert((value) => value !== void 0, {
-  name: "isDefined",
-  bail: true,
-  code: "value.defined"
-});
-const isEmail = assert(isEmail$1, { name: "isEmail", bail: true, code: "string.email" });
-const isFile = assert(isFile$1, { name: "isFile", bail: true, code: "type.file" });
-const isFunction = assert(isFunction$1, { name: "isFunction", bail: true, code: "type.function" });
-const isMap = assert(isMap$1, { name: "isMap", bail: true, code: "type.map" });
-const isNaN = assert(isNaN$1, { name: "isNaN", bail: true, code: "number.nan" });
-const isNull = assert(isNull$1, { name: "isNull", bail: true, code: "type.null" });
-const isNumber = assert(isNumber$1, { name: "isNumber", bail: true, code: "type.number" });
-const isSet = assert(isSet$1, { name: "isSet", bail: true, code: "type.set" });
-const isString = assert(isString$1, { name: "isString", bail: true, code: "type.string" });
-const isSymbol = assert(isSymbol$1, { name: "isSymbol", bail: true, code: "type.symbol" });
-const hasLength = ({
-  exact = null,
-  max = null,
-  min = null,
-  range = null,
-  bail = false
-} = {}) => {
-  const constraints = [];
-  if (exact !== null) constraints.push([length, isEqual, "length.exact", exact]);
-  if (max !== null) constraints.push([length, isLte, "length.max", max]);
-  if (min !== null) constraints.push([length, isGte, "length.min", min]);
-  if (range !== null) constraints.push([length, inRange, "length.range", range]);
-  return assert(
-    (value) => isArray(value) || isString$1(value),
-    {
-      name: "hasLength",
-      bail,
-      code: "length.unsupported-type"
-    },
-    constraints
-  );
-};
-const hasSize = ({
-  exact = null,
-  max = null,
-  min = null,
-  range = null,
-  bail = false
-} = {}) => {
-  const constraints = [];
-  if (exact !== null) constraints.push([size, isEqual, "size.exact", exact]);
-  if (max !== null) constraints.push([size, isLte, "size.max", max]);
-  if (min !== null) constraints.push([size, isGte, "size.min", min]);
-  if (range !== null) constraints.push([size, inRange, "size.range", range]);
-  return assert(
-    (value) => isMap$1(value) || isSet$1(value),
-    {
-      name: "hasSize",
-      bail,
-      code: "size.unsupported-type"
-    },
-    constraints
-  );
-};
-const hasPattern = (pattern, {
-  bail = false
-} = {}) => assert(
-  isString$1,
-  {
-    name: "hasPattern",
-    bail,
-    code: "string.unsupported-type"
-  },
-  [[
-    (value) => value,
-    matchesPattern,
-    "string.pattern",
-    pattern
-  ]]
-);
-const startsWith = (prefix, {
-  bail = false
-} = {}) => assert(
-  isString$1,
-  {
-    name: "startsWith",
-    bail,
-    code: "string.unsupported-type"
-  },
-  [[
-    (value) => value,
-    startsWith$1,
-    "string.starts-with",
-    prefix
-  ]]
-);
-const endsWith = (suffix, {
-  bail = false
-} = {}) => assert(
-  isString$1,
-  {
-    name: "endsWith",
-    bail,
-    code: "string.unsupported-type"
-  },
-  [[
-    (value) => value,
-    endsWith$1,
-    "string.ends-with",
-    suffix
-  ]]
-);
-const hasValue = ({
-  exact = null,
-  max = null,
-  min = null,
-  range = null,
-  bail = false
-} = {}) => {
-  const constraints = [];
-  if (exact !== null) constraints.push([(value) => value, isEqual, "number.exact", exact]);
-  if (max !== null) constraints.push([(value) => value, isLte, "number.max", max]);
-  if (min !== null) constraints.push([(value) => value, isGte, "number.min", min]);
-  if (range !== null) constraints.push([(value) => value, inRange, "number.range", range]);
-  return assert(
-    isNumber$1,
-    {
-      name: "hasValue",
-      bail,
-      code: "number.unsupported-type"
-    },
-    constraints
-  );
-};
-const multipleOf = (step, {
-  bail = false
-} = {}) => assert(
-  isNumber$1,
-  {
-    name: "multipleOf",
-    bail,
-    code: "number.unsupported-type"
-  },
-  [[
-    (value) => value,
-    isMultipleOf,
-    "number.multiple-of",
-    step
-  ]]
-);
-const oneOf = (values, {
-  equalTo = (a, b) => a === b,
-  bail = false
-} = {}) => {
-  const haystack = isArray(values) ? values : Object.values(values);
-  return assert((value) => haystack.some((item) => equalTo(item, value)), {
-    name: "oneOf",
-    bail,
-    code: "value.one-of",
-    args: [haystack]
-  });
-};
-export {
-  assert,
-  endsWith,
-  hasLength,
-  hasPattern,
-  hasSize,
-  hasValue,
-  isBigInt,
-  isBlob,
-  isBoolean,
-  isDate,
-  isDefined,
-  isEmail,
-  isFile,
-  isFunction,
-  isMap,
-  isNaN,
-  isNull,
-  isNumber,
-  isSet,
-  isString,
-  isSymbol,
-  multipleOf,
-  oneOf,
-  startsWith
-};
+import { a as refine, t as assert } from "./assert-CzMg5aO7.mjs";
+import { A as startsWith, C as isSafeInteger, D as isValidDate, E as isSymbol, O as multipleOf, S as isRegExp, T as isString, _ as isMap, a as hasValue, b as isNumber, c as isBoolean, d as isEmail, f as isError, g as isInteger, h as isFunction, i as hasSize, k as oneOf, l as isDate, m as isFiniteNumber, n as hasLength, o as isBigInt, p as isFile, r as hasPattern, s as isBlob, t as endsWith, u as isDefined, v as isNaN, w as isSet, x as isPromiseLike, y as isNull } from "./assertions-DPYCHREw.mjs";
+export { assert, endsWith, hasLength, hasPattern, hasSize, hasValue, isBigInt, isBlob, isBoolean, isDate, isDefined, isEmail, isError, isFile, isFiniteNumber, isFunction, isInteger, isMap, isNaN, isNull, isNumber, isPromiseLike, isRegExp, isSafeInteger, isSet, isString, isSymbol, isValidDate, multipleOf, oneOf, refine, startsWith };

package/dist/checkers.d.cts

@@ -0,0 +1,8 @@
+export declare const isEqual: (value: number, exact: number) => boolean;
+export declare const isGte: (value: number, min: number) => boolean;
+export declare const isLte: (value: number, max: number) => boolean;
+export declare const inRange: (value: number, [min, max]: readonly [number, number]) => boolean;
+export declare const startsWith: (value: string, prefix: string) => boolean;
+export declare const endsWith: (value: string, suffix: string) => boolean;
+export declare const matchesPattern: (value: string, pattern: RegExp) => boolean;
+export declare const isMultipleOf: (value: number, step: number) => boolean;

package/dist/checkers.d.mts

@@ -0,0 +1,8 @@
+export declare const isEqual: (value: number, exact: number) => boolean;
+export declare const isGte: (value: number, min: number) => boolean;
+export declare const isLte: (value: number, max: number) => boolean;
+export declare const inRange: (value: number, [min, max]: readonly [number, number]) => boolean;
+export declare const startsWith: (value: string, prefix: string) => boolean;
+export declare const endsWith: (value: string, suffix: string) => boolean;
+export declare const matchesPattern: (value: string, pattern: RegExp) => boolean;
+export declare const isMultipleOf: (value: number, step: number) => boolean;

package/dist/checkers.d.ts

@@ -1,7 +1,7 @@
 export declare const isEqual: (value: number, exact: number) => boolean;
 export declare const isGte: (value: number, min: number) => boolean;
 export declare const isLte: (value: number, max: number) => boolean;
-export declare const inRange: (value: number, [min, max]: [number, number]) => boolean;
+export declare const inRange: (value: number, [min, max]: readonly [number, number]) => boolean;
 export declare const startsWith: (value: string, prefix: string) => boolean;
 export declare const endsWith: (value: string, suffix: string) => boolean;
 export declare const matchesPattern: (value: string, pattern: RegExp) => boolean;