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

package/v3/helpers/util.d.ts

@@ -0,0 +1,85 @@
+export declare namespace util {
+    type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+    export type isAny<T> = 0 extends 1 & T ? true : false;
+    export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
+    export function assertIs<T>(_arg: T): void;
+    export function assertNever(_x: never): never;
+    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> & Partial<Pick<T, K>>;
+    export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+    export type InexactPartial<T> = {
+        [k in keyof T]?: T[k] | undefined;
+    };
+    export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
+    export const getValidEnumValues: (obj: any) => any[];
+    export const objectValues: (obj: any) => any[];
+    export const objectKeys: ObjectConstructor["keys"];
+    export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+    export type identity<T> = objectUtil.identity<T>;
+    export type flatten<T> = objectUtil.flatten<T>;
+    export type noUndefined<T> = T extends undefined ? never : T;
+    export const isInteger: NumberConstructor["isInteger"];
+    export function joinValues<T extends any[]>(array: T, separator?: string): string;
+    export const jsonStringifyReplacer: (_: string, value: any) => any;
+    export {};
+}
+export declare namespace objectUtil {
+    export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : {
+        [k in Exclude<keyof U, keyof V>]: U[k];
+    } & V;
+    type optionalKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? k : never;
+    }[keyof T];
+    type requiredKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? never : k;
+    }[keyof T];
+    export type addQuestionMarks<T extends object, _O = any> = {
+        [K in requiredKeys<T>]: T[K];
+    } & {
+        [K in optionalKeys<T>]?: T[K];
+    } & {
+        [k in keyof T]?: unknown;
+    };
+    export type identity<T> = T;
+    export type flatten<T> = identity<{
+        [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 const mergeShapes: <U, T>(first: U, second: T) => T & U;
+    export type extendShape<A extends object, B extends object> = 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 {};
+}
+export declare const ZodParsedType: {
+    string: "string";
+    nan: "nan";
+    number: "number";
+    integer: "integer";
+    float: "float";
+    boolean: "boolean";
+    date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    function: "function";
+    undefined: "undefined";
+    null: "null";
+    array: "array";
+    object: "object";
+    unknown: "unknown";
+    promise: "promise";
+    void: "void";
+    never: "never";
+    map: "map";
+    set: "set";
+};
+export type ZodParsedType = keyof typeof ZodParsedType;
+export declare const getParsedType: (data: any) => ZodParsedType;

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

@@ -27,7 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.z = void 0;
-const z = __importStar(require("./external.js"));
+const z = __importStar(require("./external.cjs"));
 exports.z = z;
-__exportStar(require("./external.js"), exports);
+__exportStar(require("./external.cjs"), exports);
 exports.default = z;

package/v3/index.d.cts

@@ -0,0 +1,4 @@
+import * as z from "./external.cjs";
+export * from "./external.cjs";
+export { z };
+export default z;

package/v3/index.d.ts

@@ -1,3 +1,4 @@
-export * from "../dist/types/v3/index.js";
-import z from "../dist/types/v3/index.js";
+import * as z from "./external.js";
+export * from "./external.js";
+export { z };
 export default z;

package/v3/index.js

@@ -1 +1,4 @@
-export * from "../dist/esm/v3/index.js";
+import * as z from "./external.js";
+export * from "./external.js";
+export { z };
+export default z;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ZodError_js_1 = require("../ZodError.js");
-const util_js_1 = require("../helpers/util.js");
+const ZodError_js_1 = require("../ZodError.cjs");
+const util_js_1 = require("../helpers/util.cjs");
 const errorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {

package/v3/locales/en.d.cts

@@ -0,0 +1,3 @@
+import { type ZodErrorMap } from "../ZodError.cjs";
+declare const errorMap: ZodErrorMap;
+export default errorMap;

package/v3/standard-schema.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The Standard Schema interface.
+ */
+export type StandardSchemaV1<Input = unknown, Output = Input> = {
+    /**
+     * The Standard Schema properties.
+     */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+};
+export declare namespace StandardSchemaV1 {
+    /**
+     * The Standard Schema properties interface.
+     */
+    export 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.
+     */
+    export type Result<Output> = SuccessResult<Output> | FailureResult;
+    /**
+     * The result interface if validation succeeds.
+     */
+    export interface SuccessResult<Output> {
+        /**
+         * The typed output value.
+         */
+        readonly value: Output;
+        /**
+         * The non-existent issues.
+         */
+        readonly issues?: undefined;
+    }
+    /**
+     * The result interface if validation fails.
+     */
+    export interface FailureResult {
+        /**
+         * The issues of failed validation.
+         */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /**
+     * The issue interface of the failure output.
+     */
+    export 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.
+     */
+    export interface PathSegment {
+        /**
+         * The key representing a path segment.
+         */
+        readonly key: PropertyKey;
+    }
+    /**
+     * The Standard Schema types interface.
+     */
+    export 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.
+     */
+    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /**
+     * Infers the output type of a Standard Schema.
+     */
+    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+    export {};
+}

package/{dist/cjs/v3/types.js → v3/types.cjs}

@@ -4,11 +4,11 @@ exports.discriminatedUnion = exports.date = exports.boolean = exports.bigint = e
 exports.NEVER = exports.void = exports.unknown = exports.union = exports.undefined = exports.tuple = exports.transformer = exports.symbol = exports.string = exports.strictObject = exports.set = exports.record = exports.promise = exports.preprocess = exports.pipeline = exports.ostring = exports.optional = exports.onumber = exports.oboolean = exports.object = exports.number = exports.nullable = exports.null = exports.never = exports.nativeEnum = exports.nan = exports.map = exports.literal = exports.lazy = exports.intersection = exports.instanceof = exports.function = exports.enum = exports.effect = void 0;
 exports.datetimeRegex = datetimeRegex;
 exports.custom = custom;
-const ZodError_js_1 = require("./ZodError.js");
-const errors_js_1 = require("./errors.js");
-const errorUtil_js_1 = require("./helpers/errorUtil.js");
-const parseUtil_js_1 = require("./helpers/parseUtil.js");
-const util_js_1 = require("./helpers/util.js");
+const ZodError_js_1 = require("./ZodError.cjs");
+const errors_js_1 = require("./errors.cjs");
+const errorUtil_js_1 = require("./helpers/errorUtil.cjs");
+const parseUtil_js_1 = require("./helpers/parseUtil.cjs");
+const util_js_1 = require("./helpers/util.cjs");
 class ParseInputLazyPath {
     constructor(parent, value, path, key) {
         this._cachedPath = [];
@@ -452,6 +452,8 @@ function isValidJWT(jwt, alg) {
         return false;
     try {
         const [header] = jwt.split(".");
+        if (!header)
+            return false;
         // Convert base64url to base64
         const base64 = header
             .replace(/-/g, "+")