zod 3.26.0-canary.20250619T152955 → 3.26.0-canary.20250702T200737

package/{dist/esm/v4 → v4}/core/schemas.js

@@ -231,7 +231,6 @@ export const $ZodKSUID = /*@__PURE__*/ core.$constructor("$ZodKSUID", (inst, def
 export const $ZodISODateTime = /*@__PURE__*/ core.$constructor("$ZodISODateTime", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.datetime(def));
     $ZodStringFormat.init(inst, def);
-    const _super = inst._zod.check;
 });
 export const $ZodISODate = /*@__PURE__*/ core.$constructor("$ZodISODate", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.date);
@@ -240,7 +239,6 @@ export const $ZodISODate = /*@__PURE__*/ core.$constructor("$ZodISODate", (inst,
 export const $ZodISOTime = /*@__PURE__*/ core.$constructor("$ZodISOTime", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.time(def));
     $ZodStringFormat.init(inst, def);
-    const _super = inst._zod.check;
 });
 export const $ZodISODuration = /*@__PURE__*/ core.$constructor("$ZodISODuration", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.duration);
@@ -376,6 +374,8 @@ export function isValidJWT(token, algorithm = null) {
         if (tokensParts.length !== 3)
             return false;
         const [header] = tokensParts;
+        if (!header)
+            return false;
         const parsedHeader = JSON.parse(atob(header));
         if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
             return false;
@@ -1416,6 +1416,9 @@ export const $ZodOptional = /*@__PURE__*/ core.$constructor("$ZodOptional", (ins
         return pattern ? new RegExp(`^(${util.cleanRegex(pattern.source)})?$`) : undefined;
     });
     inst._zod.parse = (payload, ctx) => {
+        if (def.innerType._zod.optin === "optional") {
+            return def.innerType._zod.run(payload, ctx);
+        }
         if (payload.value === undefined) {
             return payload;
         }

package/v4/core/standard-schema.d.ts

@@ -0,0 +1,55 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}

package/{dist/cjs/v4/core/to-json-schema.js → v4/core/to-json-schema.cjs}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONSchemaGenerator = void 0;
 exports.toJSONSchema = toJSONSchema;
-const registries_js_1 = require("./registries.js");
-const util_js_1 = require("./util.js");
+const registries_js_1 = require("./registries.cjs");
+const util_js_1 = require("./util.cjs");
 class JSONSchemaGenerator {
     constructor(params) {
         this.counter = 0;

package/v4/core/to-json-schema.d.cts

@@ -0,0 +1,84 @@
+import type * as JSONSchema from "./json-schema.cjs";
+import { $ZodRegistry } from "./registries.cjs";
+import type * as schemas from "./schemas.cjs";
+interface JSONSchemaGeneratorParams {
+    /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.
+     *  @default globalRegistry */
+    metadata?: $ZodRegistry<Record<string, any>>;
+    /** The JSON Schema version to target.
+     * - `"draft-2020-12"` — Default. JSON Schema Draft 2020-12
+     * - `"draft-7"` — JSON Schema Draft 7 */
+    target?: "draft-7" | "draft-2020-12";
+    /** How to handle unrepresentable types.
+     * - `"throw"` — Default. Unrepresentable types throw an error
+     * - `"any"` — Unrepresentable types become `{}` */
+    unrepresentable?: "throw" | "any";
+    /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */
+    override?: (ctx: {
+        zodSchema: schemas.$ZodTypes;
+        jsonSchema: JSONSchema.BaseSchema;
+    }) => void;
+    /** Whether to extract the `"input"` or `"output"` type. Relevant to transforms, Error converting schema to JSONz, defaults, coerced primitives, etc.
+     * - `"output" — Default. Convert the output schema.
+     * - `"input"` — Convert the input schema. */
+    io?: "input" | "output";
+}
+interface ProcessParams {
+    schemaPath: schemas.$ZodType[];
+    path: (string | number)[];
+}
+interface EmitParams {
+    /** How to handle cycles.
+     * - `"ref"` — Default. Cycles will be broken using $defs
+     * - `"throw"` — Cycles will throw an error if encountered */
+    cycles?: "ref" | "throw";
+    reused?: "ref" | "inline";
+    external?: {
+        /**  */
+        registry: $ZodRegistry<{
+            id?: string | undefined;
+        }>;
+        uri: (id: string) => string;
+        defs: Record<string, JSONSchema.BaseSchema>;
+    } | undefined;
+}
+interface Seen {
+    /** JSON Schema result for this Zod schema */
+    schema: JSONSchema.BaseSchema;
+    /** A cached version of the schema that doesn't get overwritten during ref resolution */
+    def?: JSONSchema.BaseSchema;
+    defId?: string | undefined;
+    /** Number of times this schema was encountered during traversal */
+    count: number;
+    /** Cycle path */
+    cycle?: (string | number)[] | undefined;
+    isParent?: boolean | undefined;
+    ref?: schemas.$ZodType | undefined | null;
+}
+export declare class JSONSchemaGenerator {
+    metadataRegistry: $ZodRegistry<Record<string, any>>;
+    target: "draft-7" | "draft-2020-12";
+    unrepresentable: "throw" | "any";
+    override: (ctx: {
+        zodSchema: schemas.$ZodTypes;
+        jsonSchema: JSONSchema.BaseSchema;
+    }) => void;
+    io: "input" | "output";
+    counter: number;
+    seen: Map<schemas.$ZodType, Seen>;
+    constructor(params?: JSONSchemaGeneratorParams);
+    process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
+    emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
+}
+interface ToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, "external"> {
+}
+interface RegistryToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, "external"> {
+    uri?: (id: string) => string;
+}
+export declare function toJSONSchema(schema: schemas.$ZodType, _params?: ToJSONSchemaParams): JSONSchema.BaseSchema;
+export declare function toJSONSchema(registry: $ZodRegistry<{
+    id?: string | undefined;
+}>, _params?: RegistryToJSONSchemaParams): {
+    schemas: Record<string, JSONSchema.BaseSchema>;
+};
+export {};

package/{dist/cjs/v4/core/util.js → v4/core/util.cjs}

@@ -173,9 +173,6 @@ exports.allowsEval = cached(() => {
         return false;
     }
 });
-function _isObject(o) {
-    return Object.prototype.toString.call(o) === "[object Object]";
-}
 function isPlainObject(o) {
     if (isObject(o) === false)
         return false;
@@ -400,6 +397,7 @@ function partial(Class, schema, mask) {
             }
             if (!mask[key])
                 continue;
+            // if (oldShape[key]!._zod.optin === "optional") continue;
             shape[key] = Class
                 ? new Class({
                     type: "optional",
@@ -410,6 +408,7 @@ function partial(Class, schema, mask) {
     }
     else {
         for (const key in oldShape) {
+            // if (oldShape[key]!._zod.optin === "optional") continue;
             shape[key] = Class
                 ? new Class({
                     type: "optional",
@@ -459,7 +458,7 @@ function required(Class, schema, mask) {
 }
 function aborted(x, startIndex = 0) {
     for (let i = startIndex; i < x.issues.length; i++) {
-        if (x.issues[i].continue !== true)
+        if (x.issues[i]?.continue !== true)
             return true;
     }
     return false;

package/v4/core/util.d.cts

@@ -0,0 +1,183 @@
+import type * as checks from "./checks.cjs";
+import type { $ZodConfig } from "./core.cjs";
+import type * as errors from "./errors.cjs";
+import type * as schemas from "./schemas.cjs";
+export type JSONType = string | number | boolean | null | JSONType[] | {
+    [key: string]: JSONType;
+};
+export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
+export type IPVersion = "v4" | "v6";
+export type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
+export type ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
+export type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+export type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;
+export type AssertExtends<T, U> = T extends U ? T : never;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+export type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;
+export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+export type NoUndefined<T> = T extends undefined ? never : T;
+export type Whatever = {} | undefined | null;
+export type LoosePartial<T extends object> = InexactPartial<T> & {
+    [k: string]: unknown;
+};
+export type Mask<Keys extends PropertyKey> = {
+    [K in Keys]?: true;
+};
+export type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+} & {};
+export type InexactPartial<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+export type EmptyObject = Record<string, never>;
+export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+    readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+export type SomeObject = Record<PropertyKey, any>;
+export type Identity<T> = T;
+export type Flatten<T> = Identity<{
+    [k in keyof T]: T[k];
+}>;
+export type Mapped<T> = {
+    [k in keyof T]: T[k];
+};
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type NoNeverKeys<T> = {
+    [k in keyof T]: [T[k]] extends [never] ? never : k;
+}[keyof T];
+export type NoNever<T> = Identity<{
+    [k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
+}>;
+export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {
+    [K in keyof A as K extends keyof B ? never : K]: A[K];
+} & {
+    [K in keyof B]: B[K];
+}>;
+export type TupleItems = ReadonlyArray<schemas.SomeType>;
+export type AnyFunc = (...args: any[]) => any;
+export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
+export type MaybeAsync<T> = T | Promise<T>;
+export type KeyOf<T> = keyof OmitIndexSignature<T>;
+export type OmitIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];
+};
+export type ExtractIndexSignature<T> = {
+    [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
+};
+export type Keys<T extends object> = keyof OmitIndexSignature<T>;
+export type SchemaClass<T extends schemas.SomeType> = {
+    new (def: T["_zod"]["def"]): T;
+};
+export type EnumValue = string | number;
+export type EnumLike = Readonly<Record<string, EnumValue>>;
+export type ToEnum<T extends EnumValue> = Flatten<{
+    [k in T]: k;
+}>;
+export type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;
+export type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;
+export type Literal = string | number | bigint | boolean | null | undefined;
+export type LiteralArray = Array<Literal>;
+export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+export type PrimitiveArray = Array<Primitive>;
+export type HasSize = {
+    size: number;
+};
+export type HasLength = {
+    length: number;
+};
+export type Numeric = number | bigint | Date;
+export type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;
+export type SafeParseSuccess<T> = {
+    success: true;
+    data: T;
+    error?: never;
+};
+export type SafeParseError<T> = {
+    success: false;
+    data?: never;
+    error: errors.$ZodError<T>;
+};
+export type PropValues = Record<string, Set<Primitive>>;
+export type PrimitiveSet = Set<Primitive>;
+export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
+export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
+export declare function assertIs<T>(_arg: T): void;
+export declare function assertNever(_x: never): never;
+export declare function assert<T>(_: any): asserts _ is T;
+export declare function getEnumValues(entries: EnumLike): EnumValue[];
+export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
+export declare function jsonStringifyReplacer(_: string, value: any): any;
+export declare function cached<T>(getter: () => T): {
+    value: T;
+};
+export declare function nullish(input: any): boolean;
+export declare function cleanRegex(source: string): string;
+export declare function floatSafeRemainder(val: number, step: number): number;
+export declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;
+export declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;
+export declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;
+export declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{
+    [k in keyof T]: Awaited<T[k]>;
+}>;
+export declare function randomString(length?: number): string;
+export declare function esc(str: string): string;
+export declare const captureStackTrace: typeof Error.captureStackTrace;
+export declare function isObject(data: any): data is Record<PropertyKey, unknown>;
+export declare const allowsEval: {
+    value: boolean;
+};
+export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
+export declare function numKeys(data: any): number;
+export declare const getParsedType: (data: any) => ParsedTypes;
+export declare const propertyKeyTypes: Set<string>;
+export declare const primitiveTypes: Set<string>;
+export declare function escapeRegex(str: string): string;
+export declare function clone<T extends schemas.$ZodType>(inst: T, def?: T["_zod"]["def"], params?: {
+    parent: boolean;
+}): T;
+export type EmptyToNever<T> = keyof T extends never ? never : T;
+export type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{
+    [k in keyof Omit<T, "error" | "message">]: T[k];
+} & ("error" extends keyof T ? {
+    error?: Exclude<T["error"], string>;
+} : unknown)> : never;
+export declare function normalizeParams<T>(_params: T): Normalize<T>;
+export declare function createTransparentProxy<T extends object>(getter: () => T): T;
+export declare function stringifyPrimitive(value: any): string;
+export declare function optionalKeys(shape: schemas.$ZodShape): string[];
+export type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;
+export type ToCleanMap<T extends schemas.$ZodLooseShape> = {
+    [k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;
+};
+export type FromCleanMap<T extends schemas.$ZodLooseShape> = {
+    [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;
+};
+export declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;
+export declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;
+export declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;
+export declare function omit(schema: schemas.$ZodObject, mask: object): any;
+export declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;
+export declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;
+export declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined): any;
+export declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;
+export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
+export declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;
+export declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];
+export declare function unwrapMessage(message: string | {
+    message: string;
+} | undefined | null): string | undefined;
+export declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;
+export declare function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown";
+export declare function getLengthableOrigin(input: any): "array" | "string" | "unknown";
+export declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;
+export declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;
+export declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];
+export declare abstract class Class {
+    constructor(..._args: any[]);
+}

package/{dist/esm/v4 → v4}/core/util.js

@@ -129,9 +129,6 @@ export const allowsEval = cached(() => {
         return false;
     }
 });
-function _isObject(o) {
-    return Object.prototype.toString.call(o) === "[object Object]";
-}
 export function isPlainObject(o) {
     if (isObject(o) === false)
         return false;
@@ -355,6 +352,7 @@ export function partial(Class, schema, mask) {
             }
             if (!mask[key])
                 continue;
+            // if (oldShape[key]!._zod.optin === "optional") continue;
             shape[key] = Class
                 ? new Class({
                     type: "optional",
@@ -365,6 +363,7 @@ export function partial(Class, schema, mask) {
     }
     else {
         for (const key in oldShape) {
+            // if (oldShape[key]!._zod.optin === "optional") continue;
             shape[key] = Class
                 ? new Class({
                     type: "optional",
@@ -414,7 +413,7 @@ export function required(Class, schema, mask) {
 }
 export function aborted(x, startIndex = 0) {
     for (let i = startIndex; i < x.issues.length; i++) {
-        if (x.issues[i].continue !== true)
+        if (x.issues[i]?.continue !== true)
             return true;
     }
     return false;

package/v4/core/versions.d.ts

@@ -0,0 +1,5 @@
+export declare const version: {
+    readonly major: 4;
+    readonly minor: 0;
+    readonly patch: number;
+};

package/{dist/cjs/index.js → v4/index.cjs}

@@ -17,6 +17,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = __importDefault(require("./v3/index.js"));
-__exportStar(require("./v3/index.js"), exports);
+const index_js_1 = __importDefault(require("./classic/index.cjs"));
+__exportStar(require("./classic/index.cjs"), exports);
 exports.default = index_js_1.default;

package/v4/index.d.cts

@@ -0,0 +1,3 @@
+import z4 from "./classic/index.cjs";
+export * from "./classic/index.cjs";
+export default z4;

package/v4/index.d.ts

@@ -1,3 +1,3 @@
-import z from "../dist/types/v4/index.js";
-export * from "../dist/types/v4/index.js";
-export default z;
+import z4 from "./classic/index.js";
+export * from "./classic/index.js";
+export default z4;

package/v4/index.js

@@ -1 +1,3 @@
-export * from "../dist/esm/v4/index.js";
+import z4 from "./classic/index.js";
+export * from "./classic/index.js";
+export default z4;

package/{dist/cjs/v4/locales/ar.js → v4/locales/ar.cjs}

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const util = __importStar(require("../core/util.js"));
+const util = __importStar(require("../core/util.cjs"));
 const error = () => {
     const Sizable = {
         string: { unit: "حرف", verb: "أن يحوي" },

package/v4/locales/ar.d.cts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.cjs";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/{dist/cjs/v4/locales/az.js → v4/locales/az.cjs}

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const util = __importStar(require("../core/util.js"));
+const util = __importStar(require("../core/util.cjs"));
 const error = () => {
     const Sizable = {
         string: { unit: "simvol", verb: "olmalıdır" },

package/v4/locales/az.d.cts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.cjs";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/{dist/cjs/v4/locales/be.js → v4/locales/be.cjs}

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const util = __importStar(require("../core/util.js"));
+const util = __importStar(require("../core/util.cjs"));
 function getBelarusianPlural(count, one, few, many) {
     const absCount = Math.abs(count);
     const lastDigit = absCount % 10;

package/v4/locales/be.d.cts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.cjs";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/{dist/cjs/v4/locales/ca.js → v4/locales/ca.cjs}

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const util = __importStar(require("../core/util.js"));
+const util = __importStar(require("../core/util.cjs"));
 const error = () => {
     const Sizable = {
         string: { unit: "caràcters", verb: "contenir" },

package/v4/locales/ca.d.cts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.cjs";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/{dist/cjs/v4/locales/cs.js → v4/locales/cs.cjs}

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const util = __importStar(require("../core/util.js"));
+const util = __importStar(require("../core/util.cjs"));
 const error = () => {
     const Sizable = {
         string: { unit: "znaků", verb: "mít" },

package/v4/locales/cs.d.cts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.cjs";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/{dist/cjs/v4/locales/de.js → v4/locales/de.cjs}

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
-const util = __importStar(require("../core/util.js"));
+const util = __importStar(require("../core/util.cjs"));
 const error = () => {
     const Sizable = {
         string: { unit: "Zeichen", verb: "zu haben" },

package/v4/locales/de.d.cts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.cjs";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};

package/{dist/cjs/v4/locales/en.js → v4/locales/en.cjs}

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsedType = void 0;
 exports.default = default_1;
-const util = __importStar(require("../core/util.js"));
+const util = __importStar(require("../core/util.cjs"));
 const parsedType = (data) => {
     const t = typeof data;
     switch (t) {

package/{dist/types/v4/locales/en.d.ts → v4/locales/en.d.cts}

@@ -1,4 +1,4 @@
-import type * as errors from "../core/errors.js";
+import type * as errors from "../core/errors.cjs";
 export declare const parsedType: (data: any) => string;
 export default function (): {
     localeError: errors.$ZodErrorMap;

package/v4/locales/en.d.ts

@@ -1,2 +1,5 @@
-export * from "../../dist/types/v4/locales/en.d.ts";
-export { default } from "../../dist/types/v4/locales/en.d.ts";
+import type * as errors from "../core/errors.js";
+export declare const parsedType: (data: any) => string;
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};