zod 3.20.6 → 3.21.4

package/lib/index.umd.js

@@ -67,6 +67,15 @@
             return value;
         };
     })(exports.util || (exports.util = {}));
+    exports.objectUtil = void 0;
+    (function (objectUtil) {
+        objectUtil.mergeShapes = (first, second) => {
+            return {
+                ...first,
+                ...second, // second overwrites first
+            };
+        };
+    })(exports.objectUtil || (exports.objectUtil = {}));
     const ZodParsedType = exports.util.arrayToEnum([
         "string",
         "nan",
@@ -298,7 +307,13 @@
                 break;
             case ZodIssueCode.invalid_string:
                 if (typeof issue.validation === "object") {
-                    if ("startsWith" in issue.validation) {
+                    if ("includes" in issue.validation) {
+                        message = `Invalid input: must include "${issue.validation.includes}"`;
+                        if (typeof issue.validation.position === "number") {
+                            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+                        }
+                    }
+                    else if ("startsWith" in issue.validation) {
                         message = `Invalid input: must start with "${issue.validation.startsWith}"`;
                     }
                     else if ("endsWith" in issue.validation) {
@@ -331,7 +346,7 @@
                     ? `exactly equal to `
                     : issue.inclusive
                         ? `greater than or equal to `
-                        : `greater than `}${new Date(issue.minimum)}`;
+                        : `greater than `}${new Date(Number(issue.minimum))}`;
                 else
                     message = "Invalid input";
                 break;
@@ -346,12 +361,18 @@
                     : issue.inclusive
                         ? `less than or equal to`
                         : `less than`} ${issue.maximum}`;
+                else if (issue.type === "bigint")
+                    message = `BigInt must be ${issue.exact
+                    ? `exactly`
+                    : issue.inclusive
+                        ? `less than or equal to`
+                        : `less than`} ${issue.maximum}`;
                 else if (issue.type === "date")
                     message = `Date must be ${issue.exact
                     ? `exactly`
                     : issue.inclusive
                         ? `smaller than or equal to`
-                        : `smaller than`} ${new Date(issue.maximum)}`;
+                        : `smaller than`} ${new Date(Number(issue.maximum))}`;
                 else
                     message = "Invalid input";
                 break;
@@ -488,13 +509,22 @@
 
     class ParseInputLazyPath {
         constructor(parent, value, path, key) {
+            this._cachedPath = [];
             this.parent = parent;
             this.data = value;
             this._path = path;
             this._key = key;
         }
         get path() {
-            return this._path.concat(this._key);
+            if (!this._cachedPath.length) {
+                if (this._key instanceof Array) {
+                    this._cachedPath.push(...this._path, ...this._key);
+                }
+                else {
+                    this._cachedPath.push(...this._path, this._key);
+                }
+            }
+            return this._cachedPath;
         }
     }
     const handleResult = (ctx, result) => {
@@ -505,8 +535,16 @@
             if (!ctx.common.issues.length) {
                 throw new Error("Validation failed but no issues detected.");
             }
-            const error = new ZodError(ctx.common.issues);
-            return { success: false, error };
+            return {
+                success: false,
+                get error() {
+                    if (this._error)
+                        return this._error;
+                    const error = new ZodError(ctx.common.issues);
+                    this._error = error;
+                    return this._error;
+                },
+            };
         }
     };
     function processCreateParams(params) {
@@ -779,6 +817,7 @@
     }
     const cuidRegex = /^c[^\s-]{8,}$/i;
     const cuid2Regex = /^[a-z][a-z0-9]*$/;
+    const ulidRegex = /[0-9A-HJKMNP-TV-Z]{26}/;
     const uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
     // from https://stackoverflow.com/a/46181/1550155
     // old version: too slow, didn't support unicode
@@ -786,13 +825,11 @@
     //old email regex
     // const emailRegex = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@((?!-)([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{1,})[^-<>()[\].,;:\s@"]$/i;
     // eslint-disable-next-line
-    const emailRegex = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|([^-]([a-zA-Z0-9-]*\.)+[a-zA-Z]{2,}))$/;
-    // interface IsDateStringOptions extends StringDateOptions {
-    /**
-     * Match any configuration
-     */
-    // any?: boolean;
-    // }
+    const emailRegex = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\])|(\[IPv6:(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))\])|([A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])*(\.[A-Za-z]{2,})+))$/;
+    // from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
+    const emojiRegex = /^(\p{Extended_Pictographic}|\p{Emoji_Component})+$/u;
+    const ipv4Regex = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
+    const ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;
     // Adapted from https://stackoverflow.com/a/3143231
     const datetimeRegex = (args) => {
         if (args.precision) {
@@ -820,6 +857,15 @@
             }
         }
     };
