@oxog/vld 2.0.2 → 2.1.0

package/dist/v4/core/index.d.ts

@@ -0,0 +1,260 @@
+export * from '../../index.js';
+export { core as default, core, util, ZodIssueCode } from '../../index.js';
+export { VldError as $ZodError, VldError as $ZodRealError } from '../../errors.js';
+export { VldBase as $ZodType, VldCatch as $ZodCatch, VldDefault as $ZodDefault, VldNullable as $ZodNullable, VldOptional as $ZodOptional, VldPipe as $ZodPipe, VldPrefault as $ZodPrefault, VldReadonly as $ZodReadonly, VldTransform as $ZodTransform } from '../../validators/base.js';
+export { VldString as $ZodString } from '../../validators/string.js';
+export { VldNumber as $ZodNumber } from '../../validators/number.js';
+export { VldBoolean as $ZodBoolean } from '../../validators/boolean.js';
+export { VldBigInt as $ZodBigInt } from '../../validators/bigint.js';
+export { VldSymbol as $ZodSymbol } from '../../validators/symbol.js';
+export { VldUndefined as $ZodUndefined } from '../../validators/undefined.js';
+export { VldNull as $ZodNull } from '../../validators/null.js';
+export { VldAny as $ZodAny } from '../../validators/any.js';
+export { VldUnknown as $ZodUnknown } from '../../validators/unknown.js';
+export { VldNever as $ZodNever } from '../../validators/never.js';
+export { VldVoid as $ZodVoid } from '../../validators/void.js';
+export { VldDate as $ZodDate } from '../../validators/date.js';
+export { VldArray as $ZodArray } from '../../validators/array.js';
+export { VldObject as $ZodObject } from '../../validators/object.js';
+export { VldUnion as $ZodUnion } from '../../validators/union.js';
+export { VldIntersection as $ZodIntersection } from '../../validators/intersection.js';
+export { VldTuple as $ZodTuple } from '../../validators/tuple.js';
+export { VldRecord as $ZodRecord } from '../../validators/record.js';
+export { VldMap as $ZodMap } from '../../validators/map.js';
+export { VldSet as $ZodSet } from '../../validators/set.js';
+export { VldEnum as $ZodEnum } from '../../validators/enum.js';
+export { VldLiteral as $ZodLiteral } from '../../validators/literal.js';
+export { VldFile as $ZodFile } from '../../validators/file.js';
+export { VldLazy as $ZodLazy } from '../../validators/lazy.js';
+export { VldPromise as $ZodPromise } from '../../validators/promise.js';
+export { VldCustom as $ZodCustom } from '../../validators/custom.js';
+export { VldBase64 as $ZodBase64, VldBase64 as $ZodBase64URL } from '../../validators/base64.js';
+export { VldCodec as $ZodCodec } from '../../validators/codec.js';
+export { VldDiscriminatedUnion as $ZodDiscriminatedUnion } from '../../validators/discriminated-union.js';
+export { VldFunction as $ZodFunction } from '../../validators/function.js';
+export { VldJson as $ZodSuccess } from '../../validators/json.js';
+export { VldNan as $ZodNaN } from '../../validators/nan.js';
+export { VldTemplateLiteral as $ZodTemplateLiteral } from '../../validators/template-literal.js';
+export { VldXor as $ZodXor } from '../../validators/xor.js';
+export { VldExactOptional as $ZodExactOptional, VldPreprocess as $ZodPreprocess, VldRefine as $ZodNonOptional } from '../../validators/base.js';
+export { VldStringFormat as $ZodBigIntFormat, VldStringFormat as $ZodCIDRv4, VldStringFormat as $ZodCIDRv6, VldStringFormat as $ZodCUID, VldStringFormat as $ZodCUID2, VldStringFormat as $ZodCustomStringFormat, VldStringFormat as $ZodE164, VldStringFormat as $ZodEmail, VldStringFormat as $ZodEmoji, VldStringFormat as $ZodGUID, VldStringFormat as $ZodIPv4, VldStringFormat as $ZodIPv6, VldStringFormat as $ZodISODate, VldStringFormat as $ZodISODateTime, VldStringFormat as $ZodISODuration, VldStringFormat as $ZodISOTime, VldStringFormat as $ZodJWT, VldStringFormat as $ZodKSUID, VldStringFormat as $ZodMAC, VldStringFormat as $ZodNanoID, VldStringFormat as $ZodNumberFormat, VldStringFormat as $ZodStringFormat, VldStringFormat as $ZodULID, VldStringFormat as $ZodURL, VldStringFormat as $ZodUUID, VldStringFormat as $ZodXID } from '../../validators/string-formats.js';
+export { registry as $ZodRegistry } from '../../registry.js';
+import * as root from '../../index.js';
+import type { VldBase } from '../../validators/base.js';
+type AnySchema = VldBase<any, any>;
+type Params = string | {
+    message?: string;
+    error?: string;
+};
+export declare class $ZodAsyncError extends Error {
+}
+export declare class $ZodEncodeError extends Error {
+}
+export declare class $ZodCheck {
+}
+export declare class $ZodCheckBigIntFormat extends $ZodCheck {
+}
+export declare class $ZodCheckEndsWith extends $ZodCheck {
+}
+export declare class $ZodCheckGreaterThan extends $ZodCheck {
+}
+export declare class $ZodCheckIncludes extends $ZodCheck {
+}
+export declare class $ZodCheckLengthEquals extends $ZodCheck {
+}
+export declare class $ZodCheckLessThan extends $ZodCheck {
+}
+export declare class $ZodCheckLowerCase extends $ZodCheck {
+}
+export declare class $ZodCheckMaxLength extends $ZodCheck {
+}
+export declare class $ZodCheckMaxSize extends $ZodCheck {
+}
+export declare class $ZodCheckMimeType extends $ZodCheck {
+}
+export declare class $ZodCheckMinLength extends $ZodCheck {
+}
+export declare class $ZodCheckMinSize extends $ZodCheck {
+}
+export declare class $ZodCheckMultipleOf extends $ZodCheck {
+}
+export declare class $ZodCheckNumberFormat extends $ZodCheck {
+}
+export declare class $ZodCheckOverwrite extends $ZodCheck {
+}
+export declare class $ZodCheckProperty extends $ZodCheck {
+}
+export declare class $ZodCheckRegex extends $ZodCheck {
+}
+export declare class $ZodCheckSizeEquals extends $ZodCheck {
+}
+export declare class $ZodCheckStartsWith extends $ZodCheck {
+}
+export declare class $ZodCheckStringFormat extends $ZodCheck {
+}
+export declare class $ZodCheckUpperCase extends $ZodCheck {
+}
+export declare const $ZodObjectJIT: typeof root.ZodObject;
+export declare class Doc {
+}
+export declare const JSONSchema: {};
+export declare class JSONSchemaGenerator {
+}
+export declare const globalConfig: {};
+export declare const version: {
+    major: number;
+    minor: number;
+    patch: number;
+};
+export declare const $constructor: (name: string, initializer?: (instance: unknown, def: unknown) => void) => {
+    new (def?: unknown): {};
+    displayName: string;
+};
+export declare const _parse: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+export declare const _default: (...args: unknown[]) => root.ZodDefault<any, any>;
+export declare const _safeParse: <T>(schema: VldBase<unknown, T>, value: unknown) => root.ParseResult<T>;
+export declare const _parseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+export declare const _safeParseAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<root.ParseResult<T>>;
+export declare const _encode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => TInput | TOutput;
+export declare const _safeEncode: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => root.ParseResult<TInput | TOutput>;
+export declare const _decode: <T>(schema: VldBase<unknown, T>, value: unknown) => T;
+export declare const _safeDecode: <T>(schema: VldBase<unknown, T>, value: unknown) => root.ParseResult<T>;
+export declare const _encodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<TInput | TOutput>;
+export declare const _safeEncodeAsync: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, value: unknown) => Promise<root.ParseResult<TInput | TOutput>>;
+export declare const _decodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<T>;
+export declare const _safeDecodeAsync: <T>(schema: VldBase<unknown, T>, value: unknown) => Promise<root.ParseResult<T>>;
+export declare const _string: (..._args: unknown[]) => root.ZodString;
+export declare const _number: (..._args: unknown[]) => root.ZodNumber;
+export declare const _boolean: (..._args: unknown[]) => root.ZodBoolean;
+export declare const _bigint: (..._args: unknown[]) => root.ZodBigInt;
+export declare const _symbol: (..._args: unknown[]) => root.ZodSymbol;
+export declare const _undefined: (..._args: unknown[]) => root.ZodUndefined;
+export declare const _null: (..._args: unknown[]) => root.ZodNull;
+export declare const _any: (..._args: unknown[]) => root.ZodAny;
+export declare const _unknown: (..._args: unknown[]) => root.ZodUnknown;
+export declare const _never: (..._args: unknown[]) => root.ZodNever;
+export declare const _void: (..._args: unknown[]) => root.ZodVoid;
+export declare const _date: (..._args: unknown[]) => root.ZodDate;
+export declare const _array: (...args: unknown[]) => root.ZodArray<any>;
+export declare const _object: (...args: unknown[]) => root.ZodObject<{
+    [x: string]: /*elided*/ any;
+}>;
+export declare const _union: (...args: unknown[]) => root.ZodUnion<AnySchema[]>;
+export declare const _intersection: (...args: unknown[]) => root.VldIntersection<any, any>;
+export declare const _tuple: (...args: unknown[]) => root.ZodTuple<AnySchema[]>;
+export declare const _record: (...args: unknown[]) => root.ZodRecord<any>;
+export declare const _map: (...args: unknown[]) => root.ZodMap<any, any>;
+export declare const _set: (...args: unknown[]) => root.ZodSet<any>;
+export declare const _enum: (...args: unknown[]) => root.ZodEnum<any>;
+export declare const _nativeEnum: (...args: unknown[]) => root.ZodEnum<any>;
+export declare const _literal: (...args: unknown[]) => root.ZodLiteral<any>;
+export declare const _file: (..._args: unknown[]) => root.ZodFile;
+export declare const _lazy: (...args: unknown[]) => root.ZodLazy<unknown, any>;
+export declare const _promise: (...args: unknown[]) => root.ZodPromise<any>;
+export declare const _optional: (...args: unknown[]) => root.ZodOptional<unknown, any>;
+export declare const _nullable: (...args: unknown[]) => root.ZodNullable<unknown, any>;
+export declare const _nonoptional: (...args: unknown[]) => root.ZodNonOptional<unknown, any, any>;
+export declare const _readonly: (...args: unknown[]) => root.ZodReadonly<unknown, any>;
+export declare const _templateLiteral: (...args: unknown[]) => root.ZodTemplateLiteral;
+export declare const _stringbool: (...args: unknown[]) => import("../../validators/index.js").VldStringBool;
+export declare const _nan: (..._args: unknown[]) => root.ZodNaN;
+export declare const _email: (options?: {
+    pattern?: RegExp;
+}) => root.ZodBase64;
+export declare const _guid: () => root.ZodBase64;
+export declare const _uuid: (options?: {
+    version?: "v4" | "v6" | "v7";
+}) => root.ZodBase64;
+export declare const _uuidv4: () => root.ZodBase64;
+export declare const _uuidv6: () => root.ZodBase64;
+export declare const _uuidv7: () => root.ZodBase64;
+export declare const _url: () => root.ZodString;
+export declare const _emoji: () => root.ZodBase64;
+export declare const _nanoid: () => root.ZodBase64;
+export declare const _cuid: () => root.ZodBase64;
+export declare const _cuid2: () => root.ZodBase64;
+export declare const _ulid: () => root.ZodBase64;
+export declare const _xid: () => root.ZodBase64;
+export declare const _ksuid: () => root.ZodBase64;
+export declare const _ipv4: () => root.ZodBase64;
+export declare const _ipv6: () => root.ZodBase64;
+export declare const _cidrv4: () => root.ZodBase64;
+export declare const _cidrv6: () => root.ZodBase64;
+export declare const _base64: () => root.ZodBase64;
+export declare const _base64url: () => root.ZodBase64;
+export declare const _e164: () => root.ZodBase64;
+export declare const _jwt: () => root.ZodBase64;
+export declare const _isoDateTime: () => root.ZodBase64;
+export declare const _isoDate: () => root.ZodBase64;
+export declare const _isoTime: () => root.ZodBase64;
+export declare const _isoDuration: () => root.ZodBase64;
+export declare const _mac: () => root.ZodBase64;
+export declare const _mime: (types: string | string[], message?: string) => root.ZodFile;
+export declare const _stringFormat: (name: string, validator: ((val: string) => boolean) | RegExp) => root.ZodBase64;
+export declare const _min: (value: number, params?: Params) => root.ZodNumber;
+export declare const _max: (value: number, params?: Params) => root.ZodNumber;
+export declare const _gt: (value: number, params?: Params) => root.ZodNumber;
+export declare const _gte: (value: number, params?: Params) => root.ZodNumber;
+export declare const _lt: (value: number, params?: Params) => root.ZodNumber;
+export declare const _lte: (value: number, params?: Params) => root.ZodNumber;
+export declare const _int: () => root.ZodNumber;
+export declare const _int32: () => root.ZodNumber;
+export declare const _uint32: () => root.ZodNumber;
+export declare const _int64: () => root.ZodNumber;
+export declare const _uint64: () => root.ZodNumber;
+export declare const _float32: () => root.ZodNumber;
+export declare const _float64: () => root.ZodNumber;
+export declare const _positive: (message?: import("../../validators/base.js").ErrorParam) => root.ZodNumber;
+export declare const _negative: (message?: import("../../validators/base.js").ErrorParam) => root.ZodNumber;
+export declare const _nonpositive: (message?: import("../../validators/base.js").ErrorParam) => root.ZodNumber;
+export declare const _nonnegative: (message?: import("../../validators/base.js").ErrorParam) => root.ZodNumber;
+export declare const _multipleOf: (value: number, message?: import("../../validators/base.js").ErrorParam) => root.ZodNumber;
+export declare const _minLength: (value: number, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _maxLength: (value: number, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _length: (value: number, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _size: (value: number, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _minSize: (value: number, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _maxSize: (value: number, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _regex: (pattern: RegExp, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _startsWith: (value: string, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _endsWith: (value: string, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _includes: (value: string, message?: import("../../validators/base.js").ErrorParam) => root.ZodString;
+export declare const _lowercase: () => root.ZodString;
+export declare const _uppercase: () => root.ZodString;
+export declare const _trim: () => root.ZodString;
+export declare const _normalize: (form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})) => root.ZodTransform<string, string, string>;
+export declare const _slugify: () => root.ZodTransform<string, string, string>;
+export declare const _toLowerCase: () => root.ZodString;
+export declare const _toUpperCase: () => root.ZodString;
+export declare const _check: (...args: unknown[]) => root.VldBase<unknown, unknown>;
+export declare const _custom: (...args: unknown[]) => root.ZodCustom<unknown>;
+export declare const _refine: (...args: unknown[]) => root.VldBase<unknown, unknown>;
+export declare const _superRefine: (...args: unknown[]) => root.VldBase<unknown, any>;
+export declare const _transform: (...args: unknown[]) => root.VldBase<unknown, unknown> | root.ZodTransform<unknown, unknown, unknown>;
+export declare const _overwrite: (...args: unknown[]) => root.VldBase<unknown, unknown>;
+export declare const _pipe: (...args: unknown[]) => root.ZodPipe<any, any, any>;
+export declare const _catch: (...args: unknown[]) => root.ZodCatch<unknown, any>;
+export declare const _success: (...args: unknown[]) => root.Ok<any>;
+export declare const _property: (...args: unknown[]) => root.VldBase<unknown, {
+    [x: string]: any;
+}>;
+export declare const _coercedString: () => import("../../coercion/index.js").VldCoerceString;
+export declare const _coercedNumber: () => import("../../coercion/index.js").VldCoerceNumber;
+export declare const _coercedBoolean: () => import("../../coercion/index.js").VldCoerceBoolean;
+export declare const _coercedBigint: () => import("../../coercion/index.js").VldCoerceBigInt;
+export declare const _coercedDate: () => import("../../coercion/index.js").VldCoerceDate;
+export declare const _codec: (...args: unknown[]) => root.ZodCodec<any, any>;
+export declare const _function: (..._args: unknown[]) => root.ZodFunction;
+export declare const _discriminatedUnion: (...args: unknown[]) => root.ZodDiscriminatedUnion<any, any>;
+export declare const _xor: (...args: unknown[]) => root.ZodXor<any>;
+export declare const createToJSONSchemaMethod: () => typeof root.toJSONSchema;
+export declare const createStandardJSONSchemaMethod: () => typeof root.toJSONSchema;
+export declare const extractDefs: () => {};
+export declare const finalize: (schema: unknown) => unknown;
+export declare const initializeContext: () => {};
+export declare const process: (schema: unknown) => unknown;
+export declare const toDotPath: (path: readonly (string | number)[]) => string;
+export declare const isValidBase64: (value: string) => boolean;
+export declare const isValidBase64URL: (value: string) => boolean;
+export declare const isValidJWT: (value: string) => boolean;
+export declare const _checkInternal: () => never;

package/dist/v4/core/index.js

@@ -0,0 +1,277 @@
+import { base64, base64url, cidrv4, cidrv6, coerce, cuid, cuid2, decode, decodeAsync, e164, email, emoji, encode, encodeAsync, endsWith, float32, float64, guid, includes, int, int32, int64, ipv4, ipv6, iso, jwt, ksuid, length, lowercase, mac, maxLength, maxSize, mime, minLength, minSize, multipleOf, nanoid, negative, nonnegative, nonpositive, normalize, parse, parseAsync, positive, regex, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, size, slugify, startsWith, stringFormat, toLowerCase, toUpperCase, trim, uint32, uint64, ulid, uppercase, url, uuid, uuidv4, uuidv6, uuidv7, xid, toJSONSchema, any, array, bigint, boolean, catch as catchFactory, check, codec, custom, date, discriminatedUnion, enum as enumFactory, nativeEnum, file, _function as functionFactory, number, intersection, lazy, literal, map, nan, never as neverFactory, nonoptional, null as nullFactory, nullable, object, optional, overwrite, pipe, promise, property, readonly, record, refine, set, string, stringbool, superRefine, symbol, templateLiteral, transform, tuple, undefined as undefinedFactory, union, unknown, void as voidFactory, xor } from '../../index.js';
+export { $brand, $input, $output, NEVER, TimePrecision, ZodFirstPartyTypeKind, ZodIssueCode, _ZodString, base64Bytes, clone, config, core, createLogger, createNoOpLogger, core as default, describe, disableLogging, enableDebug, exactOptional, formatError, fromJSONSchema, getErrorMap, getLogger, gt, gte, hash, hex, hexBytes, hostname, httpUrl, initLogger, instanceof, json, keyof, locales, looseObject, looseRecord, lt, lte, mapSchema, meta, nullish, partialRecord, prefault, preprocess, regexes, setErrorMap, setLogLevel, strictObject, uint8Array, util, default as v, z } from '../../index.js';
+export { flattenError, prettifyError, prettifyErrorColored, prettifyErrorPlain, treeifyError } from '../../errors.js';
+export { VldCatch as $ZodCatch, VldDefault as $ZodDefault, VldExactOptional as $ZodExactOptional, VldRefine as $ZodNonOptional, VldNullable as $ZodNullable, VldOptional as $ZodOptional, VldPipe as $ZodPipe, VldPrefault as $ZodPrefault, VldPreprocess as $ZodPreprocess, VldReadonly as $ZodReadonly, VldTransform as $ZodTransform, VldBase as $ZodType, VldBase, VldMeta, VldBrand as ZodBranded, VldCatch as ZodCatch, VldDefault as ZodDefault, VldExactOptional as ZodExactOptional, VldMeta as ZodMeta, VldRefine as ZodNonOptional, VldNullable as ZodNullable, VldOptional as ZodOptional, VldPipe as ZodPipe, VldPrefault as ZodPrefault, VldPreprocess as ZodPreprocess, VldReadonly as ZodReadonly, VldTransform as ZodTransform, VldBase as ZodType } from '../../validators/base.js';
+export { V as $ZodString, V as ZodString } from '../../chunks/string-BJRQod3t.js';
+export { VldNumber as $ZodNumber, VldNumber as ZodNumber, VldNumber as ZodNumberFormat } from '../../validators/number.js';
+export { VldBoolean as $ZodBoolean, VldBoolean as ZodBoolean } from '../../validators/boolean.js';
+export { VldBigInt as $ZodBigInt, VldBigInt as ZodBigInt, VldBigInt as ZodBigIntFormat } from '../../validators/bigint.js';
+export { VldSymbol as $ZodSymbol, VldSymbol as ZodSymbol } from '../../validators/symbol.js';
+export { VldUndefined as $ZodUndefined, VldUndefined as ZodUndefined } from '../../validators/undefined.js';
+export { VldNull as $ZodNull, VldNull as ZodNull } from '../../validators/null.js';
+export { VldAny as $ZodAny, VldAny as ZodAny } from '../../validators/any.js';
+export { VldUnknown as $ZodUnknown, VldUnknown as ZodUnknown } from '../../validators/unknown.js';
+export { VldNever as $ZodNever, VldNever as ZodNever } from '../../validators/never.js';
+export { VldVoid as $ZodVoid, VldVoid as ZodVoid } from '../../validators/void.js';
+export { VldDate as $ZodDate, VldDate as ZodDate } from '../../validators/date.js';
+export { VldArray as $ZodArray, VldArray as ZodArray } from '../../validators/array.js';
+import { VldObject } from '../../validators/object.js';
+export { VldUnion as $ZodUnion, VldUnion as ZodUnion } from '../../validators/union.js';
+export { VldIntersection as $ZodIntersection, VldIntersection, VldIntersection as ZodIntersection } from '../../validators/intersection.js';
+export { VldTuple as $ZodTuple, VldTuple as ZodTuple } from '../../validators/tuple.js';
+export { VldRecord as $ZodRecord, VldRecord as ZodRecord } from '../../validators/record.js';
+export { VldMap as $ZodMap, VldMap as ZodMap } from '../../validators/map.js';
+export { VldSet as $ZodSet, VldSet as ZodSet } from '../../validators/set.js';
+export { VldEnum as $ZodEnum, VldEnum as ZodEnum } from '../../validators/enum.js';
+export { VldLiteral as $ZodLiteral, VldLiteral as ZodLiteral } from '../../validators/literal.js';
+export { VldFile as $ZodFile, VldFile as ZodFile } from '../../validators/file.js';
+export { VldLazy as $ZodLazy, VldLazy as ZodLazy } from '../../validators/lazy.js';
+export { VldPromise as $ZodPromise, VldPromise as ZodPromise } from '../../validators/promise.js';
+export { VldCustom as $ZodCustom, VldCustom as ZodCustom, VldCustom as ZodSuccess } from '../../validators/custom.js';
+export { VldBase64 as $ZodBase64, VldBase64 as $ZodBase64URL } from '../../validators/base64.js';
+export { VldCodec as $ZodCodec, VldCodec as ZodCodec } from '../../validators/codec.js';
+export { VldDiscriminatedUnion as $ZodDiscriminatedUnion, VldDiscriminatedUnion as ZodDiscriminatedUnion } from '../../validators/discriminated-union.js';
+export { VldFunction as $ZodFunction, VldFunction as ZodFunction } from '../../validators/function.js';
+export { VldJson as $ZodSuccess, VldJson as ZodJSON } from '../../validators/json.js';
+export { VldNan as $ZodNaN, VldNan as ZodNaN } from '../../validators/nan.js';
+export { VldTemplateLiteral as $ZodTemplateLiteral, VldTemplateLiteral as ZodTemplateLiteral } from '../../validators/template-literal.js';
+export { VldXor as $ZodXor, VldXor as ZodXor } from '../../validators/xor.js';
+export { VldStringFormat as $ZodBigIntFormat, VldStringFormat as $ZodCIDRv4, VldStringFormat as $ZodCIDRv6, VldStringFormat as $ZodCUID, VldStringFormat as $ZodCUID2, VldStringFormat as $ZodCustomStringFormat, VldStringFormat as $ZodE164, VldStringFormat as $ZodEmail, VldStringFormat as $ZodEmoji, VldStringFormat as $ZodGUID, VldStringFormat as $ZodIPv4, VldStringFormat as $ZodIPv6, VldStringFormat as $ZodISODate, VldStringFormat as $ZodISODateTime, VldStringFormat as $ZodISODuration, VldStringFormat as $ZodISOTime, VldStringFormat as $ZodJWT, VldStringFormat as $ZodKSUID, VldStringFormat as $ZodMAC, VldStringFormat as $ZodNanoID, VldStringFormat as $ZodNumberFormat, VldStringFormat as $ZodStringFormat, VldStringFormat as $ZodULID, VldStringFormat as $ZodURL, VldStringFormat as $ZodUUID, VldStringFormat as $ZodXID, VldStringFormat as ZodBase64, VldStringFormat as ZodBase64URL, VldStringFormat as ZodCIDRv4, VldStringFormat as ZodCIDRv6, VldStringFormat as ZodCUID, VldStringFormat as ZodCUID2, VldStringFormat as ZodCustomStringFormat, VldStringFormat as ZodE164, VldStringFormat as ZodEmail, VldStringFormat as ZodEmoji, VldStringFormat as ZodGUID, VldStringFormat as ZodIPv4, VldStringFormat as ZodIPv6, VldStringFormat as ZodISODate, VldStringFormat as ZodISODateTime, VldStringFormat as ZodISODuration, VldStringFormat as ZodISOTime, VldStringFormat as ZodJWT, VldStringFormat as ZodKSUID, VldStringFormat as ZodMAC, VldStringFormat as ZodNanoID, VldStringFormat as ZodStringFormat, VldStringFormat as ZodULID, VldStringFormat as ZodURL, VldStringFormat as ZodUUID, VldStringFormat as ZodXID } from '../../validators/string-formats.js';
+export { registry as $ZodRegistry, globalRegistry, registry } from '../../registry.js';
+import { success } from '../../compat/result.js';
+export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, mapErr, match, tryCatch, tryCatchAsync, unwrap, unwrapOr } from '../../compat/result.js';
+export { V as $ZodError, V as $ZodRealError, V as VldError, V as ZodError, V as ZodRealError } from '../../chunks/errors-core-BeiFUtZM.js';
+export { b as base64Json, a as base64ToBytes, c as base64ToUint8Array, d as base64UrlToBytes, e as base64urlToBytes, f as bytesToUtf8, g as epochMillisToDate, h as epochSecondsToDate, i as hexLowerToBytes, j as hexToBytes, k as hexToUint8Array, l as invertCodec, m as isoDatetimeToDate, n as jsonCodec, o as jwtPayload, p as numberToBigInt, s as stringToBigInt, q as stringToBoolean, r as stringToHttpURL, t as stringToInt, u as stringToNumber, v as stringToURL, w as stringToUint8Array, x as uint8ArrayToBase64, y as uint8ArrayToBase64Url, z as uint8ArrayToHex, A as uint8ArrayToString, B as uriComponent, C as utf8ToBytes } from '../../chunks/index-0R2ntSud.js';
+export { blue, bold, createTheme, cyan, dim, gray, green, grey, italic, magenta, default as pigment, red, strip, supportsColor, underline, vldTheme, white, yellow } from '../../pigment.js';
+export { createEmitter, createEventBus, withEmitter } from '../../compat/emitter.js';
+export { createVldKernel, definePlugin, getVldKernel, resetVldKernel, usePlugin } from '../../kernel.js';
+export { getLocale, getMessages, getSupportedLocales, isLocaleLoaded, isLocaleSupported, registerLocale, setLocale } from '../../locales/runtime.js';
+export { s as setLocaleAsync } from '../../chunks/index-BvH403Yy.js';
+
+const messageFromParams = (params) => typeof params === 'string' ? params : params?.message || params?.error;
+const hasClassArg = (args) => typeof args[0] === 'function' && args.length > 1;
+const schemaArg = (args, directIndex = 0) => args[hasClassArg(args) ? directIndex + 1 : directIndex];
+const valueArg = (args, directIndex = 0) => args[hasClassArg(args) ? directIndex + 1 : directIndex];
+const schemaArrayArg = (args, directIndex = 0) => {
+    const value = valueArg(args, directIndex);
+    return Array.isArray(value) ? value : args.slice(directIndex);
+};
+const unsupportedCoreFactory = (name) => () => {
+    throw new Error(`${name} is an internal Zod core compatibility placeholder`);
+};
+class $ZodAsyncError extends Error {
+}
+class $ZodEncodeError extends Error {
+}
+class $ZodCheck {
+}
+class $ZodCheckBigIntFormat extends $ZodCheck {
+}
+class $ZodCheckEndsWith extends $ZodCheck {
+}
+class $ZodCheckGreaterThan extends $ZodCheck {
+}
+class $ZodCheckIncludes extends $ZodCheck {
+}
+class $ZodCheckLengthEquals extends $ZodCheck {
+}
+class $ZodCheckLessThan extends $ZodCheck {
+}
+class $ZodCheckLowerCase extends $ZodCheck {
+}
+class $ZodCheckMaxLength extends $ZodCheck {
+}
+class $ZodCheckMaxSize extends $ZodCheck {
+}
+class $ZodCheckMimeType extends $ZodCheck {
+}
+class $ZodCheckMinLength extends $ZodCheck {
+}
+class $ZodCheckMinSize extends $ZodCheck {
+}
+class $ZodCheckMultipleOf extends $ZodCheck {
+}
+class $ZodCheckNumberFormat extends $ZodCheck {
+}
+class $ZodCheckOverwrite extends $ZodCheck {
+}
+class $ZodCheckProperty extends $ZodCheck {
+}
+class $ZodCheckRegex extends $ZodCheck {
+}
+class $ZodCheckSizeEquals extends $ZodCheck {
+}
+class $ZodCheckStartsWith extends $ZodCheck {
+}
+class $ZodCheckStringFormat extends $ZodCheck {
+}
+class $ZodCheckUpperCase extends $ZodCheck {
+}
+const $ZodObjectJIT = VldObject;
+class Doc {
+}
+const JSONSchema = {};
+class JSONSchemaGenerator {
+}
+const globalConfig = {};
+const version = { major: 4, minor: 4, patch: 3 };
+const $constructor = (name, initializer) => { var _a; return _a = class {
+        constructor(def) {
+            Object.defineProperty(this, '_zod', { value: { def }, enumerable: false });
+            initializer?.(this, def);
+        }
+    },
+    _a.displayName = name,
+    _a; };
+const _parse = parse;
+const _default = (...args) => {
+    const schema = schemaArg(args);
+    const defaultValue = valueArg(args, 1);
+    return schema.default(typeof defaultValue === 'function' ? defaultValue() : defaultValue);
+};
+const _safeParse = safeParse;
+const _parseAsync = parseAsync;
+const _safeParseAsync = safeParseAsync;
+const _encode = encode;
+const _safeEncode = safeEncode;
+const _decode = decode;
+const _safeDecode = safeDecode;
+const _encodeAsync = encodeAsync;
+const _safeEncodeAsync = safeEncodeAsync;
+const _decodeAsync = decodeAsync;
+const _safeDecodeAsync = safeDecodeAsync;
+const _string = (..._args) => string();
+const _number = (..._args) => number();
+const _boolean = (..._args) => boolean();
+const _bigint = (..._args) => bigint();
+const _symbol = (..._args) => symbol();
+const _undefined = (..._args) => undefinedFactory();
+const _null = (..._args) => nullFactory();
+const _any = (..._args) => any();
+const _unknown = (..._args) => unknown();
+const _never = (..._args) => neverFactory();
+const _void = (..._args) => voidFactory();
+const _date = (..._args) => date();
+const _array = (...args) => array(schemaArg(args));
+const _object = (...args) => object(valueArg(args));
+const _union = (...args) => union(...schemaArrayArg(args));
+const _intersection = (...args) => intersection(schemaArg(args), schemaArg(args, 1));
+const _tuple = (...args) => tuple(...schemaArrayArg(args));
+const _record = (...args) => record(schemaArg(args, hasClassArg(args) ? 1 : 0));
+const _map = (...args) => map(schemaArg(args), schemaArg(args, 1));
+const _set = (...args) => set(schemaArg(args));
+const _enum = (...args) => {
+    const values = valueArg(args);
+    if (Array.isArray(values)) {
+        return enumFactory(...values);
+    }
+    return nativeEnum(values);
+};
+const _nativeEnum = (...args) => nativeEnum(valueArg(args));
+const _literal = (...args) => literal(valueArg(args));
+const _file = (..._args) => file();
+const _lazy = (...args) => lazy(valueArg(args));
+const _promise = (...args) => promise(schemaArg(args));
+const _optional = (...args) => optional(schemaArg(args));
+const _nullable = (...args) => nullable(schemaArg(args));
+const _nonoptional = (...args) => nonoptional(schemaArg(args));
+const _readonly = (...args) => readonly(schemaArg(args));
+const _templateLiteral = (...args) => templateLiteral(...schemaArrayArg(args));
+const _stringbool = (...args) => stringbool(valueArg(args));
+const _nan = (..._args) => nan();
+const _email = email;
+const _guid = guid;
+const _uuid = uuid;
+const _uuidv4 = uuidv4;
+const _uuidv6 = uuidv6;
+const _uuidv7 = uuidv7;
+const _url = url;
+const _emoji = emoji;
+const _nanoid = nanoid;
+const _cuid = cuid;
+const _cuid2 = cuid2;
+const _ulid = ulid;
+const _xid = xid;
+const _ksuid = ksuid;
+const _ipv4 = ipv4;
+const _ipv6 = ipv6;
+const _cidrv4 = cidrv4;
+const _cidrv6 = cidrv6;
+const _base64 = base64;
+const _base64url = base64url;
+const _e164 = e164;
+const _jwt = jwt;
+const _isoDateTime = iso.dateTime;
+const _isoDate = iso.date;
+const _isoTime = iso.time;
+const _isoDuration = iso.duration;
+const _mac = mac;
+const _mime = mime;
+const _stringFormat = stringFormat;
+const _min = (value, params) => number().min(value, messageFromParams(params));
+const _max = (value, params) => number().max(value, messageFromParams(params));
+const _gt = (value, params) => number().gt(value, messageFromParams(params));
+const _gte = (value, params) => number().gte(value, messageFromParams(params));
+const _lt = (value, params) => number().lt(value, messageFromParams(params));
+const _lte = (value, params) => number().lte(value, messageFromParams(params));
+const _int = int;
+const _int32 = int32;
+const _uint32 = uint32;
+const _int64 = int64;
+const _uint64 = uint64;
+const _float32 = float32;
+const _float64 = float64;
+const _positive = positive;
+const _negative = negative;
+const _nonpositive = nonpositive;
+const _nonnegative = nonnegative;
+const _multipleOf = multipleOf;
+const _minLength = minLength;
+const _maxLength = maxLength;
+const _length = length;
+const _size = size;
+const _minSize = minSize;
+const _maxSize = maxSize;
+const _regex = regex;
+const _startsWith = startsWith;
+const _endsWith = endsWith;
+const _includes = includes;
+const _lowercase = lowercase;
+const _uppercase = uppercase;
+const _trim = trim;
+const _normalize = normalize;
+const _slugify = slugify;
+const _toLowerCase = toLowerCase;
+const _toUpperCase = toUpperCase;
+const _check = (...args) => check(valueArg(args));
+const _custom = (...args) => custom(valueArg(args));
+const _refine = (...args) => refine(valueArg(args), valueArg(args, 1));
+const _superRefine = (...args) => superRefine(schemaArg(args), valueArg(args, 1));
+const _transform = (...args) => transform(valueArg(args));
+const _overwrite = (...args) => overwrite(valueArg(args));
+const _pipe = (...args) => pipe(schemaArg(args), schemaArg(args, 1));
+const _catch = (...args) => catchFactory(schemaArg(args), valueArg(args, 1));
+const _success = (...args) => success(valueArg(args));
+const _property = (...args) => property(valueArg(args), schemaArg(args, 1), valueArg(args, 2));
+const _coercedString = coerce.string;
+const _coercedNumber = coerce.number;
+const _coercedBoolean = coerce.boolean;
+const _coercedBigint = coerce.bigint;
+const _coercedDate = coerce.date;
+const _codec = (...args) => codec(schemaArg(args), schemaArg(args, 1), valueArg(args, 2));
+const _function = (..._args) => functionFactory();
+const _discriminatedUnion = (...args) => discriminatedUnion(valueArg(args), ...schemaArrayArg(args, 1));
+const _xor = (...args) => xor(...schemaArrayArg(args));
+const createToJSONSchemaMethod = () => toJSONSchema;
+const createStandardJSONSchemaMethod = () => toJSONSchema;
+const extractDefs = () => ({});
+const finalize = (schema) => schema;
+const initializeContext = () => ({});
+const process = (schema) => schema;
+const toDotPath = (path) => path.map(String).join('.');
+const isValidBase64 = (value) => base64().safeParse(value).success;
+const isValidBase64URL = (value) => base64url().safeParse(value).success;
+const isValidJWT = (value) => jwt().safeParse(value).success;
+const _checkInternal = unsupportedCoreFactory('_checkInternal');
+
+export { $ZodAsyncError, $ZodCheck, $ZodCheckBigIntFormat, $ZodCheckEndsWith, $ZodCheckGreaterThan, $ZodCheckIncludes, $ZodCheckLengthEquals, $ZodCheckLessThan, $ZodCheckLowerCase, $ZodCheckMaxLength, $ZodCheckMaxSize, $ZodCheckMimeType, $ZodCheckMinLength, $ZodCheckMinSize, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckOverwrite, $ZodCheckProperty, $ZodCheckRegex, $ZodCheckSizeEquals, $ZodCheckStartsWith, $ZodCheckStringFormat, $ZodCheckUpperCase, $ZodEncodeError, VldObject as $ZodObject, $ZodObjectJIT, $constructor, Doc, JSONSchema, JSONSchemaGenerator, VldObject as ZodObject, _any, _array, _base64, _base64url, _bigint, _boolean, _catch, _check, _checkInternal, _cidrv4, _cidrv6, _codec, _coercedBigint, _coercedBoolean, _coercedDate, _coercedNumber, _coercedString, _cuid, _cuid2, _custom, _date, _decode, _decodeAsync, _default, _discriminatedUnion, _e164, _email, _emoji, _encode, _encodeAsync, _endsWith, _enum, _file, _float32, _float64, _function, _gt, _gte, _guid, _includes, _int, _int32, _int64, _intersection, _ipv4, _ipv6, _isoDate, _isoDateTime, _isoDuration, _isoTime, _jwt, _ksuid, _lazy, _length, _literal, _lowercase, _lt, _lte, _mac, _map, _max, _maxLength, _maxSize, _mime, _min, _minLength, _minSize, _multipleOf, _nan, _nanoid, _nativeEnum, _negative, _never, _nonnegative, _nonoptional, _nonpositive, _normalize, _null, _nullable, _number, _object, _optional, _overwrite, _parse, _parseAsync, _pipe, _positive, _promise, _property, _readonly, _record, _refine, _regex, _safeDecode, _safeDecodeAsync, _safeEncode, _safeEncodeAsync, _safeParse, _safeParseAsync, _set, _size, _slugify, _startsWith, _string, _stringFormat, _stringbool, _success, _superRefine, _symbol, _templateLiteral, _toLowerCase, _toUpperCase, _transform, _trim, _tuple, _uint32, _uint64, _ulid, _undefined, _union, _unknown, _uppercase, _url, _uuid, _uuidv4, _uuidv6, _uuidv7, _void, _xid, _xor, any, array, base64, base64url, bigint, boolean, catchFactory as catch, check, cidrv4, cidrv6, codec, coerce, createStandardJSONSchemaMethod, createToJSONSchemaMethod, cuid, cuid2, custom, date, decode, decodeAsync, discriminatedUnion, e164, email, emoji, encode, encodeAsync, endsWith, enumFactory as enum, extractDefs, file, finalize, float32, float64, functionFactory as function, globalConfig, guid, includes, initializeContext, int, int32, int64, intersection, ipv4, ipv6, isValidBase64, isValidBase64URL, isValidJWT, iso, jwt, ksuid, lazy, length, literal, lowercase, mac, map, maxLength, maxSize, mime, minLength, minSize, multipleOf, nan, nanoid, nativeEnum, negative, neverFactory as never, nonnegative, nonoptional, nonpositive, normalize, nullFactory as null, nullable, number, object, optional, overwrite, parse, parseAsync, pipe, positive, process, promise, property, readonly, record, refine, regex, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, size, slugify, startsWith, string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, toDotPath, toJSONSchema, toLowerCase, toUpperCase, transform, trim, tuple, uint32, uint64, ulid, undefinedFactory as undefined, union, unknown, uppercase, url, uuid, uuidv4, uuidv6, uuidv7, version, voidFactory as void, xid, xor };

package/dist/v4/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../index.js';
+export { default } from '../index.js';
+import type { VldBase } from '../validators/base.js';
+export declare const _default: <TInput, TOutput>(schema: VldBase<TInput, TOutput>, defaultValue: TOutput | (() => TOutput)) => import("../index.js").ZodDefault<TInput, TOutput>;

package/dist/v4/index.js

@@ -0,0 +1,50 @@
+export { $brand, $input, $output, NEVER, TimePrecision, ZodFirstPartyTypeKind, ZodIssueCode, _ZodString, _function, any, array, base64, base64Bytes, base64url, bigint, boolean, catch, check, cidrv4, cidrv6, clone, codec, coerce, config, core, createLogger, createNoOpLogger, cuid, cuid2, custom, date, decode, decodeAsync, default, describe, disableLogging, discriminatedUnion, e164, email, emoji, enableDebug, encode, encodeAsync, endsWith, enum, exactOptional, file, float32, float64, formatError, fromJSONSchema, _function as function, getErrorMap, getLogger, gt, gte, guid, hash, hex, hexBytes, hostname, httpUrl, includes, initLogger, instanceof, int, int32, int64, intersection, ipv4, ipv6, iso, json, jwt, keyof, ksuid, lazy, length, literal, locales, looseObject, looseRecord, lowercase, lt, lte, mac, map, mapSchema, maxLength, maxSize, meta, mime, minLength, minSize, multipleOf, nan, nanoid, nativeEnum, negative, never, nonnegative, nonoptional, nonpositive, normalize, null, nullable, nullish, number, object, optional, overwrite, parse, parseAsync, partialRecord, pipe, positive, prefault, preprocess, promise, property, readonly, record, refine, regex, regexes, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, setErrorMap, setLogLevel, size, slugify, startsWith, strictObject, string, stringFormat, stringbool, superRefine, symbol, templateLiteral, toJSONSchema, toLowerCase, toUpperCase, transform, trim, tuple, uint32, uint64, uint8Array, ulid, undefined, union, unknown, uppercase, url, util, uuid, uuidv4, uuidv6, uuidv7, default as v, void, xid, xor, z } from '../index.js';
+export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, mapErr, match, success, tryCatch, tryCatchAsync, unwrap, unwrapOr } from '../compat/result.js';
+export { VldBase, VldMeta, VldBrand as ZodBranded, VldCatch as ZodCatch, VldDefault as ZodDefault, VldExactOptional as ZodExactOptional, VldMeta as ZodMeta, VldRefine as ZodNonOptional, VldNullable as ZodNullable, VldOptional as ZodOptional, VldPipe as ZodPipe, VldPrefault as ZodPrefault, VldPreprocess as ZodPreprocess, VldReadonly as ZodReadonly, VldTransform as ZodTransform, VldBase as ZodType } from '../validators/base.js';
+export { V as VldError, V as ZodError, V as ZodRealError } from '../chunks/errors-core-BeiFUtZM.js';
+export { VldIntersection, VldIntersection as ZodIntersection } from '../validators/intersection.js';
+export { VldAny as ZodAny } from '../validators/any.js';
+export { VldArray as ZodArray } from '../validators/array.js';
+export { VldStringFormat as ZodBase64, VldStringFormat as ZodBase64URL, VldStringFormat as ZodCIDRv4, VldStringFormat as ZodCIDRv6, VldStringFormat as ZodCUID, VldStringFormat as ZodCUID2, VldStringFormat as ZodCustomStringFormat, VldStringFormat as ZodE164, VldStringFormat as ZodEmail, VldStringFormat as ZodEmoji, VldStringFormat as ZodGUID, VldStringFormat as ZodIPv4, VldStringFormat as ZodIPv6, VldStringFormat as ZodISODate, VldStringFormat as ZodISODateTime, VldStringFormat as ZodISODuration, VldStringFormat as ZodISOTime, VldStringFormat as ZodJWT, VldStringFormat as ZodKSUID, VldStringFormat as ZodMAC, VldStringFormat as ZodNanoID, VldStringFormat as ZodStringFormat, VldStringFormat as ZodULID, VldStringFormat as ZodURL, VldStringFormat as ZodUUID, VldStringFormat as ZodXID } from '../validators/string-formats.js';
+export { VldBigInt as ZodBigInt, VldBigInt as ZodBigIntFormat } from '../validators/bigint.js';
+export { VldBoolean as ZodBoolean } from '../validators/boolean.js';
+export { VldCodec as ZodCodec } from '../validators/codec.js';
+export { VldCustom as ZodCustom, VldCustom as ZodSuccess } from '../validators/custom.js';
+export { VldDate as ZodDate } from '../validators/date.js';
+export { VldDiscriminatedUnion as ZodDiscriminatedUnion } from '../validators/discriminated-union.js';
+export { VldEnum as ZodEnum } from '../validators/enum.js';
+export { VldFile as ZodFile } from '../validators/file.js';
+export { VldFunction as ZodFunction } from '../validators/function.js';
+export { VldJson as ZodJSON } from '../validators/json.js';
+export { VldLazy as ZodLazy } from '../validators/lazy.js';
+export { VldLiteral as ZodLiteral } from '../validators/literal.js';
+export { VldMap as ZodMap } from '../validators/map.js';
+export { VldNan as ZodNaN } from '../validators/nan.js';
+export { VldNever as ZodNever } from '../validators/never.js';
+export { VldNull as ZodNull } from '../validators/null.js';
+export { VldNumber as ZodNumber, VldNumber as ZodNumberFormat } from '../validators/number.js';
+export { VldObject as ZodObject } from '../validators/object.js';
+export { VldPromise as ZodPromise } from '../validators/promise.js';
+export { VldRecord as ZodRecord } from '../validators/record.js';
+export { VldSet as ZodSet } from '../validators/set.js';
+export { V as ZodString } from '../chunks/string-BJRQod3t.js';
+export { VldSymbol as ZodSymbol } from '../validators/symbol.js';
+export { VldTemplateLiteral as ZodTemplateLiteral } from '../validators/template-literal.js';
+export { VldTuple as ZodTuple } from '../validators/tuple.js';
+export { VldUndefined as ZodUndefined } from '../validators/undefined.js';
+export { VldUnion as ZodUnion } from '../validators/union.js';
+export { VldUnknown as ZodUnknown } from '../validators/unknown.js';
+export { VldVoid as ZodVoid } from '../validators/void.js';
+export { VldXor as ZodXor } from '../validators/xor.js';
+export { b as base64Json, a as base64ToBytes, c as base64ToUint8Array, d as base64UrlToBytes, e as base64urlToBytes, f as bytesToUtf8, g as epochMillisToDate, h as epochSecondsToDate, i as hexLowerToBytes, j as hexToBytes, k as hexToUint8Array, l as invertCodec, m as isoDatetimeToDate, n as jsonCodec, o as jwtPayload, p as numberToBigInt, s as stringToBigInt, q as stringToBoolean, r as stringToHttpURL, t as stringToInt, u as stringToNumber, v as stringToURL, w as stringToUint8Array, x as uint8ArrayToBase64, y as uint8ArrayToBase64Url, z as uint8ArrayToHex, A as uint8ArrayToString, B as uriComponent, C as utf8ToBytes } from '../chunks/index-0R2ntSud.js';
+export { blue, bold, createTheme, cyan, dim, gray, green, grey, italic, magenta, default as pigment, red, strip, supportsColor, underline, vldTheme, white, yellow } from '../pigment.js';
+export { createEmitter, createEventBus, withEmitter } from '../compat/emitter.js';
+export { createVldKernel, definePlugin, getVldKernel, resetVldKernel, usePlugin } from '../kernel.js';
+export { flattenError, prettifyError, prettifyErrorColored, prettifyErrorPlain, treeifyError } from '../errors.js';
+export { getLocale, getMessages, getSupportedLocales, isLocaleLoaded, isLocaleSupported, registerLocale, setLocale } from '../locales/runtime.js';
+export { globalRegistry, registry } from '../registry.js';
+export { s as setLocaleAsync } from '../chunks/index-BvH403Yy.js';
+
+const _default = (schema, defaultValue) => schema.default(typeof defaultValue === 'function' ? defaultValue() : defaultValue);
+
+export { _default };