@exodus/zod 3.24.1-rc.2 → 3.24.1-rc.3

package/lib/helpers/util.d.ts

@@ -10,13 +10,13 @@ export declare namespace util {
     export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
     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 objectValues: ObjectConstructor["values"];
     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 const isInteger: (number: unknown) => boolean;
     export function joinValues<T extends any[]>(array: T, separator?: string): string;
     export const jsonStringifyReplacer: (_: string, value: any) => any;
     export {};

package/lib/index.mjs

@@ -8,7 +8,7 @@ var util;
     }
     util.assertNever = assertNever;
     util.arrayToEnum = (items) => {
-        const obj = {};
+        const obj = Object.create(null);
         for (const item of items) {
             obj[item] = item;
         }
@@ -16,28 +16,14 @@ var util;
     };
     util.getValidEnumValues = (obj) => {
         const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-        const filtered = {};
+        const filtered = Object.create(null);
         for (const k of validKeys) {
             filtered[k] = obj[k];
         }
         return util.objectValues(filtered);
     };
-    util.objectValues = (obj) => {
-        return util.objectKeys(obj).map(function (e) {
-            return obj[e];
-        });
-    };
-    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
-        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
-        : (object) => {
-            const keys = [];
-            for (const key in object) {
-                if (Object.prototype.hasOwnProperty.call(object, key)) {
-                    keys.push(key);
-                }
-            }
-            return keys;
-        };
+    util.objectValues = Object.values;
+    util.objectKeys = Object.keys;
     util.find = (arr, checker) => {
         for (const item of arr) {
             if (checker(item))
@@ -45,9 +31,7 @@ var util;
         }
         return undefined;
     };
