https://pro-demo.safehs.ai/_next/static/chunks/3881-ba2231f14a276bfc.js

110  coerce: function() { return coerce; },
111  custom: function() { return custom; },
112  date: function() { return dateType; },
113  datetimeRegex: function() { return datetimeRegex; },
114  defaultErrorMap: function() { return en; },
115  discriminatedUnion: function() { return discriminatedUnionType; },
116  effect: function() { return effectsType; },
117  "enum": function() { return enumType; },
118  "function": function() { return functionType; },
119  getErrorMap: function() { return getErrorMap; },
120  getParsedType: function() { return getParsedType; },
121  "instanceof": function() { return instanceOfType; },
122  intersection: function() { return intersectionType; },
123  isAborted: function() { return isAborted; },
124  isAsync: function() { return isAsync; },
125  isDirty: function() { return isDirty; },
126  isValid: function() { return isValid; },
127  late: function() { return late; },
128  lazy: function() { return lazyType; },
129  literal: function() { return literalType; },
130  makeIssue: function() { return makeIssue; },
131  map: function() { return mapType; },
132  nan: function() { return nanType; },
133  nativeEnum: function() { return nativeEnumType; },
134  never: function() { return neverType; },
135  "null": function() { return nullType; },
136  nullable: function() { return nullableType; },
137  number: function() { return numberType; },
138  object: function() { return objectType; },
139  objectUtil: function() { return objectUtil; },
140  oboolean: function() { return oboolean; },
141  onumber: function() { return onumber; },
142  optional: function() { return optionalType; },
143  ostring: function() { return ostring; },
144  pipeline: function() { return pipelineType; },
145  preprocess: function() { return preprocessType; },
146  promise: function() { return promiseType; },
147  quotelessJson: function() { return quotelessJson; },
148  record: function() { return recordType; },
149  set: function() { return setType; },
150  setErrorMap: function() { return setErrorMap; },
151  strictObject: function() { return strictObjectType; },
152  string: function() { return stringType; },
153  symbol: function() { return symbolType; },
154  transformer: function() { return effectsType; },
155  tuple: function() { return tupleType; },
156  undefined: function() { return undefinedType; },
157  union: function() { return unionType; },
158  unknown: function() { return unknownType; },
159  util: function() { return util; },
160  "void": function() { return voidType; }
161});
162
163;// CONCATENATED MODULE: ./node_modules/.pnpm/[email protected]/node_modules/zod/v3/helpers/util.js
164var util;
165(function (util) {
166    util.assertEqual = (_) => { };
167    function assertIs(_arg) { }
168    util.assertIs = assertIs;
169    function assertNever(_x) {
170        throw new Error();
171    }
172    util.assertNever = assertNever;
173    util.arrayToEnum = (items) => {
174        const obj = {};
175        for (const item of items) {
176            obj[item] = item;
177        }
178        return obj;
179    };
180    util.getValidEnumValues = (obj) => {
181        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
182        const filtered = {};
183        for (const k of validKeys) {
184            filtered[k] = obj[k];
185        }
186        return util.objectValues(filtered);
187    };
188    util.objectValues = (obj) => {
189        return util.objectKeys(obj).map(function (e) {
190            return obj[e];
191        });
192    };
193    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
194        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
195        : (object) => {
196            const keys = [];
197            for (const key in object) {
198                if (Object.prototype.hasOwnProperty.call(object, key)) {
199                    keys.push(key);
200                }
201            }
202            return keys;
203        };
204    util.find = (arr, checker) => {
205        for (const item of arr) {
206            if (checker(item))
207                return item;
208        }
209        return undefined;
210    };
211    util.isInteger = typeof Number.isInteger === "function"
212        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
213        : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
214    function joinValues(array, separator = " | ") {
215        return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
216    }
217    util.joinValues = joinValues;
218    util.jsonStringifyReplacer = (_, value) => {
219        if (typeof value === "bigint") {
220            return value.toString();
221        }
222        return value;
223    };
224})(util || (util = {}));
225var objectUtil;
226(function (objectUtil) {
227    objectUtil.mergeShapes = (first, second) => {
228        return {
229            ...first,
230            ...second, // second overwrites first
231        };
232    };
233})(objectUtil || (objectUtil = {}));
234const ZodParsedType = util.arrayToEnum([
235    "string",
236    "nan",
237    "number",
238    "integer",
239    "float",
240    "boolean",
241    "date",
242    "bigint",
243    "symbol",
244    "function",
245    "undefined",
246    "null",
247    "array",
248    "object",
249    "unknown",
250    "promise",
251    "void",
252    "never",
253    "map",
254    "set",
255]);
256const getParsedType = (data) => {
257    const t = typeof data;
258    switch (t) {
259        case "undefined":
260            return ZodParsedType.undefined;
261        case "string":
262            return ZodParsedType.string;
263        case "number":
264            return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
265        case "boolean":
266            return ZodParsedType.boolean;
267        case "function":
268            return ZodParsedType.function;
269        case "bigint":
270            return ZodParsedType.bigint;
271        case "symbol":
272            return ZodParsedType.symbol;
273        case "object":
274            if (Array.isArray(data)) {
275                return ZodParsedType.array;
276            }
277            if (data === null) {
278                return ZodParsedType.null;
279            }
280            if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
281                return ZodParsedType.promise;
282            }
283            if (typeof Map !== "undefined" && data instanceof Map) {
284                return ZodParsedType.map;
285            }
286            if (typeof Set !== "undefined" && data instanceof Set) {
287                return ZodParsedType.set;
288            }
289            if (typeof Date !== "undefined" && data instanceof Date) {
290                return ZodParsedType.date;
291            }
292            return ZodParsedType.object;
293        default:
294            return ZodParsedType.unknown;
295    }
296};
297
298;// CONCATENATED MODULE: ./node_modules/.pnpm/[email protected]/node_modules/zod/v3/ZodError.js
299
300const ZodIssueCode = util.arrayToEnum([
301    "invalid_type",
302    "invalid_literal",
303    "custom",
304    "invalid_union",
305    "invalid_union_discriminator",
306    "invalid_enum_value",
307    "unrecognized_keys",
308    "invalid_arguments",
309    "invalid_return_type",
310    "invalid_date",
311    "invalid_string",
312    "too_small",
313    "too_big",
314    "invalid_intersection_types",
315    "not_multiple_of",
316    "not_finite",
317]);
318const quotelessJson = (obj) => {
319    const json = JSON.stringify(obj, null, 2);
320    return json.replace(/"([^"]+)":/g, "$1:");
321};

