@nicolastoulemont/std 0.9.0 → 0.11.0

package/dist/index-DzGXoCV1.d.mts

@@ -0,0 +1,433 @@
+import { t as Pipeable } from "./pipeable-BY9yPsNK.mjs";
+import { r as Prettify } from "./type-utils.types-CnPpsvt5.mjs";
+import { t as Result } from "./result.types-JEcowzYH.mjs";
+import { i as Discriminator, n as TaggedErrorFactory, r as StructValue } from "./index-lYxaV6H7.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/schema/schema.types.d.ts
+/**
+ * Infer the input type from a Standard Schema.
+ */
+type Input<S$1 extends StandardSchemaV1> = NonNullable<S$1["~standard"]["types"]>["input"];
+/**
+ * Infer the output type from a Standard Schema.
+ */
+type Output<S$1 extends StandardSchemaV1> = NonNullable<S$1["~standard"]["types"]>["output"];
+/**
+ * Infer the validated output type from a Standard Schema.
+ *
+ * This matches the exact schema output used by `Schema.parse()` and by
+ * `Schema.is()` when the starting value is `unknown`.
+ */
+type Infer<S$1 extends StandardSchemaV1> = Output<S$1>;
+/**
+ * Compute the base-shape-preserving narrowed type used by `Schema.refine()`.
+ *
+ * This preserves fields already present on the base value while intersecting in
+ * the schema-proven output fields. This is also the shape TypeScript derives in
+ * direct control-flow checks when `Schema.is()` is used on an already-typed
+ * value.
+ */
+type Refine<Base, S$1 extends StandardSchemaV1> = Base extends Input<S$1> ? (Base extends unknown ? Prettify<Base & Output<S$1>> : never) : never;
+/**
+ * Normalized validation issue shape used across std modules.
+ */
+type ValidationIssue = {
+  readonly message: string;
+  readonly path?: ReadonlyArray<PropertyKey> | undefined;
+};
+/**
+ * Validation error containing normalized schema issues.
+ */
+type ValidationError = {
+  readonly issues: ReadonlyArray<ValidationIssue>;
+};
+/**
+ * Standard Schema value used through Schema's sync-only validation boundary.
+ *
+ * Standard Schema providers may type validation as sync-or-async even for
+ * sync schemas. Schema accepts those provider types directly and throws if
+ * validation returns a Promise at runtime.
+ */
+type SyncSchema<TInput = unknown, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;
+/**
+ * Schema whose validated output is a refinement of a broader base type.
+ */
+type RefinementSchema<Base, Sub extends Base> = StandardSchemaV1<Base, Sub>;
+/**
+ * Sync-only refinement schema for building type guards.
+ */
+type SyncRefinementSchema<Base, Sub extends Base> = SyncSchema<Base, Sub>;
+//#endregion
+//#region src/schema/schema.codec.d.ts
+declare const CodecDecodeError_base: TaggedErrorFactory<"CodecDecodeError">;
+declare class CodecDecodeError extends CodecDecodeError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const CodecDecodeValidationError_base: TaggedErrorFactory<"CodecDecodeValidationError">;
+declare class CodecDecodeValidationError extends CodecDecodeValidationError_base<{
+  readonly side: "encoded" | "decoded";
+  readonly error: ValidationError;
+}> {}
+declare const CodecEncodeValidationError_base: TaggedErrorFactory<"CodecEncodeValidationError">;
+declare class CodecEncodeValidationError extends CodecEncodeValidationError_base<{
+  readonly side: "decoded" | "encoded";
+  readonly error: ValidationError;
+}> {}
+declare const CodecEncodeError_base: TaggedErrorFactory<"CodecEncodeError">;
+declare class CodecEncodeError extends CodecEncodeError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+type CodecError = CodecDecodeError | CodecDecodeValidationError | CodecEncodeValidationError | CodecEncodeError;
+type MaybePromise<T> = T | Promise<T>;
+type IsNever<T> = [T] extends [never] ? true : false;
+type TransformIsAsync<TransformReturn> = IsNever<TransformReturn> extends true ? false : TransformReturn extends Promise<unknown> ? true : false;
+type CodecMethodResult<T, IsAsync extends boolean> = IsAsync extends true ? Promise<Result<T, CodecError>> : Result<T, CodecError>;
+type Codec$1<Decoded$1 extends StandardSchemaV1 = StandardSchemaV1, Encoded$1 extends StandardSchemaV1 = StandardSchemaV1, DecodeReturn = Input<Decoded$1>, EncodeReturn = Input<Encoded$1>> = Pipeable & {
+  readonly decoded: Decoded$1;
+  readonly encoded: Encoded$1;
+  decode(input: Input<Encoded$1>): CodecMethodResult<Output<Decoded$1>, TransformIsAsync<DecodeReturn>>;
+  encode(value: Output<Decoded$1>): CodecMethodResult<Output<Encoded$1>, TransformIsAsync<EncodeReturn>>;
+};
+type Decoded<C> = C extends {
+  readonly decoded: infer DecodedSchema extends StandardSchemaV1;
+} ? Output<DecodedSchema> : never;
+type Encoded<C> = C extends {
+  readonly encoded: infer EncodedSchema extends StandardSchemaV1;
+} ? Output<EncodedSchema> : never;
+type DecodeInput<C> = C extends {
+  decode(input: infer I): unknown;
+} ? I : never;
+type EncodeInput<C> = C extends {
+  encode(input: infer I): unknown;
+} ? I : never;
+type CodecOptions<Decoded$1 extends StandardSchemaV1, Encoded$1 extends StandardSchemaV1, DecodeReturn extends MaybePromise<Input<Decoded$1>>, EncodeReturn extends MaybePromise<Input<Encoded$1>>> = {
+  readonly decoded: Decoded$1;
+  readonly encoded: Encoded$1;
+  readonly decode: (encoded: Output<Encoded$1>) => DecodeReturn;
+  readonly encode: (decoded: Output<Decoded$1>) => EncodeReturn;
+};
+type JsonCodecOptions = {
+  readonly replacer?: Parameters<typeof JSON.stringify>[1];
+  readonly space?: Parameters<typeof JSON.stringify>[2];
+};
+declare function jsonCodec<S$1 extends StandardSchemaV1>(schema: S$1, options?: JsonCodecOptions): Codec$1<S$1, SyncSchema<string, string>, Input<S$1>, string>;
+type CodecConstructor = {
+  <Decoded$1 extends StandardSchemaV1, Encoded$1 extends StandardSchemaV1, DecodeReturn extends MaybePromise<Input<Decoded$1>>, EncodeReturn extends MaybePromise<Input<Encoded$1>>>(options: CodecOptions<Decoded$1, Encoded$1, DecodeReturn, EncodeReturn>): Codec$1<Decoded$1, Encoded$1, DecodeReturn, EncodeReturn>;
+  json<S$1 extends StandardSchemaV1>(schema: S$1, options?: JsonCodecOptions): ReturnType<typeof jsonCodec<S$1>>;
+};
+//#endregion
+//#region src/schema/schema.struct.d.ts
+type StructSchema<TInput = unknown, TOutput extends Record<string, unknown> = Record<string, unknown>> = SyncSchema<TInput, TOutput>;
+type StructConstructor<S$1 extends StructSchema> = (input: Input<S$1>) => Result<StructValue<Output<S$1>>, ValidationError>;
+/**
+ * Create a sync schema-backed constructor for struct objects.
+ *
+ * The constructor validates through the provided schema, then wraps the
+ * validated object with `Data.struct()` so the result is frozen and gains
+ * structural `equals()` and `hash()` behavior.
+ */
+declare function struct$1<S$1 extends StructSchema>(schema: S$1): StructConstructor<S$1>;
+//#endregion
+//#region src/schema/schema.union.types.d.ts
+/**
+ * Infer the input type from a Standard Schema.
+ * This is what the user provides to create().
+ */
+type TaggedSchemaInput<S$1 extends StandardSchemaV1> = NonNullable<S$1["~standard"]["types"]>["input"];
+/**
+ * Infer the output type from a Standard Schema.
+ * This is what validation returns (after transforms/defaults).
+ */
+type TaggedSchemaOutput<S$1 extends StandardSchemaV1> = NonNullable<S$1["~standard"]["types"]>["output"];
+/**
+ * A tagged variant created by the tagged() function.
+ * Can be used standalone or composed into an SchemaUnion via union().
+ * Callable as a function to create instances.
+ */
+type TaggedSchema<Tag$1 extends string = string, S$1 extends StandardSchemaV1 = StandardSchemaV1> = {
+  /** Marker to identify this as a TaggedSchema */
+  readonly _variant: true;
+  /** The _tag discriminator value */
+  readonly _tag: Tag$1;
+  /** The underlying Standard Schema */
+  readonly schema: S$1;
+  /**
+   * Create an instance of this variant.
+   * @param input - The input data (schema defaults apply)
+   * @returns Result with tagged output or validation error
+   */
+  (input: TaggedSchemaInput<S$1>): Result<TaggedSchemaOutput<S$1> & Discriminator<Tag$1>, ValidationError>;
+  /**
+   * Type guard to check if a value is this variant type.
+   * @param value - The value to check
+   */
+  is(value: unknown): value is TaggedSchemaOutput<S$1> & Discriminator<Tag$1>;
+  /**
+   * Compare two instances of this variant for value equality.
+   * Performs deep comparison of all fields.
+   */
+  equals(a: TaggedSchemaOutput<S$1> & Discriminator<Tag$1>, b: TaggedSchemaOutput<S$1> & Discriminator<Tag$1>): boolean;
+  /**
+   * Compute a hash code for a variant instance.
+   * Equal values always produce the same hash.
+   * Useful for Map/Set keys.
+   */
+  hash(value: TaggedSchemaOutput<S$1> & Discriminator<Tag$1>): number;
+};
+/**
+ * A variant definition can be either:
+ * - A raw Standard Schema (will be wrapped internally)
+ * - A pre-built TaggedSchema from tagged()
+ */
+type TaggedSchemaDef = StandardSchemaV1 | TaggedSchema<string, any>;
+/**
+ * Extract the schema from a TaggedSchemaDef (handles both raw schema and TaggedSchema)
+ */
+type ExtractTaggedSchema<T extends TaggedSchemaDef> = T extends TaggedSchema<string, infer S> ? S : T extends StandardSchemaV1 ? T : never;
+/**
+ * The SchemaUnion returned by union().
+ * Contains all variant accessors plus a root type guard.
+ */
+type SchemaUnion<R$1 extends Record<string, TaggedSchemaDef>> = {
+  /** The name of this SchemaUnion */
+  readonly _name: string;
+  /**
+   * Type guard to check if a value is any variant of this SchemaUnion.
+   */
+  is(value: unknown): value is InferSchemaUnion<R$1>;
+  /**
+   * Compare two SchemaUnion values for equality.
+   * First checks _tag matches, then compares fields.
+   */
+  equals(a: InferSchemaUnion<R$1>, b: InferSchemaUnion<R$1>): boolean;
+  /**
+   * Compute a hash code for any SchemaUnion variant.
+   */
+  hash(value: InferSchemaUnion<R$1>): number;
+} & { [K in keyof R$1]: TaggedSchema<K & string, ExtractTaggedSchema<R$1[K]>> };
+/**
+ * Infer the output type for a single variant within an SchemaUnion.
+ */
+type InferRecordOutput<Tag$1 extends string, R$1 extends TaggedSchemaDef> = TaggedSchemaOutput<ExtractTaggedSchema<R$1>> & {
+  readonly _tag: Tag$1;
+};
+/**
+ * Infer the union of all variant output types in an SchemaUnion.
+ */
+type InferSchemaUnion<R$1 extends Record<string, TaggedSchemaDef>> = { [K in keyof R$1]: InferRecordOutput<K & string, R$1[K]> }[keyof R$1];
+/**
+ * UnionInfer types from an SchemaUnion or TaggedSchema, following Zod's `z.infer` pattern.
+ *
+ * - For ADTs: Returns the union of all variant types
+ * - For TaggedSchemas: Returns the individual variant type
+ *
+ * @example
+ * ```ts
+ * // UnionInfer union type from SchemaUnion
+ * const Shape = union('Shape', { Circle, Square })
+ * type Shape = UnionInfer<typeof Shape>
+ * // => { _tag: 'Circle', radius: number } | { _tag: 'Square', size: number }
+ *
+ * // Infer individual variant type
+ * type Circle = UnionInfer<typeof Shape.Circle>
+ * // => { _tag: 'Circle', radius: number }
+ * ```
+ */
+type UnionInfer<T> = T extends SchemaUnion<infer R> ? Prettify<InferSchemaUnion<R>> : T extends TaggedSchema<infer Tag, infer S> ? Prettify<TaggedSchemaOutput<S> & Discriminator<Tag>> : never;
+/**
+ * Extract the union of all variant names from an SchemaUnion.
+ *
+ * @example
+ * ```ts
+ * const Shape = union('Shape', { Circle, Square })
+ * type Names = UnionVariantNames<typeof Shape> // "Circle" | "Square"
+ * ```
+ */
+type UnionVariantNames<T> = T extends SchemaUnion<infer R> ? keyof R & string : never;
+/**
+ * Extract the type of a specific variant from an SchemaUnion.
+ *
+ * @example
+ * ```ts
+ * const Shape = union('Shape', { Circle, Square })
+ * type CircleType = UnionVariantOf<typeof Shape, "Circle">
+ * // => { _tag: "Circle", radius: number }
+ * ```
+ */
+type UnionVariantOf<T, K$1 extends string> = T extends SchemaUnion<infer R> ? K$1 extends keyof R ? Prettify<TaggedSchemaOutput<ExtractTaggedSchema<R[K$1]>> & Discriminator<K$1>> : never : never;
+//#endregion
+//#region src/schema/schema.tagged.d.ts
+/**
+ * Create a standalone tagged variant from a Standard Schema.
+ *
+ * Variants can be used independently or composed into an SchemaUnion via union().
+ * All defaults should be defined at the schema level (e.g., Zod's .default()).
+ *
+ * @template Tag - The string literal type for the _tag discriminator
+ * @template S - The Standard Schema type for validation
+ * @param _tag - The _tag discriminator value
+ * @param schema - A Standard Schema compliant validator
+ * @returns A callable TaggedSchema with is(), equals(), and hash() methods
+ *
+ * @see {@link union} for composing variants into discriminated unions
+ * @see {@link tagged} for unvalidated tagged value constructors
+ *
+ * @example
+ * ```ts
+ * const CircleSchema = z.object({
+ *   radius: z.number().positive(),
+ *   color: z.string().default('blue')
+ * })
+ *
+ * const Circle = tagged('Circle', CircleSchema)
+ *
+ * const result = Circle({ radius: 10 })
+ * // { _tag: "Ok", value: { _tag: "Circle", radius: 10, color: "blue" } }
+ *
+ * Circle.is(someValue) // type guard
+ * ```
+ */
+declare function tagged$1<Tag$1 extends string, S$1 extends StandardSchemaV1>(_tag: Tag$1, schema: S$1): TaggedSchema<Tag$1, S$1>;
+//#endregion
+//#region src/schema/schema.union.d.ts
+/**
+ * Compose records or schemas into a discriminated union (SchemaUnion).
+ *
+ * Accepts either:
+ * - Pre-built TaggedSchemas from tagged()
+ * - Raw Standard Schema validators (will be wrapped internally)
+ *
+ * When using pre-built records, the object key overrides the original _tag.
+ *
+ * @template R - Record of variant names to TaggedSchemas or StandardSchema validators
+ * @param name - The name of this SchemaUnion (for identification)
+ * @param records - An object mapping _tag names to TaggedSchemas or schemas
+ * @returns An SchemaUnion object with accessors for each variant
+ *
+ * @see {@link variant} for creating individual variant types
+ * @see {@link match} for exhaustive pattern matching on SchemaUnion values
+ *
+ * @example
+ * ```ts
+ * // From pre-built variants
+ * const Circle = tagged('Circle', CircleSchema)
+ * const Square = tagged('Square', SquareSchema)
+ * const Shape = union('Shape', { Circle, Square })
+ *
+ * // From raw schemas (JSON codec is automatically included)
+ * const Shape = union('Shape', {
+ *   Circle: CircleSchema,
+ *   Square: SquareSchema
+ * })
+ *
+ * // Mixed
+ * const Shape = union('Shape', {
+ *   Circle,              // Pre-built variant
+ *   Square: SquareSchema // Raw schema
+ * })
+ *
+ * // Usage
+ * Shape.Circle({ radius: 10 })
+ * Shape.is(someValue)        // type guard for any variant
+ * Shape.Circle.is(someValue) // type guard for Circle
+ * ```
+ */
+declare function union$1<R$1 extends Record<string, TaggedSchemaDef>>(name: string, records: R$1): SchemaUnion<R$1>;
+declare namespace schema_d_exports {
+  export { Codec, Infer, Input, Is, Output, Refine, RefineFn, RefinementSchema, SchemaUnion, StructValue, SyncRefinementSchema, SyncSchema, TaggedSchema, TaggedSchemaDef, TaggedSchemaInput, TaggedSchemaOutput, Union, ValidationError, ValidationIssue, codec, is, parse, refine, struct, tagged, union };
+}
+declare namespace Union {
+  type Infer<T> = UnionInfer<T>;
+  type VariantNames<T> = UnionVariantNames<T>;
+  type VariantOf<T, K$1 extends string> = UnionVariantOf<T, K$1>;
+}
+declare namespace Codec {
+  const DecodeError: typeof CodecDecodeError;
+  const DecodeValidationError: typeof CodecDecodeValidationError;
+  const EncodeValidationError: typeof CodecEncodeValidationError;
+  const EncodeError: typeof CodecEncodeError;
+  type Codec<DecodedSchema$1 extends StandardSchemaV1 = StandardSchemaV1, EncodedSchema$1 extends StandardSchemaV1 = StandardSchemaV1, DecodeReturn extends Input<DecodedSchema$1> | Promise<Input<DecodedSchema$1>> = Input<DecodedSchema$1>, EncodeReturn extends Input<EncodedSchema$1> | Promise<Input<EncodedSchema$1>> = Input<EncodedSchema$1>> = Codec$1<DecodedSchema$1, EncodedSchema$1, DecodeReturn, EncodeReturn>;
+  type Decoded<C> = Decoded<C>;
+  type Encoded<C> = Encoded<C>;
+  type DecodeInput<C> = DecodeInput<C>;
+  type EncodeInput<C> = EncodeInput<C>;
+  type Error = CodecError;
+  type Options<DecodedSchema$1 extends StandardSchemaV1, EncodedSchema$1 extends StandardSchemaV1, DecodeReturn extends Input<DecodedSchema$1> | Promise<Input<DecodedSchema$1>>, EncodeReturn extends Input<EncodedSchema$1> | Promise<Input<EncodedSchema$1>>> = CodecOptions<DecodedSchema$1, EncodedSchema$1, DecodeReturn, EncodeReturn>;
+  type JsonOptions = JsonCodecOptions;
+  type Constructor = CodecConstructor;
+}
+/**
+ * Construct sync schema-backed structs with structural value semantics.
+ */
+declare const struct: typeof struct$1;
+/**
+ * Construct schema-backed tagged values.
+ */
+declare const tagged: typeof tagged$1;
+/**
+ * Compose schema-backed tagged values into a discriminated union.
+ */
+declare const union: typeof union$1;
+/**
+ * Construct first-class bidirectional schema codecs.
+ */
+declare const codec: CodecConstructor;
+/**
+ * Create a schema-backed parser.
+ *
+ * Schema validation is sync-only. Provider schemas are accepted directly even
+ * when their Standard Schema type allows async validation; a Promise result
+ * throws at runtime.
+ */
+declare function parse<S$1 extends StandardSchemaV1>(schema: S$1): (value: Input<S$1>) => Result<Output<S$1>, ValidationError>;
+type RefineFn = {
+  <S$1 extends SyncSchema, Base extends Input<S$1>>(value: Base, schema: S$1): value is Refine<Base, S$1>;
+  <S$1 extends SyncSchema>(schema: S$1): <Base extends Input<S$1>>(value: Base) => value is Refine<Base, S$1>;
+};
+type Is = {
+  <Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub;
+  <S$1 extends SyncSchema>(value: unknown, schema: S$1): value is Output<S$1>;
+  <Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub;
+  <S$1 extends SyncSchema>(schema: S$1): (value: unknown) => value is Output<S$1>;
+};
+/**
+ * Create a sync-only schema-backed reusable type guard that preserves the original value shape.
+ *
+ * Use this when a schema validates only a subset of a broader in-memory value
+ * and you need the preserved shape to survive higher-order APIs like
+ * `Array.filter`. The narrowed type is `Base & Output<typeof schema>`, not the
+ * exact schema output.
+ *
+ * Supports both data-first and data-last styles:
+ * - Data-first: `Schema.refine(value, schema)`
+ * - Data-last: `Schema.refine(schema)(value)`
+ *
+ * Only use this with sync proof schemas that validate properties already
+ * present on the original value. Transforms, defaults, and coercions are not
+ * safe here because they can change the schema output without changing the
+ * original input value.
+ */
+declare function refine<S$1 extends SyncSchema, Base extends Input<S$1>>(value: Base, schema: S$1): value is Refine<Base, S$1>;
+declare function refine<S$1 extends SyncSchema>(schema: S$1): <Base extends Input<S$1>>(value: Base) => value is Refine<Base, S$1>;
+/**
+ * Create a sync-only schema-backed proof guard.
+ *
+ * On `unknown` values this narrows to the exact schema output. On already-typed
+ * values, TypeScript preserves the current shape during direct control-flow
+ * checks. Use `Schema.refine` when that preserved shape must survive
+ * higher-order APIs like `Array.filter`.
+ *
+ * Supports both data-first and data-last styles:
+ * - Data-first: `Schema.is(value, schema)`
+ * - Data-last: `Schema.is(schema)(value)`
+ */
+declare function is<Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub;
+declare function is<S$1 extends SyncSchema>(value: unknown, schema: S$1): value is Output<S$1>;
+declare function is<Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub;
+declare function is<S$1 extends SyncSchema>(schema: S$1): (value: unknown) => value is Output<S$1>;
+//#endregion
+export { schema_d_exports as t };
+//# sourceMappingURL=index-DzGXoCV1.d.mts.map