+    function isValidIP(ip, version) {
+        if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
+            return true;
+        }
+        if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
+            return true;
+        }
+        return false;
+    }
     class ZodString extends ZodType {
         constructor() {
             super(...arguments);
@@ -837,6 +883,14 @@
                 ...this._def,
                 checks: [...this._def.checks, { kind: "trim" }],
             });
+            this.toLowerCase = () => new ZodString({
+                ...this._def,
+                checks: [...this._def.checks, { kind: "toLowerCase" }],
+            });
+            this.toUpperCase = () => new ZodString({
+                ...this._def,
+                checks: [...this._def.checks, { kind: "toUpperCase" }],
+            });
         }
         _parse(input) {
             if (this._def.coerce) {
@@ -924,6 +978,17 @@
                         status.dirty();
                     }
                 }
+                else if (check.kind === "emoji") {
+                    if (!emojiRegex.test(input.data)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            validation: "emoji",
+                            code: ZodIssueCode.invalid_string,
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
                 else if (check.kind === "uuid") {
                     if (!uuidRegex.test(input.data)) {
                         ctx = this._getOrReturnCtx(input, ctx);
@@ -957,6 +1022,17 @@
                         status.dirty();
                     }
                 }
+                else if (check.kind === "ulid") {
+                    if (!ulidRegex.test(input.data)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            validation: "ulid",
+                            code: ZodIssueCode.invalid_string,
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
                 else if (check.kind === "url") {
                     try {
                         new URL(input.data);
@@ -987,6 +1063,23 @@
                 else if (check.kind === "trim") {
                     input.data = input.data.trim();
                 }
+                else if (check.kind === "includes") {
+                    if (!input.data.includes(check.value, check.position)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.invalid_string,
+                            validation: { includes: check.value, position: check.position },
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
+                else if (check.kind === "toLowerCase") {
+                    input.data = input.data.toLowerCase();
+                }
+                else if (check.kind === "toUpperCase") {
+                    input.data = input.data.toUpperCase();
+                }
                 else if (check.kind === "startsWith") {
                     if (!input.data.startsWith(check.value)) {
                         ctx = this._getOrReturnCtx(input, ctx);
@@ -1021,6 +1114,17 @@
                         status.dirty();
                     }
                 }
+                else if (check.kind === "ip") {
+                    if (!isValidIP(input.data, check.version)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            validation: "ip",
+                            code: ZodIssueCode.invalid_string,
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
                 else {
                     exports.util.assertNever(check);
                 }
@@ -1039,6 +1143,9 @@
         url(message) {
             return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
         }
+        emoji(message) {
+            return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
+        }
         uuid(message) {
             return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
         }
@@ -1048,6 +1155,12 @@
         cuid2(message) {
             return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
         }
+        ulid(message) {
+            return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
+        }
+        ip(options) {
+            return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
+        }
         datetime(options) {
             var _a;
             if (typeof options === "string") {
@@ -1072,6 +1185,14 @@
                 ...errorUtil.errToObj(message),
             });
         }
+        includes(value, options) {
+            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),
+            });
+        }
         startsWith(value, message) {
             return this._addCheck({
                 kind: "startsWith",
@@ -1116,6 +1237,9 @@
         get isURL() {
             return !!this._def.checks.find((ch) => ch.kind === "url");
         }
+        get isEmoji() {
+            return !!this._def.checks.find((ch) => ch.kind === "emoji");
+        }
         get isUUID() {
             return !!this._def.checks.find((ch) => ch.kind === "uuid");
         }
@@ -1125,6 +1249,12 @@
         get isCUID2() {
             return !!this._def.checks.find((ch) => ch.kind === "cuid2");
         }
+        get isULID() {
+            return !!this._def.checks.find((ch) => ch.kind === "ulid");
+        }
+        get isIP() {
+            return !!this._def.checks.find((ch) => ch.kind === "ip");
+        }
         get minLength() {
             let min = null;
             for (const ch of this._def.checks) {
@@ -1344,6 +1474,19 @@
                 message: errorUtil.toString(message),
             });
         }
+        safe(message) {
+            return this._addCheck({
+                kind: "min",
+                inclusive: true,
+                value: Number.MIN_SAFE_INTEGER,
+                message: errorUtil.toString(message),
+            })._addCheck({
+                kind: "max",
+                inclusive: true,
+                value: Number.MAX_SAFE_INTEGER,
+                message: errorUtil.toString(message),
+            });
+        }
         get minValue() {
             let min = null;
             for (const ch of this._def.checks) {
@@ -1397,6 +1540,11 @@
         });
     };
     class ZodBigInt extends ZodType {
+        constructor() {
+            super(...arguments);
+            this.min = this.gte;
+            this.max = this.lte;
+        }
         _parse(input) {
             if (this._def.coerce) {
                 input.data = BigInt(input.data);
@@ -1411,12 +1559,154 @@
                 });
                 return INVALID;
             }
-            return OK(input.data);
+            let ctx = undefined;
+            const status = new ParseStatus();
+            for (const check of this._def.checks) {
+                if (check.kind === "min") {
+                    const tooSmall = check.inclusive
+                        ? input.data < check.value
+                        : input.data <= check.value;
+                    if (tooSmall) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.too_small,
+                            type: "bigint",
+                            minimum: check.value,
+                            inclusive: check.inclusive,
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
+                else if (check.kind === "max") {
+                    const tooBig = check.inclusive
+                        ? input.data > check.value
+                        : input.data >= check.value;
+                    if (tooBig) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.too_big,
+                            type: "bigint",
+                            maximum: check.value,
+                            inclusive: check.inclusive,
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
+                else if (check.kind === "multipleOf") {
+                    if (input.data % check.value !== BigInt(0)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.not_multiple_of,
+                            multipleOf: check.value,
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
+                else {
+                    exports.util.assertNever(check);
+                }
+            }
+            return { status: status.value, value: input.data };
+        }
+        gte(value, message) {
+            return this.setLimit("min", value, true, errorUtil.toString(message));
+        }
+        gt(value, message) {
+            return this.setLimit("min", value, false, errorUtil.toString(message));
+        }
+        lte(value, message) {
+            return this.setLimit("max", value, true, errorUtil.toString(message));
+        }
+        lt(value, message) {
+            return this.setLimit("max", value, false, errorUtil.toString(message));
+        }
+        setLimit(kind, value, inclusive, message) {
+            return new ZodBigInt({
+                ...this._def,
+                checks: [
+                    ...this._def.checks,
+                    {
+                        kind,
+                        value,
+                        inclusive,
+                        message: errorUtil.toString(message),
+                    },
+                ],
+            });
+        }
+        _addCheck(check) {
+            return new ZodBigInt({
+                ...this._def,
+                checks: [...this._def.checks, check],
+            });
+        }
+        positive(message) {
+            return this._addCheck({
+                kind: "min",
+                value: BigInt(0),
+                inclusive: false,
+                message: errorUtil.toString(message),
+            });
+        }
+        negative(message) {
+            return this._addCheck({
+                kind: "max",
+                value: BigInt(0),
+                inclusive: false,
+                message: errorUtil.toString(message),
+            });
+        }
+        nonpositive(message) {
+            return this._addCheck({
+                kind: "max",
+                value: BigInt(0),
+                inclusive: true,
+                message: errorUtil.toString(message),
+            });
+        }
+        nonnegative(message) {
+            return this._addCheck({
+                kind: "min",
+                value: BigInt(0),
+                inclusive: true,
+                message: errorUtil.toString(message),
+            });
+        }
+        multipleOf(value, message) {
+            return this._addCheck({
+                kind: "multipleOf",
+                value,
+                message: errorUtil.toString(message),
+            });
+        }
+        get minValue() {
+            let min = null;
+            for (const ch of this._def.checks) {
+                if (ch.kind === "min") {
+                    if (min === null || ch.value > min)
+                        min = ch.value;
+                }
+            }
+            return min;
+        }
+        get maxValue() {
+            let max = null;
+            for (const ch of this._def.checks) {
+                if (ch.kind === "max") {
+                    if (max === null || ch.value < max)
+                        max = ch.value;
+                }
+            }
+            return max;
         }
     }
     ZodBigInt.create = (params) => {
         var _a;
         return new ZodBigInt({
+            checks: [],
             typeName: exports.ZodFirstPartyTypeKind.ZodBigInt,
             coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
             ...processCreateParams(params),
@@ -1792,22 +2082,6 @@
             ...processCreateParams(params),
         });
     };
-    /////////////////////////////////////////
-    /////////////////////////////////////////
-    //////////                     //////////
-    //////////      ZodObject      //////////
-    //////////                     //////////
-    /////////////////////////////////////////
-    /////////////////////////////////////////
-    exports.objectUtil = void 0;
-    (function (objectUtil) {
-        objectUtil.mergeShapes = (first, second) => {
-            return {
-                ...first,
-                ...second, // second overwrites first
-            };
-        };
-    })(exports.objectUtil || (exports.objectUtil = {}));
     function deepPartialify(schema) {
         if (schema instanceof ZodObject) {
             const newShape = {};
@@ -1821,7 +2095,10 @@
             });
         }
         else if (schema instanceof ZodArray) {
-            return ZodArray.create(deepPartialify(schema.element));
+            return new ZodArray({
+                ...schema._def,
+                type: deepPartialify(schema.element),
+            });
         }
         else if (schema instanceof ZodOptional) {
             return ZodOptional.create(deepPartialify(schema.unwrap()));
@@ -2053,7 +2330,10 @@
             const merged = new ZodObject({
                 unknownKeys: merging._def.unknownKeys,
                 catchall: merging._def.catchall,
-                shape: () => exports.objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+                shape: () => ({
+                    ...this._def.shape(),
+                    ...merging._def.shape(),
+                }),
                 typeName: exports.ZodFirstPartyTypeKind.ZodObject,
             });
             return merged;
@@ -2147,6 +2427,9 @@
                 shape: () => shape,
             });
         }
+        /**
+         * @deprecated
+         */
         deepPartial() {
             return deepPartialify(this);
         }
@@ -3186,10 +3469,6 @@
                         path: ctx.path,
                         parent: ctx,
                     });
-                    // if (base.status === "aborted") return INVALID;
-                    // if (base.status === "dirty") {
-                    //   return { status: "dirty", value: base.value };
-                    // }
                     if (!isValid(base))
                         return base;
                     const result = effect.transform(base.value, checkCtx);
@@ -3204,10 +3483,6 @@
                         .then((base) => {
                         if (!isValid(base))
                             return base;
-                        // if (base.status === "aborted") return INVALID;
-                        // if (base.status === "dirty") {
-                        //   return { status: "dirty", value: base.value };
-                        // }
                         return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
                     });
                 }
@@ -3299,29 +3574,47 @@
     class ZodCatch extends ZodType {
         _parse(input) {
             const { ctx } = this._processInputParams(input);
+            // newCtx is used to not collect issues from inner types in ctx
+            const newCtx = {
+                ...ctx,
+                common: {
+                    ...ctx.common,
+                    issues: [],
+                },
+            };
             const result = this._def.innerType._parse({
-                data: ctx.data,
-                path: ctx.path,
+                data: newCtx.data,
+                path: newCtx.path,
                 parent: {
-                    ...ctx,
-                    common: {
-                        ...ctx.common,
-                        issues: [], // don't collect issues from inner type
-                    },
+                    ...newCtx,
                 },
             });
             if (isAsync(result)) {
                 return result.then((result) => {
                     return {
                         status: "valid",
-                        value: result.status === "valid" ? result.value : this._def.catchValue(),
+                        value: result.status === "valid"
+                            ? result.value
+                            : this._def.catchValue({
+                                get error() {
+                                    return new ZodError(newCtx.common.issues);
+                                },
+                                input: newCtx.data,
+                            }),
                     };
                 });
             }
             else {
                 return {
                     status: "valid",
-                    value: result.status === "valid" ? result.value : this._def.catchValue(),
+                    value: result.status === "valid"
+                        ? result.value
+                        : this._def.catchValue({
+                            get error() {
+                                return new ZodError(newCtx.common.issues);
+                            },
+                            input: newCtx.data,
+                        }),
                 };
             }
         }
@@ -3431,13 +3724,30 @@
             });
         }
     }