322class ZodError extends Error {
323    get errors() {
324        return this.issues;
325    }
326    constructor(issues) {
327        super();
328        this.issues = [];
329        this.addIssue = (sub) => {
330            this.issues = [...this.issues, sub];
331        };
332        this.addIssues = (subs = []) => {
333            this.issues = [...this.issues, ...subs];
334        };
335        const actualProto = new.target.prototype;
336        if (Object.setPrototypeOf) {
337            // eslint-disable-next-line ban/ban
338            Object.setPrototypeOf(this, actualProto);
339        }
340        else {
341            this.__proto__ = actualProto;
342        }
343        this.name = "ZodError";
344        this.issues = issues;
345    }
346    format(_mapper) {
347        const mapper = _mapper ||
348            function (issue) {
349                return issue.message;
350            };
351        const fieldErrors = { _errors: [] };
352        const processError = (error) => {
353            for (const issue of error.issues) {
354                if (issue.code === "invalid_union") {
355                    issue.unionErrors.map(processError);
356                }
357                else if (issue.code === "invalid_return_type") {
358                    processError(issue.returnTypeError);
359                }
360                else if (issue.code === "invalid_arguments") {
361                    processError(issue.argumentsError);
362                }
363                else if (issue.path.length === 0) {
364                    fieldErrors._errors.push(mapper(issue));
365                }
366                else {
367                    let curr = fieldErrors;
368                    let i = 0;
369                    while (i < issue.path.length) {
370                        const el = issue.path[i];
371                        const terminal = i === issue.path.length - 1;
372                        if (!terminal) {
373                            curr[el] = curr[el] || { _errors: [] };
374                            // if (typeof el === "string") {
375                            //   curr[el] = curr[el] || { _errors: [] };
376                            // } else if (typeof el === "number") {
377                            //   const errorArray: any = [];
378                            //   errorArray._errors = [];
379                            //   curr[el] = curr[el] || errorArray;
380                            // }
381                        }
382                        else {
383                            curr[el] = curr[el] || { _errors: [] };
384                            curr[el]._errors.push(mapper(issue));
385                        }
386                        curr = curr[el];
387                        i++;
388                    }
389                }
390            }
391        };
392        processError(this);
393        return fieldErrors;
394    }
395    static assert(value) {
396        if (!(value instanceof ZodError)) {
397            throw new Error(`Not a ZodError: ${value}`);
398        }
399    }
400    toString() {
401        return this.message;
402    }
403    get message() {
404        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
405    }
406    get isEmpty() {
407        return this.issues.length === 0;
408    }
409    flatten(mapper = (issue) => issue.message) {
410        const fieldErrors = {};
411        const formErrors = [];
412        for (const sub of this.issues) {
413            if (sub.path.length > 0) {
414                const firstEl = sub.path[0];
415                fieldErrors[firstEl] = fieldErrors[firstEl] || [];
416                fieldErrors[firstEl].push(mapper(sub));
417            }
418            else {
419                formErrors.push(mapper(sub));
420            }
421        }
422        return { formErrors, fieldErrors };
423    }
424    get formErrors() {
425        return this.flatten();
426    }
427}
428ZodError.create = (issues) => {
429    const error = new ZodError(issues);
430    return error;
431};
432
433;// CONCATENATED MODULE: ./node_modules/.pnpm/[email protected]/node_modules/zod/v3/locales/en.js
434
435
436const errorMap = (issue, _ctx) => {
437    let message;
438    switch (issue.code) {
439        case ZodIssueCode.invalid_type:
440            if (issue.received === ZodParsedType.undefined) {
441                message = "Required";
442            }
443            else {
444                message = `Expected ${issue.expected}, received ${issue.received}`;
445            }
446            break;
447        case ZodIssueCode.invalid_literal:
448            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
449            break;
450        case ZodIssueCode.unrecognized_keys:
451            message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
452            break;
453        case ZodIssueCode.invalid_union:
454            message = `Invalid input`;
455            break;
456        case ZodIssueCode.invalid_union_discriminator:
457            message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
458            break;
459        case ZodIssueCode.invalid_enum_value:
460            message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
461            break;
462        case ZodIssueCode.invalid_arguments:
463            message = `Invalid function arguments`;
464            break;
465        case ZodIssueCode.invalid_return_type:
466            message = `Invalid function return type`;
467            break;
468        case ZodIssueCode.invalid_date:
469            message = `Invalid date`;
470            break;
471        case ZodIssueCode.invalid_string:
472            if (typeof issue.validation === "object") {
473                if ("includes" in issue.validation) {
474                    message = `Invalid input: must include "${issue.validation.includes}"`;
475                    if (typeof issue.validation.position === "number") {
476                        message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
477                    }
478                }
479                else if ("startsWith" in issue.validation) {
480                    message = `Invalid input: must start with "${issue.validation.startsWith}"`;
481                }
482                else if ("endsWith" in issue.validation) {
483                    message = `Invalid input: must end with "${issue.validation.endsWith}"`;
484                }
485                else {
486                    util.assertNever(issue.validation);
487                }
488            }
489            else if (issue.validation !== "regex") {
490                message = `Invalid ${issue.validation}`;
491            }
492            else {
493                message = "Invalid";
494            }
495            break;
496        case ZodIssueCode.too_small:
497            if (issue.type === "array")
498                message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
499            else if (issue.type === "string")
500                message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
501            else if (issue.type === "number")
502                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
503            else if (issue.type === "bigint")
504                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
505            else if (issue.type === "date")
506                message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
507            else
508                message = "Invalid input";
509            break;
510        case ZodIssueCode.too_big:
511            if (issue.type === "array")
512                message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
513            else if (issue.type === "string")
514                message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
515            else if (issue.type === "number")
516                message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
517            else if (issue.type === "bigint")
518                message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
519            else if (issue.type === "date")
520                message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
521            else
522                message = "Invalid input";
523            break;
524        case ZodIssueCode.custom:
525            message = `Invalid input`;
526            break;
527        case ZodIssueCode.invalid_intersection_types:
528            message = `Intersection results could not be merged`;
529            break;
530        case ZodIssueCode.not_multiple_of:
531            message = `Number must be a multiple of ${issue.multipleOf}`;
532            break;
533        case ZodIssueCode.not_finite:
534            message = "Number must be finite";
535            break;
536        default:
537            message = _ctx.defaultError;
538            util.assertNever(issue);
539    }
540    return { message };
541};
542/* harmony default export */ var en = (errorMap);
543
544;// CONCATENATED MODULE: ./node_modules/.pnpm/[email protected]/node_modules/zod/v3/errors.js
545
546let overrideErrorMap = en;
547
548function setErrorMap(map) {
549    overrideErrorMap = map;
550}
551function getErrorMap() {
552    return overrideErrorMap;
553}
554
555;// CONCATENATED MODULE: ./node_modules/.pnpm/[email protected]/node_modules/zod/v3/helpers/parseUtil.js
556
557
558const makeIssue = (params) => {
559    const { data, path, errorMaps, issueData } = params;
560    const fullPath = [...path, ...(issueData.path || [])];
561    const fullIssue = {
562        ...issueData,
563        path: fullPath,
564    };
565    if (issueData.message !== undefined) {
566        return {
567            ...issueData,
568            path: fullPath,
569            message: issueData.message,
570        };
571    }
572    let errorMessage = "";
573    const maps = errorMaps
574        .filter((m) => !!m)
575        .slice()
576        .reverse();
577    for (const map of maps) {
578        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
579    }
580    return {
581        ...issueData,
582        path: fullPath,
583        message: errorMessage,
584    };
585};
586const EMPTY_PATH = [];
587function addIssueToContext(ctx, issueData) {
588    const overrideMap = getErrorMap();
589    const issue = makeIssue({
590        issueData: issueData,
591        data: ctx.data,
592        path: ctx.path,
593        errorMaps: [
594            ctx.common.contextualErrorMap, // contextual error map is first priority
595            ctx.schemaErrorMap, // then schema-bound map if available
596            overrideMap, // then global override map
597            overrideMap === en ? undefined : en, // then global default map
598        ].filter((x) => !!x),
599    });
600    ctx.common.issues.push(issue);
601}
602class ParseStatus {
603    constructor() {
604        this.value = "valid";
605    }
606    dirty() {
607        if (this.value === "valid")
608            this.value = "dirty";
609    }
610    abort() {
611        if (this.value !== "aborted")
612            this.value = "aborted";
613    }
614    static mergeArray(status, results) {
615        const arrayValue = [];
616        for (const s of results) {
617            if (s.status === "aborted")
618                return INVALID;
619            if (s.status === "dirty")
620                status.dirty();
621            arrayValue.push(s.value);
622        }
623        return { status: status.value, value: arrayValue };
624    }
625    static async mergeObjectAsync(status, pairs) {
626        const syncPairs = [];
627        for (const pair of pairs) {

896                    }
897                    else {
898                        return true;
899                    }
900                });
901            }
902            if (!result) {
903                setError();
904                return false;
905            }
906            else {
907                return true;
908            }
909        });
910    }
911    refinement(check, refinementData) {
912        return this._refinement((val, ctx) => {
913            if (!check(val)) {
914                ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
915                return false;
916            }
917            else {
918                return true;
919            }
920        });
921    }
922    _refinement(refinement) {
923        return new ZodEffects({
924            schema: this,
925            typeName: ZodFirstPartyTypeKind.ZodEffects,
926            effect: { type: "refinement", refinement },
927        });
928    }
929    superRefine(refinement) {
930        return this._refinement(refinement);
931    }
932    constructor(def) {
933        /** Alias of safeParseAsync */
934        this.spa = this.safeParseAsync;
935        this._def = def;
936        this.parse = this.parse.bind(this);
937        this.safeParse = this.safeParse.bind(this);
938        this.parseAsync = this.parseAsync.bind(this);
939        this.safeParseAsync = this.safeParseAsync.bind(this);
940        this.spa = this.spa.bind(this);
941        this.refine = this.refine.bind(this);
942        this.refinement = this.refinement.bind(this);
943        this.superRefine = this.superRefine.bind(this);
944        this.optional = this.optional.bind(this);
945        this.nullable = this.nullable.bind(this);
946        this.nullish = this.nullish.bind(this);
947        this.array = this.array.bind(this);
948        this.promise = this.promise.bind(this);
949        this.or = this.or.bind(this);
950        this.and = this.and.bind(this);
951        this.transform = this.transform.bind(this);
952        this.brand = this.brand.bind(this);
953        this.default = this.default.bind(this);
954        this.catch = this.catch.bind(this);
955        this.describe = this.describe.bind(this);
956        this.pipe = this.pipe.bind(this);
957        this.readonly = this.readonly.bind(this);
958        this.isNullable = this.isNullable.bind(this);
959        this.isOptional = this.isOptional.bind(this);
960        this["~standard"] = {
961            version: 1,
962            vendor: "zod",
963            validate: (data) => this["~validate"](data),
964        };
965    }
966    optional() {
967        return ZodOptional.create(this, this._def);
968    }
969    nullable() {
970        return ZodNullable.create(this, this._def);
971    }
972    nullish() {
973        return this.nullable().optional();
974    }
975    array() {
976        return ZodArray.create(this);
977    }
978    promise() {
979        return ZodPromise.create(this, this._def);
980    }
981    or(option) {
982        return ZodUnion.create([this, option], this._def);
983    }
984    and(incoming) {
985        return ZodIntersection.create(this, incoming, this._def);
986    }
987    transform(transform) {
988        return new ZodEffects({
989            ...processCreateParams(this._def),
990            schema: this,
991            typeName: ZodFirstPartyTypeKind.ZodEffects,
992            effect: { type: "transform", transform },
993        });
994    }
995    default(def) {
996        const defaultValueFunc = typeof def === "function" ? def : () => def;
997        return new ZodDefault({
998            ...processCreateParams(this._def),
999            innerType: this,
1000            defaultValue: defaultValueFunc,
1001            typeName: ZodFirstPartyTypeKind.ZodDefault,
1002        });
1003    }
1004    brand() {
1005        return new ZodBranded({
1006            typeName: ZodFirstPartyTypeKind.ZodBranded,
1007            type: this,
1008            ...processCreateParams(this._def),
1009        });
1010    }
1011    catch(def) {
1012        const catchValueFunc = typeof def === "function" ? def : () => def;
1013        return new ZodCatch({
1014            ...processCreateParams(this._def),
1015            innerType: this,
1016            catchValue: catchValueFunc,
1017            typeName: ZodFirstPartyTypeKind.ZodCatch,
1018        });
1019    }
1020    describe(description) {
1021        const This = this.constructor;
1022        return new This({
1023            ...this._def,
1024            description,
1025        });
1026    }
1027    pipe(target) {
1028        return ZodPipeline.create(this, target);
1029    }
1030    readonly() {
1031        return ZodReadonly.create(this);
1032    }
1033    isOptional() {
1034        return this.safeParse(undefined).success;
1035    }
1036    isNullable() {
1037        return this.safeParse(null).success;
1038    }
1039}
1040const cuidRegex = /^c[^\s-]{8,}$/i;
1041const cuid2Regex = /^[0-9a-z]+$/;