package/dist/index-DzGXoCV1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DzGXoCV1.d.mts","names":[],"sources":["../src/schema/schema.types.ts","../src/schema/schema.codec.ts","../src/schema/schema.struct.ts","../src/schema/schema.union.types.ts","../src/schema/schema.tagged.ts","../src/schema/schema.union.ts","../src/schema/schema.ts"],"sourcesContent":[],"mappings":"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AAA,WAAA,CAAA,CAAA,CAAA,GM+E6B,WN/E7B,CM+E8C,CN/E9C,CAAA;EAAmB,KAAA,WAAA,CAAA,CAAA,CAAA,GMgFU,WNhFV,CMgF2B,CNhF3B,CAAA;EAAN,KAAA,KAAA,GMiFO,UNjFP;EAAY,KAAA,OAAA,CAAA,wBMmFD,gBNnFC,EAAA,wBMoFD,gBNpFC,EAAA,qBMqFF,KNrFE,CMqFI,eNrFJ,CAAA,GMqFqB,ONrFrB,CMqF6B,KNrF7B,CMqFmC,eNrFnC,CAAA,CAAA,EAAA,qBMsFF,KNtFE,CMsFI,eNtFJ,CAAA,GMsFqB,ONtFrB,CMsF6B,KNtF7B,CMsFmC,eNtFnC,CAAA,CAAA,CAAA,GMuFrB,YNvFqB,CMuFJ,eNvFI,EMuFW,eNvFX,EMuF0B,YNvF1B,EMuFwC,YNvFxC,CAAA;EAAgC,KAAA,WAAA,GMwF/B,gBNxF+B;EAAc,KAAA,WAAA,GMyF7C,gBNzF6C;;;;AAKzE;AAQY,cMkFC,MNlFc,EAAA,OMkFR,QNjFc;AAUjC;;;AAAsF,cM4EzE,MN5EyE,EAAA,OM4EnE,QN5EmE;;;AAKtF;AAA+C,cM4ElC,KN5EkC,EAAA,OM4E7B,ON5E6B;;;;AAAwB,cMiF1D,KNjF0D,EMiFrD,gBNjFqD;AAKvE;;;;;;;iBMqFgB,kBAAgB,0BACtB,cACC,MAAM,SAAO,OAAW,OAAO,MAAI;KAOlC,QAAA;ELtJiD,CAAA,YKuJhD,ULvJgD,EAAA,aKuJvB,KLvJuB,CKuJjB,GLvJiB,CAAA,CAAA,CAAA,KAAA,EKuJN,ILvJM,EAAA,MAAA,EKuJQ,GLvJR,CAAA,EAAA,KAAA,IKuJqB,MLvJrB,CKuJ6B,ILvJ7B,EKuJmC,GLvJnC,CAAA;EAEhD,CAAA,YKsJA,ULtJiB,CAAA,CAAA,MAAA,EKsJG,GLtJK,CAAA,EAAA,CAAA,aKsJa,KLtJb,CKsJmB,GLtJnB,CAAA,CAAA,CAAA,KAAA,EKsJ8B,ILtJ9B,EAAA,GAAA,KAAA,IKsJgD,MLtJhD,CKsJwD,ILtJxD,EKsJ8D,GLtJ9D,CAAA;AAGjC,CAAA;AAEQ,KKoJD,EAAA,GLpJC;EAGR,CAAA,IAAA,EAAA,YKkJgB,ILlJhB,CAAA,CAAA,KAAA,EKkJ6B,ILlJ7B,EAAA,MAAA,EKkJ2C,oBLlJ3C,CKkJgE,ILlJhE,EKkJsE,GLlJtE,CAAA,CAAA,EAAA,KAAA,IKkJsF,GLlJtF;EAEQ,CAAA,YKiJA,ULjJA,CAAA,CAAA,KAAA,EAA2B,OAAA,EAAA,MAEtB,EK+I+B,GL/I/B,CAAA,EAAA,KAAA,IK+I4C,MLjJd,CKiJqB,GLjJrB,CAAA;EAG3C,CAAA,IAAA,EAAA,YK+IgB,IL/IhB,CAAA,CAAA,MAAA,EK+I8B,oBL/I9B,CK+ImD,IL/InD,EK+IyD,GL/IzD,CAAA,CAAA,EAAA,CAAA,KAAA,EK+IwE,IL/IxE,EAAA,GAAA,KAAA,IK+I0F,GL/I1F;EAEQ,CAAA,YK8IA,UL9IiB,CAAA,CAAA,MAAA,EK8IG,GL9IK,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IK8I4B,ML9I5B,CK8ImC,GL9InC,CAAA;AAKtC,CAAA;;;;;;AAAsH;;;;;AAEpF;AAEd;;;;;;AAKf,iBKyJW,MLzJM,CAAA,YKyJW,ULzJX,EAAA,aKyJoC,KLzJpC,CKyJ0C,GLzJ1C,CAAA,CAAA,CAAA,KAAA,EKyJqD,ILzJrD,EAAA,MAAA,EKyJmE,GLzJnE,CAAA,EAAA,KAAA,IKyJgF,MLzJhF,CKyJwF,ILzJxF,EKyJ8F,GLzJ9F,CAAA;AAA+B,iBK0JrC,ML1JqC,CAAA,YK0JpB,UL1JoB,CAAA,CAAA,MAAA,EK2J3C,GL3J2C,CAAA,EAAA,CAAA,aK4JpC,KL5JoC,CK4J9B,GL5J8B,CAAA,CAAA,CAAA,KAAA,EK4JnB,IL5JmB,EAAA,GAAA,KAAA,IK4JD,ML5JC,CK4JO,IL5JP,EK4Ja,GL5Jb,CAAA;;;;;;;;;AAIrD;;;;AAEqC,iBK6KrB,EL7KqB,CAAA,IAAA,EAAA,YK6KA,IL7KA,CAAA,CAAA,KAAA,EK6Ka,IL7Kb,EAAA,MAAA,EK6K2B,oBL7K3B,CK6KgD,IL7KhD,EK6KsD,GL7KtD,CAAA,CAAA,EAAA,KAAA,IK6KsE,GL7KtE;AACd,iBK6KP,EL7KO,CAAA,YK6KM,UL7KN,CAAA,CAAA,KAAA,EAAA,OAAA,EAAA,MAAA,EK6K0C,GL7K1C,CAAA,EAAA,KAAA,IK6KuD,ML7KvD,CK6K8D,GL7K9D,CAAA;AAAN,iBK8KD,EL9KC,CAAA,IAAA,EAAA,YK8KoB,IL9KpB,CAAA,CAAA,MAAA,EK8KkC,oBL9KlC,CK8KuD,IL9KvD,EK8K6D,GL9K7D,CAAA,CAAA,EAAA,CAAA,KAAA,EK8K4E,IL9K5E,EAAA,GAAA,KAAA,IK8K8F,GL9K9F;AACM,iBK8KP,EL9KO,CAAA,YK8KM,UL9KN,CAAA,CAAA,MAAA,EK8K0B,GL9K1B,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IK8K2D,ML9K3D,CK8KkE,GL9KlE,CAAA"}

