zod 3.14.0 → 3.14.1

package/lib/index.mjs

@@ -343,13 +343,13 @@ function addIssueToContext(ctx, issueData) {
         data: ctx.data,
         path: ctx.path,
         errorMaps: [
-            ctx.contextualErrorMap,
+            ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
             overrideErrorMap,
             defaultErrorMap, // then global default map
         ].filter((x) => !!x),
     });
-    ctx.issues.push(issue);
+    ctx.common.issues.push(issue);
 }
 class ParseStatus {
     constructor() {
@@ -424,10 +424,10 @@ const handleResult = (ctx, result) => {
         return { success: true, data: result.value };
     }
     else {
-        if (!ctx.issues.length) {
+        if (!ctx.common.issues.length) {
             throw new Error("Validation failed but no issues detected.");
         }
-        const error = new ZodError(ctx.issues);
+        const error = new ZodError(ctx.common.issues);
         return { success: false, error };
     }
 };
@@ -481,11 +481,24 @@ class ZodType {
     get description() {
         return this._def.description;
     }
+    _getType(input) {
+        return getParsedType(input.data);
+    }
+    _getOrReturnCtx(input, ctx) {
+        return (ctx || {
+            common: input.parent.common,
+            data: input.data,
+            parsedType: getParsedType(input.data),
+            schemaErrorMap: this._def.errorMap,
+            path: input.path,
+            parent: input.parent,
+        });
+    }
     _processInputParams(input) {
         return {
             status: new ParseStatus(),
             ctx: {
-                ...input.parent,
+                common: input.parent.common,
                 data: input.data,
                 parsedType: getParsedType(input.data),
                 schemaErrorMap: this._def.errorMap,
@@ -514,11 +527,14 @@ class ZodType {
     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,
+                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
+                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+            },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
-            issues: [],
-            contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
             schemaErrorMap: this._def.errorMap,
-            async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
             parent: null,
             data,
             parsedType: getParsedType(data),
@@ -534,11 +550,14 @@ class ZodType {
     }
     async safeParseAsync(data, params) {
         const ctx = {
+            common: {
+                issues: [],
+                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                async: true,
+                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
+            },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
-            issues: [],
-            contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
             schemaErrorMap: this._def.errorMap,
-            async: true,
             parent: null,
             data,
             parsedType: getParsedType(data),
@@ -679,8 +698,9 @@ class ZodString extends ZodType {
         this.nonempty = (message) => this.min(1, errorUtil.errToObj(message));
     }
     _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.string) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.string) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.string,
@@ -690,9 +710,12 @@ class ZodString extends ZodType {
             );
             return INVALID;
         }
+        const status = new ParseStatus();
+        let ctx = undefined;
         for (const check of this._def.checks) {
             if (check.kind === "min") {
-                if (ctx.data.length < check.value) {
+                if (input.data.length < check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         code: ZodIssueCode.too_small,
                         minimum: check.value,
@@ -704,7 +727,8 @@ class ZodString extends ZodType {
                 }
             }
             else if (check.kind === "max") {
-                if (ctx.data.length > check.value) {
+                if (input.data.length > check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         code: ZodIssueCode.too_big,
                         maximum: check.value,
@@ -716,7 +740,8 @@ class ZodString extends ZodType {
                 }
             }
             else if (check.kind === "email") {
-                if (!emailRegex.test(ctx.data)) {
+                if (!emailRegex.test(input.data)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "email",
                         code: ZodIssueCode.invalid_string,
@@ -726,7 +751,8 @@ class ZodString extends ZodType {
                 }
             }
             else if (check.kind === "uuid") {
-                if (!uuidRegex.test(ctx.data)) {
+                if (!uuidRegex.test(input.data)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "uuid",
                         code: ZodIssueCode.invalid_string,
@@ -736,7 +762,8 @@ class ZodString extends ZodType {
                 }
             }
             else if (check.kind === "cuid") {
-                if (!cuidRegex.test(ctx.data)) {
+                if (!cuidRegex.test(input.data)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "cuid",
                         code: ZodIssueCode.invalid_string,
@@ -747,9 +774,10 @@ class ZodString extends ZodType {
             }
             else if (check.kind === "url") {
                 try {
-                    new URL(ctx.data);
+                    new URL(input.data);
                 }
                 catch (_a) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "url",
                         code: ZodIssueCode.invalid_string,
@@ -760,8 +788,9 @@ class ZodString extends ZodType {
             }
             else if (check.kind === "regex") {
                 check.regex.lastIndex = 0;
-                const testResult = check.regex.test(ctx.data);
+                const testResult = check.regex.test(input.data);
                 if (!testResult) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "regex",
                         code: ZodIssueCode.invalid_string,
@@ -771,7 +800,7 @@ class ZodString extends ZodType {
                 }
             }
         }
-        return { status: status.value, value: ctx.data };
+        return { status: status.value, value: input.data };
     }
     _addCheck(check) {
         return new ZodString({
@@ -874,8 +903,9 @@ class ZodNumber extends ZodType {
         this.step = this.multipleOf;
     }
     _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.number) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.number) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.number,
@@ -883,9 +913,12 @@ class ZodNumber extends ZodType {
             });
             return INVALID;
         }
+        let ctx = undefined;
+        const status = new ParseStatus();
         for (const check of this._def.checks) {
             if (check.kind === "int") {
-                if (!util.isInteger(ctx.data)) {
+                if (!util.isInteger(input.data)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         code: ZodIssueCode.invalid_type,
                         expected: "integer",
@@ -897,9 +930,10 @@ class ZodNumber extends ZodType {
             }
             else if (check.kind === "min") {
                 const tooSmall = check.inclusive
-                    ? ctx.data < check.value
-                    : ctx.data <= check.value;
+                    ? input.data < check.value
+                    : input.data <= check.value;
                 if (tooSmall) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         code: ZodIssueCode.too_small,
                         minimum: check.value,
@@ -912,9 +946,10 @@ class ZodNumber extends ZodType {
             }
             else if (check.kind === "max") {
                 const tooBig = check.inclusive
-                    ? ctx.data > check.value
-                    : ctx.data >= check.value;
+                    ? input.data > check.value
+                    : input.data >= check.value;
                 if (tooBig) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         code: ZodIssueCode.too_big,
                         maximum: check.value,
@@ -926,7 +961,8 @@ class ZodNumber extends ZodType {
                 }
             }
             else if (check.kind === "multipleOf") {
-                if (floatSafeRemainder(ctx.data, check.value) !== 0) {
+                if (floatSafeRemainder(input.data, check.value) !== 0) {
+                    ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         code: ZodIssueCode.not_multiple_of,
                         multipleOf: check.value,
@@ -939,7 +975,7 @@ class ZodNumber extends ZodType {
                 util.assertNever(check);
             }
         }
-        return { status: status.value, value: ctx.data };
+        return { status: status.value, value: input.data };
     }
     gte(value, message) {
         return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -1051,8 +1087,9 @@ ZodNumber.create = (params) => {
 };
 class ZodBigInt extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.bigint) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.bigint) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.bigint,
@@ -1060,7 +1097,7 @@ class ZodBigInt extends ZodType {
             });
             return INVALID;
         }
-        return OK(ctx.data);
+        return OK(input.data);
     }
 }
 ZodBigInt.create = (params) => {
@@ -1071,8 +1108,9 @@ ZodBigInt.create = (params) => {
 };
 class ZodBoolean extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.boolean) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.boolean) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.boolean,
@@ -1080,7 +1118,7 @@ class ZodBoolean extends ZodType {
             });
             return INVALID;
         }
-        return OK(ctx.data);
+        return OK(input.data);
     }
 }
 ZodBoolean.create = (params) => {
@@ -1091,8 +1129,9 @@ ZodBoolean.create = (params) => {
 };
 class ZodDate extends ZodType {
     _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.date) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.date) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.date,
@@ -1100,15 +1139,16 @@ class ZodDate extends ZodType {
             });
             return INVALID;
         }
-        if (isNaN(ctx.data.getTime())) {
+        if (isNaN(input.data.getTime())) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_date,
             });
             return INVALID;
         }
         return {
-            status: status.value,
-            value: new Date(ctx.data.getTime()),
+            status: "valid",
+            value: new Date(input.data.getTime()),
         };
     }
 }
@@ -1120,8 +1160,9 @@ ZodDate.create = (params) => {
 };
 class ZodUndefined extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.undefined) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.undefined) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.undefined,
@@ -1129,7 +1170,7 @@ class ZodUndefined extends ZodType {
             });
             return INVALID;
         }
-        return OK(ctx.data);
+        return OK(input.data);
     }
 }
 ZodUndefined.create = (params) => {
@@ -1140,8 +1181,9 @@ ZodUndefined.create = (params) => {
 };
 class ZodNull extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.null) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.null) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.null,
