zod 3.17.0 → 3.17.2

package/lib/ZodError.d.ts

@@ -1,7 +1,6 @@
 import type { TypeOf, ZodType } from ".";
-import { ZodParsedType } from "./helpers/parseUtil";
 import { Primitive } from "./helpers/typeAliases";
-import { util } from "./helpers/util";
+import { util, ZodParsedType } from "./helpers/util";
 declare type allKeys<T> = T extends any ? keyof T : never;
 export declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
 export declare type typeToFlattenedError<T, U = string> = {

package/lib/ZodError.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setErrorMap = exports.overrideErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
-const parseUtil_1 = require("./helpers/parseUtil");
 const util_1 = require("./helpers/util");
 exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
@@ -134,7 +133,7 @@ const defaultErrorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {
         case exports.ZodIssueCode.invalid_type:
-            if (issue.received === parseUtil_1.ZodParsedType.undefined) {
+            if (issue.received === util_1.ZodParsedType.undefined) {
                 message = "Required";
             }
             else {

package/lib/external.d.ts

@@ -1,4 +1,5 @@
 export * from "./helpers/parseUtil";
 export * from "./helpers/typeAliases";
+export { getParsedType, ZodParsedType } from "./helpers/util";
 export * from "./types";
 export * from "./ZodError";

package/lib/external.js

@@ -14,7 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodParsedType = exports.getParsedType = void 0;
 __exportStar(require("./helpers/parseUtil"), exports);
 __exportStar(require("./helpers/typeAliases"), exports);
+var util_1 = require("./helpers/util");
+Object.defineProperty(exports, "getParsedType", { enumerable: true, get: function () { return util_1.getParsedType; } });
+Object.defineProperty(exports, "ZodParsedType", { enumerable: true, get: function () { return util_1.ZodParsedType; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./ZodError"), exports);

package/lib/helpers/parseUtil.d.ts

@@ -1,28 +1,5 @@
-import { IssueData, ZodErrorMap, ZodIssue } from "../ZodError";
-export declare const ZodParsedType: {
-    function: "function";
-    number: "number";
-    string: "string";
-    nan: "nan";
-    integer: "integer";
-    float: "float";
-    boolean: "boolean";
-    date: "date";
-    bigint: "bigint";
-    symbol: "symbol";
-    undefined: "undefined";
-    null: "null";
-    array: "array";
-    object: "object";
-    unknown: "unknown";
-    promise: "promise";
-    void: "void";
-    never: "never";
-    map: "map";
-    set: "set";
-};
-export declare type ZodParsedType = keyof typeof ZodParsedType;
-export declare const getParsedType: (data: any) => ZodParsedType;
+import { type IssueData, type ZodErrorMap, type ZodIssue } from "../ZodError";
+import { type ZodParsedType } from "./util";
 export declare const makeIssue: (params: {
     data: any;
     path: (string | number)[];

package/lib/helpers/parseUtil.js

@@ -1,73 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = exports.getParsedType = exports.ZodParsedType = void 0;
+exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = void 0;
 const ZodError_1 = require("../ZodError");
-const util_1 = require("./util");
-exports.ZodParsedType = util_1.util.arrayToEnum([
-    "string",
-    "nan",
-    "number",
-    "integer",
-    "float",
-    "boolean",
-    "date",
-    "bigint",
-    "symbol",
-    "function",
-    "undefined",
-    "null",
-    "array",
-    "object",
-    "unknown",
-    "promise",
-    "void",
-    "never",
-    "map",
-    "set",
-]);
-const getParsedType = (data) => {
-    const t = typeof data;
-    switch (t) {
-        case "undefined":
-            return exports.ZodParsedType.undefined;
-        case "string":
-            return exports.ZodParsedType.string;
-        case "number":
-            return isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
-        case "boolean":
-            return exports.ZodParsedType.boolean;
-        case "function":
-            return exports.ZodParsedType.function;
-        case "bigint":
-            return exports.ZodParsedType.bigint;
-        case "object":
-            if (Array.isArray(data)) {
-                return exports.ZodParsedType.array;
-            }
-            if (data === null) {
-                return exports.ZodParsedType.null;
-            }
-            if (data.then &&
-                typeof data.then === "function" &&
-                data.catch &&
-                typeof data.catch === "function") {
-                return exports.ZodParsedType.promise;
-            }
-            if (typeof Map !== "undefined" && data instanceof Map) {
-                return exports.ZodParsedType.map;
-            }
-            if (typeof Set !== "undefined" && data instanceof Set) {
-                return exports.ZodParsedType.set;
-            }
-            if (typeof Date !== "undefined" && data instanceof Date) {
-                return exports.ZodParsedType.date;
-            }
-            return exports.ZodParsedType.object;
-        default:
-            return exports.ZodParsedType.unknown;
-    }
-};
-exports.getParsedType = getParsedType;
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
     const fullPath = [...path, ...(issueData.path || [])];

package/lib/helpers/util.d.ts

@@ -17,3 +17,27 @@ export declare namespace util {
     const isInteger: NumberConstructor["isInteger"];
     function joinValues<T extends any[]>(array: T, separator?: string): string;
 }
+export declare const ZodParsedType: {
+    function: "function";
+    number: "number";
+    string: "string";
+    nan: "nan";
+    integer: "integer";
+    float: "float";
+    boolean: "boolean";
+    date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    undefined: "undefined";
+    null: "null";
+    array: "array";
+    object: "object";
+    unknown: "unknown";
+    promise: "promise";
+    void: "void";
+    never: "never";
+    map: "map";
+    set: "set";
+};
+export declare type ZodParsedType = keyof typeof ZodParsedType;
+export declare const getParsedType: (data: any) => ZodParsedType;

package/lib/helpers/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.util = void 0;
+exports.getParsedType = exports.ZodParsedType = exports.util = void 0;
 var util;
 (function (util) {
     function assertNever(_x) {
@@ -55,3 +55,68 @@ var util;
     }
     util.joinValues = joinValues;
 })(util = exports.util || (exports.util = {}));
+exports.ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return exports.ZodParsedType.undefined;
+        case "string":
+            return exports.ZodParsedType.string;
+        case "number":
+            return isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
+        case "boolean":
+            return exports.ZodParsedType.boolean;
+        case "function":
+            return exports.ZodParsedType.function;
+        case "bigint":
+            return exports.ZodParsedType.bigint;
+        case "object":
+            if (Array.isArray(data)) {
+                return exports.ZodParsedType.array;
+            }
+            if (data === null) {
+                return exports.ZodParsedType.null;
+            }
+            if (data.then &&
+                typeof data.then === "function" &&
+                data.catch &&
+                typeof data.catch === "function") {
+                return exports.ZodParsedType.promise;
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return exports.ZodParsedType.map;
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return exports.ZodParsedType.set;
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return exports.ZodParsedType.date;
+            }
+            return exports.ZodParsedType.object;
+        default:
+            return exports.ZodParsedType.unknown;
+    }
+};
+exports.getParsedType = getParsedType;

package/lib/index.mjs

@@ -52,6 +52,70 @@ var util;
     }
     util.joinValues = joinValues;
 })(util || (util = {}));
+const ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return ZodParsedType.undefined;
+        case "string":
+            return ZodParsedType.string;
+        case "number":
+            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+        case "boolean":
+            return ZodParsedType.boolean;
+        case "function":
+            return ZodParsedType.function;
+        case "bigint":
+            return ZodParsedType.bigint;
+        case "object":
+            if (Array.isArray(data)) {
+                return ZodParsedType.array;
+            }
+            if (data === null) {
+                return ZodParsedType.null;
+            }
+            if (data.then &&
+                typeof data.then === "function" &&
+                data.catch &&
+                typeof data.catch === "function") {
+                return ZodParsedType.promise;
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return ZodParsedType.map;
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return ZodParsedType.set;
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return ZodParsedType.date;
+            }
+            return ZodParsedType.object;
+        default:
+            return ZodParsedType.unknown;
+    }
+};
 
 const ZodIssueCode = util.arrayToEnum([
     "invalid_type",
@@ -259,70 +323,6 @@ const setErrorMap = (map) => {
     overrideErrorMap = map;
 };
 
-const ZodParsedType = util.arrayToEnum([
-    "string",
-    "nan",
-    "number",
-    "integer",
-    "float",
-    "boolean",
-    "date",
-    "bigint",
-    "symbol",
-    "function",
-    "undefined",
-    "null",
-    "array",
-    "object",
-    "unknown",
-    "promise",
-    "void",
-    "never",
-    "map",
-    "set",
-]);
-const getParsedType = (data) => {
-    const t = typeof data;
-    switch (t) {
-        case "undefined":
-            return ZodParsedType.undefined;
-        case "string":
-            return ZodParsedType.string;
-        case "number":
-            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
-        case "boolean":
-            return ZodParsedType.boolean;
-        case "function":
-            return ZodParsedType.function;
-        case "bigint":
-            return ZodParsedType.bigint;
-        case "object":
-            if (Array.isArray(data)) {
-                return ZodParsedType.array;
-            }
-            if (data === null) {
-                return ZodParsedType.null;
-            }
-            if (data.then &&
-                typeof data.then === "function" &&
-                data.catch &&
-                typeof data.catch === "function") {
-                return ZodParsedType.promise;
-            }
-            if (typeof Map !== "undefined" && data instanceof Map) {
-                return ZodParsedType.map;
-            }
-            if (typeof Set !== "undefined" && data instanceof Set) {
-                return ZodParsedType.set;
-            }
-            if (typeof Date !== "undefined" && data instanceof Date) {
-                return ZodParsedType.date;
-            }
-            return ZodParsedType.object;
-        default:
-            return ZodParsedType.unknown;
-    }
-};
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
     const fullPath = [...path, ...(issueData.path || [])];
@@ -1603,7 +1603,9 @@ class ZodObject extends ZodType {
     pick(mask) {
         const shape = {};
         util.objectKeys(mask).map((key) => {
-            shape[key] = this.shape[key];
+            // only add to shape if key corresponds to an element of the current shape
+            if (this.shape[key])
+                shape[key] = this.shape[key];
         });
         return new ZodObject({
             ...this._def,
@@ -2821,8 +2823,8 @@ const oboolean = () => booleanType().optional();
 
 var mod = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ZodParsedType: ZodParsedType,
     getParsedType: getParsedType,
+    ZodParsedType: ZodParsedType,
     makeIssue: makeIssue,
     EMPTY_PATH: EMPTY_PATH,
     addIssueToContext: addIssueToContext,

package/lib/index.umd.js

@@ -58,6 +58,70 @@
         }
         util.joinValues = joinValues;
     })(util || (util = {}));
+    const ZodParsedType = util.arrayToEnum([
+        "string",
+        "nan",
+        "number",
+        "integer",
+        "float",
+        "boolean",
+        "date",
+        "bigint",
+        "symbol",
+        "function",
+        "undefined",
+        "null",
+        "array",
+        "object",
+        "unknown",
+        "promise",
+        "void",
+        "never",
+        "map",
+        "set",
+    ]);
+    const getParsedType = (data) => {
+        const t = typeof data;
+        switch (t) {
+            case "undefined":
+                return ZodParsedType.undefined;
+            case "string":
+                return ZodParsedType.string;
+            case "number":
+                return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+            case "boolean":
+                return ZodParsedType.boolean;
+            case "function":
+                return ZodParsedType.function;
+            case "bigint":
+                return ZodParsedType.bigint;
+            case "object":
+                if (Array.isArray(data)) {
+                    return ZodParsedType.array;
+                }
+                if (data === null) {
+                    return ZodParsedType.null;
+                }
+                if (data.then &&
+                    typeof data.then === "function" &&
+                    data.catch &&
+                    typeof data.catch === "function") {
+                    return ZodParsedType.promise;
+                }
+                if (typeof Map !== "undefined" && data instanceof Map) {
+                    return ZodParsedType.map;
+                }
+                if (typeof Set !== "undefined" && data instanceof Set) {
+                    return ZodParsedType.set;
+                }
+                if (typeof Date !== "undefined" && data instanceof Date) {
+                    return ZodParsedType.date;
+                }
+                return ZodParsedType.object;
+            default:
+                return ZodParsedType.unknown;
+        }
+    };
 
     const ZodIssueCode = util.arrayToEnum([
         "invalid_type",
@@ -265,70 +329,6 @@
         exports.overrideErrorMap = map;
     };
 
-    const ZodParsedType = util.arrayToEnum([
-        "string",
-        "nan",
-        "number",
-        "integer",
-        "float",
-        "boolean",
-        "date",
-        "bigint",
-        "symbol",
-        "function",
-        "undefined",
-        "null",
-        "array",
-        "object",
-        "unknown",
-        "promise",
-        "void",
-        "never",
-        "map",
-        "set",
-    ]);
-    const getParsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "undefined":
-                return ZodParsedType.undefined;
-            case "string":
-                return ZodParsedType.string;
-            case "number":
-                return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
-            case "boolean":
-                return ZodParsedType.boolean;
-            case "function":
-                return ZodParsedType.function;
-            case "bigint":
-                return ZodParsedType.bigint;
-            case "object":
-                if (Array.isArray(data)) {
-                    return ZodParsedType.array;
-                }
-                if (data === null) {
-                    return ZodParsedType.null;
-                }
-                if (data.then &&
-                    typeof data.then === "function" &&
-                    data.catch &&
-                    typeof data.catch === "function") {
-                    return ZodParsedType.promise;
-                }
-                if (typeof Map !== "undefined" && data instanceof Map) {
-                    return ZodParsedType.map;
-                }
-                if (typeof Set !== "undefined" && data instanceof Set) {
-                    return ZodParsedType.set;
-                }
-                if (typeof Date !== "undefined" && data instanceof Date) {
-                    return ZodParsedType.date;
-                }
-                return ZodParsedType.object;
-            default:
-                return ZodParsedType.unknown;
-        }
-    };
     const makeIssue = (params) => {
         const { data, path, errorMaps, issueData } = params;
         const fullPath = [...path, ...(issueData.path || [])];
@@ -1609,7 +1609,9 @@
         pick(mask) {
             const shape = {};
             util.objectKeys(mask).map((key) => {
-                shape[key] = this.shape[key];
+                // only add to shape if key corresponds to an element of the current shape
+                if (this.shape[key])
+                    shape[key] = this.shape[key];
             });
             return new ZodObject({
                 ...this._def,
@@ -2827,8 +2829,8 @@
 
     var mod = /*#__PURE__*/Object.freeze({
         __proto__: null,
-        ZodParsedType: ZodParsedType,
         getParsedType: getParsedType,
+        ZodParsedType: ZodParsedType,
         makeIssue: makeIssue,
         EMPTY_PATH: EMPTY_PATH,
         addIssueToContext: addIssueToContext,

package/lib/types.js

@@ -80,13 +80,13 @@ class ZodType {
         return this._def.description;
     }
     _getType(input) {
-        return (0, parseUtil_1.getParsedType)(input.data);
+        return (0, util_1.getParsedType)(input.data);
     }
     _getOrReturnCtx(input, ctx) {
         return (ctx || {
             common: input.parent.common,
             data: input.data,
-            parsedType: (0, parseUtil_1.getParsedType)(input.data),
+            parsedType: (0, util_1.getParsedType)(input.data),
             schemaErrorMap: this._def.errorMap,
             path: input.path,
             parent: input.parent,
@@ -98,7 +98,7 @@ class ZodType {
             ctx: {
                 common: input.parent.common,
                 data: input.data,
-                parsedType: (0, parseUtil_1.getParsedType)(input.data),
+                parsedType: (0, util_1.getParsedType)(input.data),
                 schemaErrorMap: this._def.errorMap,
                 path: input.path,
                 parent: input.parent,
@@ -134,7 +134,7 @@ class ZodType {
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
-            parsedType: (0, parseUtil_1.getParsedType)(data),
+            parsedType: (0, util_1.getParsedType)(data),
         };
         const result = this._parseSync({ data, path: ctx.path, parent: ctx });
         return handleResult(ctx, result);
@@ -156,7 +156,7 @@ class ZodType {
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
-            parsedType: (0, parseUtil_1.getParsedType)(data),
+            parsedType: (0, util_1.getParsedType)(data),
         };
         const maybeAsyncResult = this._parse({ data, path: [], parent: ctx });
         const result = await ((0, parseUtil_1.isAsync)(maybeAsyncResult)
@@ -302,11 +302,11 @@ class ZodString extends ZodType {
     }
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.string) {
+        if (parsedType !== util_1.ZodParsedType.string) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.string,
+                expected: util_1.ZodParsedType.string,
                 received: ctx.parsedType,
             }
             //
@@ -514,11 +514,11 @@ class ZodNumber extends ZodType {
     }
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.number) {
+        if (parsedType !== util_1.ZodParsedType.number) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.number,
+                expected: util_1.ZodParsedType.number,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -699,11 +699,11 @@ ZodNumber.create = (params) => {
 class ZodBigInt extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.bigint) {
+        if (parsedType !== util_1.ZodParsedType.bigint) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.bigint,
+                expected: util_1.ZodParsedType.bigint,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -721,11 +721,11 @@ ZodBigInt.create = (params) => {
 class ZodBoolean extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.boolean) {
+        if (parsedType !== util_1.ZodParsedType.boolean) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.boolean,
+                expected: util_1.ZodParsedType.boolean,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -743,11 +743,11 @@ ZodBoolean.create = (params) => {
 class ZodDate extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.date) {
+        if (parsedType !== util_1.ZodParsedType.date) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.date,
+                expected: util_1.ZodParsedType.date,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -775,11 +775,11 @@ ZodDate.create = (params) => {
 class ZodUndefined extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.undefined) {
+        if (parsedType !== util_1.ZodParsedType.undefined) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.undefined,
+                expected: util_1.ZodParsedType.undefined,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -797,11 +797,11 @@ ZodUndefined.create = (params) => {
 class ZodNull extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.null) {
+        if (parsedType !== util_1.ZodParsedType.null) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.null,
+                expected: util_1.ZodParsedType.null,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -855,7 +855,7 @@ class ZodNever extends ZodType {
         const ctx = this._getOrReturnCtx(input);
         (0, parseUtil_1.addIssueToContext)(ctx, {
             code: ZodError_1.ZodIssueCode.invalid_type,
-            expected: parseUtil_1.ZodParsedType.never,
+            expected: util_1.ZodParsedType.never,
             received: ctx.parsedType,
         });
         return parseUtil_1.INVALID;
@@ -871,11 +871,11 @@ ZodNever.create = (params) => {
 class ZodVoid extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.undefined) {
+        if (parsedType !== util_1.ZodParsedType.undefined) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.void,
+                expected: util_1.ZodParsedType.void,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -894,10 +894,10 @@ class ZodArray extends ZodType {
     _parse(input) {
         const { ctx, status } = this._processInputParams(input);
         const def = this._def;
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.array) {
+        if (ctx.parsedType !== util_1.ZodParsedType.array) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.array,
+                expected: util_1.ZodParsedType.array,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -1044,11 +1044,11 @@ class ZodObject extends ZodType {
     }
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.object) {
+        if (parsedType !== util_1.ZodParsedType.object) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.object,
+                expected: util_1.ZodParsedType.object,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -1198,7 +1198,9 @@ class ZodObject extends ZodType {
     pick(mask) {
         const shape = {};
         util_1.util.objectKeys(mask).map((key) => {
-            shape[key] = this.shape[key];
+            // only add to shape if key corresponds to an element of the current shape
+            if (this.shape[key])
+                shape[key] = this.shape[key];
         });
         return new ZodObject({
             ...this._def,
@@ -1391,10 +1393,10 @@ ZodUnion.create = (types, params) => {
 class ZodDiscriminatedUnion extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.object) {
+        if (ctx.parsedType !== util_1.ZodParsedType.object) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.object,
+                expected: util_1.ZodParsedType.object,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -1468,12 +1470,12 @@ class ZodDiscriminatedUnion extends ZodType {
 }
 exports.ZodDiscriminatedUnion = ZodDiscriminatedUnion;
 function mergeValues(a, b) {
-    const aType = (0, parseUtil_1.getParsedType)(a);
-    const bType = (0, parseUtil_1.getParsedType)(b);
+    const aType = (0, util_1.getParsedType)(a);
+    const bType = (0, util_1.getParsedType)(b);
     if (a === b) {
         return { valid: true, data: a };
     }
-    else if (aType === parseUtil_1.ZodParsedType.object && bType === parseUtil_1.ZodParsedType.object) {
+    else if (aType === util_1.ZodParsedType.object && bType === util_1.ZodParsedType.object) {
         const bKeys = util_1.util.objectKeys(b);
         const sharedKeys = util_1.util
             .objectKeys(a)
@@ -1488,7 +1490,7 @@ function mergeValues(a, b) {
         }
         return { valid: true, data: newObj };
     }
-    else if (aType === parseUtil_1.ZodParsedType.array && bType === parseUtil_1.ZodParsedType.array) {
+    else if (aType === util_1.ZodParsedType.array && bType === util_1.ZodParsedType.array) {
         if (a.length !== b.length) {
             return { valid: false };
         }
@@ -1504,8 +1506,8 @@ function mergeValues(a, b) {
         }
         return { valid: true, data: newArray };
     }
-    else if (aType === parseUtil_1.ZodParsedType.date &&
-        bType === parseUtil_1.ZodParsedType.date &&
+    else if (aType === util_1.ZodParsedType.date &&
+        bType === util_1.ZodParsedType.date &&
         +a === +b) {
         return { valid: true, data: a };
     }
@@ -1571,10 +1573,10 @@ ZodIntersection.create = (left, right, params) => {
 class ZodTuple extends ZodType {
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.array) {
+        if (ctx.parsedType !== util_1.ZodParsedType.array) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.array,
+                expected: util_1.ZodParsedType.array,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -1643,10 +1645,10 @@ class ZodRecord extends ZodType {
     }
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.object) {
+        if (ctx.parsedType !== util_1.ZodParsedType.object) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.object,
+                expected: util_1.ZodParsedType.object,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -1691,10 +1693,10 @@ exports.ZodRecord = ZodRecord;
 class ZodMap extends ZodType {
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.map) {
+        if (ctx.parsedType !== util_1.ZodParsedType.map) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.map,
+                expected: util_1.ZodParsedType.map,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -1753,10 +1755,10 @@ ZodMap.create = (keyType, valueType, params) => {
 class ZodSet extends ZodType {
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.set) {
+        if (ctx.parsedType !== util_1.ZodParsedType.set) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.set,
+                expected: util_1.ZodParsedType.set,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -1842,10 +1844,10 @@ class ZodFunction extends ZodType {
     }
     _parse(input) {
         const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.function) {
+        if (ctx.parsedType !== util_1.ZodParsedType.function) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.function,
+                expected: util_1.ZodParsedType.function,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
@@ -2060,8 +2062,8 @@ class ZodNativeEnum extends ZodType {
     _parse(input) {
         const nativeEnumValues = util_1.util.getValidEnumValues(this._def.values);
         const ctx = this._getOrReturnCtx(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.string &&
-            ctx.parsedType !== parseUtil_1.ZodParsedType.number) {
+        if (ctx.parsedType !== util_1.ZodParsedType.string &&
+            ctx.parsedType !== util_1.ZodParsedType.number) {
             const expectedValues = util_1.util.objectValues(nativeEnumValues);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 expected: util_1.util.joinValues(expectedValues),
@@ -2096,16 +2098,16 @@ ZodNativeEnum.create = (values, params) => {
 class ZodPromise extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== parseUtil_1.ZodParsedType.promise &&
+        if (ctx.parsedType !== util_1.ZodParsedType.promise &&
             ctx.common.async === false) {
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.promise,
+                expected: util_1.ZodParsedType.promise,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;
         }
-        const promisified = ctx.parsedType === parseUtil_1.ZodParsedType.promise
+        const promisified = ctx.parsedType === util_1.ZodParsedType.promise
             ? ctx.data
             : Promise.resolve(ctx.data);
         return (0, parseUtil_1.OK)(promisified.then((data) => {
@@ -2263,7 +2265,7 @@ ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
 class ZodOptional extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType === parseUtil_1.ZodParsedType.undefined) {
+        if (parsedType === util_1.ZodParsedType.undefined) {
             return (0, parseUtil_1.OK)(undefined);
         }
         return this._def.innerType._parse(input);
@@ -2283,7 +2285,7 @@ ZodOptional.create = (type, params) => {
 class ZodNullable extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType === parseUtil_1.ZodParsedType.null) {
+        if (parsedType === util_1.ZodParsedType.null) {
             return (0, parseUtil_1.OK)(null);
         }
         return this._def.innerType._parse(input);
@@ -2304,7 +2306,7 @@ class ZodDefault extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
         let data = ctx.data;
-        if (ctx.parsedType === parseUtil_1.ZodParsedType.undefined) {
+        if (ctx.parsedType === util_1.ZodParsedType.undefined) {
             data = this._def.defaultValue();
         }
         return this._def.innerType._parse({
@@ -2328,11 +2330,11 @@ ZodDefault.create = (type, params) => {
 class ZodNaN extends ZodType {
     _parse(input) {
         const parsedType = this._getType(input);
-        if (parsedType !== parseUtil_1.ZodParsedType.nan) {
+        if (parsedType !== util_1.ZodParsedType.nan) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
                 code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: parseUtil_1.ZodParsedType.nan,
+                expected: util_1.ZodParsedType.nan,
                 received: ctx.parsedType,
             });
             return parseUtil_1.INVALID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.17.0",
+  "version": "3.17.2",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
   "types": "./index.d.ts",