package/dist/{index-CNTYbcY9.d.mts → index-Pma2THAy.d.mts}

@@ -1,4 +1,7 @@
+import { i as UnionToIntersection, r as Prettify } from "./type-utils.types-CnPpsvt5.mjs";
+
 //#region src/predicate/predicate.types.d.ts
+
 /**
  * A predicate function that tests a value and returns a boolean.
  *
@@ -28,6 +31,8 @@ type Refinement<in T, out U extends T> = (value: T) => value is U;
 declare namespace predicate_d_exports {
   export { all, and, andRefinement, constant, equals, none, not, or, orRefinement, some };
 }
+type PredicateInput<TPredicate> = TPredicate extends Predicate<infer T> ? T : never;
+type PredicateInputIntersection<TPredicates extends readonly Predicate<never>[]> = Prettify<UnionToIntersection<PredicateInput<TPredicates[number]>>>;
 /**
  * Negate a predicate.
  * Returns true when the original predicate returns false, and vice versa.
@@ -64,7 +69,8 @@ declare const not: <T>(predicate: Predicate<T>) => Predicate<T>;
  * // => true
  * ```
  */
-declare const and: <T>(...predicates: readonly Predicate<T>[]) => Predicate<T>;
+declare function and<T>(...predicates: readonly Predicate<T>[]): Predicate<T>;
+declare function and<const TPredicates extends readonly Predicate<never>[]>(...predicates: TPredicates): Predicate<PredicateInputIntersection<TPredicates>>;
 /**
  * Combine predicates with logical OR.
  * Returns true when ANY predicate returns true.
@@ -83,7 +89,8 @@ declare const and: <T>(...predicates: readonly Predicate<T>[]) => Predicate<T>;
  * // => true
  * ```
  */