1093 // require seconds if precision is nonzero
1094    return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
1095}
1096function timeRegex(args) {
1097    return new RegExp(`^${timeRegexSource(args)}$`);
1098}
1099// Adapted from https://stackoverflow.com/a/3143231
1100function datetimeRegex(args) {
1101    let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
1102    const opts = [];
1103    opts.push(args.local ? `Z?` : `Z`);
1104    if (args.offset)
1105        opts.push(`([+-]\\d{2}:?\\d{2})`);
1106    regex = `${regex}(${opts.join("|")})`;
1107    return new RegExp(`^${regex}$`);
1108}
1109function isValidIP(ip, version) {
1110    if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
1111        return true;
1112    }
1113    if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
1114        return true;
1115    }
1116    return false;
1117}
1118function isValidJWT(jwt, alg) {
1119    if (!jwtRegex.test(jwt))
1120        return false;
1121    try {
1122        const [header] = jwt.split(".");
1123        if (!header)
1124            return false;
1125        // Convert base64url to base64
1126        const base64 = header
1127            .replace(/-/g, "+")
1128            .replace(/_/g, "/")
1129            .padEnd(header.length + ((4 - (header.length % 4)) % 4), "=");
1130        const decoded = JSON.parse(atob(base64));
1131        if (typeof decoded !== "object" || decoded === null)
1132            return false;
1133        if ("typ" in decoded && decoded?.typ !== "JWT")
1134            return false;
1135        if (!decoded.alg)
1136            return false;
1137        if (alg && decoded.alg !== alg)
1138            return false;
1139        return true;
1140    }
1141    catch {
1142        return false;
1143    }
1144}
1145function isValidCidr(ip, version) {
1146    if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) {
1147        return true;
1148    }
1149    if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) {
1150        return true;
1151    }
1152    return false;
1153}
1154class ZodString extends ZodType {
1155    _parse(input) {
1156        if (this._def.coerce) {
1157            input.data = String(input.data);
1158        }
1159        const parsedType = this._getType(input);
1160        if (parsedType !== ZodParsedType.string) {
1161            const ctx = this._getOrReturnCtx(input);
1162            addIssueToContext(ctx, {
1163                code: ZodIssueCode.invalid_type,
1164                expected: ZodParsedType.string,
1165                received: ctx.parsedType,
1166            });
1167            return INVALID;
1168        }
1169        const status = new ParseStatus();
1170        let ctx = undefined;
1171        for (const check of this._def.checks) {
1172            if (check.kind === "min") {
1173                if (input.data.length < check.value) {
1174                    ctx = this._getOrReturnCtx(input, ctx);
1175                    addIssueToContext(ctx, {
1176                        code: ZodIssueCode.too_small,
1177                        minimum: check.value,
1178                        type: "string",
1179                        inclusive: true,
1180                        exact: false,
1181                        message: check.message,
1182                    });
1183                    status.dirty();
1184                }
1185            }
1186            else if (check.kind === "max") {
1187                if (input.data.length > check.value) {
1188                    ctx = this._getOrReturnCtx(input, ctx);
1189                    addIssueToContext(ctx, {
1190                        code: ZodIssueCode.too_big,
1191                        maximum: check.value,
1192                        type: "string",
1193                        inclusive: true,
1194                        exact: false,
1195                        message: check.message,
1196                    });
1197                    status.dirty();
1198                }
1199            }
1200            else if (check.kind === "length") {
1201                const tooBig = input.data.length > check.value;
1202                const tooSmall = input.data.length < check.value;
1203                if (tooBig || tooSmall) {
1204                    ctx = this._getOrReturnCtx(input, ctx);
1205                    if (tooBig) {
1206                        addIssueToContext(ctx, {
1207                            code: ZodIssueCode.too_big,
1208                            maximum: check.value,
1209                            type: "string",
1210                            inclusive: true,
1211                            exact: true,
1212                            message: check.message,
1213                        });
1214                    }
1215                    else if (tooSmall) {
1216                        addIssueToContext(ctx, {
1217                            code: ZodIssueCode.too_small,
1218                            minimum: check.value,
1219                            type: "string",
1220                            inclusive: true,
1221                            exact: true,
1222                            message: check.message,
1223                        });
1224                    }
1225                    status.dirty();
1226                }
1227            }
1228            else if (check.kind === "email") {
1229                if (!emailRegex.test(input.data)) {
1230                    ctx = this._getOrReturnCtx(input, ctx);
1231                    addIssueToContext(ctx, {
1232                        validation: "email",
1233                        code: ZodIssueCode.invalid_string,
1234                        message: check.message,
1235                    });
1236                    status.dirty();
1237                }
1238            }
1239            else if (check.kind === "emoji") {
1240                if (!emojiRegex) {
1241                    emojiRegex = new RegExp(_emojiRegex, "u");
1242                }
1243                if (!emojiRegex.test(input.data)) {
1244                    ctx = this._getOrReturnCtx(input, ctx);
1245                    addIssueToContext(ctx, {
1246                        validation: "emoji",
1247                        code: ZodIssueCode.invalid_string,
1248                        message: check.message,
1249                    });
1250                    status.dirty();
1251                }
1252            }
1253            else if (check.kind === "uuid") {
1254                if (!uuidRegex.test(input.data)) {
1255                    ctx = this._getOrReturnCtx(input, ctx);
1256                    addIssueToContext(ctx, {
1257                        validation: "uuid",
1258                        code: ZodIssueCode.invalid_string,
1259                        message: check.message,
1260                    });
1261                    status.dirty();
1262                }
1263            }

1264            else if (check.kind === "nanoid") {
1265                if (!nanoidRegex.test(input.data)) {
1266                    ctx = this._getOrReturnCtx(input, ctx);
1267                    addIssueToContext(ctx, {
1268                        validation: "nanoid",
1269                        code: ZodIssueCode.invalid_string,
1270                        message: check.message,
1271                    });
1272                    status.dirty();
1273                }
1274            }
1275            else if (check.kind === "cuid") {
1276                if (!cuidRegex.test(input.data)) {
1277                    ctx = this._getOrReturnCtx(input, ctx);
1278                    addIssueToContext(ctx, {
1279                        validation: "cuid",
1280                        code: ZodIssueCode.invalid_string,
1281                        message: check.message,
1282                    });
1283                    status.dirty();
1284                }
1285            }
1286            else if (check.kind === "cuid2") {
1287                if (!cuid2Regex.test(input.data)) {
1288                    ctx = this._getOrReturnCtx(input, ctx);
1289                    addIssueToContext(ctx, {
1290                        validation: "cuid2",
1291                        code: ZodIssueCode.invalid_string,
1292                        message: check.message,
1293                    });
1294                    status.dirty();
1295                }
1296            }
1297            else if (check.kind === "ulid") {
1298                if (!ulidRegex.test(input.data)) {
1299                    ctx = this._getOrReturnCtx(input, ctx);
1300                    addIssueToContext(ctx, {
1301                        validation: "ulid",
1302                        code: ZodIssueCode.invalid_string,
1303                        message: check.message,
1304                    });
1305                    status.dirty();
1306                }
1307            }
1308            else if (check.kind === "url") {
1309                try {
1310                    new URL(input.data);
1311                }
1312                catch {
1313                    ctx = this._getOrReturnCtx(input, ctx);
1314                    addIssueToContext(ctx, {
1315                        validation: "url",
1316                        code: ZodIssueCode.invalid_string,
1317                        message: check.message,
1318                    });
1319                    status.dirty();
1320                }
1321            }
1322            else if (check.kind === "regex") {
1323                check.regex.lastIndex = 0;
1324                const testResult = check.regex.test(input.data);
1325                if (!testResult) {
1326                    ctx = this._getOrReturnCtx(input, ctx);
1327                    addIssueToContext(ctx, {
1328                        validation: "regex",
1329                        code: ZodIssueCode.invalid_string,
1330                        message: check.message,
1331                    });
1332                    status.dirty();
1333                }
1334            }
1335            else if (check.kind === "trim") {
1336                input.data = input.data.trim();
1337            }
1338            else if (check.kind === "includes") {
1339                if (!input.data.includes(check.value, check.position)) {
1340                    ctx = this._getOrReturnCtx(input, ctx);
1341                    addIssueToContext(ctx, {
1342                        code: ZodIssueCode.invalid_string,
1343                        validation: { includes: check.value, position: check.position },
1344                        message: check.message,
1345                    });
1346                    status.dirty();
1347                }
1348            }
1349            else if (check.kind === "toLowerCase") {
1350                input.data = input.data.toLowerCase();
1351            }
1352            else if (check.kind === "toUpperCase") {
1353                input.data = input.data.toUpperCase();
1354            }
1355            else if (check.kind === "startsWith") {
1356                if (!input.data.startsWith(check.value)) {
1357                    ctx = this._getOrReturnCtx(input, ctx);
1358                    addIssueToContext(ctx, {
1359                        code: ZodIssueCode.invalid_string,
1360                        validation: { startsWith: check.value },
1361                        message: check.message,
1362                    });
1363                    status.dirty();
1364                }
1365            }
1366            else if (check.kind === "endsWith") {
1367                if (!input.data.endsWith(check.value)) {
1368                    ctx = this._getOrReturnCtx(input, ctx);
1369                    addIssueToContext(ctx, {
1370                        code: ZodIssueCode.invalid_string,
1371                        validation: { endsWith: check.value },
1372                        message: check.message,
1373                    });
1374                    status.dirty();
1375                }
1376            }
1377            else if (check.kind === "datetime") {
1378                const regex = datetimeRegex(check);
1379                if (!regex.test(input.data)) {
1380                    ctx = this._getOrReturnCtx(input, ctx);
1381                    addIssueToContext(ctx, {
1382                        code: ZodIssueCode.invalid_string,
1383                        validation: "datetime",
1384                        message: check.message,
1385                    });
1386                    status.dirty();
1387                }
1388            }
1389            else if (check.kind === "date") {
1390                const regex = dateRegex;
1391                if (!regex.test(input.data)) {
1392                    ctx = this._getOrReturnCtx(input, ctx);
1393                    addIssueToContext(ctx, {
1394                        code: ZodIssueCode.invalid_string,
1395                        validation: "date",
1396                        message: check.message,
1397                    });
1398                    status.dirty();
1399                }
1400            }
1401            else if (check.kind === "time") {
1402                const regex = timeRegex(check);
1403                if (!regex.test(input.data)) {
1404                    ctx = this._getOrReturnCtx(input, ctx);
1405                    addIssueToContext(ctx, {
1406                        code: ZodIssueCode.invalid_string,
1407                        validation: "time",
1408                        message: check.message,
1409                    });
1410                    status.dirty();
1411                }
1412            }
1413            else if (check.kind === "duration") {
1414                if (!durationRegex.test(input.data)) {
1415                    ctx = this._getOrReturnCtx(input, ctx);
1416                    addIssueToContext(ctx, {
1417                        validation: "duration",
1418                        code: ZodIssueCode.invalid_string,
1419                        message: check.message,
1420                    });
1421                    status.dirty();
1422                }
1423            }
1424            else if (check.kind === "ip") {
1425                if (!isValidIP(input.data, check.version)) {
1426                    ctx = this._getOrReturnCtx(input, ctx);
1427                    addIssueToContext(ctx, {
1428                        validation: "ip",
1429                        code: ZodIssueCode.invalid_string,
1430                        message: check.message,
1431                    });
1432                    status.dirty();
1433                }
1434            }
1435            else if (check.kind === "jwt") {
1436                if (!isValidJWT(input.data, check.alg)) {
1437                    ctx = this._getOrReturnCtx(input, ctx);
1438                    addIssueToContext(ctx, {
1439                        validation: "jwt",
1440                        code: ZodIssueCode.invalid_string,
1441                        message: check.message,
1442                    });
1443                    status.dirty();
1444                }
1445            }
1446            else if (check.kind === "cidr") {
1447                if (!isValidCidr(input.data, check.version)) {
1448                    ctx = this._getOrReturnCtx(input, ctx);
1449                    addIssueToContext(ctx, {
1450                        validation: "cidr",
1451                        code: ZodIssueCode.invalid_string,
1452                        message: check.message,
1453                    });
1454                    status.dirty();
1455                }
1456            }
1457            else if (check.kind === "base64") {
1458                if (!base64Regex.test(input.data)) {
1459                    ctx = this._getOrReturnCtx(input, ctx);
1460                    addIssueToContext(ctx, {
1461                        validation: "base64",
1462                        code: ZodIssueCode.invalid_string,
1463                        message: check.message,
1464                    });
1465                    status.dirty();
1466                }
1467            }
1468            else if (check.kind === "base64url") {
1469                if (!base64urlRegex.test(input.data)) {
1470                    ctx = this._getOrReturnCtx(input, ctx);
1471                    addIssueToContext(ctx, {
1472                        validation: "base64url",
1473                        code: ZodIssueCode.invalid_string,
1474                        message: check.message,
1475                    });
1476                    status.dirty();
1477                }
1478            }
1479            else {
1480                util.assertNever(check);
1481            }
1482        }
1483        return { status: status.value, value: input.data };
1484    }
1485    _regex(regex, validation, message) {
1486        return this.refinement((data) => regex.test(data), {
1487            validation,
1488            code: ZodIssueCode.invalid_string,
1489            ...errorUtil.errToObj(message),
1490        });
1491    }
1492    _addCheck(check) {
1493        return new ZodString({
1494            ...this._def,
1495            checks: [...this._def.checks, check],
1496        });
1497    }
1498    email(message) {
1499        return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
1500    }
1501    url(message) {
1502        return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
1503    }
1504    emoji(message) {
1505        return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
1506    }
1507    uuid(message) {
1508        return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
1509    }
1510    nanoid(message) {
1511        return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
1512    }
1513    cuid(message) {
1514        return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
1515    }
1516    cuid2(message) {
1517        return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
1518    }
1519    ulid(message) {
1520        return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
1521    }
1522    base64(message) {
1523        return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
1524    }
1525    base64url(message) {
1526        // base64url encoding is a modification of base64 that can safely be used in URLs and filenames
1527        return this._addCheck({
1528            kind: "base64url",
1529            ...errorUtil.errToObj(message),
1530        });
1531    }
1532    jwt(options) {
1533        return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) });
1534    }
1535    ip(options) {
1536        return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
1537    }
1538    cidr(options) {
1539        return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
1540    }
1541    datetime(options) {
1542        if (typeof options === "string") {
1543            return this._addCheck({
1544                kind: "datetime",
1545                precision: null,
1546                offset: false,
1547                local: false,
1548                message: options,
1549            });
1550        }
1551        return this._addCheck({
1552            kind: "datetime",
1553            precision: typeof options?.precision === "undefined" ? null : options?.precision,

1656    get isDate() {
1657        return !!this._def.checks.find((ch) => ch.kind === "date");
1658    }
1659    get isTime() {
1660        return !!this._def.checks.find((ch) => ch.kind === "time");
1661    }
1662    get isDuration() {
1663        return !!this._def.checks.find((ch) => ch.kind === "duration");
1664    }
1665    get isEmail() {
1666        return !!this._def.checks.find((ch) => ch.kind === "email");
1667    }
1668    get isURL() {
1669        return !!this._def.checks.find((ch) => ch.kind === "url");
1670    }
1671    get isEmoji() {
1672        return !!this._def.checks.find((ch) => ch.kind === "emoji");
1673    }
1674    get isUUID() {
1675        return !!this._def.checks.find((ch) => ch.kind === "uuid");
1676    }
1677    get isNANOID() {
1678        return !!this._def.checks.find((ch) => ch.kind === "nanoid");
1679    }
1680    get isCUID() {
1681        return !!this._def.checks.find((ch) => ch.kind === "cuid");
1682    }
1683    get isCUID2() {
1684        return !!this._def.checks.find((ch) => ch.kind === "cuid2");
1685    }
1686    get isULID() {
1687        return !!this._def.checks.find((ch) => ch.kind === "ulid");
1688    }
1689    get isIP() {
1690        return !!this._def.checks.find((ch) => ch.kind === "ip");
1691    }
1692    get isCIDR() {
1693        return !!this._def.checks.find((ch) => ch.kind === "cidr");
1694    }
1695    get isBase64() {
1696        return !!this._def.checks.find((ch) => ch.kind === "base64");
1697    }
1698    get isBase64url() {
1699        // base64url encoding is a modification of base64 that can safely be used in URLs and filenames
1700        return !!this._def.checks.find((ch) => ch.kind === "base64url");
1701    }
1702    get minLength() {
1703        let min = null;
1704        for (const ch of this._def.checks) {
1705            if (ch.kind === "min") {
1706                if (min === null || ch.value > min)
1707                    min = ch.value;
1708            }
1709        }
1710        return min;
1711    }
1712    get maxLength() {
1713        let max = null;
1714        for (const ch of this._def.checks) {
1715            if (ch.kind === "max") {
1716                if (max === null || ch.value < max)
1717                    max = ch.value;
1718            }
1719        }
1720        return max;
1721    }
1722}
1723ZodString.create = (params) => {
1724    return new ZodString({
1725        checks: [],
1726        typeName: ZodFirstPartyTypeKind.ZodString,
1727        coerce: params?.coerce ?? false,
1728        ...processCreateParams(params),
1729    });
1730};
1731// https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034
1732function floatSafeRemainder(val, step) {
1733    const valDecCount = (val.toString().split(".")[1] || "").length;
1734    const stepDecCount = (step.toString().split(".")[1] || "").length;
1735    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
1736    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
1737    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
1738    return (valInt % stepInt) / 10 ** decCount;
1739}
1740class ZodNumber extends ZodType {
1741    constructor() {
1742        super(...arguments);
1743        this.min = this.gte;
1744        this.max = this.lte;
1745        this.step = this.multipleOf;
1746    }
1747    _parse(input) {
1748        if (this._def.coerce) {
1749            input.data = Number(input.data);
1750        }
1751        const parsedType = this._getType(input);
1752        if (parsedType !== ZodParsedType.number) {
1753            const ctx = this._getOrReturnCtx(input);
1754            addIssueToContext(ctx, {
1755                code: ZodIssueCode.invalid_type,
1756                expected: ZodParsedType.number,
1757                received: ctx.parsedType,
1758            });
1759            return INVALID;
1760        }
1761        let ctx = undefined;
1762        const status = new ParseStatus();
1763        for (const check of this._def.checks) {
1764            if (check.kind === "int") {
1765                if (!util.isInteger(input.data)) {
1766                    ctx = this._getOrReturnCtx(input, ctx);
1767                    addIssueToContext(ctx, {
1768                        code: ZodIssueCode.invalid_type,
1769                        expected: "integer",
1770                        received: "float",
1771                        message: check.message,
1772                    });
1773                    status.dirty();
1774                }
1775            }
1776            else if (check.kind === "min") {
1777                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
1778                if (tooSmall) {
1779                    ctx = this._getOrReturnCtx(input, ctx);
1780                    addIssueToContext(ctx, {
1781                        code: ZodIssueCode.too_small,
1782                        minimum: check.value,
1783                        type: "number",
1784                        inclusive: check.inclusive,
1785                        exact: false,
1786                        message: check.message,
1787                    });
1788                    status.dirty();
1789                }
1790            }
1791            else if (check.kind === "max") {
1792                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
1793                if (tooBig) {
1794                    ctx = this._getOrReturnCtx(input, ctx);
1795                    addIssueToContext(ctx, {
1796                        code: ZodIssueCode.too_big,
1797                        maximum: check.value,
1798                        type: "number",
1799                        inclusive: check.inclusive,
1800                        exact: false,
1801                        message: check.message,
1802                    });
1803                    status.dirty();
1804                }
1805            }
1806            else if (check.kind === "multipleOf") {
1807                if (floatSafeRemainder(input.data, check.value) !== 0) {
1808                    ctx = this._getOrReturnCtx(input, ctx);
1809                    addIssueToContext(ctx, {
1810                        code: ZodIssueCode.not_multiple_of,
1811                        multipleOf: check.value,
1812                        message: check.message,
1813                    });
1814                    status.dirty();
1815                }
1816            }
1817            else if (check.kind === "finite") {
1818                if (!Number.isFinite(input.data)) {
1819                    ctx = this._getOrReturnCtx(input, ctx);
1820                    addIssueToContext(ctx, {
1821                        code: ZodIssueCode.not_finite,
1822                        message: check.message,
1823                    });
1824                    status.dirty();
1825                }
1826            }
1827            else {
1828                util.assertNever(check);
1829            }
1830        }
1831        return { status: status.value, value: input.data };
1832    }
1833    gte(value, message) {
1834        return this.setLimit("min", value, true, errorUtil.toString(message));
1835    }
1836    gt(value, message) {
1837        return this.setLimit("min", value, false, errorUtil.toString(message));
1838    }
1839    lte(value, message) {
1840        return this.setLimit("max", value, true, errorUtil.toString(message));
1841    }
1842    lt(value, message) {
1843        return this.setLimit("max", value, false, errorUtil.toString(message));
1844    }
1845    setLimit(kind, value, inclusive, message) {
1846        return new ZodNumber({
1847            ...this._def,
1848            checks: [
1849                ...this._def.checks,
1850                {
1851                    kind,
1852                    value,
1853                    inclusive,
1854                    message: errorUtil.toString(message),
1855                },
1856            ],
1857        });
1858    }
1859    _addCheck(check) {
1860        return new ZodNumber({
1861            ...this._def,
1862            checks: [...this._def.checks, check],
1863        });
1864    }
1865    int(message) {
1866        return this._addCheck({
1867            kind: "int",
1868            message: errorUtil.toString(message),
1869        });
1870    }
1871    positive(message) {
1872        return this._addCheck({
1873            kind: "min",
1874            value: 0,
1875            inclusive: false,
1876            message: errorUtil.toString(message),
1877        });
1878    }
1879    negative(message) {
1880        return this._addCheck({
1881            kind: "max",
1882            value: 0,
1883            inclusive: false,
1884            message: errorUtil.toString(message),
1885        });
1886    }
1887    nonpositive(message) {
1888        return this._addCheck({
1889            kind: "max",
1890            value: 0,
1891            inclusive: true,
1892            message: errorUtil.toString(message),
1893        });
1894    }
1895    nonnegative(message) {
1896        return this._addCheck({
1897            kind: "min",
1898            value: 0,
1899            inclusive: true,
1900            message: errorUtil.toString(message),
1901        });
1902    }
1903    multipleOf(value, message) {
1904        return this._addCheck({
1905            kind: "multipleOf",
1906            value: value,
1907            message: errorUtil.toString(message),
1908        });
1909    }
1910    finite(message) {
1911        return this._addCheck({
1912            kind: "finite",
1913            message: errorUtil.toString(message),
1914        });
1915    }
1916    safe(message) {
1917        return this._addCheck({
1918            kind: "min",
1919            inclusive: true,
1920            value: Number.MIN_SAFE_INTEGER,
1921            message: errorUtil.toString(message),
1922        })._addCheck({
1923            kind: "max",
1924            inclusive: true,
1925            value: Number.MAX_SAFE_INTEGER,
1926            message: errorUtil.toString(message),
1927        });
1928    }
1929    get minValue() {
1930        let min = null;
1931        for (const ch of this._def.checks) {
1932            if (ch.kind === "min") {
1933                if (min === null || ch.value > min)
1934                    min = ch.value;
1935            }
1936        }
1937        return min;
1938    }
1939    get maxValue() {
1940        let max = null;
1941        for (const ch of this._def.checks) {
1942            if (ch.kind === "max") {
1943                if (max === null || ch.value < max)
1944                    max = ch.value;
1945            }
1946        }
1947        return max;
1948    }
1949    get isInt() {
1950        return !!this._def.checks.find((ch) => ch.kind === "int" || (ch.kind === "multipleOf" && util.isInteger(ch.value)));
1951    }
1952    get isFinite() {
1953        let max = null;
1954        let min = null;
1955        for (const ch of this._def.checks) {
1956            if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
1957                return true;
1958            }
1959            else if (ch.kind === "min") {
1960                if (min === null || ch.value > min)
1961                    min = ch.value;
1962            }
1963            else if (ch.kind === "max") {
1964                if (max === null || ch.value < max)
1965                    max = ch.value;
1966            }
1967        }
1968        return Number.isFinite(min) && Number.isFinite(max);
1969    }
1970}
1971ZodNumber.create = (params) => {
1972    return new ZodNumber({
1973        checks: [],
1974        typeName: ZodFirstPartyTypeKind.ZodNumber,
1975        coerce: params?.coerce || false,
1976        ...processCreateParams(params),
1977    });
1978};
1979class ZodBigInt extends ZodType {
1980    constructor() {
1981        super(...arguments);
1982        this.min = this.gte;
1983        this.max = this.lte;
1984    }
1985    _parse(input) {
1986        if (this._def.coerce) {
1987            try {
1988                input.data = BigInt(input.data);
1989            }
1990            catch {
1991                return this._getInvalidInput(input);
1992            }
1993        }
1994        const parsedType = this._getType(input);
1995        if (parsedType !== ZodParsedType.bigint) {
1996            return this._getInvalidInput(input);
1997        }
1998        let ctx = undefined;
1999        const status = new ParseStatus();
2000        for (const check of this._def.checks) {
2001            if (check.kind === "min") {
2002                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
2003                if (tooSmall) {
2004                    ctx = this._getOrReturnCtx(input, ctx);
2005                    addIssueToContext(ctx, {
2006                        code: ZodIssueCode.too_small,
2007                        type: "bigint",
2008                        minimum: check.value,
2009                        inclusive: check.inclusive,
2010                        message: check.message,
2011                    });
2012                    status.dirty();
2013                }
2014            }
2015            else if (check.kind === "max") {
2016                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
2017                if (tooBig) {
2018                    ctx = this._getOrReturnCtx(input, ctx);
2019                    addIssueToContext(ctx, {
2020                        code: ZodIssueCode.too_big,
2021                        type: "bigint",
2022                        maximum: check.value,
2023                        inclusive: check.inclusive,
2024                        message: check.message,
2025                    });
2026                    status.dirty();
2027                }
2028            }
2029            else if (check.kind === "multipleOf") {
2030                if (input.data % check.value !== BigInt(0)) {
2031                    ctx = this._getOrReturnCtx(input, ctx);
2032                    addIssueToContext(ctx, {
2033                        code: ZodIssueCode.not_multiple_of,
2034                        multipleOf: check.value,
2035                        message: check.message,
2036                    });
2037                    status.dirty();
2038                }
2039            }
2040            else {
2041                util.assertNever(check);
2042            }
2043        }
2044        return { status: status.value, value: input.data };
2045    }
2046    _getInvalidInput(input) {
2047        const ctx = this._getOrReturnCtx(input);
2048        addIssueToContext(ctx, {
2049            code: ZodIssueCode.invalid_type,
2050            expected: ZodParsedType.bigint,
2051            received: ctx.parsedType,
2052        });
2053        return INVALID;
2054    }
2055    gte(value, message) {
2056        return this.setLimit("min", value, true, errorUtil.toString(message));
2057    }
2058    gt(value, message) {
2059        return this.setLimit("min", value, false, errorUtil.toString(message));
2060    }
2061    lte(value, message) {
2062        return this.setLimit("max", value, true, errorUtil.toString(message));
2063    }
2064    lt(value, message) {
2065        return this.setLimit("max", value, false, errorUtil.toString(message));
2066    }
2067    setLimit(kind, value, inclusive, message) {
2068        return new ZodBigInt({
2069            ...this._def,
2070            checks: [
2071                ...this._def.checks,
2072                {
2073                    kind,
2074                    value,
2075                    inclusive,
2076                    message: errorUtil.toString(message),
2077                },
2078            ],
2079        });
2080    }
2081    _addCheck(check) {
2082        return new ZodBigInt({
2083            ...this._def,
2084            checks: [...this._def.checks, check],
2085        });
2086    }
2087    positive(message) {
2088        return this._addCheck({
2089            kind: "min",
2090            value: BigInt(0),
2091            inclusive: false,
2092            message: errorUtil.toString(message),
2093        });
2094    }
2095    negative(message) {
2096        return this._addCheck({
2097            kind: "max",
2098            value: BigInt(0),
2099            inclusive: false,
2100            message: errorUtil.toString(message),
2101        });
2102    }
2103    nonpositive(message) {
2104        return this._addCheck({
2105            kind: "max",
2106            value: BigInt(0),
2107            inclusive: true,
2108            message: errorUtil.toString(message),
2109        });
2110    }
2111    nonnegative(message) {
2112        return this._addCheck({
2113            kind: "min",
2114            value: BigInt(0),
2115            inclusive: true,
2116            message: errorUtil.toString(message),
2117        });
2118    }
2119    multipleOf(value, message) {
2120        return this._addCheck({
2121            kind: "multipleOf",
2122            value,
2123            message: errorUtil.toString(message),
2124        });
2125    }
2126    get minValue() {
2127        let min = null;
2128        for (const ch of this._def.checks) {
2129            if (ch.kind === "min") {
2130                if (min === null || ch.value > min)
2131                    min = ch.value;
2132            }
2133        }
2134        return min;
2135    }
2136    get maxValue() {
2137        let max = null;
2138        for (const ch of this._def.checks) {
2139            if (ch.kind === "max") {
2140                if (max === null || ch.value < max)
2141                    max = ch.value;
2142            }
2143        }
2144        return max;
2145    }
2146}
2147ZodBigInt.create = (params) => {
2148    return new ZodBigInt({
2149        checks: [],
2150        typeName: ZodFirstPartyTypeKind.ZodBigInt,
2151        coerce: params?.coerce ?? false,
2152        ...processCreateParams(params),
2153    });
2154};
2155class ZodBoolean extends ZodType {
2156    _parse(input) {
2157        if (this._def.coerce) {
2158            input.data = Boolean(input.data);
2159        }
2160        const parsedType = this._getType(input);
2161        if (parsedType !== ZodParsedType.boolean) {
2162            const ctx = this._getOrReturnCtx(input);
2163            addIssueToContext(ctx, {
2164                code: ZodIssueCode.invalid_type,
2165                expected: ZodParsedType.boolean,
2166                received: ctx.parsedType,
2167            });
2168            return INVALID;
2169        }
2170        return OK(input.data);
2171    }
2172}
2173ZodBoolean.create = (params) => {
2174    return new ZodBoolean({
2175        typeName: ZodFirstPartyTypeKind.ZodBoolean,
2176        coerce: params?.coerce || false,
2177        ...processCreateParams(params),
2178    });
2179};
2180class ZodDate extends ZodType {
2181    _parse(input) {
2182        if (this._def.coerce) {
2183            input.data = new Date(input.data);
2184        }
2185        const parsedType = this._getType(input);
2186        if (parsedType !== ZodParsedType.date) {
2187            const ctx = this._getOrReturnCtx(input);
2188            addIssueToContext(ctx, {
2189                code: ZodIssueCode.invalid_type,
2190                expected: ZodParsedType.date,
2191                received: ctx.parsedType,
2192            });
2193            return INVALID;
2194        }
2195        if (Number.isNaN(input.data.getTime())) {
2196            const ctx = this._getOrReturnCtx(input);
2197            addIssueToContext(ctx, {
2198                code: ZodIssueCode.invalid_date,
2199            });
2200            return INVALID;
2201        }
2202        const status = new ParseStatus();
2203        let ctx = undefined;
2204        for (const check of this._def.checks) {
2205            if (check.kind === "min") {
2206                if (input.data.getTime() < check.value) {
2207                    ctx = this._getOrReturnCtx(input, ctx);
2208                    addIssueToContext(ctx, {
2209                        code: ZodIssueCode.too_small,
2210                        message: check.message,
2211                        inclusive: true,
2212                        exact: false,
2213                        minimum: check.value,
2214                        type: "date",
2215                    });
2216                    status.dirty();
2217                }
2218            }
2219            else if (check.kind === "max") {
2220                if (input.data.getTime() > check.value) {
2221                    ctx = this._getOrReturnCtx(input, ctx);
2222                    addIssueToContext(ctx, {
2223                        code: ZodIssueCode.too_big,
2224                        message: check.message,
2225                        inclusive: true,
2226                        exact: false,
2227                        maximum: check.value,
2228                        type: "date",
2229                    });
2230                    status.dirty();
2231                }
2232            }
2233            else {
2234                util.assertNever(check);
2235            }
2236        }
2237        return {
2238            status: status.value,
2239            value: new Date(input.data.getTime()),
2240        };
2241    }
2242    _addCheck(check) {
2243        return new ZodDate({
2244            ...this._def,
2245            checks: [...this._def.checks, check],
2246        });
2247    }
2248    min(minDate, message) {
2249        return this._addCheck({
2250            kind: "min",
2251            value: minDate.getTime(),
2252            message: errorUtil.toString(message),
2253        });
2254    }
2255    max(maxDate, message) {
2256        return this._addCheck({
2257            kind: "max",
2258            value: maxDate.getTime(),
2259            message: errorUtil.toString(message),
2260        });
2261    }
2262    get minDate() {
2263        let min = null;
2264        for (const ch of this._def.checks) {
2265            if (ch.kind === "min") {
2266                if (min === null || ch.value > min)
2267                    min = ch.value;
2268            }
2269        }
2270        return min != null ? new Date(min) : null;
2271    }
2272    get maxDate() {
2273        let max = null;
2274        for (const ch of this._def.checks) {
2275            if (ch.kind === "max") {
2276                if (max === null || ch.value < max)
2277                    max = ch.value;
2278            }
2279        }
2280        return max != null ? new Date(max) : null;
2281    }
2282}
2283ZodDate.create = (params) => {
2284    return new ZodDate({
2285        checks: [],
2286        coerce: params?.coerce || false,
2287        typeName: ZodFirstPartyTypeKind.ZodDate,
2288        ...processCreateParams(params),
2289    });
2290};
2291class ZodSymbol extends ZodType {
2292    _parse(input) {
2293        const parsedType = this._getType(input);
2294        if (parsedType !== ZodParsedType.symbol) {
2295            const ctx = this._getOrReturnCtx(input);
2296            addIssueToContext(ctx, {
2297                code: ZodIssueCode.invalid_type,
2298                expected: ZodParsedType.symbol,
2299                received: ctx.parsedType,
2300            });
2301            return INVALID;
2302        }
2303        return OK(input.data);
2304    }
2305}
2306ZodSymbol.create = (params) => {
2307    return new ZodSymbol({
2308        typeName: ZodFirstPartyTypeKind.ZodSymbol,
2309        ...processCreateParams(params),
2310    });
2311};
2312class ZodUndefined extends ZodType {
2313    _parse(input) {
2314        const parsedType = this._getType(input);
2315        if (parsedType !== ZodParsedType.undefined) {
2316            const ctx = this._getOrReturnCtx(input);
2317            addIssueToContext(ctx, {
2318                code: ZodIssueCode.invalid_type,
2319                expected: ZodParsedType.undefined,
2320                received: ctx.parsedType,
2321            });
2322            return INVALID;
2323        }
2324        return OK(input.data);
2325    }
2326}
2327ZodUndefined.create = (params) => {
2328    return new ZodUndefined({
2329        typeName: ZodFirstPartyTypeKind.ZodUndefined,
2330        ...processCreateParams(params),
2331    });
2332};
2333class ZodNull extends ZodType {
2334    _parse(input) {
2335        const parsedType = this._getType(input);
2336        if (parsedType !== ZodParsedType.null) {
2337            const ctx = this._getOrReturnCtx(input);
2338            addIssueToContext(ctx, {
2339                code: ZodIssueCode.invalid_type,
2340                expected: ZodParsedType.null,
2341                received: ctx.parsedType,
2342            });
2343            return INVALID;
2344        }
2345        return OK(input.data);
2346    }
2347}
2348ZodNull.create = (params) => {
2349    return new ZodNull({
2350        typeName: ZodFirstPartyTypeKind.ZodNull,
2351        ...processCreateParams(params),
2352    });
2353};
2354class ZodAny extends ZodType {
2355    constructor() {
2356        super(...arguments);
2357        // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.
2358        this._any = true;
2359    }
2360    _parse(input) {
2361        return OK(input.data);
2362    }
2363}
2364ZodAny.create = (params) => {
2365    return new ZodAny({
2366        typeName: ZodFirstPartyTypeKind.ZodAny,
2367        ...processCreateParams(params),
2368    });
2369};
2370class ZodUnknown extends ZodType {
2371    constructor() {
2372        super(...arguments);
2373        // required
2374        this._unknown = true;
2375    }
2376    _parse(input) {
2377        return OK(input.data);
2378    }
2379}
2380ZodUnknown.create = (params) => {
2381    return new ZodUnknown({
2382        typeName: ZodFirstPartyTypeKind.ZodUnknown,
2383        ...processCreateParams(params),
2384    });
2385};
2386class ZodNever extends ZodType {
2387    _parse(input) {
2388        const ctx = this._getOrReturnCtx(input);
2389        addIssueToContext(ctx, {
2390            code: ZodIssueCode.invalid_type,
2391            expected: ZodParsedType.never,
2392            received: ctx.parsedType,
2393        });
2394        return INVALID;
2395    }
2396}
2397ZodNever.create = (params) => {
2398    return new ZodNever({
2399        typeName: ZodFirstPartyTypeKind.ZodNever,
2400        ...processCreateParams(params),
2401    });
2402};
2403class ZodVoid extends ZodType {
2404    _parse(input) {
2405        const parsedType = this._getType(input);
2406        if (parsedType !== ZodParsedType.undefined) {
2407            const ctx = this._getOrReturnCtx(input);
2408            addIssueToContext(ctx, {
2409                code: ZodIssueCode.invalid_type,
2410                expected: ZodParsedType.void,
2411                received: ctx.parsedType,
2412            });
2413            return INVALID;
2414        }
2415        return OK(input.data);
2416    }
2417}
2418ZodVoid.create = (params) => {
2419    return new ZodVoid({
2420        typeName: ZodFirstPartyTypeKind.ZodVoid,
2421        ...processCreateParams(params),
2422    });
2423};
2424class ZodArray extends ZodType {
2425    _parse(input) {
2426        const { ctx, status } = this._processInputParams(input);
2427        const def = this._def;
2428        if (ctx.parsedType !== ZodParsedType.array) {
2429            addIssueToContext(ctx, {
2430                code: ZodIssueCode.invalid_type,
2431                expected: ZodParsedType.array,
2432                received: ctx.parsedType,
2433            });
2434            return INVALID;
2435        }
2436        if (def.exactLength !== null) {
2437            const tooBig = ctx.data.length > def.exactLength.value;
2438            const tooSmall = ctx.data.length < def.exactLength.value;
2439            if (tooBig || tooSmall) {
2440                addIssueToContext(ctx, {
2441                    code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
2442                    minimum: (tooSmall ? def.exactLength.value : undefined),
2443                    maximum: (tooBig ? def.exactLength.value : undefined),
2444                    type: "array",
2445                    inclusive: true,
2446                    exact: true,
2447                    message: def.exactLength.message,
2448                });
2449                status.dirty();
2450            }
2451        }
2452        if (def.minLength !== null) {
2453            if (ctx.data.length < def.minLength.value) {
2454                addIssueToContext(ctx, {
2455                    code: ZodIssueCode.too_small,
2456                    minimum: def.minLength.value,
2457                    type: "array",
2458                    inclusive: true,
2459                    exact: false,
2460                    message: def.minLength.message,
2461                });
2462                status.dirty();
2463            }
2464        }
2465        if (def.maxLength !== null) {
2466            if (ctx.data.length > def.maxLength.value) {
2467                addIssueToContext(ctx, {
2468                    code: ZodIssueCode.too_big,
2469                    maximum: def.maxLength.value,
2470                    type: "array",
2471                    inclusive: true,
2472                    exact: false,
2473                    message: def.maxLength.message,
2474                });
2475                status.dirty();
2476            }
2477        }
2478        if (ctx.common.async) {
2479            return Promise.all([...ctx.data].map((item, i) => {
2480                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
2481            })).then((result) => {
2482                return ParseStatus.mergeArray(status, result);
2483            });
2484        }
2485        const result = [...ctx.data].map((item, i) => {
2486            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
2487        });
2488        return ParseStatus.mergeArray(status, result);
2489    }
2490    get element() {
2491        return this._def.type;
2492    }
2493    min(minLength, message) {
2494        return new ZodArray({
2495            ...this._def,
2496            minLength: { value: minLength, message: errorUtil.toString(message) },
2497        });
2498    }
2499    max(maxLength, message) {
2500        return new ZodArray({
2501            ...this._def,
2502            maxLength: { value: maxLength, message: errorUtil.toString(message) },
2503        });
2504    }
2505    length(len, message) {
2506        return new ZodArray({
2507            ...this._def,
2508            exactLength: { value: len, message: errorUtil.toString(message) },
2509        });
2510    }
2511    nonempty(message) {
2512        return this.min(1, message);
2513    }
2514}
2515ZodArray.create = (schema, params) => {
2516    return new ZodArray({
2517        type: schema,
2518        minLength: null,
2519        maxLength: null,
2520        exactLength: null,
2521        typeName: ZodFirstPartyTypeKind.ZodArray,
2522        ...processCreateParams(params),
2523    });
2524};
2525function deepPartialify(schema) {
2526    if (schema instanceof ZodObject) {
2527        const newShape = {};
2528        for (const key in schema.shape) {
2529            const fieldSchema = schema.shape[key];
2530            newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
2531        }
2532        return new ZodObject({
2533            ...schema._def,
2534            shape: () => newShape,
2535        });
2536    }
2537    else if (schema instanceof ZodArray) {
2538        return new ZodArray({
2539            ...schema._def,
2540            type: deepPartialify(schema.element),
2541        });
2542    }
2543    else if (schema instanceof ZodOptional) {
2544        return ZodOptional.create(deepPartialify(schema.unwrap()));
2545    }
2546    else if (schema instanceof ZodNullable) {
2547        return ZodNullable.create(deepPartialify(schema.unwrap()));
2548    }
2549    else if (schema instanceof ZodTuple) {
2550        return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
2551    }
2552    else {
2553        return schema;
2554    }
2555}
2556class ZodObject extends ZodType {
2557    constructor() {
2558        super(...arguments);
2559        this._cached = null;
2560        /**
2561         * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
2562         * If you want to pass through unknown properties, use `.passthrough()` instead.
2563         */
2564        this.nonstrict = this.passthrough;
2565        // extend<
2566        //   Augmentation extends ZodRawShape,
2567        //   NewOutput extends util.flatten<{
2568        //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
2569        //       ? Augmentation[k]["_output"]
2570        //       : k extends keyof Output
2571        //       ? Output[k]
2572        //       : never;
2573        //   }>,
2574        //   NewInput extends util.flatten<{
2575        //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
2576        //       ? Augmentation[k]["_input"]
2577        //       : k extends keyof Input
2578        //       ? Input[k]
2579        //       : never;
2580        //   }>
2581        // >(
2582        //   augmentation: Augmentation
2583        // ): ZodObject<
2584        //   extendShape<T, Augmentation>,
2585        //   UnknownKeys,
2586        //   Catchall,
2587        //   NewOutput,
2588        //   NewInput
2589        // > {
2590        //   return new ZodObject({
2591        //     ...this._def,
2592        //     shape: () => ({
2593        //       ...this._def.shape(),
2594        //       ...augmentation,
2595        //     }),
2596        //   }) as any;
2597        // }
2598        /**
2599         * @deprecated Use `.extend` instead
2600         *  */
2601        this.augment = this.extend;
2602    }
2603    _getCached() {
2604        if (this._cached !== null)
2605            return this._cached;
2606        const shape = this._def.shape();
2607        const keys = util.objectKeys(shape);
2608        this._cached = { shape, keys };
2609        return this._cached;
2610    }
2611    _parse(input) {
2612        const parsedType = this._getType(input);
2613        if (parsedType !== ZodParsedType.object) {
2614            const ctx = this._getOrReturnCtx(input);
2615            addIssueToContext(ctx, {
2616                code: ZodIssueCode.invalid_type,
2617                expected: ZodParsedType.object,
2618                received: ctx.parsedType,
2619            });
2620            return INVALID;
2621        }
2622        const { status, ctx } = this._processInputParams(input);
2623        const { shape, keys: shapeKeys } = this._getCached();
2624        const extraKeys = [];
2625        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
2626            for (const key in ctx.data) {
2627                if (!shapeKeys.includes(key)) {
2628                    extraKeys.push(key);
2629                }
2630            }
2631        }
2632        const pairs = [];
2633        for (const key of shapeKeys) {
2634            const keyValidator = shape[key];
2635            const value = ctx.data[key];
2636            pairs.push({
2637                key: { status: "valid", value: key },
2638                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
2639                alwaysSet: key in ctx.data,
2640            });
2641        }
2642        if (this._def.catchall instanceof ZodNever) {
2643            const unknownKeys = this._def.unknownKeys;
2644            if (unknownKeys === "passthrough") {
2645                for (const key of extraKeys) {
2646                    pairs.push({
2647                        key: { status: "valid", value: key },
2648                        value: { status: "valid", value: ctx.data[key] },
2649                    });
2650                }
2651            }
2652            else if (unknownKeys === "strict") {
2653                if (extraKeys.length > 0) {
2654                    addIssueToContext(ctx, {
2655                        code: ZodIssueCode.unrecognized_keys,
2656                        keys: extraKeys,
2657                    });
2658                    status.dirty();
2659                }
2660            }
2661            else if (unknownKeys === "strip") {
2662            }
2663            else {
2664                throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
2665            }
2666        }
2667        else {
2668            // run catchall validation
2669            const catchall = this._def.catchall;
2670            for (const key of extraKeys) {
2671                const value = ctx.data[key];
2672                pairs.push({
2673                    key: { status: "valid", value: key },
2674                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
2675                    ),
2676                    alwaysSet: key in ctx.data,
2677                });
2678            }
2679        }
2680        if (ctx.common.async) {
2681            return Promise.resolve()
2682                .then(async () => {
2683                const syncPairs = [];
2684                for (const pair of pairs) {
2685                    const key = await pair.key;
2686                    const value = await pair.value;
2687                    syncPairs.push({
2688                        key,
2689                        value,
2690                        alwaysSet: pair.alwaysSet,
2691                    });
2692                }
2693                return syncPairs;
2694            })
2695                .then((syncPairs) => {
2696                return ParseStatus.mergeObjectSync(status, syncPairs);
2697            });
2698        }
2699        else {
2700            return ParseStatus.mergeObjectSync(status, pairs);
2701        }
2702    }
2703    get shape() {
2704        return this._def.shape();
2705    }
2706    strict(message) {
2707        errorUtil.errToObj;
2708        return new ZodObject({
2709            ...this._def,
2710            unknownKeys: "strict",
2711            ...(message !== undefined
2712                ? {
2713                    errorMap: (issue, ctx) => {
2714                        const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
2715                        if (issue.code === "unrecognized_keys")
2716                            return {
2717                                message: errorUtil.errToObj(message).message ?? defaultError,
2718                            };
2719                        return {
2720                            message: defaultError,
2721                        };
2722                    },
2723                }
2724                : {}),
2725        });
2726    }
2727    strip() {
2728        return new ZodObject({
2729            ...this._def,
2730            unknownKeys: "strip",
2731        });
2732    }
2733    passthrough() {
2734        return new ZodObject({
2735            ...this._def,
2736            unknownKeys: "passthrough",
2737        });
2738    }
2739    // const AugmentFactory =
2740    //   <Def extends ZodObjectDef>(def: Def) =>
2741    //   <Augmentation extends ZodRawShape>(
2742    //     augmentation: Augmentation
2743    //   ): ZodObject<
2744    //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
2745    //     Def["unknownKeys"],
2746    //     Def["catchall"]
2747    //   > => {
2748    //     return new ZodObject({
2749    //       ...def,
2750    //       shape: () => ({
2751    //         ...def.shape(),
2752    //         ...augmentation,
2753    //       }),
2754    //     }) as any;
2755    //   };
2756    extend(augmentation) {
2757        return new ZodObject({
2758            ...this._def,
2759            shape: () => ({
2760                ...this._def.shape(),
2761                ...augmentation,
2762            }),
2763        });
2764    }
2765    /**
2766     * Prior to [email protected] there was a bug in the
2767     * inferred type of merged objects. Please
2768     * upgrade if you are experiencing issues.
2769     */
2770    merge(merging) {
2771        const merged = new ZodObject({
2772            unknownKeys: merging._def.unknownKeys,
2773            catchall: merging._def.catchall,
2774            shape: () => ({
2775                ...this._def.shape(),
2776                ...merging._def.shape(),
2777            }),
2778            typeName: ZodFirstPartyTypeKind.ZodObject,
2779        });
2780        return merged;
2781    }
2782    // merge<
2783    //   Incoming extends AnyZodObject,
2784    //   Augmentation extends Incoming["shape"],
2785    //   NewOutput extends {
2786    //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
2787    //       ? Augmentation[k]["_output"]
2788    //       : k extends keyof Output
2789    //       ? Output[k]
2790    //       : never;
2791    //   },
2792    //   NewInput extends {
2793    //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
2794    //       ? Augmentation[k]["_input"]
2795    //       : k extends keyof Input
2796    //       ? Input[k]
2797    //       : never;
2798    //   }
2799    // >(
2800    //   merging: Incoming
2801    // ): ZodObject<
2802    //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
2803    //   Incoming["_def"]["unknownKeys"],
2804    //   Incoming["_def"]["catchall"],
2805    //   NewOutput,
2806    //   NewInput
2807    // > {
2808    //   const merged: any = new ZodObject({
2809    //     unknownKeys: merging._def.unknownKeys,
2810    //     catchall: merging._def.catchall,
2811    //     shape: () =>
2812    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
2813    //     typeName: ZodFirstPartyTypeKind.ZodObject,
2814    //   }) as any;
2815    //   return merged;
2816    // }
2817    setKey(key, schema) {
2818        return this.augment({ [key]: schema });
2819    }
2820    // merge<Incoming extends AnyZodObject>(
2821    //   merging: Incoming
2822    // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
2823    // ZodObject<
2824    //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
2825    //   Incoming["_def"]["unknownKeys"],
2826    //   Incoming["_def"]["catchall"]
2827    // > {
2828    //   // const mergedShape = objectUtil.mergeShapes(
2829    //   //   this._def.shape(),
2830    //   //   merging._def.shape()
2831    //   // );
2832    //   const merged: any = new ZodObject({
2833    //     unknownKeys: merging._def.unknownKeys,
2834    //     catchall: merging._def.catchall,
2835    //     shape: () =>
2836    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
2837    //     typeName: ZodFirstPartyTypeKind.ZodObject,
2838    //   }) as any;
2839    //   return merged;
2840    // }
2841    catchall(index) {
2842        return new ZodObject({
2843            ...this._def,
2844            catchall: index,
2845        });
2846    }
2847    pick(mask) {
2848        const shape = {};
2849        for (const key of util.objectKeys(mask)) {
2850            if (mask[key] && this.shape[key]) {
2851                shape[key] = this.shape[key];
2852            }
2853        }
2854        return new ZodObject({
2855            ...this._def,
2856            shape: () => shape,
2857        });
2858    }
2859    omit(mask) {
2860        const shape = {};
2861        for (const key of util.objectKeys(this.shape)) {
2862            if (!mask[key]) {
2863                shape[key] = this.shape[key];
2864            }
2865        }
2866        return new ZodObject({
2867            ...this._def,
2868            shape: () => shape,
2869        });
2870    }
2871    /**
2872     * @deprecated
2873     */
2874    deepPartial() {
2875        return deepPartialify(this);
2876    }
2877    partial(mask) {
2878        const newShape = {};
2879        for (const key of util.objectKeys(this.shape)) {
2880            const fieldSchema = this.shape[key];
2881            if (mask && !mask[key]) {
2882                newShape[key] = fieldSchema;
2883            }
2884            else {
2885                newShape[key] = fieldSchema.optional();
2886            }
2887        }
2888        return new ZodObject({
2889            ...this._def,
2890            shape: () => newShape,
2891        });
2892    }
2893    required(mask) {
2894        const newShape = {};
2895        for (const key of util.objectKeys(this.shape)) {
2896            if (mask && !mask[key]) {
2897                newShape[key] = this.shape[key];
2898            }
2899            else {
2900                const fieldSchema = this.shape[key];
2901                let newField = fieldSchema;
2902                while (newField instanceof ZodOptional) {
2903                    newField = newField._def.innerType;
2904                }
2905                newShape[key] = newField;
2906            }
2907        }
2908        return new ZodObject({
2909            ...this._def,
2910            shape: () => newShape,
2911        });
2912    }
2913    keyof() {
2914        return createZodEnum(util.objectKeys(this.shape));
2915    }
2916}
2917ZodObject.create = (shape, params) => {
2918    return new ZodObject({
2919        shape: () => shape,
2920        unknownKeys: "strip",
2921        catchall: ZodNever.create(),
2922        typeName: ZodFirstPartyTypeKind.ZodObject,
2923        ...processCreateParams(params),
2924    });
2925};
2926ZodObject.strictCreate = (shape, params) => {
2927    return new ZodObject({
2928        shape: () => shape,
2929        unknownKeys: "strict",
2930        catchall: ZodNever.create(),
2931        typeName: ZodFirstPartyTypeKind.ZodObject,
2932        ...processCreateParams(params),
2933    });
2934};
2935ZodObject.lazycreate = (shape, params) => {
2936    return new ZodObject({
2937        shape,
2938        unknownKeys: "strip",
2939        catchall: ZodNever.create(),
2940        typeName: ZodFirstPartyTypeKind.ZodObject,
2941        ...processCreateParams(params),
2942    });
2943};
2944class ZodUnion extends ZodType {
2945    _parse(input) {
2946        const { ctx } = this._processInputParams(input);
2947        const options = this._def.options;
2948        function handleResults(results) {
2949            // return first issue-free validation if it exists
2950            for (const result of results) {
2951                if (result.result.status === "valid") {
2952                    return result.result;
2953                }
2954            }
2955            for (const result of results) {
2956                if (result.result.status === "dirty") {
2957                    // add issues from dirty option
2958                    ctx.common.issues.push(...result.ctx.common.issues);
2959                    return result.result;
2960                }
2961            }
2962            // return invalid
2963            const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
2964            addIssueToContext(ctx, {
2965                code: ZodIssueCode.invalid_union,
2966                unionErrors,
2967            });
2968            return INVALID;
2969        }
2970        if (ctx.common.async) {
2971            return Promise.all(options.map(async (option) => {
2972                const childCtx = {
2973                    ...ctx,
2974                    common: {
2975                        ...ctx.common,
2976                        issues: [],
2977                    },
2978                    parent: null,
2979                };
2980                return {
2981                    result: await option._parseAsync({
2982                        data: ctx.data,
2983                        path: ctx.path,
2984                        parent: childCtx,
2985                    }),
2986                    ctx: childCtx,
2987                };
2988            })).then(handleResults);
2989        }
2990        else {
2991            let dirty = undefined;
2992            const issues = [];
2993            for (const option of options) {
2994                const childCtx = {
2995                    ...ctx,
2996                    common: {
2997                        ...ctx.common,
2998                        issues: [],
2999                    },
3000                    parent: null,
3001                };
3002                const result = option._parseSync({
3003                    data: ctx.data,
3004                    path: ctx.path,
3005                    parent: childCtx,
3006                });
3007                if (result.status === "valid") {
3008                    return result;
3009                }
3010                else if (result.status === "dirty" && !dirty) {
3011                    dirty = { result, ctx: childCtx };
3012                }
3013                if (childCtx.common.issues.length) {
3014                    issues.push(childCtx.common.issues);
3015                }
3016            }
3017            if (dirty) {
3018                ctx.common.issues.push(...dirty.ctx.common.issues);
3019                return dirty.result;
3020            }
3021            const unionErrors = issues.map((issues) => new ZodError(issues));
3022            addIssueToContext(ctx, {
3023                code: ZodIssueCode.invalid_union,
3024                unionErrors,
3025            });
3026            return INVALID;
3027        }
3028    }
3029    get options() {
3030        return this._def.options;
3031    }
3032}
3033ZodUnion.create = (types, params) => {
3034    return new ZodUnion({
3035        options: types,
3036        typeName: ZodFirstPartyTypeKind.ZodUnion,
3037        ...processCreateParams(params),
3038    });
3039};
3040/////////////////////////////////////////////////////
3041/////////////////////////////////////////////////////