-    const custom = (check, params = {}, fatal) => {
+    const custom = (check, params = {}, 
+    /*
+     * @deprecated
+     *
+     * Pass `fatal` into the params object instead:
+     *
+     * ```ts
+     * z.string().custom((val) => val.length > 5, { fatal: false })
+     * ```
+     *
+     */
+    fatal) => {
         if (check)
             return ZodAny.create().superRefine((data, ctx) => {
+                var _a, _b;
                 if (!check(data)) {
-                    const p = typeof params === "function" ? params(data) : params;
+                    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 p2 = typeof p === "string" ? { message: p } : p;
-                    ctx.addIssue({ code: "custom", ...p2, fatal });
+                    ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
                 }
             });
         return ZodAny.create();
@@ -3487,7 +3797,7 @@
     // const instanceOfType = <T extends new (...args: any[]) => any>(
     cls, params = {
         message: `Input not instance of ${cls.name}`,
-    }) => custom((data) => data instanceof cls, params, true);
+    }) => custom((data) => data instanceof cls, params);
     const stringType = ZodString.create;
     const numberType = ZodNumber.create;
     const nanType = ZodNaN.create;
@@ -3537,7 +3847,7 @@
     };
     const NEVER = INVALID;
 
-    var mod = /*#__PURE__*/Object.freeze({
+    var z = /*#__PURE__*/Object.freeze({
         __proto__: null,
         defaultErrorMap: errorMap,
         setErrorMap: setErrorMap,
@@ -3554,6 +3864,7 @@
         isValid: isValid,
         isAsync: isAsync,
         get util () { return exports.util; },
+        get objectUtil () { return exports.objectUtil; },
         ZodParsedType: ZodParsedType,
         getParsedType: getParsedType,
         ZodType: ZodType,
@@ -3570,7 +3881,6 @@
         ZodNever: ZodNever,
         ZodVoid: ZodVoid,
         ZodArray: ZodArray,
-        get objectUtil () { return exports.objectUtil; },
         ZodObject: ZodObject,
         ZodUnion: ZodUnion,
         ZodDiscriminatedUnion: ZodDiscriminatedUnion,
@@ -3703,7 +4013,7 @@
     exports.coerce = coerce;
     exports.custom = custom;
     exports.date = dateType;
-    exports["default"] = mod;
+    exports["default"] = z;
     exports.defaultErrorMap = errorMap;
     exports.discriminatedUnion = discriminatedUnionType;
     exports.effect = effectsType;
@@ -3749,7 +4059,7 @@
     exports.union = unionType;
     exports.unknown = unknownType;
     exports["void"] = voidType;
-    exports.z = mod;
+    exports.z = z;
 
     Object.defineProperty(exports, '__esModule', { value: true });