-declare const or: <T>(...predicates: readonly Predicate<T>[]) => Predicate<T>;
+declare function or<T>(...predicates: readonly Predicate<T>[]): Predicate<T>;
+declare function or<const TPredicates extends readonly Predicate<never>[]>(...predicates: TPredicates): Predicate<PredicateInputIntersection<TPredicates>>;
 /**
  * Create a predicate that tests if ALL elements in an array match.
  * Returns true for empty arrays (vacuous truth).
@@ -218,4 +225,4 @@ declare const constant: <T>(value: boolean) => Predicate<T>;
 declare const equals: <T>(expected: T) => Predicate<T>;
 //#endregion
 export { predicate_d_exports as t };
-//# sourceMappingURL=index-CNTYbcY9.d.mts.map
+//# sourceMappingURL=index-Pma2THAy.d.mts.map

package/dist/index-Pma2THAy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Pma2THAy.d.mts","names":[],"sources":["../src/predicate/predicate.types.ts","../src/predicate/predicate.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAKA;AAqBY,KArBA,SAqBU,CAAA,IAAA,CAAA,GAAA,CAAA,KAAA,EArBgB,CAqBhB,EAAA,GAAA,OAAA;;;;;;;;;;;;;;;;;;;;ACvBjB,KDuBO,UCvBO,CAAA,IAAA,EAAA,cDuBwB,CCvBT,CAAA,GAAA,CAAA,KAAA,EDuBsB,CCvBH,EAAA,GAAA,KAAa,IDuBK,CCvBL;AAAA;;;KAA7D,6BAA6B,mBAAmB;KAEhD,wDAAwD,sBAA0B,SACrF,oBAAoB,eAAe;ADDrC;AAqBA;;;;;;;;;;;;;;;;cCAa,oBAAqB,UAAc,OAAK,UAAc;;;;AAzBY;AAEb;;;;;;;AAuBlE;;;;;;AAsBA;AAA6D,iBAA7C,GAA6C,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SAAd,SAAc,CAAA,CAAA,CAAA,EAAA,CAAA,EAAO,SAAP,CAAqB,CAArB,CAAA;AAAd,iBAC/B,GAD+B,CAAA,0BAAA,SACQ,SADR,CAAA,KAAA,CAAA,EAAA,CAAA,CAAA,GAAA,UAAA,EAE9B,WAF8B,CAAA,EAG5C,SAH4C,CAG9B,0BAH8B,CAGH,WAHG,CAAA,CAAA;;;;AAC/C;;;;;;;AA8BA;;;;;;AACA;;AACiB,iBAFD,EAEC,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SAF6B,SAE7B,CAF2C,CAE3C,CAAA,EAAA,CAAA,EAFkD,SAElD,CAFgE,CAEhE,CAAA;AAC2B,iBAF5B,EAE4B,CAAA,0BAAA,SAFU,SAEV,CAAA,KAAA,CAAA,EAAA,CAAA,CAAA,GAAA,UAAA,EAD3B,WAC2B,CAAA,EAAzC,SAAyC,CAA3B,0BAA2B,CAAA,WAAA,CAAA,CAAA;;;;AA2B5C;;;;;;AAqBA;;;;;;AAsBA;;AAAmC,cA3CtB,GA2CsB,EAAA,CAAA,CAAA,CAAA,CAAA,SAAA,EA3CD,SA2CC,CA3Ca,CA2Cb,CAAA,EAAA,GA3CkB,SA2ClB,CAAA,SA3CyC,CA2CzC,EAAA,CAAA;;;;AAwBnC;;;;;;;;;AA6BA;;;;;AAAsG,cA3EzF,IA2EyF,EAAA,CAAA,CAAA,CAAA,CAAA,SAAA,EA3EnE,SA2EmE,CA3ErD,CA2EqD,CAAA,EAAA,GA3EhD,SA2EgD,CAAA,SA3EzB,CA2EyB,EAAA,CAAA;;;;AA0BtG;AAoBA;;;;;;;;;;;;;;cAnGa,qBAAsB,UAAc,OAAK,mBAAuB;;;;;;;;;;;;;;;;;;;;;cAwBhE,6BAA8B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;cA6B7F,4BAA6B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;cA0B5F,iCAAgC,UAAc;;;;;;;;;;;;;;;;;cAoB9C,sBAAuB,MAAI,UAAc"}

package/dist/{index-CIvNgjsx.d.mts → index-hrn4s4Vn.d.mts}

@@ -1,4 +1,4 @@
-import { a as ResultFromTry, c as ResultMatch, d as ResultUnwrapOr, f as ResultUnwrapOrElse, i as ResultFlatMap, l as ResultOrElse, n as ResultAll, o as ResultMap, r as ResultFilter, s as ResultMapErr, t as Result$1, u as ResultTap } from "./result.types-BKzChyWY.mjs";
+import { a as ResultFromTry, c as ResultMatch, d as ResultUnwrapOr, f as ResultUnwrapOrElse, i as ResultFlatMap, l as ResultOrElse, n as ResultAll, o as ResultMap, r as ResultFilter, s as ResultMapErr, t as Result$1, u as ResultTap } from "./result.types-JEcowzYH.mjs";
 
 //#region src/result/result.d.ts
 declare namespace result_d_exports {
@@ -370,4 +370,4 @@ declare const fromTry: ResultFromTry;
 declare const try_: ResultFromTry;
 //#endregion
 export { result_d_exports as n, Result as t };
-//# sourceMappingURL=index-CIvNgjsx.d.mts.map
+//# sourceMappingURL=index-hrn4s4Vn.d.mts.map

package/dist/{index-CIvNgjsx.d.mts.map → index-hrn4s4Vn.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CIvNgjsx.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;KA0DY,eAAe,SAAW,GAAG;;;;;;;;;;;;AAAzC;;;AAA2B,cAsBd,EAtBc,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAsBE,CAtBF,EAAA,GAsBM,QAtBN,CAsBiB,CAtBjB,EAAA,KAAA,CAAA;;AAsB3B;;;;;AAgCA;;;;;AAoCA;;;AAAmC,cApCtB,GAoCsB,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EApCL,CAoCK,EAAA,GApCD,QAoCC,CAAA,KAAA,EApCiB,CAoCjB,CAAA;;;;;;AAiBnC;;;;;;;;;AAmCa,cApDA,IAoDK,EAAA,CAAA,CAAA,EAAA,CAAA,CAOhB,CAAA,MAAA,EA3DiC,QA2DjC,CA3D4C,CA2D5C,EA3D+C,CA2D/C,CAAA,EAAA,GAAA,MAAA,IA3D8D,OA2D9D,CA3DsE,QA2DtE,CA3DiF,CA2DjF,EA3DoF,CA2DpF,CAAA,EAAA;EA+BW,IAAA,EAAA,IAOX;AA+BF,CAAA,CAAA;AAsCA;AAsCA;AA6BA;AAmCA;AAgDA;AA2BA;AAiCA;AA8BA;AA0BC;;;;;;cA/ZY,sBAAuB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmC1E,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BR,QAAQ;;;;;;;;;;;;;;;;;;;cAmCR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cAgDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;cA2BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCd,OAAO;;;;;;;;;;;;;;;;;;;;cA8BP,SAAS;cA6BhB,MAAI"}
+{"version":3,"file":"index-hrn4s4Vn.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;KA0DY,eAAe,SAAW,GAAG;;;;;;;;;;;;AAAzC;;;AAA2B,cAsBd,EAtBc,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAsBE,CAtBF,EAAA,GAsBM,QAtBN,CAsBiB,CAtBjB,EAAA,KAAA,CAAA;;AAsB3B;;;;;AAgCA;;;;;AAoCA;;;AAAmC,cApCtB,GAoCsB,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EApCL,CAoCK,EAAA,GApCD,QAoCC,CAAA,KAAA,EApCiB,CAoCjB,CAAA;;;;;;AAiBnC;;;;;;;;;AAmCa,cApDA,IAoDK,EAAA,CAAA,CAAA,EAAA,CAAA,CAOhB,CAAA,MAAA,EA3DiC,QA2DjC,CA3D4C,CA2D5C,EA3D+C,CA2D/C,CAAA,EAAA,GAAA,MAAA,IA3D8D,OA2D9D,CA3DsE,QA2DtE,CA3DiF,CA2DjF,EA3DoF,CA2DpF,CAAA,EAAA;EA+BW,IAAA,EAAA,IAOX;AA+BF,CAAA,CAAA;AAsCA;AAsCA;AA6BA;AAmCA;AAgDA;AA2BA;AAiCA;AA8BA;AA0BC;;;;;;cA/ZY,sBAAuB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmC1E,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BR,QAAQ;;;;;;;;;;;;;;;;;;;cAmCR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cAgDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;cA2BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCd,OAAO;;;;;;;;;;;;;;;;;;;;cA8BP,SAAS;cA6BhB,MAAI"}