-    util.isInteger = typeof Number.isInteger === "function"
-        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
-        : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+    util.isInteger = Number.isInteger;
     function joinValues(array, separator = " | ") {
         return array
             .map((val) => (typeof val === "string" ? `'${val}'` : val))
@@ -160,18 +144,12 @@ const quotelessJson = (obj) => {
     return json.replace(/"([^"]+)":/g, "$1:");
 };
 class ZodError extends Error {
+    issues = [];
     get errors() {
         return this.issues;
     }
     constructor(issues) {
         super();
-        this.issues = [];
-        this.addIssue = (sub) => {
-            this.issues = [...this.issues, sub];
-        };
-        this.addIssues = (subs = []) => {
-            this.issues = [...this.issues, ...subs];
-        };
         const actualProto = new.target.prototype;
         if (Object.setPrototypeOf) {
             // eslint-disable-next-line ban/ban
@@ -232,6 +210,10 @@ class ZodError extends Error {
         processError(this);
         return fieldErrors;
     }
+    static create = (issues) => {
+        const error = new ZodError(issues);
+        return error;
+    };
     static assert(value) {
         if (!(value instanceof ZodError)) {
             throw new Error(`Not a ZodError: ${value}`);
@@ -246,6 +228,12 @@ class ZodError extends Error {
     get isEmpty() {
         return this.issues.length === 0;
     }
+    addIssue = (sub) => {
+        this.issues = [...this.issues, sub];
+    };
+    addIssues = (subs = []) => {
+        this.issues = [...this.issues, ...subs];
+    };
     flatten(mapper = (issue) => issue.message) {
         const fieldErrors = {};
         const formErrors = [];
@@ -264,10 +252,6 @@ class ZodError extends Error {
         return this.flatten();
     }
 }
-ZodError.create = (issues) => {
-    const error = new ZodError(issues);
-    return error;
-};
 
 const errorMap = (issue, _ctx) => {
     let message;
@@ -447,9 +431,7 @@ function addIssueToContext(ctx, issueData) {
     ctx.common.issues.push(issue);
 }
 class ParseStatus {
-    constructor() {
-        this.value = "valid";
-    }
+    value = "valid";
     dirty() {
         if (this.value === "valid")
             this.value = "dirty";
@@ -511,49 +493,19 @@ const isDirty = (x) => x.status === "dirty";
 const isValid = (x) => x.status === "valid";
 const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 var errorUtil;
 (function (errorUtil) {
     errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-    errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+    errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
-var _ZodEnum_cache, _ZodNativeEnum_cache;
 class ParseInputLazyPath {
+    parent;
+    data;
+    _path;
+    _key;
+    _cachedPath = [];
     constructor(parent, value, path, key) {
-        this._cachedPath = [];
         this.parent = parent;
         this.data = value;
         this._path = path;
@@ -601,24 +553,28 @@ function processCreateParams(params) {
     if (errorMap)
         return { errorMap: errorMap, description };
     const customMap = (iss, ctx) => {
-        var _a, _b;
         const { message } = params;
         if (iss.code === "invalid_enum_value") {
-            return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
+            return { message: message ?? ctx.defaultError };
         }
         if (typeof ctx.data === "undefined") {
-            return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
+            return { message: message ?? required_error ?? ctx.defaultError };
         }
         if (iss.code !== "invalid_type")
             return { message: ctx.defaultError };
-        return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
+        return { message: message ?? invalid_type_error ?? ctx.defaultError };
     };
     return { errorMap: customMap, description };
 }
 class ZodType {
+    _type;
+    _output;
+    _input;
+    _def;
     get description() {
         return this._def.description;
     }
+    "~standard";
     _getType(input) {
         return getParsedType(input.data);
     }
@@ -663,14 +619,13 @@ class ZodType {
         throw result.error;
     }
     safeParse(data, params) {
-        var _a;
         const ctx = {
             common: {
                 issues: [],
-                async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                async: params?.async ?? false,
+                contextualErrorMap: params?.errorMap,
             },
-            path: (params === null || params === void 0 ? void 0 : params.path) || [],
+            path: params?.path || [],
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
@@ -680,7 +635,6 @@ class ZodType {
         return handleResult(ctx, result);
     }
     "~validate"(data) {
-        var _a, _b;
         const ctx = {
             common: {
                 issues: [],
@@ -704,7 +658,7 @@ class ZodType {
                     };
             }
             catch (err) {
-                if ((_b = (_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes("encountered")) {
+                if (err?.message?.toLowerCase()?.includes("encountered")) {
                     this["~standard"].async = true;
                 }
                 ctx.common = {
@@ -731,10 +685,10 @@ class ZodType {
         const ctx = {
             common: {
                 issues: [],
-                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                contextualErrorMap: params?.errorMap,
                 async: true,
             },
-            path: (params === null || params === void 0 ? void 0 : params.path) || [],
+            path: params?.path || [],
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
@@ -746,6 +700,8 @@ class ZodType {
             : Promise.resolve(maybeAsyncResult));
         return handleResult(ctx, result);
     }
+    /** Alias of safeParseAsync */
+    spa = this.safeParseAsync;
     refine(check, message) {
         const getIssueProperties = (val) => {
             if (typeof message === "string" || typeof message === "undefined") {
@@ -808,8 +764,6 @@ class ZodType {
         return this._refinement(refinement);
     }
     constructor(def) {
-        /** Alias of safeParseAsync */
-        this.spa = this.safeParseAsync;
         this._def = def;
         this.parse = this.parse.bind(this);
         this.safeParse = this.safeParse.bind(this);
@@ -1012,7 +966,7 @@ function isValidJWT(jwt, alg) {
             return false;
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -1183,7 +1137,7 @@ class ZodString extends ZodType {
                 try {
                     new URL(input.data);
                 }
-                catch (_a) {
+                catch {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "url",
@@ -1413,7 +1367,6 @@ class ZodString extends ZodType {
         return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
     }
     datetime(options) {
-        var _a, _b;
         if (typeof options === "string") {
             return this._addCheck({
                 kind: "datetime",
@@ -1425,10 +1378,10 @@ class ZodString extends ZodType {
         }
         return this._addCheck({
             kind: "datetime",
-            precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
-            offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
-            local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            precision: typeof options?.precision === "undefined" ? null : options?.precision,
+            offset: options?.offset ?? false,
+            local: options?.local ?? false,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     date(message) {
@@ -1444,8 +1397,8 @@ class ZodString extends ZodType {
         }
         return this._addCheck({
             kind: "time",
-            precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            precision: typeof options?.precision === "undefined" ? null : options?.precision,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     duration(message) {
@@ -1462,8 +1415,8 @@ class ZodString extends ZodType {
         return this._addCheck({
             kind: "includes",
             value: value,
-            position: options === null || options === void 0 ? void 0 : options.position,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            position: options?.position,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     startsWith(value, message) {
@@ -1594,16 +1547,15 @@ class ZodString extends ZodType {
         }
         return max;
     }
+    static create = (params) => {
+        return new ZodString({
+            checks: [],
+            typeName: ZodFirstPartyTypeKind.ZodString,
+            coerce: params?.coerce ?? false,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodString.create = (params) => {
-    var _a;
-    return new ZodString({
-        checks: [],
-        typeName: ZodFirstPartyTypeKind.ZodString,
-        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
-        ...processCreateParams(params),
-    });
-};
 // https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034
 function floatSafeRemainder(val, step) {
     const valDecCount = (val.toString().split(".")[1] || "").length;
@@ -1614,12 +1566,6 @@ function floatSafeRemainder(val, step) {
     return (valInt % stepInt) / Math.pow(10, decCount);
 }
 class ZodNumber extends ZodType {
-    constructor() {
-        super(...arguments);
-        this.min = this.gte;
-        this.max = this.lte;
-        this.step = this.multipleOf;
-    }
     _parse(input) {
         if (this._def.coerce) {
             input.data = Number(input.data);
@@ -1710,15 +1656,25 @@ class ZodNumber extends ZodType {
         }
         return { status: status.value, value: input.data };
     }
+    static create = (params) => {
+        return new ZodNumber({
+            checks: [],
+            typeName: ZodFirstPartyTypeKind.ZodNumber,
+            coerce: params?.coerce || false,
+            ...processCreateParams(params),
+        });
+    };
     gte(value, message) {
         return this.setLimit("min", value, true, errorUtil.toString(message));
     }
+    min = this.gte;
     gt(value, message) {
         return this.setLimit("min", value, false, errorUtil.toString(message));
     }
     lte(value, message) {
         return this.setLimit("max", value, true, errorUtil.toString(message));
     }
+    max = this.lte;
     lt(value, message) {
         return this.setLimit("max", value, false, errorUtil.toString(message));
     }
@@ -1787,6 +1743,7 @@ class ZodNumber extends ZodType {
             message: errorUtil.toString(message),
         });
     }
+    step = this.multipleOf;
     finite(message) {
         return this._addCheck({
             kind: "finite",
@@ -1850,26 +1807,13 @@ class ZodNumber extends ZodType {
         return Number.isFinite(min) && Number.isFinite(max);
     }
 }
-ZodNumber.create = (params) => {
-    return new ZodNumber({
-        checks: [],
-        typeName: ZodFirstPartyTypeKind.ZodNumber,
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
-        ...processCreateParams(params),
-    });
-};
 class ZodBigInt extends ZodType {
-    constructor() {
-        super(...arguments);
-        this.min = this.gte;
-        this.max = this.lte;
-    }
     _parse(input) {
         if (this._def.coerce) {
             try {
                 input.data = BigInt(input.data);
             }
-            catch (_a) {
+            catch {
                 return this._getInvalidInput(input);
             }
         }
@@ -1938,15 +1882,25 @@ class ZodBigInt extends ZodType {
         });
         return INVALID;
     }
+    static create = (params) => {
+        return new ZodBigInt({
+            checks: [],
+            typeName: ZodFirstPartyTypeKind.ZodBigInt,
+            coerce: params?.coerce ?? false,
+            ...processCreateParams(params),
+        });
+    };
     gte(value, message) {
         return this.setLimit("min", value, true, errorUtil.toString(message));
     }
+    min = this.gte;
     gt(value, message) {
         return this.setLimit("min", value, false, errorUtil.toString(message));
     }
     lte(value, message) {
         return this.setLimit("max", value, true, errorUtil.toString(message));
     }
+    max = this.lte;
     lt(value, message) {
         return this.setLimit("max", value, false, errorUtil.toString(message));
     }
@@ -2030,15 +1984,6 @@ class ZodBigInt extends ZodType {
         return max;
     }
 }
-ZodBigInt.create = (params) => {
-    var _a;
-    return new ZodBigInt({
-        checks: [],
-        typeName: ZodFirstPartyTypeKind.ZodBigInt,
-        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
-        ...processCreateParams(params),
-    });
-};
 class ZodBoolean extends ZodType {
     _parse(input) {
         if (this._def.coerce) {
@@ -2056,14 +2001,14 @@ class ZodBoolean extends ZodType {
         }
         return OK(input.data);
     }
+    static create = (params) => {
+        return new ZodBoolean({
+            typeName: ZodFirstPartyTypeKind.ZodBoolean,
+            coerce: params?.coerce || false,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodBoolean.create = (params) => {
-    return new ZodBoolean({
-        typeName: ZodFirstPartyTypeKind.ZodBoolean,
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
-        ...processCreateParams(params),
-    });
-};
 class ZodDate extends ZodType {
     _parse(input) {
         if (this._def.coerce) {
@@ -2166,15 +2111,15 @@ class ZodDate extends ZodType {
         }
         return max != null ? new Date(max) : null;
     }
+    static create = (params) => {
+        return new ZodDate({
+            checks: [],
+            coerce: params?.coerce || false,
+            typeName: ZodFirstPartyTypeKind.ZodDate,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodDate.create = (params) => {
-    return new ZodDate({
-        checks: [],
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
-        typeName: ZodFirstPartyTypeKind.ZodDate,
-        ...processCreateParams(params),
-    });
-};
 class ZodSymbol extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
@@ -2189,13 +2134,13 @@ class ZodSymbol extends ZodType {
         }
         return OK(input.data);
     }
+    static create = (params) => {
+        return new ZodSymbol({
+            typeName: ZodFirstPartyTypeKind.ZodSymbol,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodSymbol.create = (params) => {
-    return new ZodSymbol({
-        typeName: ZodFirstPartyTypeKind.ZodSymbol,
-        ...processCreateParams(params),
-    });
-};
 class ZodUndefined extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
@@ -2210,13 +2155,14 @@ class ZodUndefined extends ZodType {
         }
         return OK(input.data);
     }
+    params;
+    static create = (params) => {
+        return new ZodUndefined({
+            typeName: ZodFirstPartyTypeKind.ZodUndefined,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodUndefined.create = (params) => {
-    return new ZodUndefined({
-        typeName: ZodFirstPartyTypeKind.ZodUndefined,
-        ...processCreateParams(params),
-    });
-};
 class ZodNull extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
@@ -2231,45 +2177,39 @@ class ZodNull extends ZodType {
         }
         return OK(input.data);
     }
+    static create = (params) => {
+        return new ZodNull({
+            typeName: ZodFirstPartyTypeKind.ZodNull,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodNull.create = (params) => {
-    return new ZodNull({
-        typeName: ZodFirstPartyTypeKind.ZodNull,
-        ...processCreateParams(params),
-    });
-};
 class ZodAny extends ZodType {
-    constructor() {
-        super(...arguments);
-        // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.
-        this._any = true;
-    }
+    // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.
+    _any = true;
     _parse(input) {
         return OK(input.data);
     }
+    static create = (params) => {
+        return new ZodAny({
+            typeName: ZodFirstPartyTypeKind.ZodAny,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodAny.create = (params) => {
-    return new ZodAny({
-        typeName: ZodFirstPartyTypeKind.ZodAny,
-        ...processCreateParams(params),
-    });
-};
 class ZodUnknown extends ZodType {
-    constructor() {
-        super(...arguments);
-        // required
-        this._unknown = true;
-    }
+    // required
+    _unknown = true;
     _parse(input) {
         return OK(input.data);
     }
+    static create = (params) => {
+        return new ZodUnknown({
+            typeName: ZodFirstPartyTypeKind.ZodUnknown,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodUnknown.create = (params) => {
-    return new ZodUnknown({
-        typeName: ZodFirstPartyTypeKind.ZodUnknown,
-        ...processCreateParams(params),
-    });
-};
 class ZodNever extends ZodType {
     _parse(input) {
         const ctx = this._getOrReturnCtx(input);
@@ -2280,13 +2220,13 @@ class ZodNever extends ZodType {
         });
         return INVALID;
     }
+    static create = (params) => {
+        return new ZodNever({
+            typeName: ZodFirstPartyTypeKind.ZodNever,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodNever.create = (params) => {
-    return new ZodNever({
-        typeName: ZodFirstPartyTypeKind.ZodNever,
-        ...processCreateParams(params),
-    });
-};
 class ZodVoid extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
@@ -2301,13 +2241,13 @@ class ZodVoid extends ZodType {
         }
         return OK(input.data);
     }
+    static create = (params) => {
+        return new ZodVoid({
+            typeName: ZodFirstPartyTypeKind.ZodVoid,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodVoid.create = (params) => {
-    return new ZodVoid({
-        typeName: ZodFirstPartyTypeKind.ZodVoid,
-        ...processCreateParams(params),
-    });
-};
 class ZodArray extends ZodType {
     _parse(input) {
         const { ctx, status } = this._processInputParams(input);
@@ -2398,17 +2338,17 @@ class ZodArray extends ZodType {
     nonempty(message) {
         return this.min(1, message);
     }
+    static create = (schema, params) => {
+        return new ZodArray({
+            type: schema,
+            minLength: null,
+            maxLength: null,
+            exactLength: null,
+            typeName: ZodFirstPartyTypeKind.ZodArray,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodArray.create = (schema, params) => {
-    return new ZodArray({
-        type: schema,
-        minLength: null,
-        maxLength: null,
-        exactLength: null,
-        typeName: ZodFirstPartyTypeKind.ZodArray,
-        ...processCreateParams(params),
-    });
-};
 function deepPartialify(schema) {
     if (schema instanceof ZodObject) {
         const newShape = {};
@@ -2441,52 +2381,7 @@ function deepPartialify(schema) {
     }
 }
 class ZodObject extends ZodType {
-    constructor() {
-        super(...arguments);
-        this._cached = null;
-        /**
-         * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
-         * If you want to pass through unknown properties, use `.passthrough()` instead.
-         */
-        this.nonstrict = this.passthrough;
-        // extend<
-        //   Augmentation extends ZodRawShape,
-        //   NewOutput extends util.flatten<{
-        //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
-        //       ? Augmentation[k]["_output"]
-        //       : k extends keyof Output
-        //       ? Output[k]
-        //       : never;
-        //   }>,
-        //   NewInput extends util.flatten<{
-        //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
-        //       ? Augmentation[k]["_input"]
-        //       : k extends keyof Input
-        //       ? Input[k]
-        //       : never;
-        //   }>
-        // >(
-        //   augmentation: Augmentation
-        // ): ZodObject<
-        //   extendShape<T, Augmentation>,
-        //   UnknownKeys,
-        //   Catchall,
-        //   NewOutput,
-        //   NewInput
-        // > {
-        //   return new ZodObject({
-        //     ...this._def,
-        //     shape: () => ({
-        //       ...this._def.shape(),
-        //       ...augmentation,
-        //     }),
-        //   }) as any;
-        // }
-        /**
-         * @deprecated Use `.extend` instead
-         *  */
-        this.augment = this.extend;
-    }
+    _cached = null;
     _getCached() {
         if (this._cached !== null)
             return this._cached;
@@ -2597,11 +2492,10 @@ class ZodObject extends ZodType {
             ...(message !== undefined
                 ? {
                     errorMap: (issue, ctx) => {
-                        var _a, _b, _c, _d;
-                        const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
+                        const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
                         if (issue.code === "unrecognized_keys")
                             return {
-                                message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError,
+                                message: errorUtil.errToObj(message).message ?? defaultError,
                             };
                         return {
                             message: defaultError,
@@ -2623,6 +2517,11 @@ class ZodObject extends ZodType {
             unknownKeys: "passthrough",
         });
     }
+    /**
+     * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
+     * If you want to pass through unknown properties, use `.passthrough()` instead.
+     */
+    nonstrict = this.passthrough;
     // const AugmentFactory =
     //   <Def extends ZodObjectDef>(def: Def) =>
     //   <Augmentation extends ZodRawShape>(
@@ -2649,6 +2548,43 @@ class ZodObject extends ZodType {
             }),
         });
     }
+    // extend<
+    //   Augmentation extends ZodRawShape,
+    //   NewOutput extends util.flatten<{
+    //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+    //       ? Augmentation[k]["_output"]
+    //       : k extends keyof Output
+    //       ? Output[k]
+    //       : never;
+    //   }>,
+    //   NewInput extends util.flatten<{
+    //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+    //       ? Augmentation[k]["_input"]
+    //       : k extends keyof Input
+    //       ? Input[k]
+    //       : never;
+    //   }>
+    // >(
+    //   augmentation: Augmentation
+    // ): ZodObject<
+    //   extendShape<T, Augmentation>,
+    //   UnknownKeys,
+    //   Catchall,
+    //   NewOutput,
+    //   NewInput
+    // > {
+    //   return new ZodObject({
+    //     ...this._def,
+    //     shape: () => ({
+    //       ...this._def.shape(),
+    //       ...augmentation,
+    //     }),
+    //   }) as any;
+    // }
+    /**
+     * @deprecated Use `.extend` instead
+     *  */
+    augment = this.extend;
     /**
      * Prior to zod@1.0.12 there was a bug in the
      * inferred type of merged objects. Please
@@ -2800,34 +2736,34 @@ class ZodObject extends ZodType {
     keyof() {
         return createZodEnum(util.objectKeys(this.shape));
     }
+    static create = (shape, params) => {
+        return new ZodObject({
+            shape: () => shape,
+            unknownKeys: "strip",
+            catchall: ZodNever.create(),
+            typeName: ZodFirstPartyTypeKind.ZodObject,
+            ...processCreateParams(params),
+        });
+    };
+    static strictCreate = (shape, params) => {
+        return new ZodObject({
+            shape: () => shape,
+            unknownKeys: "strict",
+            catchall: ZodNever.create(),
+            typeName: ZodFirstPartyTypeKind.ZodObject,
+            ...processCreateParams(params),
+        });
+    };
+    static lazycreate = (shape, params) => {
+        return new ZodObject({
+            shape,
+            unknownKeys: "strip",
+            catchall: ZodNever.create(),
+            typeName: ZodFirstPartyTypeKind.ZodObject,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodObject.create = (shape, params) => {
-    return new ZodObject({
-        shape: () => shape,
-        unknownKeys: "strip",
-        catchall: ZodNever.create(),
-        typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params),
-    });
-};
-ZodObject.strictCreate = (shape, params) => {
-    return new ZodObject({
-        shape: () => shape,
-        unknownKeys: "strict",
-        catchall: ZodNever.create(),
-        typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params),
-    });
-};
-ZodObject.lazycreate = (shape, params) => {
-    return new ZodObject({
-        shape,
-        unknownKeys: "strip",
-        catchall: ZodNever.create(),
-        typeName: ZodFirstPartyTypeKind.ZodObject,
-        ...processCreateParams(params),
-    });
-};
 class ZodUnion extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
@@ -2916,14 +2852,14 @@ class ZodUnion extends ZodType {
     get options() {
         return this._def.options;
     }
+    static create = (types, params) => {
+        return new ZodUnion({
+            options: types,
+            typeName: ZodFirstPartyTypeKind.ZodUnion,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodUnion.create = (types, params) => {
-    return new ZodUnion({
-        options: types,
-        typeName: ZodFirstPartyTypeKind.ZodUnion,
-        ...processCreateParams(params),
-    });
-};
 /////////////////////////////////////////////////////
 /////////////////////////////////////////////////////
 //////////                                 //////////
@@ -3146,15 +3082,15 @@ class ZodIntersection extends ZodType {
             }));
         }
     }
+    static create = (left, right, params) => {
+        return new ZodIntersection({
+            left: left,
+            right: right,
+            typeName: ZodFirstPartyTypeKind.ZodIntersection,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodIntersection.create = (left, right, params) => {
-    return new ZodIntersection({
-        left: left,
-        right: right,
-        typeName: ZodFirstPartyTypeKind.ZodIntersection,
-        ...processCreateParams(params),
-    });
-};
 class ZodTuple extends ZodType {
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
@@ -3213,18 +3149,18 @@ class ZodTuple extends ZodType {
             rest,
         });
     }
+    static create = (schemas, params) => {
+        if (!Array.isArray(schemas)) {
+            throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+        }
+        return new ZodTuple({
+            items: schemas,
+            typeName: ZodFirstPartyTypeKind.ZodTuple,
+            rest: null,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodTuple.create = (schemas, params) => {
-    if (!Array.isArray(schemas)) {
-        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
-    }
-    return new ZodTuple({
-        items: schemas,
-        typeName: ZodFirstPartyTypeKind.ZodTuple,
-        rest: null,
-        ...processCreateParams(params),
-    });
-};
 class ZodRecord extends ZodType {
     get keySchema() {
         return this._def.keyType;
@@ -3337,15 +3273,15 @@ class ZodMap extends ZodType {
             return { status: status.value, value: finalMap };
         }
     }
+    static create = (keyType, valueType, params) => {
+        return new ZodMap({
+            valueType,
+            keyType,
+            typeName: ZodFirstPartyTypeKind.ZodMap,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodMap.create = (keyType, valueType, params) => {
-    return new ZodMap({
-        valueType,
-        keyType,
-        typeName: ZodFirstPartyTypeKind.ZodMap,
-        ...processCreateParams(params),
-    });
-};
 class ZodSet extends ZodType {
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
@@ -3422,21 +3358,17 @@ class ZodSet extends ZodType {
     nonempty(message) {
         return this.min(1, message);
     }
+    static create = (valueType, params) => {
+        return new ZodSet({
+            valueType,
+            minSize: null,
+            maxSize: null,
+            typeName: ZodFirstPartyTypeKind.ZodSet,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodSet.create = (valueType, params) => {
-    return new ZodSet({
-        valueType,
-        minSize: null,
-        maxSize: null,
-        typeName: ZodFirstPartyTypeKind.ZodSet,
-        ...processCreateParams(params),
-    });
-};
 class ZodFunction extends ZodType {
-    constructor() {
-        super(...arguments);
-        this.validate = this.implement;
-    }
     _parse(input) {
         const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.function) {
@@ -3549,6 +3481,7 @@ class ZodFunction extends ZodType {
         const validatedFunc = this.parse(func);
         return validatedFunc;
     }
+    validate = this.implement;
     static create(args, returns, params) {
         return new ZodFunction({
             args: (args
@@ -3569,14 +3502,14 @@ class ZodLazy extends ZodType {
         const lazySchema = this._def.getter();
         return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
     }
+    static create = (getter, params) => {
+        return new ZodLazy({
+            getter: getter,
+            typeName: ZodFirstPartyTypeKind.ZodLazy,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodLazy.create = (getter, params) => {
-    return new ZodLazy({
-        getter: getter,
-        typeName: ZodFirstPartyTypeKind.ZodLazy,
-        ...processCreateParams(params),
-    });
-};
 class ZodLiteral extends ZodType {
     _parse(input) {
         if (input.data !== this._def.value) {
@@ -3593,14 +3526,14 @@ class ZodLiteral extends ZodType {
     get value() {
         return this._def.value;
     }
+    static create = (value, params) => {
+        return new ZodLiteral({
+            value: value,
+            typeName: ZodFirstPartyTypeKind.ZodLiteral,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodLiteral.create = (value, params) => {
-    return new ZodLiteral({
-        value: value,
-        typeName: ZodFirstPartyTypeKind.ZodLiteral,
-        ...processCreateParams(params),
-    });
-};
 function createZodEnum(values, params) {
     return new ZodEnum({
         values,
@@ -3609,10 +3542,7 @@ function createZodEnum(values, params) {
     });
 }
 class ZodEnum extends ZodType {
-    constructor() {
-        super(...arguments);
-        _ZodEnum_cache.set(this, void 0);
-    }
+    #cache;
     _parse(input) {
         if (typeof input.data !== "string") {
             const ctx = this._getOrReturnCtx(input);
@@ -3624,10 +3554,10 @@ class ZodEnum extends ZodType {
             });
             return INVALID;
         }
-        if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f")) {
-            __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values), "f");
+        if (!this.#cache) {
+            this.#cache = new Set(this._def.values);
         }
-        if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f").has(input.data)) {
+        if (!this.#cache.has(input.data)) {
             const ctx = this._getOrReturnCtx(input);
             const expectedValues = this._def.values;
             addIssueToContext(ctx, {
@@ -3675,14 +3605,10 @@ class ZodEnum extends ZodType {
             ...newDef,
         });
     }
+    static create = createZodEnum;
 }
-_ZodEnum_cache = new WeakMap();
-ZodEnum.create = createZodEnum;
 class ZodNativeEnum extends ZodType {
-    constructor() {
-        super(...arguments);
-        _ZodNativeEnum_cache.set(this, void 0);
-    }
+    #cache;
     _parse(input) {
         const nativeEnumValues = util.getValidEnumValues(this._def.values);
         const ctx = this._getOrReturnCtx(input);
@@ -3696,10 +3622,10 @@ class ZodNativeEnum extends ZodType {
             });
             return INVALID;
         }
-        if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f")) {
-            __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)), "f");
+        if (!this.#cache) {
+            this.#cache = new Set(util.getValidEnumValues(this._def.values));
         }
-        if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f").has(input.data)) {
+        if (!this.#cache.has(input.data)) {
             const expectedValues = util.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
                 received: ctx.data,
@@ -3713,15 +3639,14 @@ class ZodNativeEnum extends ZodType {
     get enum() {
         return this._def.values;
     }
+    static create = (values, params) => {
+        return new ZodNativeEnum({
+            values: values,
+            typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
+            ...processCreateParams(params),
+        });
+    };
 }
-_ZodNativeEnum_cache = new WeakMap();
-ZodNativeEnum.create = (values, params) => {
-    return new ZodNativeEnum({
-        values: values,
-        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
-        ...processCreateParams(params),
-    });
-};
 class ZodPromise extends ZodType {
     unwrap() {
         return this._def.type;
@@ -3747,14 +3672,14 @@ class ZodPromise extends ZodType {
             });
         }));
     }
+    static create = (schema, params) => {
+        return new ZodPromise({
+            type: schema,
+            typeName: ZodFirstPartyTypeKind.ZodPromise,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodPromise.create = (schema, params) => {
-    return new ZodPromise({
-        type: schema,
-        typeName: ZodFirstPartyTypeKind.ZodPromise,
-        ...processCreateParams(params),
-    });
-};
 class ZodEffects extends ZodType {
     innerType() {
         return this._def.schema;
@@ -3885,23 +3810,23 @@ class ZodEffects extends ZodType {
         }
         util.assertNever(effect);
     }
+    static create = (schema, effect, params) => {
+        return new ZodEffects({
+            schema,
+            typeName: ZodFirstPartyTypeKind.ZodEffects,
+            effect,
+            ...processCreateParams(params),
+        });
+    };
+    static createWithPreprocess = (preprocess, schema, params) => {
+        return new ZodEffects({
+            schema,
+            effect: { type: "preprocess", transform: preprocess },
+            typeName: ZodFirstPartyTypeKind.ZodEffects,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodEffects.create = (schema, effect, params) => {
-    return new ZodEffects({
-        schema,
-        typeName: ZodFirstPartyTypeKind.ZodEffects,
-        effect,
-        ...processCreateParams(params),
-    });
-};
-ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
-    return new ZodEffects({
-        schema,
-        effect: { type: "preprocess", transform: preprocess },
-        typeName: ZodFirstPartyTypeKind.ZodEffects,
-        ...processCreateParams(params),
-    });
-};
 class ZodOptional extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
@@ -3913,14 +3838,14 @@ class ZodOptional extends ZodType {
     unwrap() {
         return this._def.innerType;
     }
+    static create = (type, params) => {
+        return new ZodOptional({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind.ZodOptional,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodOptional.create = (type, params) => {
-    return new ZodOptional({
-        innerType: type,
-        typeName: ZodFirstPartyTypeKind.ZodOptional,
-        ...processCreateParams(params),
-    });
-};
 class ZodNullable extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
@@ -3932,14 +3857,14 @@ class ZodNullable extends ZodType {
     unwrap() {
         return this._def.innerType;
     }
+    static create = (type, params) => {
+        return new ZodNullable({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind.ZodNullable,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodNullable.create = (type, params) => {
-    return new ZodNullable({
-        innerType: type,
-        typeName: ZodFirstPartyTypeKind.ZodNullable,
-        ...processCreateParams(params),
-    });
-};
 class ZodDefault extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
@@ -3956,17 +3881,17 @@ class ZodDefault extends ZodType {
     removeDefault() {
         return this._def.innerType;
     }
+    static create = (type, params) => {
+        return new ZodDefault({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind.ZodDefault,
+            defaultValue: typeof params.default === "function"
+                ? params.default
+                : () => params.default,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodDefault.create = (type, params) => {
-    return new ZodDefault({
-        innerType: type,
-        typeName: ZodFirstPartyTypeKind.ZodDefault,
-        defaultValue: typeof params.default === "function"
-            ? params.default
-            : () => params.default,
-        ...processCreateParams(params),
-    });
-};
 class ZodCatch extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
@@ -4017,15 +3942,15 @@ class ZodCatch extends ZodType {
     removeCatch() {
         return this._def.innerType;
     }
+    static create = (type, params) => {
+        return new ZodCatch({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind.ZodCatch,
+            catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodCatch.create = (type, params) => {
-    return new ZodCatch({
-        innerType: type,
-        typeName: ZodFirstPartyTypeKind.ZodCatch,
-        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
-        ...processCreateParams(params),
-    });
-};
 class ZodNaN extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
@@ -4040,13 +3965,13 @@ class ZodNaN extends ZodType {
         }
         return { status: "valid", value: input.data };
     }
+    static create = (params) => {
+        return new ZodNaN({
+            typeName: ZodFirstPartyTypeKind.ZodNaN,
+            ...processCreateParams(params),
+        });
+    };
 }
-ZodNaN.create = (params) => {
-    return new ZodNaN({
-        typeName: ZodFirstPartyTypeKind.ZodNaN,
-        ...processCreateParams(params),
-    });
-};
 const BRAND = Symbol("zod_brand");
 class ZodBranded extends ZodType {
     _parse(input) {
@@ -4133,17 +4058,17 @@ class ZodReadonly extends ZodType {
             ? result.then((data) => freeze(data))
             : freeze(result);
     }
+    static create = (type, params) => {
+        return new ZodReadonly({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind.ZodReadonly,
+            ...processCreateParams(params),
+        });
+    };
     unwrap() {
         return this._def.innerType;
     }
 }
-ZodReadonly.create = (type, params) => {
-    return new ZodReadonly({
-        innerType: type,
-        typeName: ZodFirstPartyTypeKind.ZodReadonly,
-        ...processCreateParams(params),
-    });
-};
 function custom(check, params = {}, 
 /**
  * @deprecated
@@ -4158,14 +4083,13 @@ function custom(check, params = {},
 fatal) {
     if (check)
         return ZodAny.create().superRefine((data, ctx) => {
-            var _a, _b;
             if (!check(data)) {
                 const p = typeof params === "function"
                     ? params(data)
                     : typeof params === "string"
                         ? { message: params }
                         : params;
-                const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
+                const _fatal = p.fatal ?? fatal ?? true;
                 const p2 = typeof p === "string" ? { message: p } : p;
                 ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/zod",
-  "version": "3.24.1-rc.2",
+  "version": "3.24.1-rc.3",
   "author": "Colin McDonnell <colin@colinhacks.com>",
   "repository": {
     "type": "git",