@@ -1149,7 +1191,7 @@ class ZodNull extends ZodType {
             });
             return INVALID;
         }
-        return OK(ctx.data);
+        return OK(input.data);
     }
 }
 ZodNull.create = (params) => {
@@ -1165,8 +1207,7 @@ class ZodAny extends ZodType {
         this._any = true;
     }
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        return OK(ctx.data);
+        return OK(input.data);
     }
 }
 ZodAny.create = (params) => {
@@ -1182,8 +1223,7 @@ class ZodUnknown extends ZodType {
         this._unknown = true;
     }
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        return OK(ctx.data);
+        return OK(input.data);
     }
 }
 ZodUnknown.create = (params) => {
@@ -1194,7 +1234,7 @@ ZodUnknown.create = (params) => {
 };
 class ZodNever extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
+        const ctx = this._getOrReturnCtx(input);
         addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.never,
@@ -1211,8 +1251,9 @@ ZodNever.create = (params) => {
 };
 class ZodVoid extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.undefined) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.undefined) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.void,
@@ -1220,7 +1261,7 @@ class ZodVoid extends ZodType {
             });
             return INVALID;
         }
-        return OK(ctx.data);
+        return OK(input.data);
     }
 }
 ZodVoid.create = (params) => {
@@ -1231,7 +1272,7 @@ ZodVoid.create = (params) => {
 };
 class ZodArray extends ZodType {
     _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+        const { ctx, status } = this._processInputParams(input);
         const def = this._def;
         if (ctx.parsedType !== ZodParsedType.array) {
             addIssueToContext(ctx, {
@@ -1265,7 +1306,7 @@ class ZodArray extends ZodType {
                 status.dirty();
             }
         }
-        if (ctx.async) {
+        if (ctx.common.async) {
             return Promise.all(ctx.data.map((item, i) => {
                 return def.type._parseAsync({
                     parent: ctx,
@@ -1389,8 +1430,9 @@ class ZodObject extends ZodType {
         return (this._cached = { shape, keys });
     }
     _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.object) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.object) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.object,
@@ -1398,6 +1440,7 @@ class ZodObject extends ZodType {
             });
             return INVALID;
         }
+        const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
         const dataKeys = util.objectKeys(ctx.data);
         const extraKeys = dataKeys.filter((k) => !shapeKeys.includes(k));
@@ -1452,7 +1495,7 @@ class ZodObject extends ZodType {
                 });
             }
         }
-        if (ctx.async) {
+        if (ctx.common.async) {
             return Promise.resolve()
                 .then(async () => {
                 const syncPairs = [];
@@ -1647,23 +1690,26 @@ class ZodUnion extends ZodType {
             for (const result of results) {
                 if (result.result.status === "dirty") {
                     // add issues from dirty option
-                    ctx.issues.push(...result.ctx.issues);
+                    ctx.common.issues.push(...result.ctx.common.issues);
                     return result.result;
                 }
             }
             // return invalid
-            const unionErrors = results.map((result) => new ZodError(result.ctx.issues));
+            const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_union,
                 unionErrors,
             });
             return INVALID;
         }
-        if (ctx.async) {
+        if (ctx.common.async) {
             return Promise.all(options.map(async (option) => {
                 const childCtx = {
                     ...ctx,
-                    issues: [],
+                    common: {
+                        ...ctx.common,
+                        issues: [],
+                    },
                     parent: null,
                 };
                 return {
@@ -1682,7 +1728,10 @@ class ZodUnion extends ZodType {
             for (const option of options) {
                 const childCtx = {
                     ...ctx,
-                    issues: [],
+                    common: {
+                        ...ctx.common,
+                        issues: [],
+                    },
                     parent: null,
                 };
                 const result = option._parseSync({
@@ -1696,12 +1745,12 @@ class ZodUnion extends ZodType {
                 else if (result.status === "dirty" && !dirty) {
                     dirty = { result, ctx: childCtx };
                 }
-                if (childCtx.issues.length) {
-                    issues.push(childCtx.issues);
+                if (childCtx.common.issues.length) {
+                    issues.push(childCtx.common.issues);
                 }
             }
             if (dirty) {
-                ctx.issues.push(...dirty.ctx.issues);
+                ctx.common.issues.push(...dirty.ctx.common.issues);
                 return dirty.result;
             }
             const unionErrors = issues.map((issues) => new ZodError(issues));
@@ -1745,7 +1794,7 @@ class ZodDiscriminatedUnion extends ZodType {
             });
             return INVALID;
         }
-        if (ctx.async) {
+        if (ctx.common.async) {
             return option._parseAsync({
                 data: ctx.data,
                 path: ctx.path,
@@ -1866,7 +1915,7 @@ class ZodIntersection extends ZodType {
             }
             return { status: status.value, value: merged.data };
         };
-        if (ctx.async) {
+        if (ctx.common.async) {
             return Promise.all([
                 this._def.left._parseAsync({
                     data: ctx.data,
@@ -1943,7 +1992,7 @@ class ZodTuple extends ZodType {
             });
         })
             .filter((x) => !!x); // filter nulls
-        if (ctx.async) {
+        if (ctx.common.async) {
             return Promise.all(items).then((results) => {
                 return ParseStatus.mergeArray(status, results);
             });
@@ -2004,7 +2053,7 @@ class ZodRecord extends ZodType {
                 }),
             });
         }
-        if (ctx.async) {
+        if (ctx.common.async) {
             return ParseStatus.mergeObjectAsync(status, pairs);
         }
         else {
@@ -2058,7 +2107,7 @@ class ZodMap extends ZodType {
                 }),
             };
         });
-        if (ctx.async) {
+        if (ctx.common.async) {
             const finalMap = new Map();
             return Promise.resolve().then(async () => {
                 for (const pair of pairs) {
@@ -2149,7 +2198,7 @@ class ZodSet extends ZodType {
             return { status: status.value, value: parsedSet };
         }
         const elements = [...ctx.data.values()].map((item, i) => valueType._parse({ data: item, path: [...ctx.path, i], parent: ctx }));
-        if (ctx.async) {
+        if (ctx.common.async) {
             return Promise.all(elements).then((elements) => finalizeSet(elements));
         }
         else {
@@ -2204,7 +2253,7 @@ class ZodFunction extends ZodType {
                 data: args,
                 path: ctx.path,
                 errorMaps: [
-                    ctx.contextualErrorMap,
+                    ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
                     overrideErrorMap,
                     defaultErrorMap,
@@ -2220,7 +2269,7 @@ class ZodFunction extends ZodType {
                 data: returns,
                 path: ctx.path,
                 errorMaps: [
-                    ctx.contextualErrorMap,
+                    ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
                     overrideErrorMap,
                     defaultErrorMap,
@@ -2231,7 +2280,7 @@ class ZodFunction extends ZodType {
                 },
             });
         }
-        const params = { errorMap: ctx.contextualErrorMap };
+        const params = { errorMap: ctx.common.contextualErrorMap };
         const fn = ctx.data;
         if (this._def.returns instanceof ZodPromise) {
             return OK(async (...args) => {
@@ -2323,8 +2372,8 @@ ZodLazy.create = (getter, params) => {
 };
 class ZodLiteral extends ZodType {
     _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.data !== this._def.value) {
+        if (input.data !== this._def.value) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: getParsedType(this._def.value),
@@ -2332,7 +2381,7 @@ class ZodLiteral extends ZodType {
             });
             return INVALID;
         }
-        return { status: status.value, value: ctx.data };
+        return { status: "valid", value: input.data };
     }
     get value() {
         return this._def.value;
@@ -2353,15 +2402,15 @@ function createZodEnum(values) {
 }
 class ZodEnum extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (this._def.values.indexOf(ctx.data) === -1) {
+        if (this._def.values.indexOf(input.data) === -1) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_enum_value,
                 options: this._def.values,
             });
             return INVALID;
         }
-        return OK(ctx.data);
+        return OK(input.data);
     }
     get options() {
         return this._def.values;
@@ -2391,16 +2440,16 @@ class ZodEnum extends ZodType {
 ZodEnum.create = createZodEnum;
 class ZodNativeEnum extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
         const nativeEnumValues = util.getValidEnumValues(this._def.values);
-        if (nativeEnumValues.indexOf(ctx.data) === -1) {
+        if (nativeEnumValues.indexOf(input.data) === -1) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_enum_value,
                 options: util.objectValues(nativeEnumValues),
             });
             return INVALID;
         }
-        return OK(ctx.data);
+        return OK(input.data);
     }
     get enum() {
         return this._def.values;
@@ -2416,7 +2465,8 @@ ZodNativeEnum.create = (values, params) => {
 class ZodPromise extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.promise && ctx.async === false) {
+        if (ctx.parsedType !== ZodParsedType.promise &&
+            ctx.common.async === false) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.promise,
@@ -2430,7 +2480,7 @@ class ZodPromise extends ZodType {
         return OK(promisified.then((data) => {
             return this._def.type.parseAsync(data, {
                 path: ctx.path,
-                errorMap: ctx.contextualErrorMap,
+                errorMap: ctx.common.contextualErrorMap,
             });
         }));
     }
@@ -2451,7 +2501,7 @@ class ZodEffects extends ZodType {
         const effect = this._def.effect || null;
         if (effect.type === "preprocess") {
             const processed = effect.transform(ctx.data);
-            if (ctx.async) {
+            if (ctx.common.async) {
                 return Promise.resolve(processed).then((processed) => {
                     return this._def.schema._parseAsync({
                         data: processed,
@@ -2488,7 +2538,7 @@ class ZodEffects extends ZodType {
             // effect: RefinementEffect<any>
             ) => {
                 const result = effect.refinement(acc, checkCtx);
-                if (ctx.async) {
+                if (ctx.common.async) {
                     return Promise.resolve(result);
                 }
                 if (result instanceof Promise) {
@@ -2496,7 +2546,7 @@ class ZodEffects extends ZodType {
                 }
                 return acc;
             };
-            if (ctx.async === false) {
+            if (ctx.common.async === false) {
                 const inner = this._def.schema._parseSync({
                     data: ctx.data,
                     path: ctx.path,
@@ -2525,7 +2575,7 @@ class ZodEffects extends ZodType {
             }
         }
         if (effect.type === "transform") {
-            if (ctx.async === false) {
+            if (ctx.common.async === false) {
                 const base = this._def.schema._parseSync({
                     data: ctx.data,
                     path: ctx.path,
@@ -2578,10 +2628,11 @@ ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
 };
 class ZodOptional extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType === ZodParsedType.undefined) {
+        const parsedType = this._getType(input);
+        if (parsedType === ZodParsedType.undefined) {
             return OK(undefined);
         }
+        const { ctx } = this._processInputParams(input);
         return this._def.innerType._parse({
             data: ctx.data,
             path: ctx.path,
@@ -2601,10 +2652,11 @@ ZodOptional.create = (type, params) => {
 };
 class ZodNullable extends ZodType {
     _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType === ZodParsedType.null) {
+        const parsedType = this._getType(input);
+        if (parsedType === ZodParsedType.null) {
             return OK(null);
         }
+        const { ctx } = this._processInputParams(input);
         return this._def.innerType._parse({
             data: ctx.data,
             path: ctx.path,
@@ -2648,8 +2700,9 @@ ZodDefault.create = (type, params) => {
 };
 class ZodNaN extends ZodType {
     _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.nan) {
+        const parsedType = this._getType(input);
+        if (parsedType !== ZodParsedType.nan) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.nan,
@@ -2657,7 +2710,7 @@ class ZodNaN extends ZodType {
             });
             return INVALID;
         }
-        return { status: status.value, value: ctx.data };
+        return { status: "valid", value: input.data };
     }
 }
 ZodNaN.create = (params) => {