zod 3.13.2 → 3.14.0

package/lib/index.mjs

@@ -1,207 +1,53 @@
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
 var util;
 (function (util) {
     function assertNever(_x) {
         throw new Error();
     }
     util.assertNever = assertNever;
-    util.arrayToEnum = function (items) {
-        var e_1, _a;
-        var obj = {};
-        try {
-            for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
-                var item = items_1_1.value;
-                obj[item] = item;
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
-            }
-            finally { if (e_1) throw e_1.error; }
+    util.arrayToEnum = (items) => {
+        const obj = {};
+        for (const item of items) {
+            obj[item] = item;
         }
         return obj;
     };
-    util.getValidEnumValues = function (obj) {
-        var e_2, _a;
-        var validKeys = util.objectKeys(obj).filter(function (k) { return typeof obj[obj[k]] !== "number"; });
-        var filtered = {};
-        try {
-            for (var validKeys_1 = __values(validKeys), validKeys_1_1 = validKeys_1.next(); !validKeys_1_1.done; validKeys_1_1 = validKeys_1.next()) {
-                var k = validKeys_1_1.value;
-                filtered[k] = obj[k];
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (validKeys_1_1 && !validKeys_1_1.done && (_a = validKeys_1.return)) _a.call(validKeys_1);
-            }
-            finally { if (e_2) throw e_2.error; }
+    util.getValidEnumValues = (obj) => {
+        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+        const filtered = {};
+        for (const k of validKeys) {
+            filtered[k] = obj[k];
         }
         return util.objectValues(filtered);
     };
-    util.objectValues = function (obj) {
+    util.objectValues = (obj) => {
         return util.objectKeys(obj).map(function (e) {
             return obj[e];
         });
     };
     util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
-        ? function (obj) { return Object.keys(obj); } // eslint-disable-line ban/ban
-        : function (object) {
-            var keys = [];
-            for (var key in object) {
+        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
+        : (object) => {
+            const keys = [];
+            for (const key in object) {
                 if (Object.prototype.hasOwnProperty.call(object, key)) {
                     keys.push(key);
                 }
             }
             return keys;
         };
-    util.find = function (arr, checker) {
-        var e_3, _a;
-        try {
-            for (var arr_1 = __values(arr), arr_1_1 = arr_1.next(); !arr_1_1.done; arr_1_1 = arr_1.next()) {
-                var item = arr_1_1.value;
-                if (checker(item))
-                    return item;
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1);
-            }
-            finally { if (e_3) throw e_3.error; }
+    util.find = (arr, checker) => {
+        for (const item of arr) {
+            if (checker(item))
+                return item;
         }
         return undefined;
     };
     util.isInteger = typeof Number.isInteger === "function"
-        ? function (val) { return Number.isInteger(val); } // eslint-disable-line ban/ban
-        : function (val) {
-            return typeof val === "number" && isFinite(val) && Math.floor(val) === val;
-        };
+        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
+        : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
 })(util || (util = {}));
 
-var ZodIssueCode = util.arrayToEnum([
+const ZodIssueCode = util.arrayToEnum([
     "invalid_type",
     "custom",
     "invalid_union",
@@ -217,239 +63,195 @@ var ZodIssueCode = util.arrayToEnum([
     "invalid_intersection_types",
     "not_multiple_of",
 ]);
-var quotelessJson = function (obj) {
-    var json = JSON.stringify(obj, null, 2);
+const quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
     return json.replace(/"([^"]+)":/g, "$1:");
 };
-var ZodError = /** @class */ (function (_super) {
-    __extends(ZodError, _super);
-    function ZodError(issues) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this) || this;
-        _this.issues = [];
-        _this.format = function () {
-            var fieldErrors = { _errors: [] };
-            var processError = function (error) {
-                var e_1, _a;
-                try {
-                    for (var _b = __values(error.issues), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var issue = _c.value;
-                        if (issue.code === "invalid_union") {
-                            issue.unionErrors.map(processError);
-                        }
-                        else if (issue.code === "invalid_return_type") {
-                            processError(issue.returnTypeError);
-                        }
-                        else if (issue.code === "invalid_arguments") {
-                            processError(issue.argumentsError);
-                        }
-                        else if (issue.path.length === 0) {
-                            fieldErrors._errors.push(issue.message);
-                        }
-                        else {
-                            var curr = fieldErrors;
-                            var i = 0;
-                            while (i < issue.path.length) {
-                                var el = issue.path[i];
-                                var terminal = i === issue.path.length - 1;
-                                if (!terminal) {
-                                    if (typeof el === "string") {
-                                        curr[el] = curr[el] || { _errors: [] };
-                                    }
-                                    else if (typeof el === "number") {
-                                        var errorArray = [];
-                                        errorArray._errors = [];
-                                        curr[el] = curr[el] || errorArray;
-                                    }
-                                }
-                                else {
+class ZodError extends Error {
+    constructor(issues) {
+        super();
+        this.issues = [];
+        this.format = () => {
+            const fieldErrors = { _errors: [] };
+            const processError = (error) => {
+                for (const issue of error.issues) {
+                    if (issue.code === "invalid_union") {
+                        issue.unionErrors.map(processError);
+                    }
+                    else if (issue.code === "invalid_return_type") {
+                        processError(issue.returnTypeError);
+                    }
+                    else if (issue.code === "invalid_arguments") {
+                        processError(issue.argumentsError);
+                    }
+                    else if (issue.path.length === 0) {
+                        fieldErrors._errors.push(issue.message);
+                    }
+                    else {
+                        let curr = fieldErrors;
+                        let i = 0;
+                        while (i < issue.path.length) {
+                            const el = issue.path[i];
+                            const terminal = i === issue.path.length - 1;
+                            if (!terminal) {
+                                if (typeof el === "string") {
                                     curr[el] = curr[el] || { _errors: [] };
-                                    curr[el]._errors.push(issue.message);
                                 }
-                                curr = curr[el];
-                                i++;
+                                else if (typeof el === "number") {
+                                    const errorArray = [];
+                                    errorArray._errors = [];
+                                    curr[el] = curr[el] || errorArray;
+                                }
+                            }
+                            else {
+                                curr[el] = curr[el] || { _errors: [] };
+                                curr[el]._errors.push(issue.message);
                             }
+                            curr = curr[el];
+                            i++;
                         }
                     }
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
             };
-            processError(_this);
+            processError(this);
             return fieldErrors;
         };
-        _this.addIssue = function (sub) {
-            _this.issues = __spreadArray(__spreadArray([], __read(_this.issues), false), [sub], false);
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
         };
-        _this.addIssues = function (subs) {
-            if (subs === void 0) { subs = []; }
-            _this.issues = __spreadArray(__spreadArray([], __read(_this.issues), false), __read(subs), false);
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
         };
-        var actualProto = _newTarget.prototype;
+        const actualProto = new.target.prototype;
         if (Object.setPrototypeOf) {
             // eslint-disable-next-line ban/ban
-            Object.setPrototypeOf(_this, actualProto);
+            Object.setPrototypeOf(this, actualProto);
         }
         else {
-            _this.__proto__ = actualProto;
-        }
-        _this.name = "ZodError";
-        _this.issues = issues;
-        return _this;
-    }
-    Object.defineProperty(ZodError.prototype, "errors", {
-        get: function () {
-            return this.issues;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodError.prototype.toString = function () {
+            this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    get errors() {
+        return this.issues;
+    }
+    toString() {
         return this.message;
-    };
-    Object.defineProperty(ZodError.prototype, "message", {
-        get: function () {
-            return JSON.stringify(this.issues, null, 2);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodError.prototype, "isEmpty", {
-        get: function () {
-            return this.issues.length === 0;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodError.prototype.flatten = function (mapper) {
-        var e_2, _a;
-        if (mapper === void 0) { mapper = function (issue) { return issue.message; }; }
-        var fieldErrors = {};
-        var formErrors = [];
-        try {
-            for (var _b = __values(this.issues), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var sub = _c.value;
-                if (sub.path.length > 0) {
-                    fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                    fieldErrors[sub.path[0]].push(mapper(sub));
-                }
-                else {
-                    formErrors.push(mapper(sub));
-                }
+    }
+    get message() {
+        return JSON.stringify(this.issues, null, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = {};
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                fieldErrors[sub.path[0]].push(mapper(sub));
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                formErrors.push(mapper(sub));
             }
-            finally { if (e_2) throw e_2.error; }
         }
-        return { formErrors: formErrors, fieldErrors: fieldErrors };
-    };
-    Object.defineProperty(ZodError.prototype, "formErrors", {
-        get: function () {
-            return this.flatten();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodError.create = function (issues) {
-        var error = new ZodError(issues);
-        return error;
-    };
-    return ZodError;
-}(Error));
-var defaultErrorMap = function (issue, _ctx) {
-    var message;
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};
+const defaultErrorMap = (issue, _ctx) => {
+    let message;
     switch (issue.code) {
         case ZodIssueCode.invalid_type:
             if (issue.received === "undefined") {
                 message = "Required";
             }
             else {
-                message = "Expected ".concat(issue.expected, ", received ").concat(issue.received);
+                message = `Expected ${issue.expected}, received ${issue.received}`;
             }
             break;
         case ZodIssueCode.unrecognized_keys:
-            message = "Unrecognized key(s) in object: ".concat(issue.keys
-                .map(function (k) { return "'".concat(k, "'"); })
-                .join(", "));
+            message = `Unrecognized key(s) in object: ${issue.keys
+                .map((k) => `'${k}'`)
+                .join(", ")}`;
             break;
         case ZodIssueCode.invalid_union:
-            message = "Invalid input";
+            message = `Invalid input`;
             break;
         case ZodIssueCode.invalid_union_discriminator:
-            message = "Invalid discriminator value. Expected ".concat(issue.options
-                .map(function (val) { return (typeof val === "string" ? "'".concat(val, "'") : val); })
-                .join(" | "));
+            message = `Invalid discriminator value. Expected ${issue.options
+                .map((val) => (typeof val === "string" ? `'${val}'` : val))
+                .join(" | ")}`;
             break;
         case ZodIssueCode.invalid_enum_value:
-            message = "Invalid enum value. Expected ".concat(issue.options
-                .map(function (val) { return (typeof val === "string" ? "'".concat(val, "'") : val); })
-                .join(" | "));
+            message = `Invalid enum value. Expected ${issue.options
+                .map((val) => (typeof val === "string" ? `'${val}'` : val))
+                .join(" | ")}`;
             break;
         case ZodIssueCode.invalid_arguments:
-            message = "Invalid function arguments";
+            message = `Invalid function arguments`;
             break;
         case ZodIssueCode.invalid_return_type:
-            message = "Invalid function return type";
+            message = `Invalid function return type`;
             break;
         case ZodIssueCode.invalid_date:
-            message = "Invalid date";
+            message = `Invalid date`;
             break;
         case ZodIssueCode.invalid_string:
             if (issue.validation !== "regex")
-                message = "Invalid ".concat(issue.validation);
+                message = `Invalid ${issue.validation}`;
             else
                 message = "Invalid";
             break;
         case ZodIssueCode.too_small:
             if (issue.type === "array")
-                message = "Array must contain ".concat(issue.inclusive ? "at least" : "more than", " ").concat(issue.minimum, " element(s)");
+                message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
             else if (issue.type === "string")
-                message = "String must contain ".concat(issue.inclusive ? "at least" : "over", " ").concat(issue.minimum, " character(s)");
+                message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
             else if (issue.type === "number")
-                message = "Number must be greater than ".concat(issue.inclusive ? "or equal to " : "").concat(issue.minimum);
+                message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
             else
                 message = "Invalid input";
             break;
         case ZodIssueCode.too_big:
             if (issue.type === "array")
-                message = "Array must contain ".concat(issue.inclusive ? "at most" : "less than", " ").concat(issue.maximum, " element(s)");
+                message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
             else if (issue.type === "string")
-                message = "String must contain ".concat(issue.inclusive ? "at most" : "under", " ").concat(issue.maximum, " character(s)");
+                message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
             else if (issue.type === "number")
-                message = "Number must be less than ".concat(issue.inclusive ? "or equal to " : "").concat(issue.maximum);
+                message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
             else
                 message = "Invalid input";
             break;
         case ZodIssueCode.custom:
-            message = "Invalid input";
+            message = `Invalid input`;
             break;
         case ZodIssueCode.invalid_intersection_types:
-            message = "Intersection results could not be merged";
+            message = `Intersection results could not be merged`;
             break;
         case ZodIssueCode.not_multiple_of:
-            message = "Number must be a multiple of ".concat(issue.multipleOf);
+            message = `Number must be a multiple of ${issue.multipleOf}`;
             break;
         default:
             message = _ctx.defaultError;
             util.assertNever(issue);
     }
-    return { message: message };
+    return { message };
 };
-var overrideErrorMap = defaultErrorMap;
-var setErrorMap = function (map) {
+let overrideErrorMap = defaultErrorMap;
+const setErrorMap = (map) => {
     overrideErrorMap = map;
 };
 
-var ZodParsedType = util.arrayToEnum([
+const ZodParsedType = util.arrayToEnum([
     "string",
     "nan",
     "number",
@@ -471,83 +273,72 @@ var ZodParsedType = util.arrayToEnum([
     "map",
     "set",
 ]);
-function cacheAndReturn(data, parsedType, cache) {
-    if (cache)
-        cache.set(data, parsedType);
-    return parsedType;
-}
-var getParsedType = function (data, cache) {
-    if (cache && cache.has(data))
-        return cache.get(data);
-    var t = typeof data;
+const getParsedType = (data) => {
+    const t = typeof data;
     switch (t) {
         case "undefined":
-            return cacheAndReturn(data, ZodParsedType.undefined, cache);
+            return ZodParsedType.undefined;
         case "string":
-            return cacheAndReturn(data, ZodParsedType.string, cache);
+            return ZodParsedType.string;
         case "number":
-            return cacheAndReturn(data, isNaN(data) ? ZodParsedType.nan : ZodParsedType.number, cache);
+            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
         case "boolean":
-            return cacheAndReturn(data, ZodParsedType.boolean, cache);
+            return ZodParsedType.boolean;
         case "function":
-            return cacheAndReturn(data, ZodParsedType.function, cache);
+            return ZodParsedType.function;
         case "bigint":
-            return cacheAndReturn(data, ZodParsedType.bigint, cache);
+            return ZodParsedType.bigint;
         case "object":
             if (Array.isArray(data)) {
-                return cacheAndReturn(data, ZodParsedType.array, cache);
+                return ZodParsedType.array;
             }
             if (data === null) {
-                return cacheAndReturn(data, ZodParsedType.null, cache);
+                return ZodParsedType.null;
             }
             if (data.then &&
                 typeof data.then === "function" &&
                 data.catch &&
                 typeof data.catch === "function") {
-                return cacheAndReturn(data, ZodParsedType.promise, cache);
+                return ZodParsedType.promise;
             }
             if (typeof Map !== "undefined" && data instanceof Map) {
-                return cacheAndReturn(data, ZodParsedType.map, cache);
+                return ZodParsedType.map;
             }
             if (typeof Set !== "undefined" && data instanceof Set) {
-                return cacheAndReturn(data, ZodParsedType.set, cache);
+                return ZodParsedType.set;
             }
             if (typeof Date !== "undefined" && data instanceof Date) {
-                return cacheAndReturn(data, ZodParsedType.date, cache);
+                return ZodParsedType.date;
             }
-            return cacheAndReturn(data, ZodParsedType.object, cache);
+            return ZodParsedType.object;
         default:
-            return cacheAndReturn(data, ZodParsedType.unknown, cache);
+            return ZodParsedType.unknown;
     }
 };
-var makeIssue = function (params) {
-    var e_1, _a;
-    var data = params.data, path = params.path, errorMaps = params.errorMaps, issueData = params.issueData;
-    var fullPath = __spreadArray(__spreadArray([], __read(path), false), __read((issueData.path || [])), false);
-    var fullIssue = __assign(__assign({}, issueData), { path: fullPath });
-    var errorMessage = "";
-    var maps = errorMaps
-        .filter(function (m) { return !!m; })
+const makeIssue = (params) => {
+    const { data, path, errorMaps, issueData } = params;
+    const fullPath = [...path, ...(issueData.path || [])];
+    const fullIssue = {
+        ...issueData,
+        path: fullPath,
+    };
+    let errorMessage = "";
+    const maps = errorMaps
+        .filter((m) => !!m)
         .slice()
         .reverse();
-    try {
-        for (var maps_1 = __values(maps), maps_1_1 = maps_1.next(); !maps_1_1.done; maps_1_1 = maps_1.next()) {
-            var map = maps_1_1.value;
-            errorMessage = map(fullIssue, { data: data, defaultError: errorMessage }).message;
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (maps_1_1 && !maps_1_1.done && (_a = maps_1.return)) _a.call(maps_1);
-        }
-        finally { if (e_1) throw e_1.error; }
+    for (const map of maps) {
+        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
     }
-    return __assign(__assign({}, issueData), { path: fullPath, message: issueData.message || errorMessage });
+    return {
+        ...issueData,
+        path: fullPath,
+        message: issueData.message || errorMessage,
+    };
 };
-var EMPTY_PATH = [];
+const EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
-    var issue = makeIssue({
+    const issue = makeIssue({
         issueData: issueData,
         data: ctx.data,
         path: ctx.path,
@@ -556,149 +347,79 @@ function addIssueToContext(ctx, issueData) {
             ctx.schemaErrorMap,
             overrideErrorMap,
             defaultErrorMap, // then global default map
-        ].filter(function (x) { return !!x; }),
+        ].filter((x) => !!x),
     });
     ctx.issues.push(issue);
 }
-var ParseStatus = /** @class */ (function () {
-    function ParseStatus() {
+class ParseStatus {
+    constructor() {
         this.value = "valid";
     }
-    ParseStatus.prototype.dirty = function () {
+    dirty() {
         if (this.value === "valid")
             this.value = "dirty";
-    };
-    ParseStatus.prototype.abort = function () {
+    }
+    abort() {
         if (this.value !== "aborted")
             this.value = "aborted";
-    };
-    ParseStatus.mergeArray = function (status, results) {
-        var e_2, _a;
-        var arrayValue = [];
-        try {
-            for (var results_1 = __values(results), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
-                var s = results_1_1.value;
-                if (s.status === "aborted")
-                    return INVALID;
-                if (s.status === "dirty")
-                    status.dirty();
-                arrayValue.push(s.value);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1);
-            }
-            finally { if (e_2) throw e_2.error; }
+    }
+    static mergeArray(status, results) {
+        const arrayValue = [];
+        for (const s of results) {
+            if (s.status === "aborted")
+                return INVALID;
+            if (s.status === "dirty")
+                status.dirty();
+            arrayValue.push(s.value);
         }
         return { status: status.value, value: arrayValue };
-    };
-    ParseStatus.mergeObjectAsync = function (status, pairs) {
-        return __awaiter(this, void 0, void 0, function () {
-            var syncPairs, pairs_1, pairs_1_1, pair, _a, _b, e_3_1;
-            var e_3, _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        syncPairs = [];
-                        _e.label = 1;
-                    case 1:
-                        _e.trys.push([1, 7, 8, 9]);
-                        pairs_1 = __values(pairs), pairs_1_1 = pairs_1.next();
-                        _e.label = 2;
-                    case 2:
-                        if (!!pairs_1_1.done) return [3 /*break*/, 6];
-                        pair = pairs_1_1.value;
-                        _b = (_a = syncPairs).push;
-                        _d = {};
-                        return [4 /*yield*/, pair.key];
-                    case 3:
-                        _d.key = _e.sent();
-                        return [4 /*yield*/, pair.value];
-                    case 4:
-                        _b.apply(_a, [(_d.value = _e.sent(),
-                                _d)]);
-                        _e.label = 5;
-                    case 5:
-                        pairs_1_1 = pairs_1.next();
-                        return [3 /*break*/, 2];
-                    case 6: return [3 /*break*/, 9];
-                    case 7:
-                        e_3_1 = _e.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 9];
-                    case 8:
-                        try {
-                            if (pairs_1_1 && !pairs_1_1.done && (_c = pairs_1.return)) _c.call(pairs_1);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                        return [7 /*endfinally*/];
-                    case 9: return [2 /*return*/, ParseStatus.mergeObjectSync(status, syncPairs)];
-                }
+    }
+    static async mergeObjectAsync(status, pairs) {
+        const syncPairs = [];
+        for (const pair of pairs) {
+            syncPairs.push({
+                key: await pair.key,
+                value: await pair.value,
             });
-        });
-    };
-    ParseStatus.mergeObjectSync = function (status, pairs) {
-        var e_4, _a;
-        var finalObject = {};
-        try {
-            for (var pairs_2 = __values(pairs), pairs_2_1 = pairs_2.next(); !pairs_2_1.done; pairs_2_1 = pairs_2.next()) {
-                var pair = pairs_2_1.value;
-                var key = pair.key, value = pair.value;
-                if (key.status === "aborted")
-                    return INVALID;
-                if (value.status === "aborted")
-                    return INVALID;
-                if (key.status === "dirty")
-                    status.dirty();
-                if (value.status === "dirty")
-                    status.dirty();
-                if (typeof value.value !== "undefined" || pair.alwaysSet) {
-                    finalObject[key.value] = value.value;
-                }
-            }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (pairs_2_1 && !pairs_2_1.done && (_a = pairs_2.return)) _a.call(pairs_2);
+        return ParseStatus.mergeObjectSync(status, syncPairs);
+    }
+    static mergeObjectSync(status, pairs) {
+        const finalObject = {};
+        for (const pair of pairs) {
+            const { key, value } = pair;
+            if (key.status === "aborted")
+                return INVALID;
+            if (value.status === "aborted")
+                return INVALID;
+            if (key.status === "dirty")
+                status.dirty();
+            if (value.status === "dirty")
+                status.dirty();
+            if (typeof value.value !== "undefined" || pair.alwaysSet) {
+                finalObject[key.value] = value.value;
             }
-            finally { if (e_4) throw e_4.error; }
         }
         return { status: status.value, value: finalObject };
-    };
-    return ParseStatus;
-}());
-var INVALID = Object.freeze({
+    }
+}
+const INVALID = Object.freeze({
     status: "aborted",
 });
-var DIRTY = function (value) { return ({ status: "dirty", value: value }); };
-var OK = function (value) { return ({ status: "valid", value: value }); };
-var isAborted = function (x) {
-    return x.status === "aborted";
-};
-var isDirty = function (x) {
-    return x.status === "dirty";
-};
-var isValid = function (x) {
-    return x.status === "valid";
-};
-var isAsync = function (x) {
-    return typeof Promise !== undefined && x instanceof Promise;
-};
+const DIRTY = (value) => ({ status: "dirty", value });
+const OK = (value) => ({ status: "valid", value });
+const isAborted = (x) => x.status === "aborted";
+const isDirty = (x) => x.status === "dirty";
+const isValid = (x) => x.status === "valid";
+const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;
 
 var errorUtil;
 (function (errorUtil) {
-    errorUtil.errToObj = function (message) {
-        return typeof message === "string" ? { message: message } : message || {};
-    };
-    errorUtil.toString = function (message) {
-        return typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
-    };
+    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+    errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 
-var handleResult = function (ctx, result) {
+const handleResult = (ctx, result) => {
     if (isValid(result)) {
         return { success: true, data: result.value };
     }
@@ -706,20 +427,20 @@ var handleResult = function (ctx, result) {
         if (!ctx.issues.length) {
             throw new Error("Validation failed but no issues detected.");
         }
-        var error = new ZodError(ctx.issues);
-        return { success: false, error: error };
+        const error = new ZodError(ctx.issues);
+        return { success: false, error };
     }
 };
 function processCreateParams(params) {
     if (!params)
         return {};
-    var errorMap = params.errorMap, invalid_type_error = params.invalid_type_error, required_error = params.required_error, description = params.description;
+    const { errorMap, invalid_type_error, required_error, description } = params;
     if (errorMap && (invalid_type_error || required_error)) {
-        throw new Error("Can't use \"invalid\" or \"required\" in conjunction with custom error map.");
+        throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
     }
     if (errorMap)
-        return { errorMap: errorMap, description: description };
-    var customMap = function (iss, ctx) {
+        return { errorMap: errorMap, description };
+    const customMap = (iss, ctx) => {
         if (iss.code !== "invalid_type")
             return { message: ctx.defaultError };
         if (typeof ctx.data === "undefined" && required_error)
@@ -728,10 +449,10 @@ function processCreateParams(params) {
             return { message: params.invalid_type_error };
         return { message: ctx.defaultError };
     };
-    return { errorMap: customMap, description: description };
+    return { errorMap: customMap, description };
 }
-var ZodType = /** @class */ (function () {
-    function ZodType(def) {
+class ZodType {
+    constructor(def) {
         /** Alias of safeParseAsync */
         this.spa = this.safeParseAsync;
         this.superRefine = this._refinement;
@@ -757,99 +478,81 @@ var ZodType = /** @class */ (function () {
         this.isOptional = this.isOptional.bind(this);
         this.isNullable = this.isNullable.bind(this);
     }
-    Object.defineProperty(ZodType.prototype, "description", {
-        get: function () {
-            return this._def.description;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodType.prototype._processInputParams = function (input) {
+    get description() {
+        return this._def.description;
+    }
+    _processInputParams(input) {
         return {
             status: new ParseStatus(),
-            ctx: __assign(__assign({}, input.parent), { data: input.data, parsedType: getParsedType(input.data, input.parent.typeCache), schemaErrorMap: this._def.errorMap, path: input.path, parent: input.parent }),
+            ctx: {
+                ...input.parent,
+                data: input.data,
+                parsedType: getParsedType(input.data),
+                schemaErrorMap: this._def.errorMap,
+                path: input.path,
+                parent: input.parent,
+            },
         };
-    };
-    ZodType.prototype._parseSync = function (input) {
-        var result = this._parse(input);
+    }
+    _parseSync(input) {
+        const result = this._parse(input);
         if (isAsync(result)) {
             throw new Error("Synchronous parse encountered promise.");
         }
         return result;
-    };
-    ZodType.prototype._parseAsync = function (input) {
-        var result = this._parse(input);
+    }
+    _parseAsync(input) {
+        const result = this._parse(input);
         return Promise.resolve(result);
-    };
-    ZodType.prototype.parse = function (data, params) {
-        var result = this.safeParse(data, params);
+    }
+    parse(data, params) {
+        const result = this.safeParse(data, params);
         if (result.success)
             return result.data;
         throw result.error;
-    };
-    ZodType.prototype.safeParse = function (data, params) {
+    }
+    safeParse(data, params) {
         var _a;
-        var ctx = {
+        const ctx = {
             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,
-            typeCache: typeof Map !== "undefined" ? new Map() : undefined,
             parent: null,
-            data: data,
+            data,
             parsedType: getParsedType(data),
         };
-        var result = this._parseSync({ data: data, path: ctx.path, parent: ctx });
+        const result = this._parseSync({ data, path: ctx.path, parent: ctx });
         return handleResult(ctx, result);
-    };
-    ZodType.prototype.parseAsync = function (data, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.safeParseAsync(data, params)];
-                    case 1:
-                        result = _a.sent();
-                        if (result.success)
-                            return [2 /*return*/, result.data];
-                        throw result.error;
-                }
-            });
-        });
-    };
-    ZodType.prototype.safeParseAsync = function (data, params) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ctx, maybeAsyncResult, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        ctx = {
-                            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,
-                            typeCache: typeof Map !== "undefined" ? new Map() : undefined,
-                            parent: null,
-                            data: data,
-                            parsedType: getParsedType(data),
-                        };
-                        maybeAsyncResult = this._parse({ data: data, path: [], parent: ctx });
-                        return [4 /*yield*/, (isAsync(maybeAsyncResult)
-                                ? maybeAsyncResult
-                                : Promise.resolve(maybeAsyncResult))];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, handleResult(ctx, result)];
-                }
-            });
-        });
-    };
-    ZodType.prototype.refine = function (check, message) {
-        var getIssueProperties = function (val) {
+    }
+    async parseAsync(data, params) {
+        const result = await this.safeParseAsync(data, params);
+        if (result.success)
+            return result.data;
+        throw result.error;
+    }
+    async safeParseAsync(data, params) {
+        const ctx = {
+            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),
+        };
+        const maybeAsyncResult = this._parse({ data, path: [], parent: ctx });
+        const result = await (isAsync(maybeAsyncResult)
+            ? maybeAsyncResult
+            : Promise.resolve(maybeAsyncResult));
+        return handleResult(ctx, result);
+    }
+    refine(check, message) {
+        const getIssueProperties = (val) => {
             if (typeof message === "string" || typeof message === "undefined") {
-                return { message: message };
+                return { message };
             }
             else if (typeof message === "function") {
                 return message(val);
@@ -858,13 +561,14 @@ var ZodType = /** @class */ (function () {
                 return message;
             }
         };
-        return this._refinement(function (val, ctx) {
-            var result = check(val);
-            var setError = function () {
-                return ctx.addIssue(__assign({ code: ZodIssueCode.custom }, getIssueProperties(val)));
-            };
+        return this._refinement((val, ctx) => {
+            const result = check(val);
+            const setError = () => ctx.addIssue({
+                code: ZodIssueCode.custom,
+                ...getIssueProperties(val),
+            });
             if (typeof Promise !== "undefined" && result instanceof Promise) {
-                return result.then(function (data) {
+                return result.then((data) => {
                     if (!data) {
                         setError();
                         return false;
@@ -882,9 +586,9 @@ var ZodType = /** @class */ (function () {
                 return true;
             }
         });
-    };
-    ZodType.prototype.refinement = function (check, refinementData) {
-        return this._refinement(function (val, ctx) {
+    }
+    refinement(check, refinementData) {
+        return this._refinement((val, ctx) => {
             if (!check(val)) {
                 ctx.addIssue(typeof refinementData === "function"
                     ? refinementData(val, ctx)
@@ -895,88 +599,87 @@ var ZodType = /** @class */ (function () {
                 return true;
             }
         });
-    };
-    ZodType.prototype._refinement = function (refinement) {
+    }
+    _refinement(refinement) {
         return new ZodEffects({
             schema: this,
             typeName: ZodFirstPartyTypeKind.ZodEffects,
-            effect: { type: "refinement", refinement: refinement },
+            effect: { type: "refinement", refinement },
         });
-    };
-    ZodType.prototype.optional = function () {
+    }
+    optional() {
         return ZodOptional.create(this);
-    };
-    ZodType.prototype.nullable = function () {
+    }
+    nullable() {
         return ZodNullable.create(this);
-    };
-    ZodType.prototype.nullish = function () {
+    }
+    nullish() {
         return this.optional().nullable();
-    };
-    ZodType.prototype.array = function () {
+    }
+    array() {
         return ZodArray.create(this);
-    };
-    ZodType.prototype.promise = function () {
+    }
+    promise() {
         return ZodPromise.create(this);
-    };
-    ZodType.prototype.or = function (option) {
+    }
+    or(option) {
         return ZodUnion.create([this, option]);
-    };
-    ZodType.prototype.and = function (incoming) {
+    }
+    and(incoming) {
         return ZodIntersection.create(this, incoming);
-    };
-    ZodType.prototype.transform = function (transform) {
+    }
+    transform(transform) {
         return new ZodEffects({
             schema: this,
             typeName: ZodFirstPartyTypeKind.ZodEffects,
-            effect: { type: "transform", transform: transform },
+            effect: { type: "transform", transform },
         });
-    };
-    ZodType.prototype.default = function (def) {
-        var defaultValueFunc = typeof def === "function" ? def : function () { return def; };
+    }
+    default(def) {
+        const defaultValueFunc = typeof def === "function" ? def : () => def;
         return new ZodDefault({
             innerType: this,
             defaultValue: defaultValueFunc,
             typeName: ZodFirstPartyTypeKind.ZodDefault,
         });
-    };
-    ZodType.prototype.describe = function (description) {
-        var This = this.constructor;
-        return new This(__assign(__assign({}, this._def), { description: description }));
-    };
-    ZodType.prototype.isOptional = function () {
+    }
+    describe(description) {
+        const This = this.constructor;
+        return new This({
+            ...this._def,
+            description,
+        });
+    }
+    isOptional() {
         return this.safeParse(undefined).success;
-    };
-    ZodType.prototype.isNullable = function () {
+    }
+    isNullable() {
         return this.safeParse(null).success;
-    };
-    return ZodType;
-}());
-var cuidRegex = /^c[^\s-]{8,}$/i;
-var 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;
+    }
+}
+const cuidRegex = /^c[^\s-]{8,}$/i;
+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
 // const emailRegex = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
 // eslint-disable-next-line
-var emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
-var ZodString = /** @class */ (function (_super) {
-    __extends(ZodString, _super);
-    function ZodString() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._regex = function (regex, validation, message) {
-            return _this.refinement(function (data) { return regex.test(data); }, __assign({ validation: validation, code: ZodIssueCode.invalid_string }, errorUtil.errToObj(message)));
-        };
+const emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+class ZodString extends ZodType {
+    constructor() {
+        super(...arguments);
+        this._regex = (regex, validation, message) => this.refinement((data) => regex.test(data), {
+            validation,
+            code: ZodIssueCode.invalid_string,
+            ...errorUtil.errToObj(message),
+        });
         /**
          * Deprecated.
          * Use z.string().min(1) instead.
          */
-        _this.nonempty = function (message) {
-            return _this.min(1, errorUtil.errToObj(message));
-        };
-        return _this;
+        this.nonempty = (message) => this.min(1, errorUtil.errToObj(message));
     }
-    ZodString.prototype._parse = function (input) {
-        var e_1, _a;
-        var _b = this._processInputParams(input), status = _b.status, ctx = _b.ctx;
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.string) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -987,210 +690,191 @@ var ZodString = /** @class */ (function (_super) {
             );
             return INVALID;
         }
-        try {
-            for (var _c = __values(this._def.checks), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var check = _d.value;
-                if (check.kind === "min") {
-                    if (ctx.data.length < check.value) {
-                        addIssueToContext(ctx, {
-                            code: ZodIssueCode.too_small,
-                            minimum: check.value,
-                            type: "string",
-                            inclusive: true,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+        for (const check of this._def.checks) {
+            if (check.kind === "min") {
+                if (ctx.data.length < check.value) {
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_small,
+                        minimum: check.value,
+                        type: "string",
+                        inclusive: true,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else if (check.kind === "max") {
-                    if (ctx.data.length > check.value) {
-                        addIssueToContext(ctx, {
-                            code: ZodIssueCode.too_big,
-                            maximum: check.value,
-                            type: "string",
-                            inclusive: true,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+            }
+            else if (check.kind === "max") {
+                if (ctx.data.length > check.value) {
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_big,
+                        maximum: check.value,
+                        type: "string",
+                        inclusive: true,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else if (check.kind === "email") {
-                    if (!emailRegex.test(ctx.data)) {
-                        addIssueToContext(ctx, {
-                            validation: "email",
-                            code: ZodIssueCode.invalid_string,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+            }
+            else if (check.kind === "email") {
+                if (!emailRegex.test(ctx.data)) {
+                    addIssueToContext(ctx, {
+                        validation: "email",
+                        code: ZodIssueCode.invalid_string,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else if (check.kind === "uuid") {
-                    if (!uuidRegex.test(ctx.data)) {
-                        addIssueToContext(ctx, {
-                            validation: "uuid",
-                            code: ZodIssueCode.invalid_string,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+            }
+            else if (check.kind === "uuid") {
+                if (!uuidRegex.test(ctx.data)) {
+                    addIssueToContext(ctx, {
+                        validation: "uuid",
+                        code: ZodIssueCode.invalid_string,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else if (check.kind === "cuid") {
-                    if (!cuidRegex.test(ctx.data)) {
-                        addIssueToContext(ctx, {
-                            validation: "cuid",
-                            code: ZodIssueCode.invalid_string,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+            }
+            else if (check.kind === "cuid") {
+                if (!cuidRegex.test(ctx.data)) {
+                    addIssueToContext(ctx, {
+                        validation: "cuid",
+                        code: ZodIssueCode.invalid_string,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else if (check.kind === "url") {
-                    try {
-                        new URL(ctx.data);
-                    }
-                    catch (_e) {
-                        addIssueToContext(ctx, {
-                            validation: "url",
-                            code: ZodIssueCode.invalid_string,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+            }
+            else if (check.kind === "url") {
+                try {
+                    new URL(ctx.data);
                 }
-                else if (check.kind === "regex") {
-                    check.regex.lastIndex = 0;
-                    var testResult = check.regex.test(ctx.data);
-                    if (!testResult) {
-                        addIssueToContext(ctx, {
-                            validation: "regex",
-                            code: ZodIssueCode.invalid_string,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+                catch (_a) {
+                    addIssueToContext(ctx, {
+                        validation: "url",
+                        code: ZodIssueCode.invalid_string,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            else if (check.kind === "regex") {
+                check.regex.lastIndex = 0;
+                const testResult = check.regex.test(ctx.data);
+                if (!testResult) {
+                    addIssueToContext(ctx, {
+                        validation: "regex",
+                        code: ZodIssueCode.invalid_string,
+                        message: check.message,
+                    });
+                    status.dirty();
+                }
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return { status: status.value, value: ctx.data };
-    };
-    ZodString.prototype._addCheck = function (check) {
-        return new ZodString(__assign(__assign({}, this._def), { checks: __spreadArray(__spreadArray([], __read(this._def.checks), false), [check], false) }));
-    };
-    ZodString.prototype.email = function (message) {
-        return this._addCheck(__assign({ kind: "email" }, errorUtil.errToObj(message)));
-    };
-    ZodString.prototype.url = function (message) {
-        return this._addCheck(__assign({ kind: "url" }, errorUtil.errToObj(message)));
-    };
-    ZodString.prototype.uuid = function (message) {
-        return this._addCheck(__assign({ kind: "uuid" }, errorUtil.errToObj(message)));
-    };
-    ZodString.prototype.cuid = function (message) {
-        return this._addCheck(__assign({ kind: "cuid" }, errorUtil.errToObj(message)));
-    };
-    ZodString.prototype.regex = function (regex, message) {
-        return this._addCheck(__assign({ kind: "regex", regex: regex }, errorUtil.errToObj(message)));
-    };
-    ZodString.prototype.min = function (minLength, message) {
-        return this._addCheck(__assign({ kind: "min", value: minLength }, errorUtil.errToObj(message)));
-    };
-    ZodString.prototype.max = function (maxLength, message) {
-        return this._addCheck(__assign({ kind: "max", value: maxLength }, errorUtil.errToObj(message)));
-    };
-    ZodString.prototype.length = function (len, message) {
+    }
+    _addCheck(check) {
+        return new ZodString({
+            ...this._def,
+            checks: [...this._def.checks, check],
+        });
+    }
+    email(message) {
+        return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
+    }
+    url(message) {
+        return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
+    }
+    uuid(message) {
+        return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
+    }
+    cuid(message) {
+        return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
+    }
+    regex(regex, message) {
+        return this._addCheck({
+            kind: "regex",
+            regex: regex,
+            ...errorUtil.errToObj(message),
+        });
+    }
+    min(minLength, message) {
+        return this._addCheck({
+            kind: "min",
+            value: minLength,
+            ...errorUtil.errToObj(message),
+        });
+    }
+    max(maxLength, message) {
+        return this._addCheck({
+            kind: "max",
+            value: maxLength,
+            ...errorUtil.errToObj(message),
+        });
+    }
+    length(len, message) {
         return this.min(len, message).max(len, message);
-    };
-    Object.defineProperty(ZodString.prototype, "isEmail", {
-        get: function () {
-            return !!this._def.checks.find(function (ch) { return ch.kind === "email"; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodString.prototype, "isURL", {
-        get: function () {
-            return !!this._def.checks.find(function (ch) { return ch.kind === "url"; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodString.prototype, "isUUID", {
-        get: function () {
-            return !!this._def.checks.find(function (ch) { return ch.kind === "uuid"; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodString.prototype, "isCUID", {
-        get: function () {
-            return !!this._def.checks.find(function (ch) { return ch.kind === "cuid"; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodString.prototype, "minLength", {
-        get: function () {
-            var min = -Infinity;
-            this._def.checks.map(function (ch) {
-                if (ch.kind === "min") {
-                    if (min === null || ch.value > min) {
-                        min = ch.value;
-                    }
+    }
+    get isEmail() {
+        return !!this._def.checks.find((ch) => ch.kind === "email");
+    }
+    get isURL() {
+        return !!this._def.checks.find((ch) => ch.kind === "url");
+    }
+    get isUUID() {
+        return !!this._def.checks.find((ch) => ch.kind === "uuid");
+    }
+    get isCUID() {
+        return !!this._def.checks.find((ch) => ch.kind === "cuid");
+    }
+    get minLength() {
+        let min = -Infinity;
+        this._def.checks.map((ch) => {
+            if (ch.kind === "min") {
+                if (min === null || ch.value > min) {
+                    min = ch.value;
                 }
-            });
-            return min;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodString.prototype, "maxLength", {
-        get: function () {
-            var max = null;
-            this._def.checks.map(function (ch) {
-                if (ch.kind === "max") {
-                    if (max === null || ch.value < max) {
-                        max = ch.value;
-                    }
+            }
+        });
+        return min;
+    }
+    get maxLength() {
+        let max = null;
+        this._def.checks.map((ch) => {
+            if (ch.kind === "max") {
+                if (max === null || ch.value < max) {
+                    max = ch.value;
                 }
-            });
-            return max;
-        },
-        enumerable: false,
-        configurable: true
+            }
+        });
+        return max;
+    }
+}
+ZodString.create = (params) => {
+    return new ZodString({
+        checks: [],
+        typeName: ZodFirstPartyTypeKind.ZodString,
+        ...processCreateParams(params),
     });
-    ZodString.create = function (params) {
-        return new ZodString(__assign({ checks: [], typeName: ZodFirstPartyTypeKind.ZodString }, processCreateParams(params)));
-    };
-    return ZodString;
-}(ZodType));
+};
 // https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034
 function floatSafeRemainder(val, step) {
-    var valDecCount = (val.toString().split(".")[1] || "").length;
-    var stepDecCount = (step.toString().split(".")[1] || "").length;
-    var decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-    var valInt = parseInt(val.toFixed(decCount).replace(".", ""));
-    var stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
+    const valDecCount = (val.toString().split(".")[1] || "").length;
+    const stepDecCount = (step.toString().split(".")[1] || "").length;
+    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+    const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
+    const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
     return (valInt % stepInt) / Math.pow(10, decCount);
 }
-var ZodNumber = /** @class */ (function (_super) {
-    __extends(ZodNumber, _super);
-    function ZodNumber() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.min = _this.gte;
-        _this.max = _this.lte;
-        _this.step = _this.multipleOf;
-        return _this;
-    }
-    ZodNumber.prototype._parse = function (input) {
-        var e_2, _a;
-        var _b = this._processInputParams(input), status = _b.status, ctx = _b.ctx;
+class ZodNumber extends ZodType {
+    constructor() {
+        super(...arguments);
+        this.min = this.gte;
+        this.max = this.lte;
+        this.step = this.multipleOf;
+    }
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.number) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1199,213 +883,175 @@ var ZodNumber = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        try {
-            for (var _c = __values(this._def.checks), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var check = _d.value;
-                if (check.kind === "int") {
-                    if (!util.isInteger(ctx.data)) {
-                        addIssueToContext(ctx, {
-                            code: ZodIssueCode.invalid_type,
-                            expected: "integer",
-                            received: "float",
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
-                }
-                else if (check.kind === "min") {
-                    var tooSmall = check.inclusive
-                        ? ctx.data < check.value
-                        : ctx.data <= check.value;
-                    if (tooSmall) {
-                        addIssueToContext(ctx, {
-                            code: ZodIssueCode.too_small,
-                            minimum: check.value,
-                            type: "number",
-                            inclusive: check.inclusive,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+        for (const check of this._def.checks) {
+            if (check.kind === "int") {
+                if (!util.isInteger(ctx.data)) {
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.invalid_type,
+                        expected: "integer",
+                        received: "float",
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else if (check.kind === "max") {
-                    var tooBig = check.inclusive
-                        ? ctx.data > check.value
-                        : ctx.data >= check.value;
-                    if (tooBig) {
-                        addIssueToContext(ctx, {
-                            code: ZodIssueCode.too_big,
-                            maximum: check.value,
-                            type: "number",
-                            inclusive: check.inclusive,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+            }
+            else if (check.kind === "min") {
+                const tooSmall = check.inclusive
+                    ? ctx.data < check.value
+                    : ctx.data <= check.value;
+                if (tooSmall) {
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_small,
+                        minimum: check.value,
+                        type: "number",
+                        inclusive: check.inclusive,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else if (check.kind === "multipleOf") {
-                    if (floatSafeRemainder(ctx.data, check.value) !== 0) {
-                        addIssueToContext(ctx, {
-                            code: ZodIssueCode.not_multiple_of,
-                            multipleOf: check.value,
-                            message: check.message,
-                        });
-                        status.dirty();
-                    }
+            }
+            else if (check.kind === "max") {
+                const tooBig = check.inclusive
+                    ? ctx.data > check.value
+                    : ctx.data >= check.value;
+                if (tooBig) {
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_big,
+                        maximum: check.value,
+                        type: "number",
+                        inclusive: check.inclusive,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
-                else {
-                    util.assertNever(check);
+            }
+            else if (check.kind === "multipleOf") {
+                if (floatSafeRemainder(ctx.data, check.value) !== 0) {
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.not_multiple_of,
+                        multipleOf: check.value,
+                        message: check.message,
+                    });
+                    status.dirty();
                 }
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            else {
+                util.assertNever(check);
             }
-            finally { if (e_2) throw e_2.error; }
         }
         return { status: status.value, value: ctx.data };
-    };
-    ZodNumber.prototype.gte = function (value, message) {
+    }
+    gte(value, message) {
         return this.setLimit("min", value, true, errorUtil.toString(message));
-    };
-    ZodNumber.prototype.gt = function (value, message) {
+    }
+    gt(value, message) {
         return this.setLimit("min", value, false, errorUtil.toString(message));
-    };
-    ZodNumber.prototype.lte = function (value, message) {
+    }
+    lte(value, message) {
         return this.setLimit("max", value, true, errorUtil.toString(message));
-    };
-    ZodNumber.prototype.lt = function (value, message) {
+    }
+    lt(value, message) {
         return this.setLimit("max", value, false, errorUtil.toString(message));
-    };
-    ZodNumber.prototype.setLimit = function (kind, value, inclusive, message) {
-        return new ZodNumber(__assign(__assign({}, this._def), { checks: __spreadArray(__spreadArray([], __read(this._def.checks), false), [
+    }
+    setLimit(kind, value, inclusive, message) {
+        return new ZodNumber({
+            ...this._def,
+            checks: [
+                ...this._def.checks,
                 {
-                    kind: kind,
-                    value: value,
-                    inclusive: inclusive,
+                    kind,
+                    value,
+                    inclusive,
                     message: errorUtil.toString(message),
                 },
-            ], false) }));
-    };
-    ZodNumber.prototype._addCheck = function (check) {
-        return new ZodNumber(__assign(__assign({}, this._def), { checks: __spreadArray(__spreadArray([], __read(this._def.checks), false), [check], false) }));
-    };
-    ZodNumber.prototype.int = function (message) {
+            ],
+        });
+    }
+    _addCheck(check) {
+        return new ZodNumber({
+            ...this._def,
+            checks: [...this._def.checks, check],
+        });
+    }
+    int(message) {
         return this._addCheck({
             kind: "int",
             message: errorUtil.toString(message),
         });
-    };
-    ZodNumber.prototype.positive = function (message) {
+    }
+    positive(message) {
         return this._addCheck({
             kind: "min",
             value: 0,
             inclusive: false,
             message: errorUtil.toString(message),
         });
-    };
-    ZodNumber.prototype.negative = function (message) {
+    }
+    negative(message) {
         return this._addCheck({
             kind: "max",
             value: 0,
             inclusive: false,
             message: errorUtil.toString(message),
         });
-    };
-    ZodNumber.prototype.nonpositive = function (message) {
+    }
+    nonpositive(message) {
         return this._addCheck({
             kind: "max",
             value: 0,
             inclusive: true,
             message: errorUtil.toString(message),
         });
-    };
-    ZodNumber.prototype.nonnegative = function (message) {
+    }
+    nonnegative(message) {
         return this._addCheck({
             kind: "min",
             value: 0,
             inclusive: true,
             message: errorUtil.toString(message),
         });
-    };
-    ZodNumber.prototype.multipleOf = function (value, message) {
+    }
+    multipleOf(value, message) {
         return this._addCheck({
             kind: "multipleOf",
             value: value,
             message: errorUtil.toString(message),
         });
-    };
-    Object.defineProperty(ZodNumber.prototype, "minValue", {
-        get: function () {
-            var e_3, _a;
-            var min = null;
-            try {
-                for (var _b = __values(this._def.checks), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var ch = _c.value;
-                    if (ch.kind === "min") {
-                        if (min === null || ch.value > min)
-                            min = ch.value;
-                    }
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            return min;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodNumber.prototype, "maxValue", {
-        get: function () {
-            var e_4, _a;
-            var max = null;
-            try {
-                for (var _b = __values(this._def.checks), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var ch = _c.value;
-                    if (ch.kind === "max") {
-                        if (max === null || ch.value < max)
-                            max = ch.value;
-                    }
-                }
+    }
+    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;
             }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_4) throw e_4.error; }
+        }
+        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;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodNumber.prototype, "isInt", {
-        get: function () {
-            return !!this._def.checks.find(function (ch) { return ch.kind === "int"; });
-        },
-        enumerable: false,
-        configurable: true
+        }
+        return max;
+    }
+    get isInt() {
+        return !!this._def.checks.find((ch) => ch.kind === "int");
+    }
+}
+ZodNumber.create = (params) => {
+    return new ZodNumber({
+        checks: [],
+        typeName: ZodFirstPartyTypeKind.ZodNumber,
+        ...processCreateParams(params),
     });
-    ZodNumber.create = function (params) {
-        return new ZodNumber(__assign({ checks: [], typeName: ZodFirstPartyTypeKind.ZodNumber }, processCreateParams(params)));
-    };
-    return ZodNumber;
-}(ZodType));
-var ZodBigInt = /** @class */ (function (_super) {
-    __extends(ZodBigInt, _super);
-    function ZodBigInt() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodBigInt.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+};
+class ZodBigInt extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.bigint) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1415,19 +1061,17 @@ var ZodBigInt = /** @class */ (function (_super) {
             return INVALID;
         }
         return OK(ctx.data);
-    };
-    ZodBigInt.create = function (params) {
-        return new ZodBigInt(__assign({ typeName: ZodFirstPartyTypeKind.ZodBigInt }, processCreateParams(params)));
-    };
-    return ZodBigInt;
-}(ZodType));
-var ZodBoolean = /** @class */ (function (_super) {
-    __extends(ZodBoolean, _super);
-    function ZodBoolean() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodBoolean.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodBigInt.create = (params) => {
+    return new ZodBigInt({
+        typeName: ZodFirstPartyTypeKind.ZodBigInt,
+        ...processCreateParams(params),
+    });
+};
+class ZodBoolean extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.boolean) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1437,19 +1081,17 @@ var ZodBoolean = /** @class */ (function (_super) {
             return INVALID;
         }
         return OK(ctx.data);
-    };
-    ZodBoolean.create = function (params) {
-        return new ZodBoolean(__assign({ typeName: ZodFirstPartyTypeKind.ZodBoolean }, processCreateParams(params)));
-    };
-    return ZodBoolean;
-}(ZodType));
-var ZodDate = /** @class */ (function (_super) {
-    __extends(ZodDate, _super);
-    function ZodDate() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodDate.prototype._parse = function (input) {
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
+    }
+}
+ZodBoolean.create = (params) => {
+    return new ZodBoolean({
+        typeName: ZodFirstPartyTypeKind.ZodBoolean,
+        ...processCreateParams(params),
+    });
+};
+class ZodDate extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.date) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1468,19 +1110,17 @@ var ZodDate = /** @class */ (function (_super) {
             status: status.value,
             value: new Date(ctx.data.getTime()),
         };
-    };
-    ZodDate.create = function (params) {
-        return new ZodDate(__assign({ typeName: ZodFirstPartyTypeKind.ZodDate }, processCreateParams(params)));
-    };
-    return ZodDate;
-}(ZodType));
-var ZodUndefined = /** @class */ (function (_super) {
-    __extends(ZodUndefined, _super);
-    function ZodUndefined() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodUndefined.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodDate.create = (params) => {
+    return new ZodDate({
+        typeName: ZodFirstPartyTypeKind.ZodDate,
+        ...processCreateParams(params),
+    });
+};
+class ZodUndefined extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.undefined) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1490,19 +1130,17 @@ var ZodUndefined = /** @class */ (function (_super) {
             return INVALID;
         }
         return OK(ctx.data);
-    };
-    ZodUndefined.create = function (params) {
-        return new ZodUndefined(__assign({ typeName: ZodFirstPartyTypeKind.ZodUndefined }, processCreateParams(params)));
-    };
-    return ZodUndefined;
-}(ZodType));
-var ZodNull = /** @class */ (function (_super) {
-    __extends(ZodNull, _super);
-    function ZodNull() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodNull.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodUndefined.create = (params) => {
+    return new ZodUndefined({
+        typeName: ZodFirstPartyTypeKind.ZodUndefined,
+        ...processCreateParams(params),
+    });
+};
+class ZodNull extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.null) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1512,72 +1150,68 @@ var ZodNull = /** @class */ (function (_super) {
             return INVALID;
         }
         return OK(ctx.data);
-    };
-    ZodNull.create = function (params) {
-        return new ZodNull(__assign({ typeName: ZodFirstPartyTypeKind.ZodNull }, processCreateParams(params)));
-    };
-    return ZodNull;
-}(ZodType));
-var ZodAny = /** @class */ (function (_super) {
-    __extends(ZodAny, _super);
-    function ZodAny() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
+    }
+}
+ZodNull.create = (params) => {
+    return new ZodNull({
+        typeName: ZodFirstPartyTypeKind.ZodNull,
+        ...processCreateParams(params),
+    });
+};
+class ZodAny extends ZodType {
+    constructor() {
+        super(...arguments);
         // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.
-        _this._any = true;
-        return _this;
+        this._any = true;
     }
-    ZodAny.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         return OK(ctx.data);
-    };
-    ZodAny.create = function (params) {
-        return new ZodAny(__assign({ typeName: ZodFirstPartyTypeKind.ZodAny }, processCreateParams(params)));
-    };
-    return ZodAny;
-}(ZodType));
-var ZodUnknown = /** @class */ (function (_super) {
-    __extends(ZodUnknown, _super);
-    function ZodUnknown() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
+    }
+}
+ZodAny.create = (params) => {
+    return new ZodAny({
+        typeName: ZodFirstPartyTypeKind.ZodAny,
+        ...processCreateParams(params),
+    });
+};
+class ZodUnknown extends ZodType {
+    constructor() {
+        super(...arguments);
         // required
-        _this._unknown = true;
-        return _this;
+        this._unknown = true;
     }
-    ZodUnknown.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         return OK(ctx.data);
-    };
-    ZodUnknown.create = function (params) {
-        return new ZodUnknown(__assign({ typeName: ZodFirstPartyTypeKind.ZodUnknown }, processCreateParams(params)));
-    };
-    return ZodUnknown;
-}(ZodType));
-var ZodNever = /** @class */ (function (_super) {
-    __extends(ZodNever, _super);
-    function ZodNever() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodNever.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodUnknown.create = (params) => {
+    return new ZodUnknown({
+        typeName: ZodFirstPartyTypeKind.ZodUnknown,
+        ...processCreateParams(params),
+    });
+};
+class ZodNever extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.never,
             received: ctx.parsedType,
         });
         return INVALID;
-    };
-    ZodNever.create = function (params) {
-        return new ZodNever(__assign({ typeName: ZodFirstPartyTypeKind.ZodNever }, processCreateParams(params)));
-    };
-    return ZodNever;
-}(ZodType));
-var ZodVoid = /** @class */ (function (_super) {
-    __extends(ZodVoid, _super);
-    function ZodVoid() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodVoid.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodNever.create = (params) => {
+    return new ZodNever({
+        typeName: ZodFirstPartyTypeKind.ZodNever,
+        ...processCreateParams(params),
+    });
+};
+class ZodVoid extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.undefined) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1587,20 +1221,18 @@ var ZodVoid = /** @class */ (function (_super) {
             return INVALID;
         }
         return OK(ctx.data);
-    };
-    ZodVoid.create = function (params) {
-        return new ZodVoid(__assign({ typeName: ZodFirstPartyTypeKind.ZodVoid }, processCreateParams(params)));
-    };
-    return ZodVoid;
-}(ZodType));
-var ZodArray = /** @class */ (function (_super) {
-    __extends(ZodArray, _super);
-    function ZodArray() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodArray.prototype._parse = function (input) {
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
-        var def = this._def;
+    }
+}
+ZodVoid.create = (params) => {
+    return new ZodVoid({
+        typeName: ZodFirstPartyTypeKind.ZodVoid,
+        ...processCreateParams(params),
+    });
+};
+class ZodArray extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        const def = this._def;
         if (ctx.parsedType !== ZodParsedType.array) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1634,49 +1266,56 @@ var ZodArray = /** @class */ (function (_super) {
             }
         }
         if (ctx.async) {
-            return Promise.all(ctx.data.map(function (item, i) {
+            return Promise.all(ctx.data.map((item, i) => {
                 return def.type._parseAsync({
                     parent: ctx,
-                    path: __spreadArray(__spreadArray([], __read(ctx.path), false), [i], false),
+                    path: [...ctx.path, i],
                     data: item,
                 });
-            })).then(function (result) {
+            })).then((result) => {
                 return ParseStatus.mergeArray(status, result);
             });
         }
-        var result = ctx.data.map(function (item, i) {
+        const result = ctx.data.map((item, i) => {
             return def.type._parseSync({
                 parent: ctx,
-                path: __spreadArray(__spreadArray([], __read(ctx.path), false), [i], false),
+                path: [...ctx.path, i],
                 data: item,
             });
         });
         return ParseStatus.mergeArray(status, result);
-    };
-    Object.defineProperty(ZodArray.prototype, "element", {
-        get: function () {
-            return this._def.type;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodArray.prototype.min = function (minLength, message) {
-        return new ZodArray(__assign(__assign({}, this._def), { minLength: { value: minLength, message: errorUtil.toString(message) } }));
-    };
-    ZodArray.prototype.max = function (maxLength, message) {
-        return new ZodArray(__assign(__assign({}, this._def), { maxLength: { value: maxLength, message: errorUtil.toString(message) } }));
-    };
-    ZodArray.prototype.length = function (len, message) {
+    }
+    get element() {
+        return this._def.type;
+    }
+    min(minLength, message) {
+        return new ZodArray({
+            ...this._def,
+            minLength: { value: minLength, message: errorUtil.toString(message) },
+        });
+    }
+    max(maxLength, message) {
+        return new ZodArray({
+            ...this._def,
+            maxLength: { value: maxLength, message: errorUtil.toString(message) },
+        });
+    }
+    length(len, message) {
         return this.min(len, message).max(len, message);
-    };
-    ZodArray.prototype.nonempty = function (message) {
+    }
+    nonempty(message) {
         return this.min(1, message);
-    };
-    ZodArray.create = function (schema, params) {
-        return new ZodArray(__assign({ type: schema, minLength: null, maxLength: null, typeName: ZodFirstPartyTypeKind.ZodArray }, processCreateParams(params)));
-    };
-    return ZodArray;
-}(ZodType));
+    }
+}
+ZodArray.create = (schema, params) => {
+    return new ZodArray({
+        type: schema,
+        minLength: null,
+        maxLength: null,
+        typeName: ZodFirstPartyTypeKind.ZodArray,
+        ...processCreateParams(params),
+    });
+};
 /////////////////////////////////////////
 /////////////////////////////////////////
 //////////                     //////////
@@ -1686,21 +1325,33 @@ var ZodArray = /** @class */ (function (_super) {
 /////////////////////////////////////////
 var objectUtil;
 (function (objectUtil) {
-    objectUtil.mergeShapes = function (first, second) {
-        return __assign(__assign({}, first), second);
+    objectUtil.mergeShapes = (first, second) => {
+        return {
+            ...first,
+            ...second, // second overwrites first
+        };
     };
 })(objectUtil || (objectUtil = {}));
-var AugmentFactory = function (def) { return function (augmentation) {
-    return new ZodObject(__assign(__assign({}, def), { shape: function () { return (__assign(__assign({}, def.shape()), augmentation)); } }));
-}; };
+const AugmentFactory = (def) => (augmentation) => {
+    return new ZodObject({
+        ...def,
+        shape: () => ({
+            ...def.shape(),
+            ...augmentation,
+        }),
+    });
+};
 function deepPartialify(schema) {
     if (schema instanceof ZodObject) {
-        var newShape_1 = {};
-        for (var key in schema.shape) {
-            var fieldSchema = schema.shape[key];
-            newShape_1[key] = ZodOptional.create(deepPartialify(fieldSchema));
-        }
-        return new ZodObject(__assign(__assign({}, schema._def), { shape: function () { return newShape_1; } }));
+        const newShape = {};
+        for (const key in schema.shape) {
+            const fieldSchema = schema.shape[key];
+            newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
+        }
+        return new ZodObject({
+            ...schema._def,
+            shape: () => newShape,
+        });
     }
     else if (schema instanceof ZodArray) {
         return ZodArray.create(deepPartialify(schema.element));
@@ -1712,37 +1363,33 @@ function deepPartialify(schema) {
         return ZodNullable.create(deepPartialify(schema.unwrap()));
     }
     else if (schema instanceof ZodTuple) {
-        return ZodTuple.create(schema.items.map(function (item) { return deepPartialify(item); }));
+        return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
     }
     else {
         return schema;
     }
 }
-var ZodObject = /** @class */ (function (_super) {
-    __extends(ZodObject, _super);
-    function ZodObject() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._cached = null;
+class ZodObject extends ZodType {
+    constructor() {
+        super(...arguments);
+        this._cached = null;
         /**
          * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
          * If you want to pass through unknown properties, use `.passthrough()` instead.
          */
-        _this.nonstrict = _this.passthrough;
-        _this.augment = AugmentFactory(_this._def);
-        _this.extend = AugmentFactory(_this._def);
-        return _this;
+        this.nonstrict = this.passthrough;
+        this.augment = AugmentFactory(this._def);
+        this.extend = AugmentFactory(this._def);
     }
-    ZodObject.prototype._getCached = function () {
+    _getCached() {
         if (this._cached !== null)
             return this._cached;
-        var shape = this._def.shape();
-        var keys = util.objectKeys(shape);
-        return (this._cached = { shape: shape, keys: keys });
-    };
-    ZodObject.prototype._parse = function (input) {
-        var e_5, _a, e_6, _b, e_7, _c;
-        var _this = this;
-        var _d = this._processInputParams(input), status = _d.status, ctx = _d.ctx;
+        const shape = this._def.shape();
+        const keys = util.objectKeys(shape);
+        return (this._cached = { shape, keys });
+    }
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.object) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -1751,51 +1398,31 @@ var ZodObject = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        var _e = this._getCached(), shape = _e.shape, shapeKeys = _e.keys;
-        var dataKeys = util.objectKeys(ctx.data);
-        var extraKeys = dataKeys.filter(function (k) { return !shapeKeys.includes(k); });
-        var pairs = [];
-        try {
-            for (var shapeKeys_1 = __values(shapeKeys), shapeKeys_1_1 = shapeKeys_1.next(); !shapeKeys_1_1.done; shapeKeys_1_1 = shapeKeys_1.next()) {
-                var key = shapeKeys_1_1.value;
-                var keyValidator = shape[key];
-                var value = ctx.data[key];
-                pairs.push({
-                    key: { status: "valid", value: key },
-                    value: keyValidator._parse({
-                        parent: ctx,
-                        data: value,
-                        path: __spreadArray(__spreadArray([], __read(ctx.path), false), [key], false),
-                    }),
-                    alwaysSet: key in ctx.data,
-                });
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (shapeKeys_1_1 && !shapeKeys_1_1.done && (_a = shapeKeys_1.return)) _a.call(shapeKeys_1);
-            }
-            finally { if (e_5) throw e_5.error; }
+        const { shape, keys: shapeKeys } = this._getCached();
+        const dataKeys = util.objectKeys(ctx.data);
+        const extraKeys = dataKeys.filter((k) => !shapeKeys.includes(k));
+        const pairs = [];
+        for (const key of shapeKeys) {
+            const keyValidator = shape[key];
+            const value = ctx.data[key];
+            pairs.push({
+                key: { status: "valid", value: key },
+                value: keyValidator._parse({
+                    parent: ctx,
+                    data: value,
+                    path: [...ctx.path, key],
+                }),
+                alwaysSet: key in ctx.data,
+            });
         }
         if (this._def.catchall instanceof ZodNever) {
-            var unknownKeys = this._def.unknownKeys;
+            const unknownKeys = this._def.unknownKeys;
             if (unknownKeys === "passthrough") {
-                try {
-                    for (var extraKeys_1 = __values(extraKeys), extraKeys_1_1 = extraKeys_1.next(); !extraKeys_1_1.done; extraKeys_1_1 = extraKeys_1.next()) {
-                        var key = extraKeys_1_1.value;
-                        pairs.push({
-                            key: { status: "valid", value: key },
-                            value: { status: "valid", value: ctx.data[key] },
-                        });
-                    }
-                }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                finally {
-                    try {
-                        if (extraKeys_1_1 && !extraKeys_1_1.done && (_b = extraKeys_1.return)) _b.call(extraKeys_1);
-                    }
-                    finally { if (e_6) throw e_6.error; }
+                for (const key of extraKeys) {
+                    pairs.push({
+                        key: { status: "valid", value: key },
+                        value: { status: "valid", value: ctx.data[key] },
+                    });
                 }
             }
             else if (unknownKeys === "strict") {
@@ -1809,321 +1436,296 @@ var ZodObject = /** @class */ (function (_super) {
             }
             else if (unknownKeys === "strip") ;
             else {
-                throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+                throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
             }
         }
         else {
             // run catchall validation
-            var catchall = this._def.catchall;
-            try {
-                for (var extraKeys_2 = __values(extraKeys), extraKeys_2_1 = extraKeys_2.next(); !extraKeys_2_1.done; extraKeys_2_1 = extraKeys_2.next()) {
-                    var key = extraKeys_2_1.value;
-                    var value = ctx.data[key];
-                    pairs.push({
-                        key: { status: "valid", value: key },
-                        value: catchall._parse({ parent: ctx, path: __spreadArray(__spreadArray([], __read(ctx.path), false), [key], false), data: value } //, ctx.child(key), value, getParsedType(value)
-                        ),
-                        alwaysSet: key in ctx.data,
-                    });
-                }
-            }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (extraKeys_2_1 && !extraKeys_2_1.done && (_c = extraKeys_2.return)) _c.call(extraKeys_2);
-                }
-                finally { if (e_7) throw e_7.error; }
+            const catchall = this._def.catchall;
+            for (const key of extraKeys) {
+                const value = ctx.data[key];
+                pairs.push({
+                    key: { status: "valid", value: key },
+                    value: catchall._parse({ parent: ctx, path: [...ctx.path, key], data: value } //, ctx.child(key), value, getParsedType(value)
+                    ),
+                    alwaysSet: key in ctx.data,
+                });
             }
         }
         if (ctx.async) {
             return Promise.resolve()
-                .then(function () { return __awaiter(_this, void 0, void 0, function () {
-                var syncPairs, pairs_1, pairs_1_1, pair, key, _a, _b, e_8_1;
-                var e_8, _c, _d;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
-                        case 0:
-                            syncPairs = [];
-                            _e.label = 1;
-                        case 1:
-                            _e.trys.push([1, 7, 8, 9]);
-                            pairs_1 = __values(pairs), pairs_1_1 = pairs_1.next();
-                            _e.label = 2;
-                        case 2:
-                            if (!!pairs_1_1.done) return [3 /*break*/, 6];
-                            pair = pairs_1_1.value;
-                            return [4 /*yield*/, pair.key];
-                        case 3:
-                            key = _e.sent();
-                            _b = (_a = syncPairs).push;
-                            _d = {
-                                key: key
-                            };
-                            return [4 /*yield*/, pair.value];
-                        case 4:
-                            _b.apply(_a, [(_d.value = _e.sent(),
-                                    _d.alwaysSet = pair.alwaysSet,
-                                    _d)]);
-                            _e.label = 5;
-                        case 5:
-                            pairs_1_1 = pairs_1.next();
-                            return [3 /*break*/, 2];
-                        case 6: return [3 /*break*/, 9];
-                        case 7:
-                            e_8_1 = _e.sent();
-                            e_8 = { error: e_8_1 };
-                            return [3 /*break*/, 9];
-                        case 8:
-                            try {
-                                if (pairs_1_1 && !pairs_1_1.done && (_c = pairs_1.return)) _c.call(pairs_1);
-                            }
-                            finally { if (e_8) throw e_8.error; }
-                            return [7 /*endfinally*/];
-                        case 9: return [2 /*return*/, syncPairs];
-                    }
-                });
-            }); })
-                .then(function (syncPairs) {
+                .then(async () => {
+                const syncPairs = [];
+                for (const pair of pairs) {
+                    const key = await pair.key;
+                    syncPairs.push({
+                        key,
+                        value: await pair.value,
+                        alwaysSet: pair.alwaysSet,
+                    });
+                }
+                return syncPairs;
+            })
+                .then((syncPairs) => {
                 return ParseStatus.mergeObjectSync(status, syncPairs);
             });
         }
         else {
             return ParseStatus.mergeObjectSync(status, pairs);
         }
-    };
-    Object.defineProperty(ZodObject.prototype, "shape", {
-        get: function () {
-            return this._def.shape();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodObject.prototype.strict = function (message) {
-        var _this = this;
+    }
+    get shape() {
+        return this._def.shape();
+    }
+    strict(message) {
         errorUtil.errToObj;
-        return new ZodObject(__assign(__assign(__assign({}, this._def), { unknownKeys: "strict" }), (message !== undefined
-            ? {
-                errorMap: function (issue, ctx) {
-                    var _a, _b, _c, _d;
-                    var defaultError = (_c = (_b = (_a = _this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
-                    if (issue.code === "unrecognized_keys")
+        return new ZodObject({
+            ...this._def,
+            unknownKeys: "strict",
+            ...(message !== undefined
+                ? {
+                    errorMap: (issue, ctx) => {
+                        var _a, _b, _c, _d;
+                        const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
+                        if (issue.code === "unrecognized_keys")
+                            return {
+                                message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError,
+                            };
                         return {
-                            message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError,
+                            message: defaultError,
                         };
-                    return {
-                        message: defaultError,
-                    };
-                },
-            }
-            : {})));
-    };
-    ZodObject.prototype.strip = function () {
-        return new ZodObject(__assign(__assign({}, this._def), { unknownKeys: "strip" }));
-    };
-    ZodObject.prototype.passthrough = function () {
-        return new ZodObject(__assign(__assign({}, this._def), { unknownKeys: "passthrough" }));
-    };
-    ZodObject.prototype.setKey = function (key, schema) {
-        var _a;
-        return this.augment((_a = {}, _a[key] = schema, _a));
-    };
+                    },
+                }
+                : {}),
+        });
+    }
+    strip() {
+        return new ZodObject({
+            ...this._def,
+            unknownKeys: "strip",
+        });
+    }
+    passthrough() {
+        return new ZodObject({
+            ...this._def,
+            unknownKeys: "passthrough",
+        });
+    }
+    setKey(key, schema) {
+        return this.augment({ [key]: schema });
+    }
     /**
      * Prior to zod@1.0.12 there was a bug in the
      * inferred type of merged objects. Please
      * upgrade if you are experiencing issues.
      */
-    ZodObject.prototype.merge = function (merging) {
-        var _this = this;
+    merge(merging) {
         // const mergedShape = objectUtil.mergeShapes(
         //   this._def.shape(),
         //   merging._def.shape()
         // );
-        var merged = new ZodObject({
+        const merged = new ZodObject({
             unknownKeys: merging._def.unknownKeys,
             catchall: merging._def.catchall,
-            shape: function () {
-                return objectUtil.mergeShapes(_this._def.shape(), merging._def.shape());
-            },
+            shape: () => objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
             typeName: ZodFirstPartyTypeKind.ZodObject,
         });
         return merged;
-    };
-    ZodObject.prototype.catchall = function (index) {
-        return new ZodObject(__assign(__assign({}, this._def), { catchall: index }));
-    };
-    ZodObject.prototype.pick = function (mask) {
-        var _this = this;
-        var shape = {};
-        util.objectKeys(mask).map(function (key) {
-            shape[key] = _this.shape[key];
+    }
+    catchall(index) {
+        return new ZodObject({
+            ...this._def,
+            catchall: index,
         });
-        return new ZodObject(__assign(__assign({}, this._def), { shape: function () { return shape; } }));
-    };
-    ZodObject.prototype.omit = function (mask) {
-        var _this = this;
-        var shape = {};
-        util.objectKeys(this.shape).map(function (key) {
+    }
+    pick(mask) {
+        const shape = {};
+        util.objectKeys(mask).map((key) => {
+            shape[key] = this.shape[key];
+        });
+        return new ZodObject({
+            ...this._def,
+            shape: () => shape,
+        });
+    }
+    omit(mask) {
+        const shape = {};
+        util.objectKeys(this.shape).map((key) => {
             if (util.objectKeys(mask).indexOf(key) === -1) {
-                shape[key] = _this.shape[key];
+                shape[key] = this.shape[key];
             }
         });
-        return new ZodObject(__assign(__assign({}, this._def), { shape: function () { return shape; } }));
-    };
-    ZodObject.prototype.deepPartial = function () {
+        return new ZodObject({
+            ...this._def,
+            shape: () => shape,
+        });
+    }
+    deepPartial() {
         return deepPartialify(this);
-    };
-    ZodObject.prototype.partial = function (mask) {
-        var _this = this;
-        var newShape = {};
+    }
+    partial(mask) {
+        const newShape = {};
         if (mask) {
-            util.objectKeys(this.shape).map(function (key) {
+            util.objectKeys(this.shape).map((key) => {
                 if (util.objectKeys(mask).indexOf(key) === -1) {
-                    newShape[key] = _this.shape[key];
+                    newShape[key] = this.shape[key];
                 }
                 else {
-                    newShape[key] = _this.shape[key].optional();
+                    newShape[key] = this.shape[key].optional();
                 }
             });
-            return new ZodObject(__assign(__assign({}, this._def), { shape: function () { return newShape; } }));
+            return new ZodObject({
+                ...this._def,
+                shape: () => newShape,
+            });
         }
         else {
-            for (var key in this.shape) {
-                var fieldSchema = this.shape[key];
+            for (const key in this.shape) {
+                const fieldSchema = this.shape[key];
                 newShape[key] = fieldSchema.optional();
             }
         }
-        return new ZodObject(__assign(__assign({}, this._def), { shape: function () { return newShape; } }));
-    };
-    ZodObject.prototype.required = function () {
-        var newShape = {};
-        for (var key in this.shape) {
-            var fieldSchema = this.shape[key];
-            var newField = fieldSchema;
+        return new ZodObject({
+            ...this._def,
+            shape: () => newShape,
+        });
+    }
+    required() {
+        const newShape = {};
+        for (const key in this.shape) {
+            const fieldSchema = this.shape[key];
+            let newField = fieldSchema;
             while (newField instanceof ZodOptional) {
                 newField = newField._def.innerType;
             }
             newShape[key] = newField;
         }
-        return new ZodObject(__assign(__assign({}, this._def), { shape: function () { return newShape; } }));
-    };
-    ZodObject.create = function (shape, params) {
-        return new ZodObject(__assign({ shape: function () { return shape; }, unknownKeys: "strip", catchall: ZodNever.create(), typeName: ZodFirstPartyTypeKind.ZodObject }, processCreateParams(params)));
-    };
-    ZodObject.strictCreate = function (shape, params) {
-        return new ZodObject(__assign({ shape: function () { return shape; }, unknownKeys: "strict", catchall: ZodNever.create(), typeName: ZodFirstPartyTypeKind.ZodObject }, processCreateParams(params)));
-    };
-    ZodObject.lazycreate = function (shape, params) {
-        return new ZodObject(__assign({ shape: shape, unknownKeys: "strip", catchall: ZodNever.create(), typeName: ZodFirstPartyTypeKind.ZodObject }, processCreateParams(params)));
-    };
-    return ZodObject;
-}(ZodType));
-var ZodUnion = /** @class */ (function (_super) {
-    __extends(ZodUnion, _super);
-    function ZodUnion() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodUnion.prototype._parse = function (input) {
-        var _this = this;
-        var ctx = this._processInputParams(input).ctx;
-        var options = this._def.options;
+        return new ZodObject({
+            ...this._def,
+            shape: () => newShape,
+        });
+    }
+}
+ZodObject.create = (shape, params) => {
+    return new ZodObject({
+        shape: () => shape,
+        unknownKeys: "strip",
+        catchall: ZodNever.create(),
+        typeName: ZodFirstPartyTypeKind.ZodObject,
+        ...processCreateParams(params),
+    });
+};
+ZodObject.strictCreate = (shape, params) => {
+    return new ZodObject({
+        shape: () => shape,
+        unknownKeys: "strict",
+        catchall: ZodNever.create(),
+        typeName: ZodFirstPartyTypeKind.ZodObject,
+        ...processCreateParams(params),
+    });
+};
+ZodObject.lazycreate = (shape, params) => {
+    return new ZodObject({
+        shape,
+        unknownKeys: "strip",
+        catchall: ZodNever.create(),
+        typeName: ZodFirstPartyTypeKind.ZodObject,
+        ...processCreateParams(params),
+    });
+};
+class ZodUnion extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        const options = this._def.options;
         function handleResults(results) {
-            var e_9, _a, e_10, _b, _c;
-            try {
-                // return first issue-free validation if it exists
-                for (var results_1 = __values(results), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
-                    var result = results_1_1.value;
-                    if (result.result.status === "valid") {
-                        return result.result;
-                    }
-                }
-            }
-            catch (e_9_1) { e_9 = { error: e_9_1 }; }
-            finally {
-                try {
-                    if (results_1_1 && !results_1_1.done && (_a = results_1.return)) _a.call(results_1);
-                }
-                finally { if (e_9) throw e_9.error; }
-            }
-            try {
-                for (var results_2 = __values(results), results_2_1 = results_2.next(); !results_2_1.done; results_2_1 = results_2.next()) {
-                    var result = results_2_1.value;
-                    if (result.result.status === "dirty") {
-                        // add issues from dirty option
-                        (_c = ctx.issues).push.apply(_c, __spreadArray([], __read(result.ctx.issues), false));
-                        return result.result;
-                    }
+            // return first issue-free validation if it exists
+            for (const result of results) {
+                if (result.result.status === "valid") {
+                    return result.result;
                 }
             }
-            catch (e_10_1) { e_10 = { error: e_10_1 }; }
-            finally {
-                try {
-                    if (results_2_1 && !results_2_1.done && (_b = results_2.return)) _b.call(results_2);
+            for (const result of results) {
+                if (result.result.status === "dirty") {
+                    // add issues from dirty option
+                    ctx.issues.push(...result.ctx.issues);
+                    return result.result;
                 }
-                finally { if (e_10) throw e_10.error; }
             }
             // return invalid
-            var unionErrors = results.map(function (result) { return new ZodError(result.ctx.issues); });
+            const unionErrors = results.map((result) => new ZodError(result.ctx.issues));
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_union,
-                unionErrors: unionErrors,
+                unionErrors,
             });
             return INVALID;
         }
         if (ctx.async) {
-            return Promise.all(options.map(function (option) { return __awaiter(_this, void 0, void 0, function () {
-                var childCtx;
-                var _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            childCtx = __assign(__assign({}, ctx), { issues: [], parent: null });
-                            _a = {};
-                            return [4 /*yield*/, option._parseAsync({
-                                    data: ctx.data,
-                                    path: ctx.path,
-                                    parent: childCtx,
-                                })];
-                        case 1: return [2 /*return*/, (_a.result = _b.sent(),
-                                _a.ctx = childCtx,
-                                _a)];
-                    }
-                });
-            }); })).then(handleResults);
-        }
-        else {
-            var optionResults = options.map(function (option) {
-                var childCtx = __assign(__assign({}, ctx), { issues: [], parent: null });
+            return Promise.all(options.map(async (option) => {
+                const childCtx = {
+                    ...ctx,
+                    issues: [],
+                    parent: null,
+                };
                 return {
-                    result: option._parseSync({
+                    result: await option._parseAsync({
                         data: ctx.data,
                         path: ctx.path,
                         parent: childCtx,
                     }),
                     ctx: childCtx,
                 };
+            })).then(handleResults);
+        }
+        else {
+            let dirty = undefined;
+            const issues = [];
+            for (const option of options) {
+                const childCtx = {
+                    ...ctx,
+                    issues: [],
+                    parent: null,
+                };
+                const result = option._parseSync({
+                    data: ctx.data,
+                    path: ctx.path,
+                    parent: childCtx,
+                });
+                if (result.status === "valid") {
+                    return result;
+                }
+                else if (result.status === "dirty" && !dirty) {
+                    dirty = { result, ctx: childCtx };
+                }
+                if (childCtx.issues.length) {
+                    issues.push(childCtx.issues);
+                }
+            }
+            if (dirty) {
+                ctx.issues.push(...dirty.ctx.issues);
+                return dirty.result;
+            }
+            const unionErrors = issues.map((issues) => new ZodError(issues));
+            addIssueToContext(ctx, {
+                code: ZodIssueCode.invalid_union,
+                unionErrors,
             });
-            return handleResults(optionResults);
+            return INVALID;
         }
-    };
-    Object.defineProperty(ZodUnion.prototype, "options", {
-        get: function () {
-            return this._def.options;
-        },
-        enumerable: false,
-        configurable: true
+    }
+    get options() {
+        return this._def.options;
+    }
+}
+ZodUnion.create = (types, params) => {
+    return new ZodUnion({
+        options: types,
+        typeName: ZodFirstPartyTypeKind.ZodUnion,
+        ...processCreateParams(params),
     });
-    ZodUnion.create = function (types, params) {
-        return new ZodUnion(__assign({ options: types, typeName: ZodFirstPartyTypeKind.ZodUnion }, processCreateParams(params)));
-    };
-    return ZodUnion;
-}(ZodType));
-var ZodDiscriminatedUnion = /** @class */ (function (_super) {
-    __extends(ZodDiscriminatedUnion, _super);
-    function ZodDiscriminatedUnion() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodDiscriminatedUnion.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+};
+class ZodDiscriminatedUnion extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.object) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2132,9 +1734,9 @@ var ZodDiscriminatedUnion = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        var discriminator = this.discriminator;
-        var discriminatorValue = ctx.data[discriminator];
-        var option = this.options.get(discriminatorValue);
+        const discriminator = this.discriminator;
+        const discriminatorValue = ctx.data[discriminator];
+        const option = this.options.get(discriminatorValue);
         if (!option) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_union_discriminator,
@@ -2157,28 +1759,16 @@ var ZodDiscriminatedUnion = /** @class */ (function (_super) {
                 parent: ctx,
             });
         }
-    };
-    Object.defineProperty(ZodDiscriminatedUnion.prototype, "discriminator", {
-        get: function () {
-            return this._def.discriminator;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodDiscriminatedUnion.prototype, "validDiscriminatorValues", {
-        get: function () {
-            return Array.from(this.options.keys());
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodDiscriminatedUnion.prototype, "options", {
-        get: function () {
-            return this._def.options;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    get discriminator() {
+        return this._def.discriminator;
+    }
+    get validDiscriminatorValues() {
+        return Array.from(this.options.keys());
+    }
+    get options() {
+        return this._def.options;
+    }
     /**
      * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
      * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
@@ -2187,12 +1777,12 @@ var ZodDiscriminatedUnion = /** @class */ (function (_super) {
      * @param types an array of object schemas
      * @param params
      */
-    ZodDiscriminatedUnion.create = function (discriminator, types, params) {
+    static create(discriminator, types, params) {
         // Get all the valid discriminator values
-        var options = new Map();
+        const options = new Map();
         try {
-            types.forEach(function (type) {
-                var discriminatorValue = type.shape[discriminator].value;
+            types.forEach((type) => {
+                const discriminatorValue = type.shape[discriminator].value;
                 options.set(discriminatorValue, type);
             });
         }
@@ -2203,39 +1793,32 @@ var ZodDiscriminatedUnion = /** @class */ (function (_super) {
         if (options.size !== types.length) {
             throw new Error("Some of the discriminator values are not unique");
         }
-        return new ZodDiscriminatedUnion(__assign({ typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion, discriminator: discriminator, options: options }, processCreateParams(params)));
-    };
-    return ZodDiscriminatedUnion;
-}(ZodType));
+        return new ZodDiscriminatedUnion({
+            typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
+            discriminator,
+            options,
+            ...processCreateParams(params),
+        });
+    }
+}
 function mergeValues(a, b) {
-    var e_11, _a;
-    var aType = getParsedType(a);
-    var bType = getParsedType(b);
+    const aType = getParsedType(a);
+    const bType = getParsedType(b);
     if (a === b) {
         return { valid: true, data: a };
     }
     else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
-        var bKeys_1 = util.objectKeys(b);
-        var sharedKeys = util
+        const bKeys = util.objectKeys(b);
+        const sharedKeys = util
             .objectKeys(a)
-            .filter(function (key) { return bKeys_1.indexOf(key) !== -1; });
-        var newObj = __assign(__assign({}, a), b);
-        try {
-            for (var sharedKeys_1 = __values(sharedKeys), sharedKeys_1_1 = sharedKeys_1.next(); !sharedKeys_1_1.done; sharedKeys_1_1 = sharedKeys_1.next()) {
-                var key = sharedKeys_1_1.value;
-                var sharedValue = mergeValues(a[key], b[key]);
-                if (!sharedValue.valid) {
-                    return { valid: false };
-                }
-                newObj[key] = sharedValue.data;
-            }
-        }
-        catch (e_11_1) { e_11 = { error: e_11_1 }; }
-        finally {
-            try {
-                if (sharedKeys_1_1 && !sharedKeys_1_1.done && (_a = sharedKeys_1.return)) _a.call(sharedKeys_1);
+            .filter((key) => bKeys.indexOf(key) !== -1);
+        const newObj = { ...a, ...b };
+        for (const key of sharedKeys) {
+            const sharedValue = mergeValues(a[key], b[key]);
+            if (!sharedValue.valid) {
+                return { valid: false };
             }
-            finally { if (e_11) throw e_11.error; }
+            newObj[key] = sharedValue.data;
         }
         return { valid: true, data: newObj };
     }
@@ -2243,11 +1826,11 @@ function mergeValues(a, b) {
         if (a.length !== b.length) {
             return { valid: false };
         }
-        var newArray = [];
-        for (var index = 0; index < a.length; index++) {
-            var itemA = a[index];
-            var itemB = b[index];
-            var sharedValue = mergeValues(itemA, itemB);
+        const newArray = [];
+        for (let index = 0; index < a.length; index++) {
+            const itemA = a[index];
+            const itemB = b[index];
+            const sharedValue = mergeValues(itemA, itemB);
             if (!sharedValue.valid) {
                 return { valid: false };
             }
@@ -2264,18 +1847,14 @@ function mergeValues(a, b) {
         return { valid: false };
     }
 }
-var ZodIntersection = /** @class */ (function (_super) {
-    __extends(ZodIntersection, _super);
-    function ZodIntersection() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodIntersection.prototype._parse = function (input) {
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
-        var handleParsed = function (parsedLeft, parsedRight) {
+class ZodIntersection extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        const handleParsed = (parsedLeft, parsedRight) => {
             if (isAborted(parsedLeft) || isAborted(parsedRight)) {
                 return INVALID;
             }
-            var merged = mergeValues(parsedLeft.value, parsedRight.value);
+            const merged = mergeValues(parsedLeft.value, parsedRight.value);
             if (!merged.valid) {
                 addIssueToContext(ctx, {
                     code: ZodIssueCode.invalid_intersection_types,
@@ -2299,10 +1878,7 @@ var ZodIntersection = /** @class */ (function (_super) {
                     path: ctx.path,
                     parent: ctx,
                 }),
-            ]).then(function (_a) {
-                var _b = __read(_a, 2), left = _b[0], right = _b[1];
-                return handleParsed(left, right);
-            });
+            ]).then(([left, right]) => handleParsed(left, right));
         }
         else {
             return handleParsed(this._def.left._parseSync({
@@ -2315,20 +1891,19 @@ var ZodIntersection = /** @class */ (function (_super) {
                 parent: ctx,
             }));
         }
-    };
-    ZodIntersection.create = function (left, right, params) {
-        return new ZodIntersection(__assign({ left: left, right: right, typeName: ZodFirstPartyTypeKind.ZodIntersection }, processCreateParams(params)));
-    };
-    return ZodIntersection;
-}(ZodType));
-var ZodTuple = /** @class */ (function (_super) {
-    __extends(ZodTuple, _super);
-    function ZodTuple() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodTuple.prototype._parse = function (input) {
-        var _this = this;
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
+    }
+}
+ZodIntersection.create = (left, right, params) => {
+    return new ZodIntersection({
+        left: left,
+        right: right,
+        typeName: ZodFirstPartyTypeKind.ZodIntersection,
+        ...processCreateParams(params),
+    });
+};
+class ZodTuple extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.array) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2346,7 +1921,7 @@ var ZodTuple = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        var rest = this._def.rest;
+        const rest = this._def.rest;
         if (!rest && ctx.data.length > this._def.items.length) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.too_big,
@@ -2356,63 +1931,54 @@ var ZodTuple = /** @class */ (function (_super) {
             });
             status.dirty();
         }
-        var items = ctx.data
-            .map(function (item, itemIndex) {
-            var schema = _this._def.items[itemIndex] || _this._def.rest;
+        const items = ctx.data
+            .map((item, itemIndex) => {
+            const schema = this._def.items[itemIndex] || this._def.rest;
             if (!schema)
                 return null;
             return schema._parse({
                 data: item,
-                path: __spreadArray(__spreadArray([], __read(ctx.path), false), [itemIndex], false),
+                path: [...ctx.path, itemIndex],
                 parent: ctx,
             });
         })
-            .filter(function (x) { return !!x; }); // filter nulls
+            .filter((x) => !!x); // filter nulls
         if (ctx.async) {
-            return Promise.all(items).then(function (results) {
+            return Promise.all(items).then((results) => {
                 return ParseStatus.mergeArray(status, results);
             });
         }
         else {
             return ParseStatus.mergeArray(status, items);
         }
-    };
-    Object.defineProperty(ZodTuple.prototype, "items", {
-        get: function () {
-            return this._def.items;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodTuple.prototype.rest = function (rest) {
-        return new ZodTuple(__assign(__assign({}, this._def), { rest: rest }));
-    };
-    ZodTuple.create = function (schemas, params) {
-        return new ZodTuple(__assign({ items: schemas, typeName: ZodFirstPartyTypeKind.ZodTuple, rest: null }, processCreateParams(params)));
-    };
-    return ZodTuple;
-}(ZodType));
-var ZodRecord = /** @class */ (function (_super) {
-    __extends(ZodRecord, _super);
-    function ZodRecord() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(ZodRecord.prototype, "keySchema", {
-        get: function () {
-            return this._def.keyType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodRecord.prototype, "valueSchema", {
-        get: function () {
-            return this._def.valueType;
-        },
-        enumerable: false,
-        configurable: true
+    }
+    get items() {
+        return this._def.items;
+    }
+    rest(rest) {
+        return new ZodTuple({
+            ...this._def,
+            rest,
+        });
+    }
+}
+ZodTuple.create = (schemas, params) => {
+    return new ZodTuple({
+        items: schemas,
+        typeName: ZodFirstPartyTypeKind.ZodTuple,
+        rest: null,
+        ...processCreateParams(params),
     });
-    ZodRecord.prototype._parse = function (input) {
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
+};
+class ZodRecord extends ZodType {
+    get keySchema() {
+        return this._def.keyType;
+    }
+    get valueSchema() {
+        return this._def.valueType;
+    }
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.object) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2421,19 +1987,19 @@ var ZodRecord = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        var pairs = [];
-        var keyType = this._def.keyType;
-        var valueType = this._def.valueType;
-        for (var key in ctx.data) {
+        const pairs = [];
+        const keyType = this._def.keyType;
+        const valueType = this._def.valueType;
+        for (const key in ctx.data) {
             pairs.push({
                 key: keyType._parse({
                     data: key,
-                    path: __spreadArray(__spreadArray([], __read(ctx.path), false), [key], false),
+                    path: [...ctx.path, key],
                     parent: ctx,
                 }),
                 value: valueType._parse({
                     data: ctx.data[key],
-                    path: __spreadArray(__spreadArray([], __read(ctx.path), false), [key], false),
+                    path: [...ctx.path, key],
                     parent: ctx,
                 }),
             });
@@ -2444,31 +2010,30 @@ var ZodRecord = /** @class */ (function (_super) {
         else {
             return ParseStatus.mergeObjectSync(status, pairs);
         }
-    };
-    Object.defineProperty(ZodRecord.prototype, "element", {
-        get: function () {
-            return this._def.valueType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodRecord.create = function (first, second, third) {
+    }
+    get element() {
+        return this._def.valueType;
+    }
+    static create(first, second, third) {
         if (second instanceof ZodType) {
-            return new ZodRecord(__assign({ keyType: first, valueType: second, typeName: ZodFirstPartyTypeKind.ZodRecord }, processCreateParams(third)));
+            return new ZodRecord({
+                keyType: first,
+                valueType: second,
+                typeName: ZodFirstPartyTypeKind.ZodRecord,
+                ...processCreateParams(third),
+            });
         }
-        return new ZodRecord(__assign({ keyType: ZodString.create(), valueType: first, typeName: ZodFirstPartyTypeKind.ZodRecord }, processCreateParams(second)));
-    };
-    return ZodRecord;
-}(ZodType));
-var ZodMap = /** @class */ (function (_super) {
-    __extends(ZodMap, _super);
-    function ZodMap() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodMap.prototype._parse = function (input) {
-        var e_12, _a;
-        var _this = this;
-        var _b = this._processInputParams(input), status = _b.status, ctx = _b.ctx;
+        return new ZodRecord({
+            keyType: ZodString.create(),
+            valueType: first,
+            typeName: ZodFirstPartyTypeKind.ZodRecord,
+            ...processCreateParams(second),
+        });
+    }
+}
+class ZodMap extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.map) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2477,77 +2042,28 @@ var ZodMap = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        var keyType = this._def.keyType;
-        var valueType = this._def.valueType;
-        var pairs = __spreadArray([], __read(ctx.data.entries()), false).map(function (_a, index) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        const keyType = this._def.keyType;
+        const valueType = this._def.valueType;
+        const pairs = [...ctx.data.entries()].map(([key, value], index) => {
             return {
                 key: keyType._parse({
                     data: key,
-                    path: __spreadArray(__spreadArray([], __read(ctx.path), false), [index, "key"], false),
+                    path: [...ctx.path, index, "key"],
                     parent: ctx,
                 }),
                 value: valueType._parse({
                     data: value,
-                    path: __spreadArray(__spreadArray([], __read(ctx.path), false), [index, "value"], false),
+                    path: [...ctx.path, index, "value"],
                     parent: ctx,
                 }),
             };
         });
         if (ctx.async) {
-            var finalMap_1 = new Map();
-            return Promise.resolve().then(function () { return __awaiter(_this, void 0, void 0, function () {
-                var pairs_3, pairs_3_1, pair, key, value, e_13_1;
-                var e_13, _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _b.trys.push([0, 6, 7, 8]);
-                            pairs_3 = __values(pairs), pairs_3_1 = pairs_3.next();
-                            _b.label = 1;
-                        case 1:
-                            if (!!pairs_3_1.done) return [3 /*break*/, 5];
-                            pair = pairs_3_1.value;
-                            return [4 /*yield*/, pair.key];
-                        case 2:
-                            key = _b.sent();
-                            return [4 /*yield*/, pair.value];
-                        case 3:
-                            value = _b.sent();
-                            if (key.status === "aborted" || value.status === "aborted") {
-                                return [2 /*return*/, INVALID];
-                            }
-                            if (key.status === "dirty" || value.status === "dirty") {
-                                status.dirty();
-                            }
-                            finalMap_1.set(key.value, value.value);
-                            _b.label = 4;
-                        case 4:
-                            pairs_3_1 = pairs_3.next();
-                            return [3 /*break*/, 1];
-                        case 5: return [3 /*break*/, 8];
-                        case 6:
-                            e_13_1 = _b.sent();
-                            e_13 = { error: e_13_1 };
-                            return [3 /*break*/, 8];
-                        case 7:
-                            try {
-                                if (pairs_3_1 && !pairs_3_1.done && (_a = pairs_3.return)) _a.call(pairs_3);
-                            }
-                            finally { if (e_13) throw e_13.error; }
-                            return [7 /*endfinally*/];
-                        case 8: return [2 /*return*/, { status: status.value, value: finalMap_1 }];
-                    }
-                });
-            }); });
-        }
-        else {
-            var finalMap = new Map();
-            try {
-                for (var pairs_2 = __values(pairs), pairs_2_1 = pairs_2.next(); !pairs_2_1.done; pairs_2_1 = pairs_2.next()) {
-                    var pair = pairs_2_1.value;
-                    var key = pair.key;
-                    var value = pair.value;
+            const finalMap = new Map();
+            return Promise.resolve().then(async () => {
+                for (const pair of pairs) {
+                    const key = await pair.key;
+                    const value = await pair.value;
                     if (key.status === "aborted" || value.status === "aborted") {
                         return INVALID;
                     }
@@ -2556,29 +2072,37 @@ var ZodMap = /** @class */ (function (_super) {
                     }
                     finalMap.set(key.value, value.value);
                 }
-            }
-            catch (e_12_1) { e_12 = { error: e_12_1 }; }
-            finally {
-                try {
-                    if (pairs_2_1 && !pairs_2_1.done && (_a = pairs_2.return)) _a.call(pairs_2);
+                return { status: status.value, value: finalMap };
+            });
+        }
+        else {
+            const finalMap = new Map();
+            for (const pair of pairs) {
+                const key = pair.key;
+                const value = pair.value;
+                if (key.status === "aborted" || value.status === "aborted") {
+                    return INVALID;
+                }
+                if (key.status === "dirty" || value.status === "dirty") {
+                    status.dirty();
                 }
-                finally { if (e_12) throw e_12.error; }
+                finalMap.set(key.value, value.value);
             }
             return { status: status.value, value: finalMap };
         }
-    };
-    ZodMap.create = function (keyType, valueType, params) {
-        return new ZodMap(__assign({ valueType: valueType, keyType: keyType, typeName: ZodFirstPartyTypeKind.ZodMap }, processCreateParams(params)));
-    };
-    return ZodMap;
-}(ZodType));
-var ZodSet = /** @class */ (function (_super) {
-    __extends(ZodSet, _super);
-    function ZodSet() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodSet.prototype._parse = function (input) {
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
+    }
+}
+ZodMap.create = (keyType, valueType, params) => {
+    return new ZodMap({
+        valueType,
+        keyType,
+        typeName: ZodFirstPartyTypeKind.ZodMap,
+        ...processCreateParams(params),
+    });
+};
+class ZodSet extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.set) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2587,7 +2111,7 @@ var ZodSet = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        var def = this._def;
+        const def = this._def;
         if (def.minSize !== null) {
             if (ctx.data.size < def.minSize.value) {
                 addIssueToContext(ctx, {
@@ -2612,66 +2136,61 @@ var ZodSet = /** @class */ (function (_super) {
                 status.dirty();
             }
         }
-        var valueType = this._def.valueType;
+        const valueType = this._def.valueType;
         function finalizeSet(elements) {
-            var e_14, _a;
-            var parsedSet = new Set();
-            try {
-                for (var elements_1 = __values(elements), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
-                    var element = elements_1_1.value;
-                    if (element.status === "aborted")
-                        return INVALID;
-                    if (element.status === "dirty")
-                        status.dirty();
-                    parsedSet.add(element.value);
-                }
-            }
-            catch (e_14_1) { e_14 = { error: e_14_1 }; }
-            finally {
-                try {
-                    if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
-                }
-                finally { if (e_14) throw e_14.error; }
+            const parsedSet = new Set();
+            for (const element of elements) {
+                if (element.status === "aborted")
+                    return INVALID;
+                if (element.status === "dirty")
+                    status.dirty();
+                parsedSet.add(element.value);
             }
             return { status: status.value, value: parsedSet };
         }
-        var elements = __spreadArray([], __read(ctx.data.values()), false).map(function (item, i) {
-            return valueType._parse({ data: item, path: __spreadArray(__spreadArray([], __read(ctx.path), false), [i], false), parent: ctx });
-        });
+        const elements = [...ctx.data.values()].map((item, i) => valueType._parse({ data: item, path: [...ctx.path, i], parent: ctx }));
         if (ctx.async) {
-            return Promise.all(elements).then(function (elements) { return finalizeSet(elements); });
+            return Promise.all(elements).then((elements) => finalizeSet(elements));
         }
         else {
             return finalizeSet(elements);
         }
-    };
-    ZodSet.prototype.min = function (minSize, message) {
-        return new ZodSet(__assign(__assign({}, this._def), { minSize: { value: minSize, message: errorUtil.toString(message) } }));
-    };
-    ZodSet.prototype.max = function (maxSize, message) {
-        return new ZodSet(__assign(__assign({}, this._def), { maxSize: { value: maxSize, message: errorUtil.toString(message) } }));
-    };
-    ZodSet.prototype.size = function (size, message) {
+    }
+    min(minSize, message) {
+        return new ZodSet({
+            ...this._def,
+            minSize: { value: minSize, message: errorUtil.toString(message) },
+        });
+    }
+    max(maxSize, message) {
+        return new ZodSet({
+            ...this._def,
+            maxSize: { value: maxSize, message: errorUtil.toString(message) },
+        });
+    }
+    size(size, message) {
         return this.min(size, message).max(size, message);
-    };
-    ZodSet.prototype.nonempty = function (message) {
+    }
+    nonempty(message) {
         return this.min(1, message);
-    };
-    ZodSet.create = function (valueType, params) {
-        return new ZodSet(__assign({ valueType: valueType, minSize: null, maxSize: null, typeName: ZodFirstPartyTypeKind.ZodSet }, processCreateParams(params)));
-    };
-    return ZodSet;
-}(ZodType));
-var ZodFunction = /** @class */ (function (_super) {
-    __extends(ZodFunction, _super);
-    function ZodFunction() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.validate = _this.implement;
-        return _this;
-    }
-    ZodFunction.prototype._parse = function (input) {
-        var _this = this;
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodSet.create = (valueType, params) => {
+    return new ZodSet({
+        valueType,
+        minSize: null,
+        maxSize: null,
+        typeName: ZodFirstPartyTypeKind.ZodSet,
+        ...processCreateParams(params),
+    });
+};
+class ZodFunction extends ZodType {
+    constructor() {
+        super(...arguments);
+        this.validate = this.implement;
+    }
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.function) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2689,7 +2208,7 @@ var ZodFunction = /** @class */ (function (_super) {
                     ctx.schemaErrorMap,
                     overrideErrorMap,
                     defaultErrorMap,
-                ].filter(function (x) { return !!x; }),
+                ].filter((x) => !!x),
                 issueData: {
                     code: ZodIssueCode.invalid_arguments,
                     argumentsError: error,
@@ -2705,132 +2224,106 @@ var ZodFunction = /** @class */ (function (_super) {
                     ctx.schemaErrorMap,
                     overrideErrorMap,
                     defaultErrorMap,
-                ].filter(function (x) { return !!x; }),
+                ].filter((x) => !!x),
                 issueData: {
                     code: ZodIssueCode.invalid_return_type,
                     returnTypeError: error,
                 },
             });
         }
-        var params = { errorMap: ctx.contextualErrorMap };
-        var fn = ctx.data;
+        const params = { errorMap: ctx.contextualErrorMap };
+        const fn = ctx.data;
         if (this._def.returns instanceof ZodPromise) {
-            return OK(function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                return __awaiter(_this, void 0, void 0, function () {
-                    var error, parsedArgs, result, parsedReturns;
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                error = new ZodError([]);
-                                return [4 /*yield*/, this._def.args
-                                        .parseAsync(args, params)
-                                        .catch(function (e) {
-                                        error.addIssue(makeArgsIssue(args, e));
-                                        throw error;
-                                    })];
-                            case 1:
-                                parsedArgs = _a.sent();
-                                return [4 /*yield*/, fn.apply(void 0, __spreadArray([], __read(parsedArgs), false))];
-                            case 2:
-                                result = _a.sent();
-                                return [4 /*yield*/, this._def
-                                        .returns._def.type
-                                        .parseAsync(result, params)
-                                        .catch(function (e) {
-                                        error.addIssue(makeReturnsIssue(result, e));
-                                        throw error;
-                                    })];
-                            case 3:
-                                parsedReturns = _a.sent();
-                                return [2 /*return*/, parsedReturns];
-                        }
-                    });
+            return OK(async (...args) => {
+                const error = new ZodError([]);
+                const parsedArgs = await this._def.args
+                    .parseAsync(args, params)
+                    .catch((e) => {
+                    error.addIssue(makeArgsIssue(args, e));
+                    throw error;
+                });
+                const result = await fn(...parsedArgs);
+                const parsedReturns = await this._def.returns._def.type
+                    .parseAsync(result, params)
+                    .catch((e) => {
+                    error.addIssue(makeReturnsIssue(result, e));
+                    throw error;
                 });
+                return parsedReturns;
             });
         }
         else {
-            return OK(function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var parsedArgs = _this._def.args.safeParse(args, params);
+            return OK((...args) => {
+                const parsedArgs = this._def.args.safeParse(args, params);
                 if (!parsedArgs.success) {
                     throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
                 }
-                var result = fn.apply(void 0, __spreadArray([], __read(parsedArgs.data), false));
-                var parsedReturns = _this._def.returns.safeParse(result, params);
+                const result = fn(...parsedArgs.data);
+                const parsedReturns = this._def.returns.safeParse(result, params);
                 if (!parsedReturns.success) {
                     throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
                 }
                 return parsedReturns.data;
             });
         }
-    };
-    ZodFunction.prototype.parameters = function () {
+    }
+    parameters() {
         return this._def.args;
-    };
-    ZodFunction.prototype.returnType = function () {
+    }
+    returnType() {
         return this._def.returns;
-    };
-    ZodFunction.prototype.args = function () {
-        var items = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            items[_i] = arguments[_i];
-        }
-        return new ZodFunction(__assign(__assign({}, this._def), { args: ZodTuple.create(items).rest(ZodUnknown.create()) }));
-    };
-    ZodFunction.prototype.returns = function (returnType) {
-        return new ZodFunction(__assign(__assign({}, this._def), { returns: returnType }));
-    };
-    ZodFunction.prototype.implement = function (func) {
-        var validatedFunc = this.parse(func);
+    }
+    args(...items) {
+        return new ZodFunction({
+            ...this._def,
+            args: ZodTuple.create(items).rest(ZodUnknown.create()),
+        });
+    }
+    returns(returnType) {
+        return new ZodFunction({
+            ...this._def,
+            returns: returnType,
+        });
+    }
+    implement(func) {
+        const validatedFunc = this.parse(func);
         return validatedFunc;
-    };
-    ZodFunction.prototype.strictImplement = function (func) {
-        var validatedFunc = this.parse(func);
+    }
+    strictImplement(func) {
+        const validatedFunc = this.parse(func);
         return validatedFunc;
-    };
-    ZodFunction.create = function (args, returns, params) {
-        return new ZodFunction(__assign({ args: (args
-                ? args.rest(ZodUnknown.create())
-                : ZodTuple.create([]).rest(ZodUnknown.create())), returns: returns || ZodUnknown.create(), typeName: ZodFirstPartyTypeKind.ZodFunction }, processCreateParams(params)));
-    };
-    return ZodFunction;
-}(ZodType));
-var ZodLazy = /** @class */ (function (_super) {
-    __extends(ZodLazy, _super);
-    function ZodLazy() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(ZodLazy.prototype, "schema", {
-        get: function () {
-            return this._def.getter();
-        },
-        enumerable: false,
-        configurable: true
+    }
+}
+ZodFunction.create = (args, returns, params) => {
+    return new ZodFunction({
+        args: (args
+            ? args.rest(ZodUnknown.create())
+            : ZodTuple.create([]).rest(ZodUnknown.create())),
+        returns: returns || ZodUnknown.create(),
+        typeName: ZodFirstPartyTypeKind.ZodFunction,
+        ...processCreateParams(params),
     });
-    ZodLazy.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
-        var lazySchema = this._def.getter();
+};
+class ZodLazy extends ZodType {
+    get schema() {
+        return this._def.getter();
+    }
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        const lazySchema = this._def.getter();
         return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
-    };
-    ZodLazy.create = function (getter, params) {
-        return new ZodLazy(__assign({ getter: getter, typeName: ZodFirstPartyTypeKind.ZodLazy }, processCreateParams(params)));
-    };
-    return ZodLazy;
-}(ZodType));
-var ZodLiteral = /** @class */ (function (_super) {
-    __extends(ZodLiteral, _super);
-    function ZodLiteral() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodLiteral.prototype._parse = function (input) {
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
+    }
+}
+ZodLazy.create = (getter, params) => {
+    return new ZodLazy({
+        getter: getter,
+        typeName: ZodFirstPartyTypeKind.ZodLazy,
+        ...processCreateParams(params),
+    });
+};
+class ZodLiteral extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.data !== this._def.value) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2840,32 +2333,27 @@ var ZodLiteral = /** @class */ (function (_super) {
             return INVALID;
         }
         return { status: status.value, value: ctx.data };
-    };
-    Object.defineProperty(ZodLiteral.prototype, "value", {
-        get: function () {
-            return this._def.value;
-        },
-        enumerable: false,
-        configurable: true
+    }
+    get value() {
+        return this._def.value;
+    }
+}
+ZodLiteral.create = (value, params) => {
+    return new ZodLiteral({
+        value: value,
+        typeName: ZodFirstPartyTypeKind.ZodLiteral,
+        ...processCreateParams(params),
     });
-    ZodLiteral.create = function (value, params) {
-        return new ZodLiteral(__assign({ value: value, typeName: ZodFirstPartyTypeKind.ZodLiteral }, processCreateParams(params)));
-    };
-    return ZodLiteral;
-}(ZodType));
+};
 function createZodEnum(values) {
     return new ZodEnum({
         values: values,
         typeName: ZodFirstPartyTypeKind.ZodEnum,
     });
 }
-var ZodEnum = /** @class */ (function (_super) {
-    __extends(ZodEnum, _super);
-    function ZodEnum() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodEnum.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+class ZodEnum extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (this._def.values.indexOf(ctx.data) === -1) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_enum_value,
@@ -2874,91 +2362,37 @@ var ZodEnum = /** @class */ (function (_super) {
             return INVALID;
         }
         return OK(ctx.data);
-    };
-    Object.defineProperty(ZodEnum.prototype, "options", {
-        get: function () {
-            return this._def.values;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodEnum.prototype, "enum", {
-        get: function () {
-            var e_15, _a;
-            var enumValues = {};
-            try {
-                for (var _b = __values(this._def.values), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var val = _c.value;
-                    enumValues[val] = val;
-                }
-            }
-            catch (e_15_1) { e_15 = { error: e_15_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_15) throw e_15.error; }
-            }
-            return enumValues;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodEnum.prototype, "Values", {
-        get: function () {
-            var e_16, _a;
-            var enumValues = {};
-            try {
-                for (var _b = __values(this._def.values), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var val = _c.value;
-                    enumValues[val] = val;
-                }
-            }
-            catch (e_16_1) { e_16 = { error: e_16_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_16) throw e_16.error; }
-            }
-            return enumValues;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ZodEnum.prototype, "Enum", {
-        get: function () {
-            var e_17, _a;
-            var enumValues = {};
-            try {
-                for (var _b = __values(this._def.values), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var val = _c.value;
-                    enumValues[val] = val;
-                }
-            }
-            catch (e_17_1) { e_17 = { error: e_17_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_17) throw e_17.error; }
-            }
-            return enumValues;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ZodEnum.create = createZodEnum;
-    return ZodEnum;
-}(ZodType));
-var ZodNativeEnum = /** @class */ (function (_super) {
-    __extends(ZodNativeEnum, _super);
-    function ZodNativeEnum() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodNativeEnum.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
-        var nativeEnumValues = util.getValidEnumValues(this._def.values);
+    }
+    get options() {
+        return this._def.values;
+    }
+    get enum() {
+        const enumValues = {};
+        for (const val of this._def.values) {
+            enumValues[val] = val;
+        }
+        return enumValues;
+    }
+    get Values() {
+        const enumValues = {};
+        for (const val of this._def.values) {
+            enumValues[val] = val;
+        }
+        return enumValues;
+    }
+    get Enum() {
+        const enumValues = {};
+        for (const val of this._def.values) {
+            enumValues[val] = val;
+        }
+        return enumValues;
+    }
+}
+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) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_enum_value,
@@ -2967,20 +2401,21 @@ var ZodNativeEnum = /** @class */ (function (_super) {
             return INVALID;
         }
         return OK(ctx.data);
-    };
-    ZodNativeEnum.create = function (values, params) {
-        return new ZodNativeEnum(__assign({ values: values, typeName: ZodFirstPartyTypeKind.ZodNativeEnum }, processCreateParams(params)));
-    };
-    return ZodNativeEnum;
-}(ZodType));
-var ZodPromise = /** @class */ (function (_super) {
-    __extends(ZodPromise, _super);
-    function ZodPromise() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodPromise.prototype._parse = function (input) {
-        var _this = this;
-        var ctx = this._processInputParams(input).ctx;
+    }
+    get enum() {
+        return this._def.values;
+    }
+}
+ZodNativeEnum.create = (values, params) => {
+    return new ZodNativeEnum({
+        values: values,
+        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
+        ...processCreateParams(params),
+    });
+};
+class ZodPromise extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.promise && ctx.async === false) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -2989,38 +2424,36 @@ var ZodPromise = /** @class */ (function (_super) {
             });
             return INVALID;
         }
-        var promisified = ctx.parsedType === ZodParsedType.promise
+        const promisified = ctx.parsedType === ZodParsedType.promise
             ? ctx.data
             : Promise.resolve(ctx.data);
-        return OK(promisified.then(function (data) {
-            return _this._def.type.parseAsync(data, {
+        return OK(promisified.then((data) => {
+            return this._def.type.parseAsync(data, {
                 path: ctx.path,
                 errorMap: ctx.contextualErrorMap,
             });
         }));
-    };
-    ZodPromise.create = function (schema, params) {
-        return new ZodPromise(__assign({ type: schema, typeName: ZodFirstPartyTypeKind.ZodPromise }, processCreateParams(params)));
-    };
-    return ZodPromise;
-}(ZodType));
-var ZodEffects = /** @class */ (function (_super) {
-    __extends(ZodEffects, _super);
-    function ZodEffects() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodEffects.prototype.innerType = function () {
+    }
+}
+ZodPromise.create = (schema, params) => {
+    return new ZodPromise({
+        type: schema,
+        typeName: ZodFirstPartyTypeKind.ZodPromise,
+        ...processCreateParams(params),
+    });
+};
+class ZodEffects extends ZodType {
+    innerType() {
         return this._def.schema;
-    };
-    ZodEffects.prototype._parse = function (input) {
-        var _this = this;
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
-        var effect = this._def.effect || null;
+    }
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
+        const effect = this._def.effect || null;
         if (effect.type === "preprocess") {
-            var processed = effect.transform(ctx.data);
+            const processed = effect.transform(ctx.data);
             if (ctx.async) {
-                return Promise.resolve(processed).then(function (processed) {
-                    return _this._def.schema._parseAsync({
+                return Promise.resolve(processed).then((processed) => {
+                    return this._def.schema._parseAsync({
                         data: processed,
                         path: ctx.path,
                         parent: ctx,
@@ -3036,8 +2469,8 @@ var ZodEffects = /** @class */ (function (_super) {
             }
         }
         if (effect.type === "refinement") {
-            var checkCtx_1 = {
-                addIssue: function (arg) {
+            const checkCtx = {
+                addIssue: (arg) => {
                     addIssueToContext(ctx, arg);
                     if (arg.fatal) {
                         status.abort();
@@ -3050,11 +2483,11 @@ var ZodEffects = /** @class */ (function (_super) {
                     return ctx.path;
                 },
             };
-            checkCtx_1.addIssue = checkCtx_1.addIssue.bind(checkCtx_1);
-            var executeRefinement_1 = function (acc
+            checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+            const executeRefinement = (acc
             // effect: RefinementEffect<any>
-            ) {
-                var result = effect.refinement(acc, checkCtx_1);
+            ) => {
+                const result = effect.refinement(acc, checkCtx);
                 if (ctx.async) {
                     return Promise.resolve(result);
                 }
@@ -3064,7 +2497,7 @@ var ZodEffects = /** @class */ (function (_super) {
                 return acc;
             };
             if (ctx.async === false) {
-                var inner = this._def.schema._parseSync({
+                const inner = this._def.schema._parseSync({
                     data: ctx.data,
                     path: ctx.path,
                     parent: ctx,
@@ -3074,18 +2507,18 @@ var ZodEffects = /** @class */ (function (_super) {
                 if (inner.status === "dirty")
                     status.dirty();
                 // return value is ignored
-                executeRefinement_1(inner.value);
+                executeRefinement(inner.value);
                 return { status: status.value, value: inner.value };
             }
             else {
                 return this._def.schema
                     ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
-                    .then(function (inner) {
+                    .then((inner) => {
                     if (inner.status === "aborted")
                         return INVALID;
                     if (inner.status === "dirty")
                         status.dirty();
-                    return executeRefinement_1(inner.value).then(function () {
+                    return executeRefinement(inner.value).then(() => {
                         return { status: status.value, value: inner.value };
                     });
                 });
@@ -3093,7 +2526,7 @@ var ZodEffects = /** @class */ (function (_super) {
         }
         if (effect.type === "transform") {
             if (ctx.async === false) {
-                var base = this._def.schema._parseSync({
+                const base = this._def.schema._parseSync({
                     data: ctx.data,
                     path: ctx.path,
                     parent: ctx,
@@ -3104,16 +2537,16 @@ var ZodEffects = /** @class */ (function (_super) {
                 // }
                 if (!isValid(base))
                     return base;
-                var result = effect.transform(base.value);
+                const result = effect.transform(base.value);
                 if (result instanceof Promise) {
-                    throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+                    throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
                 }
                 return OK(result);
             }
             else {
                 return this._def.schema
                     ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
-                    .then(function (base) {
+                    .then((base) => {
                     if (!isValid(base))
                         return base;
                     // if (base.status === "aborted") return INVALID;
@@ -3125,22 +2558,27 @@ var ZodEffects = /** @class */ (function (_super) {
             }
         }
         util.assertNever(effect);
-    };
-    ZodEffects.create = function (schema, effect, params) {
-        return new ZodEffects(__assign({ schema: schema, typeName: ZodFirstPartyTypeKind.ZodEffects, effect: effect }, processCreateParams(params)));
-    };
-    ZodEffects.createWithPreprocess = function (preprocess, schema, params) {
-        return new ZodEffects(__assign({ schema: schema, effect: { type: "preprocess", transform: preprocess }, typeName: ZodFirstPartyTypeKind.ZodEffects }, processCreateParams(params)));
-    };
-    return ZodEffects;
-}(ZodType));
-var ZodOptional = /** @class */ (function (_super) {
-    __extends(ZodOptional, _super);
-    function ZodOptional() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodOptional.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodEffects.create = (schema, effect, params) => {
+    return new ZodEffects({
+        schema,
+        typeName: ZodFirstPartyTypeKind.ZodEffects,
+        effect,
+        ...processCreateParams(params),
+    });
+};
+ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+    return new ZodEffects({
+        schema,
+        effect: { type: "preprocess", transform: preprocess },
+        typeName: ZodFirstPartyTypeKind.ZodEffects,
+        ...processCreateParams(params),
+    });
+};
+class ZodOptional extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType === ZodParsedType.undefined) {
             return OK(undefined);
         }
@@ -3149,22 +2587,21 @@ var ZodOptional = /** @class */ (function (_super) {
             path: ctx.path,
             parent: ctx,
         });
-    };
-    ZodOptional.prototype.unwrap = function () {
+    }
+    unwrap() {
         return this._def.innerType;
-    };
-    ZodOptional.create = function (type, params) {
-        return new ZodOptional(__assign({ innerType: type, typeName: ZodFirstPartyTypeKind.ZodOptional }, processCreateParams(params)));
-    };
-    return ZodOptional;
-}(ZodType));
-var ZodNullable = /** @class */ (function (_super) {
-    __extends(ZodNullable, _super);
-    function ZodNullable() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodNullable.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
+    }
+}
+ZodOptional.create = (type, params) => {
+    return new ZodOptional({
+        innerType: type,
+        typeName: ZodFirstPartyTypeKind.ZodOptional,
+        ...processCreateParams(params),
+    });
+};
+class ZodNullable extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
         if (ctx.parsedType === ZodParsedType.null) {
             return OK(null);
         }
@@ -3173,47 +2610,45 @@ var ZodNullable = /** @class */ (function (_super) {
             path: ctx.path,
             parent: ctx,
         });
-    };
-    ZodNullable.prototype.unwrap = function () {
+    }
+    unwrap() {
         return this._def.innerType;
-    };
-    ZodNullable.create = function (type, params) {
-        return new ZodNullable(__assign({ innerType: type, typeName: ZodFirstPartyTypeKind.ZodNullable }, processCreateParams(params)));
-    };
-    return ZodNullable;
-}(ZodType));
-var ZodDefault = /** @class */ (function (_super) {
-    __extends(ZodDefault, _super);
-    function ZodDefault() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodDefault.prototype._parse = function (input) {
-        var ctx = this._processInputParams(input).ctx;
-        var data = ctx.data;
+    }
+}
+ZodNullable.create = (type, params) => {
+    return new ZodNullable({
+        innerType: type,
+        typeName: ZodFirstPartyTypeKind.ZodNullable,
+        ...processCreateParams(params),
+    });
+};
+class ZodDefault extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        let data = ctx.data;
         if (ctx.parsedType === ZodParsedType.undefined) {
             data = this._def.defaultValue();
         }
         return this._def.innerType._parse({
-            data: data,
+            data,
             path: ctx.path,
             parent: ctx,
         });
-    };
-    ZodDefault.prototype.removeDefault = function () {
+    }
+    removeDefault() {
         return this._def.innerType;
-    };
-    ZodDefault.create = function (type, params) {
-        return new ZodOptional(__assign({ innerType: type, typeName: ZodFirstPartyTypeKind.ZodOptional }, processCreateParams(params)));
-    };
-    return ZodDefault;
-}(ZodType));
-var ZodNaN = /** @class */ (function (_super) {
-    __extends(ZodNaN, _super);
-    function ZodNaN() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ZodNaN.prototype._parse = function (input) {
-        var _a = this._processInputParams(input), status = _a.status, ctx = _a.ctx;
+    }
+}
+ZodDefault.create = (type, params) => {
+    return new ZodOptional({
+        innerType: type,
+        typeName: ZodFirstPartyTypeKind.ZodOptional,
+        ...processCreateParams(params),
+    });
+};
+class ZodNaN extends ZodType {
+    _parse(input) {
+        const { status, ctx } = this._processInputParams(input);
         if (ctx.parsedType !== ZodParsedType.nan) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
@@ -3223,18 +2658,20 @@ var ZodNaN = /** @class */ (function (_super) {
             return INVALID;
         }
         return { status: status.value, value: ctx.data };
-    };
-    ZodNaN.create = function (params) {
-        return new ZodNaN(__assign({ typeName: ZodFirstPartyTypeKind.ZodNaN }, processCreateParams(params)));
-    };
-    return ZodNaN;
-}(ZodType));
-var custom = function (check, params) {
+    }
+}
+ZodNaN.create = (params) => {
+    return new ZodNaN({
+        typeName: ZodFirstPartyTypeKind.ZodNaN,
+        ...processCreateParams(params),
+    });
+};
+const custom = (check, params) => {
     if (check)
         return ZodAny.create().refine(check, params);
     return ZodAny.create();
 };
-var late = {
+const late = {
     object: ZodObject.lazycreate,
 };
 var ZodFirstPartyTypeKind;
@@ -3271,47 +2708,44 @@ var ZodFirstPartyTypeKind;
     ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
     ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = function (cls, params) {
-    if (params === void 0) { params = {
-        message: "Input not instance of ".concat(cls.name),
-    }; }
-    return custom(function (data) { return data instanceof cls; }, params);
-};
-var stringType = ZodString.create;
-var numberType = ZodNumber.create;
-var nanType = ZodNaN.create;
-var bigIntType = ZodBigInt.create;
-var booleanType = ZodBoolean.create;
-var dateType = ZodDate.create;
-var undefinedType = ZodUndefined.create;
-var nullType = ZodNull.create;
-var anyType = ZodAny.create;
-var unknownType = ZodUnknown.create;
-var neverType = ZodNever.create;
-var voidType = ZodVoid.create;
-var arrayType = ZodArray.create;
-var objectType = ZodObject.create;
-var strictObjectType = ZodObject.strictCreate;
-var unionType = ZodUnion.create;
-var discriminatedUnionType = ZodDiscriminatedUnion.create;
-var intersectionType = ZodIntersection.create;
-var tupleType = ZodTuple.create;
-var recordType = ZodRecord.create;
-var mapType = ZodMap.create;
-var setType = ZodSet.create;
-var functionType = ZodFunction.create;
-var lazyType = ZodLazy.create;
-var literalType = ZodLiteral.create;
-var enumType = ZodEnum.create;
-var nativeEnumType = ZodNativeEnum.create;
-var promiseType = ZodPromise.create;
-var effectsType = ZodEffects.create;
-var optionalType = ZodOptional.create;
-var nullableType = ZodNullable.create;
-var preprocessType = ZodEffects.createWithPreprocess;
-var ostring = function () { return stringType().optional(); };
-var onumber = function () { return numberType().optional(); };
-var oboolean = function () { return booleanType().optional(); };
+const instanceOfType = (cls, params = {
+    message: `Input not instance of ${cls.name}`,
+}) => custom((data) => data instanceof cls, params);
+const stringType = ZodString.create;
+const numberType = ZodNumber.create;
+const nanType = ZodNaN.create;
+const bigIntType = ZodBigInt.create;
+const booleanType = ZodBoolean.create;
+const dateType = ZodDate.create;
+const undefinedType = ZodUndefined.create;
+const nullType = ZodNull.create;
+const anyType = ZodAny.create;
+const unknownType = ZodUnknown.create;
+const neverType = ZodNever.create;
+const voidType = ZodVoid.create;
+const arrayType = ZodArray.create;
+const objectType = ZodObject.create;
+const strictObjectType = ZodObject.strictCreate;
+const unionType = ZodUnion.create;
+const discriminatedUnionType = ZodDiscriminatedUnion.create;
+const intersectionType = ZodIntersection.create;
+const tupleType = ZodTuple.create;
+const recordType = ZodRecord.create;
+const mapType = ZodMap.create;
+const setType = ZodSet.create;
+const functionType = ZodFunction.create;
+const lazyType = ZodLazy.create;
+const literalType = ZodLiteral.create;
+const enumType = ZodEnum.create;
+const nativeEnumType = ZodNativeEnum.create;
+const promiseType = ZodPromise.create;
+const effectsType = ZodEffects.create;
+const optionalType = ZodOptional.create;
+const nullableType = ZodNullable.create;
+const preprocessType = ZodEffects.createWithPreprocess;
+const ostring = () => stringType().optional();
+const onumber = () => numberType().optional();
+const oboolean = () => booleanType().optional();
 
 var mod = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -3412,5 +2846,4 @@ var mod = /*#__PURE__*/Object.freeze({
     setErrorMap: setErrorMap
 });
 
-export default mod;
-export { DIRTY, EMPTY_PATH, INVALID, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPromise, ZodRecord, ZodType as ZodSchema, ZodSet, ZodString, ZodEffects as ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, custom, dateType as date, defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getParsedType, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, overrideErrorMap, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, mod as z };
+export { DIRTY, EMPTY_PATH, INVALID, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPromise, ZodRecord, ZodType as ZodSchema, ZodSet, ZodString, ZodEffects as ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, custom, dateType as date, mod as default, defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getParsedType, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, overrideErrorMap, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, mod as z };