@learncard/core 1.1.1 → 1.1.2

package/dist/core.cjs.development.js

@@ -39,8 +39,8 @@ var __objRest = (source, exclude) => {
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __commonJS = (cb, mod2) => function __require() {
+  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
 };
 var __export = (target, all) => {
   for (var name5 in all)
@@ -54,8 +54,8 @@ var __copyProps = (to, from4, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, mod2));
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 var __superGet = (cls, obj, key2) => __reflectGet(__getProtoOf(cls), key2, obj);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -826,20 +826,20 @@ var require_tslib = __commonJS({
       } : function(o, v) {
         o["default"] = v;
       };
-      __importStar2 = /* @__PURE__ */ __name(function(mod) {
-        if (mod && mod.__esModule)
-          return mod;
+      __importStar2 = /* @__PURE__ */ __name(function(mod2) {
+        if (mod2 && mod2.__esModule)
+          return mod2;
         var result = {};
-        if (mod != null) {
-          for (var k in mod)
-            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
-              __createBinding2(result, mod, k);
+        if (mod2 != null) {
+          for (var k in mod2)
+            if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
+              __createBinding2(result, mod2, k);
         }
-        __setModuleDefault(result, mod);
+        __setModuleDefault(result, mod2);
         return result;
       }, "__importStar");
-      __importDefault2 = /* @__PURE__ */ __name(function(mod) {
-        return mod && mod.__esModule ? mod : { "default": mod };
+      __importDefault2 = /* @__PURE__ */ __name(function(mod2) {
+        return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
       }, "__importDefault");
       __classPrivateFieldGet4 = /* @__PURE__ */ __name(function(receiver, state, kind, f) {
         if (kind === "a" && !f)
@@ -3784,8 +3784,8 @@ var require_bn = __commonJS({
         limbLen--;
         limbPow = limbPow / base4 | 0;
         var total = number.length - start;
-        var mod = total % limbLen;
-        var end = Math.min(total, total - mod) + start;
+        var mod2 = total % limbLen;
+        var end = Math.min(total, total - mod2) + start;
         var word = 0;
         for (var i = start; i < end; i += limbLen) {
           word = parseBase(number, i, i + limbLen, base4);
@@ -3796,10 +3796,10 @@ var require_bn = __commonJS({
             this._iaddn(word);
           }
         }
-        if (mod !== 0) {
+        if (mod2 !== 0) {
           var pow = 1;
           word = parseBase(number, i, number.length, base4);
-          for (i = 0; i < mod; i++) {
+          for (i = 0; i < mod2; i++) {
             pow *= base4;
           }
           this.imuln(pow);
@@ -5534,21 +5534,21 @@ var require_bn = __commonJS({
             mod: new BN3(0)
           };
         }
-        var div, mod, res;
+        var div, mod2, res;
         if (this.negative !== 0 && num.negative === 0) {
           res = this.neg().divmod(num, mode2);
           if (mode2 !== "mod") {
             div = res.div.neg();
           }
           if (mode2 !== "div") {
-            mod = res.mod.neg();
-            if (positive && mod.negative !== 0) {
-              mod.iadd(num);
+            mod2 = res.mod.neg();
+            if (positive && mod2.negative !== 0) {
+              mod2.iadd(num);
             }
           }
           return {
             div,
-            mod
+            mod: mod2
           };
         }
         if (this.negative === 0 && num.negative !== 0) {
@@ -5564,14 +5564,14 @@ var require_bn = __commonJS({
         if ((this.negative & num.negative) !== 0) {
           res = this.neg().divmod(num.neg(), mode2);
           if (mode2 !== "div") {
-            mod = res.mod.neg();
-            if (positive && mod.negative !== 0) {
-              mod.isub(num);
+            mod2 = res.mod.neg();
+            if (positive && mod2.negative !== 0) {
+              mod2.isub(num);
             }
           }
           return {
             div: res.div,
-            mod
+            mod: mod2
           };
         }
         if (num.length > this.length || this.cmp(num) < 0) {
@@ -5603,7 +5603,7 @@ var require_bn = __commonJS({
       BN3.prototype.div = /* @__PURE__ */ __name(function div(num) {
         return this.divmod(num, "div", false).div;
       }, "div");
-      BN3.prototype.mod = /* @__PURE__ */ __name(function mod(num) {
+      BN3.prototype.mod = /* @__PURE__ */ __name(function mod2(num) {
         return this.divmod(num, "mod", false).mod;
       }, "mod");
       BN3.prototype.umod = /* @__PURE__ */ __name(function umod(num) {
@@ -5613,10 +5613,10 @@ var require_bn = __commonJS({
         var dm = this.divmod(num);
         if (dm.mod.isZero())
           return dm.div;
-        var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+        var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
         var half = num.ushrn(1);
         var r2 = num.andln(1);
-        var cmp = mod.cmp(half);
+        var cmp = mod2.cmp(half);
         if (cmp < 0 || r2 === 1 && cmp === 0)
           return dm.div;
         return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
@@ -6490,12 +6490,12 @@ var require_utils2 = __commonJS({
       var k = num.clone();
       for (var i = 0; i < naf.length; i++) {
         var z;
-        var mod = k.andln(ws - 1);
+        var mod2 = k.andln(ws - 1);
         if (k.isOdd()) {
-          if (mod > (ws >> 1) - 1)
-            z = (ws >> 1) - mod;
+          if (mod2 > (ws >> 1) - 1)
+            z = (ws >> 1) - mod2;
           else
-            z = mod;
+            z = mod2;
           k.isubn(z);
         } else {
           z = 0;
@@ -23664,7 +23664,7 @@ var require_api = __commonJS({
       const abnfToHtml = /* @__PURE__ */ __name(function abnfToHtml2(chars, beg, len) {
         const NORMAL = 0;
         const CONTROL = 1;
-        const INVALID = 2;
+        const INVALID2 = 2;
         const CONTROL_BEG = `<span class="${apglib.style.CLASS_CTRLCHAR}">`;
         const CONTROL_END = "</span>";
         const INVALID_BEG = `<span class="${apglib.style.CLASS_NOMATCH}">`;
@@ -23694,7 +23694,7 @@ var require_api = __commonJS({
               if (state === CONTROL) {
                 html += CONTROL_END;
                 state = NORMAL;
-              } else if (state === INVALID) {
+              } else if (state === INVALID2) {
                 html += INVALID_END;
                 state = NORMAL;
               }
@@ -23728,7 +23728,7 @@ var require_api = __commonJS({
               if (state === NORMAL) {
                 html += CONTROL_BEG;
                 state = CONTROL;
-              } else if (state === INVALID) {
+              } else if (state === INVALID2) {
                 html += INVALID_END + CONTROL_BEG;
                 state = CONTROL;
               }
@@ -23744,15 +23744,15 @@ var require_api = __commonJS({
             } else {
               if (state === NORMAL) {
                 html += INVALID_BEG;
-                state = INVALID;
+                state = INVALID2;
               } else if (state === CONTROL) {
                 html += CONTROL_END + INVALID_BEG;
-                state = INVALID;
+                state = INVALID2;
               }
               html += `\\x${apglib.utils.charToHex(ch)}`;
             }
           }
-          if (state === INVALID) {
+          if (state === INVALID2) {
             html += INVALID_END;
           }
           if (state === CONTROL) {
@@ -24728,16 +24728,16 @@ var require_secp256k12 = __commonJS({
     } : function(o, v) {
       o["default"] = v;
     });
-    var __importStar2 = exports && exports.__importStar || function(mod) {
-      if (mod && mod.__esModule)
-        return mod;
+    var __importStar2 = exports && exports.__importStar || function(mod2) {
+      if (mod2 && mod2.__esModule)
+        return mod2;
       var result = {};
-      if (mod != null) {
-        for (var k in mod)
-          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
-            __createBinding2(result, mod, k);
+      if (mod2 != null) {
+        for (var k in mod2)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
+            __createBinding2(result, mod2, k);
       }
-      __setModuleDefault(result, mod);
+      __setModuleDefault(result, mod2);
       return result;
     };
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -24785,16 +24785,16 @@ var require_ed255192 = __commonJS({
     } : function(o, v) {
       o["default"] = v;
     });
-    var __importStar2 = exports && exports.__importStar || function(mod) {
-      if (mod && mod.__esModule)
-        return mod;
+    var __importStar2 = exports && exports.__importStar || function(mod2) {
+      if (mod2 && mod2.__esModule)
+        return mod2;
       var result = {};
-      if (mod != null) {
-        for (var k in mod)
-          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
-            __createBinding2(result, mod, k);
+      if (mod2 != null) {
+        for (var k in mod2)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
+            __createBinding2(result, mod2, k);
       }
-      __setModuleDefault(result, mod);
+      __setModuleDefault(result, mod2);
       return result;
     };
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -24859,20 +24859,20 @@ var require_lib = __commonJS({
     } : function(o, v) {
       o["default"] = v;
     });
-    var __importStar2 = exports && exports.__importStar || function(mod) {
-      if (mod && mod.__esModule)
-        return mod;
+    var __importStar2 = exports && exports.__importStar || function(mod2) {
+      if (mod2 && mod2.__esModule)
+        return mod2;
       var result = {};
-      if (mod != null) {
-        for (var k in mod)
-          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
-            __createBinding2(result, mod, k);
+      if (mod2 != null) {
+        for (var k in mod2)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod2, k))
+            __createBinding2(result, mod2, k);
       }
-      __setModuleDefault(result, mod);
+      __setModuleDefault(result, mod2);
       return result;
     };
-    var __importDefault2 = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
+    var __importDefault2 = exports && exports.__importDefault || function(mod2) {
+      return mod2 && mod2.__esModule ? mod2 : { "default": mod2 };
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     var varint_1 = __importDefault2(require_varint());
@@ -37464,9 +37464,9 @@ function is(value) {
   if (isBuffer(value)) {
     return "Buffer";
   }
-  const objectType = getObjectType(value);
-  if (objectType) {
-    return objectType;
+  const objectType2 = getObjectType(value);
+  if (objectType2) {
+    return objectType2;
   }
   return "Object";
 }
@@ -40643,12 +40643,12 @@ var utils_1$1 = createCommonjsModule(function(module2, exports) {
     var k = num.clone();
     for (var i = 0; i < naf.length; i++) {
       var z;
-      var mod = k.andln(ws - 1);
+      var mod2 = k.andln(ws - 1);
       if (k.isOdd()) {
-        if (mod > (ws >> 1) - 1)
-          z = (ws >> 1) - mod;
+        if (mod2 > (ws >> 1) - 1)
+          z = (ws >> 1) - mod2;
         else
-          z = mod;
+          z = mod2;
         k.isubn(z);
       } else {
         z = 0;
@@ -48520,7 +48520,7 @@ var getVCPlugin = /* @__PURE__ */ __name((wallet) => __async(void 0, null, funct
       getTestVc: (_wallet, subject = "did:example:d23dd687a7dc6787646f2eb98d0") => {
         const did = _wallet.pluginMethods.getSubjectDid();
         return {
-          "@context": "https://www.w3.org/2018/credentials/v1",
+          "@context": ["https://www.w3.org/2018/credentials/v1"],
           id: "http://example.org/credentials/3731",
           type: ["VerifiableCredential"],
           issuer: did,
@@ -48532,13 +48532,3050 @@ var getVCPlugin = /* @__PURE__ */ __name((wallet) => __async(void 0, null, funct
   };
 }), "getVCPlugin");
 
+// ../../node_modules/.pnpm/zod@3.17.3/node_modules/zod/lib/index.mjs
+var util;
+(function(util2) {
+  function assertNever(_x) {
+    throw new Error();
+  }
+  __name(assertNever, "assertNever");
+  util2.assertNever = assertNever;
+  util2.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
+    }
+    return obj;
+  };
+  util2.getValidEnumValues = (obj) => {
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
+    }
+    return util2.objectValues(filtered);
+  };
+  util2.objectValues = (obj) => {
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
+  };
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
+    for (const key2 in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key2)) {
+        keys.push(key2);
+      }
+    }
+    return keys;
+  };
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
+    }
+    return void 0;
+  };
+  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+  function joinValues(array, separator = " | ") {
+    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+  }
+  __name(joinValues, "joinValues");
+  util2.joinValues = joinValues;
+})(util || (util = {}));
+var ZodParsedType = util.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]);
+var getParsedType = /* @__PURE__ */ __name((data) => {
+  const t = typeof data;
+  switch (t) {
+    case "undefined":
+      return ZodParsedType.undefined;
+    case "string":
+      return ZodParsedType.string;
+    case "number":
+      return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+    case "boolean":
+      return ZodParsedType.boolean;
+    case "function":
+      return ZodParsedType.function;
+    case "bigint":
+      return ZodParsedType.bigint;
+    case "object":
+      if (Array.isArray(data)) {
+        return ZodParsedType.array;
+      }
+      if (data === null) {
+        return ZodParsedType.null;
+      }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return ZodParsedType.promise;
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return ZodParsedType.map;
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return ZodParsedType.set;
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return ZodParsedType.date;
+      }
+      return ZodParsedType.object;
+    default:
+      return ZodParsedType.unknown;
+  }
+}, "getParsedType");
+var ZodIssueCode = util.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of"
+]);
+var quotelessJson = /* @__PURE__ */ __name((obj) => {
+  const json = JSON.stringify(obj, null, 2);
+  return json.replace(/"([^"]+)":/g, "$1:");
+}, "quotelessJson");
+var ZodError = class extends Error {
+  constructor(issues) {
+    super();
+    this.issues = [];
+    this.addIssue = (sub) => {
+      this.issues = [...this.issues, sub];
+    };
+    this.addIssues = (subs = []) => {
+      this.issues = [...this.issues, ...subs];
+    };
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      this.__proto__ = actualProto;
+    }
+    this.name = "ZodError";
+    this.issues = issues;
+  }
+  get errors() {
+    return this.issues;
+  }
+  format(_mapper) {
+    const mapper = _mapper || function(issue) {
+      return issue.message;
+    };
+    const fieldErrors = { _errors: [] };
+    const processError = /* @__PURE__ */ __name((error) => {
+      for (const issue of error.issues) {
+        if (issue.code === "invalid_union") {
+          issue.unionErrors.map(processError);
+        } else if (issue.code === "invalid_return_type") {
+          processError(issue.returnTypeError);
+        } else if (issue.code === "invalid_arguments") {
+          processError(issue.argumentsError);
+        } else if (issue.path.length === 0) {
+          fieldErrors._errors.push(mapper(issue));
+        } else {
+          let curr = fieldErrors;
+          let i = 0;
+          while (i < issue.path.length) {
+            const el = issue.path[i];
+            const terminal = i === issue.path.length - 1;
+            if (!terminal) {
+              curr[el] = curr[el] || { _errors: [] };
+            } else {
+              curr[el] = curr[el] || { _errors: [] };
+              curr[el]._errors.push(mapper(issue));
+            }
+            curr = curr[el];
+            i++;
+          }
+        }
+      }
+    }, "processError");
+    processError(this);
+    return fieldErrors;
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, null, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(mapper = (issue) => issue.message) {
+    const fieldErrors = {};
+    const formErrors = [];
+    for (const sub of this.issues) {
+      if (sub.path.length > 0) {
+        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+        fieldErrors[sub.path[0]].push(mapper(sub));
+      } else {
+        formErrors.push(mapper(sub));
+      }
+    }
+    return { formErrors, fieldErrors };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+};
+__name(ZodError, "ZodError");
+ZodError.create = (issues) => {
+  const error = new ZodError(issues);
+  return error;
+};
+var defaultErrorMap = /* @__PURE__ */ __name((issue, _ctx) => {
+  let message;
+  switch (issue.code) {
+    case ZodIssueCode.invalid_type:
+      if (issue.received === ZodParsedType.undefined) {
+        message = "Required";
+      } else {
+        message = `Expected ${issue.expected}, received ${issue.received}`;
+      }
+      break;
+    case ZodIssueCode.invalid_literal:
+      message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+      break;
+    case ZodIssueCode.unrecognized_keys:
+      message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+      break;
+    case ZodIssueCode.invalid_union:
+      message = `Invalid input`;
+      break;
+    case ZodIssueCode.invalid_union_discriminator:
+      message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+      break;
+    case ZodIssueCode.invalid_enum_value:
+      message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+      break;
+    case ZodIssueCode.invalid_arguments:
+      message = `Invalid function arguments`;
+      break;
+    case ZodIssueCode.invalid_return_type:
+      message = `Invalid function return type`;
+      break;
+    case ZodIssueCode.invalid_date:
+      message = `Invalid date`;
+      break;
+    case ZodIssueCode.invalid_string:
+      if (issue.validation !== "regex")
+        message = `Invalid ${issue.validation}`;
+      else
+        message = "Invalid";
+      break;
+    case ZodIssueCode.too_small:
+      if (issue.type === "array")
+        message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+      else if (issue.type === "string")
+        message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+      else if (issue.type === "number")
+        message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+      else
+        message = "Invalid input";
+      break;
+    case ZodIssueCode.too_big:
+      if (issue.type === "array")
+        message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+      else if (issue.type === "string")
+        message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+      else if (issue.type === "number")
+        message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+      else
+        message = "Invalid input";
+      break;
+    case ZodIssueCode.custom:
+      message = `Invalid input`;
+      break;
+    case ZodIssueCode.invalid_intersection_types:
+      message = `Intersection results could not be merged`;
+      break;
+    case ZodIssueCode.not_multiple_of:
+      message = `Number must be a multiple of ${issue.multipleOf}`;
+      break;
+    default:
+      message = _ctx.defaultError;
+      util.assertNever(issue);
+  }
+  return { message };
+}, "defaultErrorMap");
+var overrideErrorMap = defaultErrorMap;
+var setErrorMap = /* @__PURE__ */ __name((map2) => {
+  overrideErrorMap = map2;
+}, "setErrorMap");
+var makeIssue = /* @__PURE__ */ __name((params) => {
+  const { data, path, errorMaps, issueData } = params;
+  const fullPath = [...path, ...issueData.path || []];
+  const fullIssue = __spreadProps(__spreadValues({}, issueData), {
+    path: fullPath
+  });
+  let errorMessage = "";
+  const maps = errorMaps.filter((m) => !!m).slice().reverse();
+  for (const map2 of maps) {
+    errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message;
+  }
+  return __spreadProps(__spreadValues({}, issueData), {
+    path: fullPath,
+    message: issueData.message || errorMessage
+  });
+}, "makeIssue");
+var EMPTY_PATH = [];
+function addIssueToContext(ctx, issueData) {
+  const issue = makeIssue({
+    issueData,
+    data: ctx.data,
+    path: ctx.path,
+    errorMaps: [
+      ctx.common.contextualErrorMap,
+      ctx.schemaErrorMap,
+      overrideErrorMap,
+      defaultErrorMap
+    ].filter((x) => !!x)
+  });
+  ctx.common.issues.push(issue);
+}
+__name(addIssueToContext, "addIssueToContext");
+var ParseStatus = class {
+  constructor() {
+    this.value = "valid";
+  }
+  dirty() {
+    if (this.value === "valid")
+      this.value = "dirty";
+  }
+  abort() {
+    if (this.value !== "aborted")
+      this.value = "aborted";
+  }
+  static mergeArray(status, results) {
+    const arrayValue = [];
+    for (const s of results) {
+      if (s.status === "aborted")
+        return INVALID;
+      if (s.status === "dirty")
+        status.dirty();
+      arrayValue.push(s.value);
+    }
+    return { status: status.value, value: arrayValue };
+  }
+  static mergeObjectAsync(status, pairs) {
+    return __async(this, null, function* () {
+      const syncPairs = [];
+      for (const pair of pairs) {
+        syncPairs.push({
+          key: yield pair.key,
+          value: yield pair.value
+        });
+      }
+      return ParseStatus.mergeObjectSync(status, syncPairs);
+    });
+  }
+  static mergeObjectSync(status, pairs) {
+    const finalObject = {};
+    for (const pair of pairs) {
+      const { key: key2, value } = pair;
+      if (key2.status === "aborted")
+        return INVALID;
+      if (value.status === "aborted")
+        return INVALID;
+      if (key2.status === "dirty")
+        status.dirty();
+      if (value.status === "dirty")
+        status.dirty();
+      if (typeof value.value !== "undefined" || pair.alwaysSet) {
+        finalObject[key2.value] = value.value;
+      }
+    }
+    return { status: status.value, value: finalObject };
+  }
+};
+__name(ParseStatus, "ParseStatus");
+var INVALID = Object.freeze({
+  status: "aborted"
+});
+var DIRTY = /* @__PURE__ */ __name((value) => ({ status: "dirty", value }), "DIRTY");
+var OK = /* @__PURE__ */ __name((value) => ({ status: "valid", value }), "OK");
+var isAborted = /* @__PURE__ */ __name((x) => x.status === "aborted", "isAborted");
+var isDirty = /* @__PURE__ */ __name((x) => x.status === "dirty", "isDirty");
+var isValid = /* @__PURE__ */ __name((x) => x.status === "valid", "isValid");
+var isAsync = /* @__PURE__ */ __name((x) => typeof Promise !== void 0 && x instanceof Promise, "isAsync");
+var errorUtil;
+(function(errorUtil2) {
+  errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+  errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+})(errorUtil || (errorUtil = {}));
+var ParseInputLazyPath = class {
+  constructor(parent, value, path, key2) {
+    this.parent = parent;
+    this.data = value;
+    this._path = path;
+    this._key = key2;
+  }
+  get path() {
+    return this._path.concat(this._key);
+  }
+};
+__name(ParseInputLazyPath, "ParseInputLazyPath");
+var handleResult = /* @__PURE__ */ __name((ctx, result) => {
+  if (isValid(result)) {
+    return { success: true, data: result.value };
+  } else {
+    if (!ctx.common.issues.length) {
+      throw new Error("Validation failed but no issues detected.");
+    }
+    const error = new ZodError(ctx.common.issues);
+    return { success: false, error };
+  }
+}, "handleResult");
+function processCreateParams(params) {
+  if (!params)
+    return {};
+  const { errorMap, invalid_type_error, required_error, description } = params;
+  if (errorMap && (invalid_type_error || required_error)) {
+    throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
+  }
+  if (errorMap)
+    return { errorMap, description };
+  const customMap = /* @__PURE__ */ __name((iss, ctx) => {
+    if (iss.code !== "invalid_type")
+      return { message: ctx.defaultError };
+    if (typeof ctx.data === "undefined" && required_error)
+      return { message: required_error };
+    if (params.invalid_type_error)
+      return { message: params.invalid_type_error };
+    return { message: ctx.defaultError };
+  }, "customMap");
+  return { errorMap: customMap, description };
+}
+__name(processCreateParams, "processCreateParams");
+var ZodType = class {
+  constructor(def) {
+    this.spa = this.safeParseAsync;
+    this.superRefine = this._refinement;
+    this._def = def;
+    this.parse = this.parse.bind(this);
+    this.safeParse = this.safeParse.bind(this);
+    this.parseAsync = this.parseAsync.bind(this);
+    this.safeParseAsync = this.safeParseAsync.bind(this);
+    this.spa = this.spa.bind(this);
+    this.refine = this.refine.bind(this);
+    this.refinement = this.refinement.bind(this);
+    this.superRefine = this.superRefine.bind(this);
+    this.optional = this.optional.bind(this);
+    this.nullable = this.nullable.bind(this);
+    this.nullish = this.nullish.bind(this);
+    this.array = this.array.bind(this);
+    this.promise = this.promise.bind(this);
+    this.or = this.or.bind(this);
+    this.and = this.and.bind(this);
+    this.transform = this.transform.bind(this);
+    this.default = this.default.bind(this);
+    this.describe = this.describe.bind(this);
+    this.isNullable = this.isNullable.bind(this);
+    this.isOptional = this.isOptional.bind(this);
+  }
+  get description() {
+    return this._def.description;
+  }
+  _getType(input) {
+    return getParsedType(input.data);
+  }
+  _getOrReturnCtx(input, ctx) {
+    return ctx || {
+      common: input.parent.common,
+      data: input.data,
+      parsedType: getParsedType(input.data),
+      schemaErrorMap: this._def.errorMap,
+      path: input.path,
+      parent: input.parent
+    };
+  }
+  _processInputParams(input) {
+    return {
+      status: new ParseStatus(),
+      ctx: {
+        common: input.parent.common,
+        data: input.data,
+        parsedType: getParsedType(input.data),
+        schemaErrorMap: this._def.errorMap,
+        path: input.path,
+        parent: input.parent
+      }
+    };
+  }
+  _parseSync(input) {
+    const result = this._parse(input);
+    if (isAsync(result)) {
+      throw new Error("Synchronous parse encountered promise.");
+    }
+    return result;
+  }
+  _parseAsync(input) {
+    const result = this._parse(input);
+    return Promise.resolve(result);
+  }
+  parse(data, params) {
+    const result = this.safeParse(data, params);
+    if (result.success)
+      return result.data;
+    throw result.error;
+  }
+  safeParse(data, params) {
+    var _a2;
+    const ctx = {
+      common: {
+        issues: [],
+        async: (_a2 = params === null || params === void 0 ? void 0 : params.async) !== null && _a2 !== void 0 ? _a2 : false,
+        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
+      },
+      path: (params === null || params === void 0 ? void 0 : params.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data,
+      parsedType: getParsedType(data)
+    };
+    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+    return handleResult(ctx, result);
+  }
+  parseAsync(data, params) {
+    return __async(this, null, function* () {
+      const result = yield this.safeParseAsync(data, params);
+      if (result.success)
+        return result.data;
+      throw result.error;
+    });
+  }
+  safeParseAsync(data, params) {
+    return __async(this, null, function* () {
+      const ctx = {
+        common: {
+          issues: [],
+          contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+          async: true
+        },
+        path: (params === null || params === void 0 ? void 0 : params.path) || [],
+        schemaErrorMap: this._def.errorMap,
+        parent: null,
+        data,
+        parsedType: getParsedType(data)
+      };
+      const maybeAsyncResult = this._parse({ data, path: [], parent: ctx });
+      const result = yield isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult);
+      return handleResult(ctx, result);
+    });
+  }
+  refine(check, message) {
+    const getIssueProperties = /* @__PURE__ */ __name((val) => {
+      if (typeof message === "string" || typeof message === "undefined") {
+        return { message };
+      } else if (typeof message === "function") {
+        return message(val);
+      } else {
+        return message;
+      }
+    }, "getIssueProperties");
+    return this._refinement((val, ctx) => {
+      const result = check(val);
+      const setError = /* @__PURE__ */ __name(() => ctx.addIssue(__spreadValues({
+        code: ZodIssueCode.custom
+      }, getIssueProperties(val))), "setError");
+      if (typeof Promise !== "undefined" && result instanceof Promise) {
+        return result.then((data) => {
+          if (!data) {
+            setError();
+            return false;
+          } else {
+            return true;
+          }
+        });
+      }
+      if (!result) {
+        setError();
+        return false;
+      } else {
+        return true;
+      }
+    });
+  }
+  refinement(check, refinementData) {
+    return this._refinement((val, ctx) => {
+      if (!check(val)) {
+        ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
+        return false;
+      } else {
+        return true;
+      }
+    });
+  }
+  _refinement(refinement) {
+    return new ZodEffects({
+      schema: this,
+      typeName: ZodFirstPartyTypeKind.ZodEffects,
+      effect: { type: "refinement", refinement }
+    });
+  }
+  optional() {
+    return ZodOptional.create(this);
+  }
+  nullable() {
+    return ZodNullable.create(this);
+  }
+  nullish() {
+    return this.optional().nullable();
+  }
+  array() {
+    return ZodArray.create(this);
+  }
+  promise() {
+    return ZodPromise.create(this);
+  }
+  or(option) {
+    return ZodUnion.create([this, option]);
+  }
+  and(incoming) {
+    return ZodIntersection.create(this, incoming);
+  }
+  transform(transform) {
+    return new ZodEffects({
+      schema: this,
+      typeName: ZodFirstPartyTypeKind.ZodEffects,
+      effect: { type: "transform", transform }
+    });
+  }
+  default(def) {
+    const defaultValueFunc = typeof def === "function" ? def : () => def;
+    return new ZodDefault({
+      innerType: this,
+      defaultValue: defaultValueFunc,
+      typeName: ZodFirstPartyTypeKind.ZodDefault
+    });
+  }
+  describe(description) {
+    const This = this.constructor;
+    return new This(__spreadProps(__spreadValues({}, this._def), {
+      description
+    }));
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+};
+__name(ZodType, "ZodType");
+var cuidRegex = /^c[^\s-]{8,}$/i;
+var uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
+var emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+var ZodString = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    this._regex = (regex, validation, message) => this.refinement((data) => regex.test(data), __spreadValues({
+      validation,
+      code: ZodIssueCode.invalid_string
+    }, errorUtil.errToObj(message)));
+    this.nonempty = (message) => this.min(1, errorUtil.errToObj(message));
+    this.trim = () => new ZodString(__spreadProps(__spreadValues({}, this._def), {
+      checks: [...this._def.checks, { kind: "trim" }]
+    }));
+  }
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.string) {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.string,
+        received: ctx2.parsedType
+      });
+      return INVALID;
+    }
+    const status = new ParseStatus();
+    let ctx = void 0;
+    for (const check of this._def.checks) {
+      if (check.kind === "min") {
+        if (input.data.length < check.value) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_small,
+            minimum: check.value,
+            type: "string",
+            inclusive: true,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "max") {
+        if (input.data.length > check.value) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_big,
+            maximum: check.value,
+            type: "string",
+            inclusive: true,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "email") {
+        if (!emailRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "email",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "uuid") {
+        if (!uuidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "uuid",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "cuid") {
+        if (!cuidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "cuid",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "url") {
+        try {
+          new URL(input.data);
+        } catch (_a2) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "url",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "regex") {
+        check.regex.lastIndex = 0;
+        const testResult = check.regex.test(input.data);
+        if (!testResult) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "regex",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "trim") {
+        input.data = input.data.trim();
+      } else {
+        util.assertNever(check);
+      }
+    }
+    return { status: status.value, value: input.data };
+  }
+  _addCheck(check) {
+    return new ZodString(__spreadProps(__spreadValues({}, this._def), {
+      checks: [...this._def.checks, check]
+    }));
+  }
+  email(message) {
+    return this._addCheck(__spreadValues({ kind: "email" }, errorUtil.errToObj(message)));
+  }
+  url(message) {
+    return this._addCheck(__spreadValues({ kind: "url" }, errorUtil.errToObj(message)));
+  }
+  uuid(message) {
+    return this._addCheck(__spreadValues({ kind: "uuid" }, errorUtil.errToObj(message)));
+  }
+  cuid(message) {
+    return this._addCheck(__spreadValues({ kind: "cuid" }, errorUtil.errToObj(message)));
+  }
+  regex(regex, message) {
+    return this._addCheck(__spreadValues({
+      kind: "regex",
+      regex
+    }, errorUtil.errToObj(message)));
+  }
+  min(minLength, message) {
+    return this._addCheck(__spreadValues({
+      kind: "min",
+      value: minLength
+    }, errorUtil.errToObj(message)));
+  }
+  max(maxLength, message) {
+    return this._addCheck(__spreadValues({
+      kind: "max",
+      value: maxLength
+    }, errorUtil.errToObj(message)));
+  }
+  length(len, message) {
+    return this.min(len, message).max(len, message);
+  }
+  get isEmail() {
+    return !!this._def.checks.find((ch) => ch.kind === "email");
+  }
+  get isURL() {
+    return !!this._def.checks.find((ch) => ch.kind === "url");
+  }
+  get isUUID() {
+    return !!this._def.checks.find((ch) => ch.kind === "uuid");
+  }
+  get isCUID() {
+    return !!this._def.checks.find((ch) => ch.kind === "cuid");
+  }
+  get minLength() {
+    let min = -Infinity;
+    this._def.checks.map((ch) => {
+      if (ch.kind === "min") {
+        if (min === null || ch.value > min) {
+          min = ch.value;
+        }
+      }
+    });
+    return min;
+  }
+  get maxLength() {
+    let max = null;
+    this._def.checks.map((ch) => {
+      if (ch.kind === "max") {
+        if (max === null || ch.value < max) {
+          max = ch.value;
+        }
+      }
+    });
+    return max;
+  }
+};
+__name(ZodString, "ZodString");
+ZodString.create = (params) => {
+  return new ZodString(__spreadValues({
+    checks: [],
+    typeName: ZodFirstPartyTypeKind.ZodString
+  }, processCreateParams(params)));
+};
+function floatSafeRemainder(val, step) {
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepDecCount = (step.toString().split(".")[1] || "").length;
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
+  const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
+  return valInt % stepInt / Math.pow(10, decCount);
+}
+__name(floatSafeRemainder, "floatSafeRemainder");
+var ZodNumber = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    this.min = this.gte;
+    this.max = this.lte;
+    this.step = this.multipleOf;
+  }
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.number) {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.number,
+        received: ctx2.parsedType
+      });
+      return INVALID;
+    }
+    let ctx = void 0;
+    const status = new ParseStatus();
+    for (const check of this._def.checks) {
+      if (check.kind === "int") {
+        if (!util.isInteger(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_type,
+            expected: "integer",
+            received: "float",
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "min") {
+        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        if (tooSmall) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_small,
+            minimum: check.value,
+            type: "number",
+            inclusive: check.inclusive,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "max") {
+        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        if (tooBig) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.too_big,
+            maximum: check.value,
+            type: "number",
+            inclusive: check.inclusive,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "multipleOf") {
+        if (floatSafeRemainder(input.data, check.value) !== 0) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.not_multiple_of,
+            multipleOf: check.value,
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else {
+        util.assertNever(check);
+      }
+    }
+    return { status: status.value, value: input.data };
+  }
+  gte(value, message) {
+    return this.setLimit("min", value, true, errorUtil.toString(message));
+  }
+  gt(value, message) {
+    return this.setLimit("min", value, false, errorUtil.toString(message));
+  }
+  lte(value, message) {
+    return this.setLimit("max", value, true, errorUtil.toString(message));
+  }
+  lt(value, message) {
+    return this.setLimit("max", value, false, errorUtil.toString(message));
+  }
+  setLimit(kind, value, inclusive, message) {
+    return new ZodNumber(__spreadProps(__spreadValues({}, this._def), {
+      checks: [
+        ...this._def.checks,
+        {
+          kind,
+          value,
+          inclusive,
+          message: errorUtil.toString(message)
+        }
+      ]
+    }));
+  }
+  _addCheck(check) {
+    return new ZodNumber(__spreadProps(__spreadValues({}, this._def), {
+      checks: [...this._def.checks, check]
+    }));
+  }
+  int(message) {
+    return this._addCheck({
+      kind: "int",
+      message: errorUtil.toString(message)
+    });
+  }
+  positive(message) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: false,
+      message: errorUtil.toString(message)
+    });
+  }
+  negative(message) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: false,
+      message: errorUtil.toString(message)
+    });
+  }
+  nonpositive(message) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: true,
+      message: errorUtil.toString(message)
+    });
+  }
+  nonnegative(message) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: true,
+      message: errorUtil.toString(message)
+    });
+  }
+  multipleOf(value, message) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value,
+      message: errorUtil.toString(message)
+    });
+  }
+  get minValue() {
+    let min = null;
+    for (const ch of this._def.checks) {
+      if (ch.kind === "min") {
+        if (min === null || ch.value > min)
+          min = ch.value;
+      }
+    }
+    return min;
+  }
+  get maxValue() {
+    let max = null;
+    for (const ch of this._def.checks) {
+      if (ch.kind === "max") {
+        if (max === null || ch.value < max)
+          max = ch.value;
+      }
+    }
+    return max;
+  }
+  get isInt() {
+    return !!this._def.checks.find((ch) => ch.kind === "int");
+  }
+};
+__name(ZodNumber, "ZodNumber");
+ZodNumber.create = (params) => {
+  return new ZodNumber(__spreadValues({
+    checks: [],
+    typeName: ZodFirstPartyTypeKind.ZodNumber
+  }, processCreateParams(params)));
+};
+var ZodBigInt = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.bigint) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.bigint,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+};
+__name(ZodBigInt, "ZodBigInt");
+ZodBigInt.create = (params) => {
+  return new ZodBigInt(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodBigInt
+  }, processCreateParams(params)));
+};
+var ZodBoolean = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.boolean) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.boolean,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+};
+__name(ZodBoolean, "ZodBoolean");
+ZodBoolean.create = (params) => {
+  return new ZodBoolean(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodBoolean
+  }, processCreateParams(params)));
+};
+var ZodDate = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.date) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.date,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    if (isNaN(input.data.getTime())) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_date
+      });
+      return INVALID;
+    }
+    return {
+      status: "valid",
+      value: new Date(input.data.getTime())
+    };
+  }
+};
+__name(ZodDate, "ZodDate");
+ZodDate.create = (params) => {
+  return new ZodDate(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodDate
+  }, processCreateParams(params)));
+};
+var ZodUndefined = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.undefined) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.undefined,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+};
+__name(ZodUndefined, "ZodUndefined");
+ZodUndefined.create = (params) => {
+  return new ZodUndefined(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodUndefined
+  }, processCreateParams(params)));
+};
+var ZodNull = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.null) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.null,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+};
+__name(ZodNull, "ZodNull");
+ZodNull.create = (params) => {
+  return new ZodNull(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodNull
+  }, processCreateParams(params)));
+};
+var ZodAny = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    this._any = true;
+  }
+  _parse(input) {
+    return OK(input.data);
+  }
+};
+__name(ZodAny, "ZodAny");
+ZodAny.create = (params) => {
+  return new ZodAny(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodAny
+  }, processCreateParams(params)));
+};
+var ZodUnknown = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    this._unknown = true;
+  }
+  _parse(input) {
+    return OK(input.data);
+  }
+};
+__name(ZodUnknown, "ZodUnknown");
+ZodUnknown.create = (params) => {
+  return new ZodUnknown(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodUnknown
+  }, processCreateParams(params)));
+};
+var ZodNever = class extends ZodType {
+  _parse(input) {
+    const ctx = this._getOrReturnCtx(input);
+    addIssueToContext(ctx, {
+      code: ZodIssueCode.invalid_type,
+      expected: ZodParsedType.never,
+      received: ctx.parsedType
+    });
+    return INVALID;
+  }
+};
+__name(ZodNever, "ZodNever");
+ZodNever.create = (params) => {
+  return new ZodNever(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodNever
+  }, processCreateParams(params)));
+};
+var ZodVoid = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.undefined) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.void,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+};
+__name(ZodVoid, "ZodVoid");
+ZodVoid.create = (params) => {
+  return new ZodVoid(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodVoid
+  }, processCreateParams(params)));
+};
+var ZodArray = class extends ZodType {
+  _parse(input) {
+    const { ctx, status } = this._processInputParams(input);
+    const def = this._def;
+    if (ctx.parsedType !== ZodParsedType.array) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.array,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    if (def.minLength !== null) {
+      if (ctx.data.length < def.minLength.value) {
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.too_small,
+          minimum: def.minLength.value,
+          type: "array",
+          inclusive: true,
+          message: def.minLength.message
+        });
+        status.dirty();
+      }
+    }
+    if (def.maxLength !== null) {
+      if (ctx.data.length > def.maxLength.value) {
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.too_big,
+          maximum: def.maxLength.value,
+          type: "array",
+          inclusive: true,
+          message: def.maxLength.message
+        });
+        status.dirty();
+      }
+    }
+    if (ctx.common.async) {
+      return Promise.all(ctx.data.map((item, i) => {
+        return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+      })).then((result2) => {
+        return ParseStatus.mergeArray(status, result2);
+      });
+    }
+    const result = ctx.data.map((item, i) => {
+      return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+    });
+    return ParseStatus.mergeArray(status, result);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(minLength, message) {
+    return new ZodArray(__spreadProps(__spreadValues({}, this._def), {
+      minLength: { value: minLength, message: errorUtil.toString(message) }
+    }));
+  }
+  max(maxLength, message) {
+    return new ZodArray(__spreadProps(__spreadValues({}, this._def), {
+      maxLength: { value: maxLength, message: errorUtil.toString(message) }
+    }));
+  }
+  length(len, message) {
+    return this.min(len, message).max(len, message);
+  }
+  nonempty(message) {
+    return this.min(1, message);
+  }
+};
+__name(ZodArray, "ZodArray");
+ZodArray.create = (schema, params) => {
+  return new ZodArray(__spreadValues({
+    type: schema,
+    minLength: null,
+    maxLength: null,
+    typeName: ZodFirstPartyTypeKind.ZodArray
+  }, processCreateParams(params)));
+};
+var objectUtil;
+(function(objectUtil2) {
+  objectUtil2.mergeShapes = (first2, second) => {
+    return __spreadValues(__spreadValues({}, first2), second);
+  };
+})(objectUtil || (objectUtil = {}));
+var AugmentFactory = /* @__PURE__ */ __name((def) => (augmentation) => {
+  return new ZodObject(__spreadProps(__spreadValues({}, def), {
+    shape: () => __spreadValues(__spreadValues({}, def.shape()), augmentation)
+  }));
+}, "AugmentFactory");
+function deepPartialify(schema) {
+  if (schema instanceof ZodObject) {
+    const newShape = {};
+    for (const key2 in schema.shape) {
+      const fieldSchema = schema.shape[key2];
+      newShape[key2] = ZodOptional.create(deepPartialify(fieldSchema));
+    }
+    return new ZodObject(__spreadProps(__spreadValues({}, schema._def), {
+      shape: () => newShape
+    }));
+  } else if (schema instanceof ZodArray) {
+    return ZodArray.create(deepPartialify(schema.element));
+  } else if (schema instanceof ZodOptional) {
+    return ZodOptional.create(deepPartialify(schema.unwrap()));
+  } else if (schema instanceof ZodNullable) {
+    return ZodNullable.create(deepPartialify(schema.unwrap()));
+  } else if (schema instanceof ZodTuple) {
+    return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
+  } else {
+    return schema;
+  }
+}
+__name(deepPartialify, "deepPartialify");
+var ZodObject = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    this._cached = null;
+    this.nonstrict = this.passthrough;
+    this.augment = AugmentFactory(this._def);
+    this.extend = AugmentFactory(this._def);
+  }
+  _getCached() {
+    if (this._cached !== null)
+      return this._cached;
+    const shape = this._def.shape();
+    const keys = util.objectKeys(shape);
+    return this._cached = { shape, keys };
+  }
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.object) {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.object,
+        received: ctx2.parsedType
+      });
+      return INVALID;
+    }
+    const { status, ctx } = this._processInputParams(input);
+    const { shape, keys: shapeKeys } = this._getCached();
+    const extraKeys = [];
+    for (const key2 in ctx.data) {
+      if (!shapeKeys.includes(key2)) {
+        extraKeys.push(key2);
+      }
+    }
+    const pairs = [];
+    for (const key2 of shapeKeys) {
+      const keyValidator = shape[key2];
+      const value = ctx.data[key2];
+      pairs.push({
+        key: { status: "valid", value: key2 },
+        value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key2)),
+        alwaysSet: key2 in ctx.data
+      });
+    }
+    if (this._def.catchall instanceof ZodNever) {
+      const unknownKeys = this._def.unknownKeys;
+      if (unknownKeys === "passthrough") {
+        for (const key2 of extraKeys) {
+          pairs.push({
+            key: { status: "valid", value: key2 },
+            value: { status: "valid", value: ctx.data[key2] }
+          });
+        }
+      } else if (unknownKeys === "strict") {
+        if (extraKeys.length > 0) {
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.unrecognized_keys,
+            keys: extraKeys
+          });
+          status.dirty();
+        }
+      } else if (unknownKeys === "strip")
+        ;
+      else {
+        throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
+      }
+    } else {
+      const catchall = this._def.catchall;
+      for (const key2 of extraKeys) {
+        const value = ctx.data[key2];
+        pairs.push({
+          key: { status: "valid", value: key2 },
+          value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key2)),
+          alwaysSet: key2 in ctx.data
+        });
+      }
+    }
+    if (ctx.common.async) {
+      return Promise.resolve().then(() => __async(this, null, function* () {
+        const syncPairs = [];
+        for (const pair of pairs) {
+          const key2 = yield pair.key;
+          syncPairs.push({
+            key: key2,
+            value: yield pair.value,
+            alwaysSet: pair.alwaysSet
+          });
+        }
+        return syncPairs;
+      })).then((syncPairs) => {
+        return ParseStatus.mergeObjectSync(status, syncPairs);
+      });
+    } else {
+      return ParseStatus.mergeObjectSync(status, pairs);
+    }
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(message) {
+    errorUtil.errToObj;
+    return new ZodObject(__spreadValues(__spreadProps(__spreadValues({}, this._def), {
+      unknownKeys: "strict"
+    }), message !== void 0 ? {
+      errorMap: (issue, ctx) => {
+        var _a2, _b, _c, _d;
+        const defaultError = (_c = (_b = (_a2 = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a2, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
+        if (issue.code === "unrecognized_keys")
+          return {
+            message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError
+          };
+        return {
+          message: defaultError
+        };
+      }
+    } : {}));
+  }
+  strip() {
+    return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+      unknownKeys: "strip"
+    }));
+  }
+  passthrough() {
+    return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+      unknownKeys: "passthrough"
+    }));
+  }
+  setKey(key2, schema) {
+    return this.augment({ [key2]: schema });
+  }
+  merge(merging) {
+    const merged = new ZodObject({
+      unknownKeys: merging._def.unknownKeys,
+      catchall: merging._def.catchall,
+      shape: () => objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+      typeName: ZodFirstPartyTypeKind.ZodObject
+    });
+    return merged;
+  }
+  catchall(index) {
+    return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+      catchall: index
+    }));
+  }
+  pick(mask) {
+    const shape = {};
+    util.objectKeys(mask).map((key2) => {
+      if (this.shape[key2])
+        shape[key2] = this.shape[key2];
+    });
+    return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+      shape: () => shape
+    }));
+  }
+  omit(mask) {
+    const shape = {};
+    util.objectKeys(this.shape).map((key2) => {
+      if (util.objectKeys(mask).indexOf(key2) === -1) {
+        shape[key2] = this.shape[key2];
+      }
+    });
+    return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+      shape: () => shape
+    }));
+  }
+  deepPartial() {
+    return deepPartialify(this);
+  }
+  partial(mask) {
+    const newShape = {};
+    if (mask) {
+      util.objectKeys(this.shape).map((key2) => {
+        if (util.objectKeys(mask).indexOf(key2) === -1) {
+          newShape[key2] = this.shape[key2];
+        } else {
+          newShape[key2] = this.shape[key2].optional();
+        }
+      });
+      return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+        shape: () => newShape
+      }));
+    } else {
+      for (const key2 in this.shape) {
+        const fieldSchema = this.shape[key2];
+        newShape[key2] = fieldSchema.optional();
+      }
+    }
+    return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+      shape: () => newShape
+    }));
+  }
+  required() {
+    const newShape = {};
+    for (const key2 in this.shape) {
+      const fieldSchema = this.shape[key2];
+      let newField = fieldSchema;
+      while (newField instanceof ZodOptional) {
+        newField = newField._def.innerType;
+      }
+      newShape[key2] = newField;
+    }
+    return new ZodObject(__spreadProps(__spreadValues({}, this._def), {
+      shape: () => newShape
+    }));
+  }
+};
+__name(ZodObject, "ZodObject");
+ZodObject.create = (shape, params) => {
+  return new ZodObject(__spreadValues({
+    shape: () => shape,
+    unknownKeys: "strip",
+    catchall: ZodNever.create(),
+    typeName: ZodFirstPartyTypeKind.ZodObject
+  }, processCreateParams(params)));
+};
+ZodObject.strictCreate = (shape, params) => {
+  return new ZodObject(__spreadValues({
+    shape: () => shape,
+    unknownKeys: "strict",
+    catchall: ZodNever.create(),
+    typeName: ZodFirstPartyTypeKind.ZodObject
+  }, processCreateParams(params)));
+};
+ZodObject.lazycreate = (shape, params) => {
+  return new ZodObject(__spreadValues({
+    shape,
+    unknownKeys: "strip",
+    catchall: ZodNever.create(),
+    typeName: ZodFirstPartyTypeKind.ZodObject
+  }, processCreateParams(params)));
+};
+var ZodUnion = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const options = this._def.options;
+    function handleResults(results) {
+      for (const result of results) {
+        if (result.result.status === "valid") {
+          return result.result;
+        }
+      }
+      for (const result of results) {
+        if (result.result.status === "dirty") {
+          ctx.common.issues.push(...result.ctx.common.issues);
+          return result.result;
+        }
+      }
+      const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_union,
+        unionErrors
+      });
+      return INVALID;
+    }
+    __name(handleResults, "handleResults");
+    if (ctx.common.async) {
+      return Promise.all(options.map((option) => __async(this, null, function* () {
+        const childCtx = __spreadProps(__spreadValues({}, ctx), {
+          common: __spreadProps(__spreadValues({}, ctx.common), {
+            issues: []
+          }),
+          parent: null
+        });
+        return {
+          result: yield option._parseAsync({
+            data: ctx.data,
+            path: ctx.path,
+            parent: childCtx
+          }),
+          ctx: childCtx
+        };
+      }))).then(handleResults);
+    } else {
+      let dirty = void 0;
+      const issues = [];
+      for (const option of options) {
+        const childCtx = __spreadProps(__spreadValues({}, ctx), {
+          common: __spreadProps(__spreadValues({}, ctx.common), {
+            issues: []
+          }),
+          parent: null
+        });
+        const result = option._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: childCtx
+        });
+        if (result.status === "valid") {
+          return result;
+        } else if (result.status === "dirty" && !dirty) {
+          dirty = { result, ctx: childCtx };
+        }
+        if (childCtx.common.issues.length) {
+          issues.push(childCtx.common.issues);
+        }
+      }
+      if (dirty) {
+        ctx.common.issues.push(...dirty.ctx.common.issues);
+        return dirty.result;
+      }
+      const unionErrors = issues.map((issues2) => new ZodError(issues2));
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_union,
+        unionErrors
+      });
+      return INVALID;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+};
+__name(ZodUnion, "ZodUnion");
+ZodUnion.create = (types, params) => {
+  return new ZodUnion(__spreadValues({
+    options: types,
+    typeName: ZodFirstPartyTypeKind.ZodUnion
+  }, processCreateParams(params)));
+};
+var ZodDiscriminatedUnion = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.object) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.object,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    const discriminator = this.discriminator;
+    const discriminatorValue = ctx.data[discriminator];
+    const option = this.options.get(discriminatorValue);
+    if (!option) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_union_discriminator,
+        options: this.validDiscriminatorValues,
+        path: [discriminator]
+      });
+      return INVALID;
+    }
+    if (ctx.common.async) {
+      return option._parseAsync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+    } else {
+      return option._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+    }
+  }
+  get discriminator() {
+    return this._def.discriminator;
+  }
+  get validDiscriminatorValues() {
+    return Array.from(this.options.keys());
+  }
+  get options() {
+    return this._def.options;
+  }
+  static create(discriminator, types, params) {
+    const options = /* @__PURE__ */ new Map();
+    try {
+      types.forEach((type) => {
+        const discriminatorValue = type.shape[discriminator].value;
+        options.set(discriminatorValue, type);
+      });
+    } catch (e) {
+      throw new Error("The discriminator value could not be extracted from all the provided schemas");
+    }
+    if (options.size !== types.length) {
+      throw new Error("Some of the discriminator values are not unique");
+    }
+    return new ZodDiscriminatedUnion(__spreadValues({
+      typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
+      discriminator,
+      options
+    }, processCreateParams(params)));
+  }
+};
+__name(ZodDiscriminatedUnion, "ZodDiscriminatedUnion");
+function mergeValues(a, b) {
+  const aType = getParsedType(a);
+  const bType = getParsedType(b);
+  if (a === b) {
+    return { valid: true, data: a };
+  } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
+    const bKeys = util.objectKeys(b);
+    const sharedKeys = util.objectKeys(a).filter((key2) => bKeys.indexOf(key2) !== -1);
+    const newObj = __spreadValues(__spreadValues({}, a), b);
+    for (const key2 of sharedKeys) {
+      const sharedValue = mergeValues(a[key2], b[key2]);
+      if (!sharedValue.valid) {
+        return { valid: false };
+      }
+      newObj[key2] = sharedValue.data;
+    }
+    return { valid: true, data: newObj };
+  } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
+    if (a.length !== b.length) {
+      return { valid: false };
+    }
+    const newArray = [];
+    for (let index = 0; index < a.length; index++) {
+      const itemA = a[index];
+      const itemB = b[index];
+      const sharedValue = mergeValues(itemA, itemB);
+      if (!sharedValue.valid) {
+        return { valid: false };
+      }
+      newArray.push(sharedValue.data);
+    }
+    return { valid: true, data: newArray };
+  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
+    return { valid: true, data: a };
+  } else {
+    return { valid: false };
+  }
+}
+__name(mergeValues, "mergeValues");
+var ZodIntersection = class extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    const handleParsed = /* @__PURE__ */ __name((parsedLeft, parsedRight) => {
+      if (isAborted(parsedLeft) || isAborted(parsedRight)) {
+        return INVALID;
+      }
+      const merged = mergeValues(parsedLeft.value, parsedRight.value);
+      if (!merged.valid) {
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.invalid_intersection_types
+        });
+        return INVALID;
+      }
+      if (isDirty(parsedLeft) || isDirty(parsedRight)) {
+        status.dirty();
+      }
+      return { status: status.value, value: merged.data };
+    }, "handleParsed");
+    if (ctx.common.async) {
+      return Promise.all([
+        this._def.left._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        }),
+        this._def.right._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        })
+      ]).then(([left, right]) => handleParsed(left, right));
+    } else {
+      return handleParsed(this._def.left._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      }), this._def.right._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      }));
+    }
+  }
+};
+__name(ZodIntersection, "ZodIntersection");
+ZodIntersection.create = (left, right, params) => {
+  return new ZodIntersection(__spreadValues({
+    left,
+    right,
+    typeName: ZodFirstPartyTypeKind.ZodIntersection
+  }, processCreateParams(params)));
+};
+var ZodTuple = class extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.array) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.array,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    if (ctx.data.length < this._def.items.length) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.too_small,
+        minimum: this._def.items.length,
+        inclusive: true,
+        type: "array"
+      });
+      return INVALID;
+    }
+    const rest = this._def.rest;
+    if (!rest && ctx.data.length > this._def.items.length) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.too_big,
+        maximum: this._def.items.length,
+        inclusive: true,
+        type: "array"
+      });
+      status.dirty();
+    }
+    const items = ctx.data.map((item, itemIndex) => {
+      const schema = this._def.items[itemIndex] || this._def.rest;
+      if (!schema)
+        return null;
+      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+    }).filter((x) => !!x);
+    if (ctx.common.async) {
+      return Promise.all(items).then((results) => {
+        return ParseStatus.mergeArray(status, results);
+      });
+    } else {
+      return ParseStatus.mergeArray(status, items);
+    }
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(rest) {
+    return new ZodTuple(__spreadProps(__spreadValues({}, this._def), {
+      rest
+    }));
+  }
+};
+__name(ZodTuple, "ZodTuple");
+ZodTuple.create = (schemas, params) => {
+  return new ZodTuple(__spreadValues({
+    items: schemas,
+    typeName: ZodFirstPartyTypeKind.ZodTuple,
+    rest: null
+  }, processCreateParams(params)));
+};
+var ZodRecord = class extends ZodType {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.object) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.object,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    const pairs = [];
+    const keyType = this._def.keyType;
+    const valueType = this._def.valueType;
+    for (const key2 in ctx.data) {
+      pairs.push({
+        key: keyType._parse(new ParseInputLazyPath(ctx, key2, ctx.path, key2)),
+        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key2], ctx.path, key2))
+      });
+    }
+    if (ctx.common.async) {
+      return ParseStatus.mergeObjectAsync(status, pairs);
+    } else {
+      return ParseStatus.mergeObjectSync(status, pairs);
+    }
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(first2, second, third) {
+    if (second instanceof ZodType) {
+      return new ZodRecord(__spreadValues({
+        keyType: first2,
+        valueType: second,
+        typeName: ZodFirstPartyTypeKind.ZodRecord
+      }, processCreateParams(third)));
+    }
+    return new ZodRecord(__spreadValues({
+      keyType: ZodString.create(),
+      valueType: first2,
+      typeName: ZodFirstPartyTypeKind.ZodRecord
+    }, processCreateParams(second)));
+  }
+};
+__name(ZodRecord, "ZodRecord");
+var ZodMap = class extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.map) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.map,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    const keyType = this._def.keyType;
+    const valueType = this._def.valueType;
+    const pairs = [...ctx.data.entries()].map(([key2, value], index) => {
+      return {
+        key: keyType._parse(new ParseInputLazyPath(ctx, key2, ctx.path, [index, "key"])),
+        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
+      };
+    });
+    if (ctx.common.async) {
+      const finalMap = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(() => __async(this, null, function* () {
+        for (const pair of pairs) {
+          const key2 = yield pair.key;
+          const value = yield pair.value;
+          if (key2.status === "aborted" || value.status === "aborted") {
+            return INVALID;
+          }
+          if (key2.status === "dirty" || value.status === "dirty") {
+            status.dirty();
+          }
+          finalMap.set(key2.value, value.value);
+        }
+        return { status: status.value, value: finalMap };
+      }));
+    } else {
+      const finalMap = /* @__PURE__ */ new Map();
+      for (const pair of pairs) {
+        const key2 = pair.key;
+        const value = pair.value;
+        if (key2.status === "aborted" || value.status === "aborted") {
+          return INVALID;
+        }
+        if (key2.status === "dirty" || value.status === "dirty") {
+          status.dirty();
+        }
+        finalMap.set(key2.value, value.value);
+      }
+      return { status: status.value, value: finalMap };
+    }
+  }
+};
+__name(ZodMap, "ZodMap");
+ZodMap.create = (keyType, valueType, params) => {
+  return new ZodMap(__spreadValues({
+    valueType,
+    keyType,
+    typeName: ZodFirstPartyTypeKind.ZodMap
+  }, processCreateParams(params)));
+};
+var ZodSet = class extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.set) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.set,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    const def = this._def;
+    if (def.minSize !== null) {
+      if (ctx.data.size < def.minSize.value) {
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.too_small,
+          minimum: def.minSize.value,
+          type: "set",
+          inclusive: true,
+          message: def.minSize.message
+        });
+        status.dirty();
+      }
+    }
+    if (def.maxSize !== null) {
+      if (ctx.data.size > def.maxSize.value) {
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.too_big,
+          maximum: def.maxSize.value,
+          type: "set",
+          inclusive: true,
+          message: def.maxSize.message
+        });
+        status.dirty();
+      }
+    }
+    const valueType = this._def.valueType;
+    function finalizeSet(elements2) {
+      const parsedSet = /* @__PURE__ */ new Set();
+      for (const element of elements2) {
+        if (element.status === "aborted")
+          return INVALID;
+        if (element.status === "dirty")
+          status.dirty();
+        parsedSet.add(element.value);
+      }
+      return { status: status.value, value: parsedSet };
+    }
+    __name(finalizeSet, "finalizeSet");
+    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+    if (ctx.common.async) {
+      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
+    } else {
+      return finalizeSet(elements);
+    }
+  }
+  min(minSize, message) {
+    return new ZodSet(__spreadProps(__spreadValues({}, this._def), {
+      minSize: { value: minSize, message: errorUtil.toString(message) }
+    }));
+  }
+  max(maxSize, message) {
+    return new ZodSet(__spreadProps(__spreadValues({}, this._def), {
+      maxSize: { value: maxSize, message: errorUtil.toString(message) }
+    }));
+  }
+  size(size, message) {
+    return this.min(size, message).max(size, message);
+  }
+  nonempty(message) {
+    return this.min(1, message);
+  }
+};
+__name(ZodSet, "ZodSet");
+ZodSet.create = (valueType, params) => {
+  return new ZodSet(__spreadValues({
+    valueType,
+    minSize: null,
+    maxSize: null,
+    typeName: ZodFirstPartyTypeKind.ZodSet
+  }, processCreateParams(params)));
+};
+var ZodFunction = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    this.validate = this.implement;
+  }
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.function) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.function,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    function makeArgsIssue(args, error) {
+      return makeIssue({
+        data: args,
+        path: ctx.path,
+        errorMaps: [
+          ctx.common.contextualErrorMap,
+          ctx.schemaErrorMap,
+          overrideErrorMap,
+          defaultErrorMap
+        ].filter((x) => !!x),
+        issueData: {
+          code: ZodIssueCode.invalid_arguments,
+          argumentsError: error
+        }
+      });
+    }
+    __name(makeArgsIssue, "makeArgsIssue");
+    function makeReturnsIssue(returns, error) {
+      return makeIssue({
+        data: returns,
+        path: ctx.path,
+        errorMaps: [
+          ctx.common.contextualErrorMap,
+          ctx.schemaErrorMap,
+          overrideErrorMap,
+          defaultErrorMap
+        ].filter((x) => !!x),
+        issueData: {
+          code: ZodIssueCode.invalid_return_type,
+          returnTypeError: error
+        }
+      });
+    }
+    __name(makeReturnsIssue, "makeReturnsIssue");
+    const params = { errorMap: ctx.common.contextualErrorMap };
+    const fn = ctx.data;
+    if (this._def.returns instanceof ZodPromise) {
+      return OK((...args) => __async(this, null, function* () {
+        const error = new ZodError([]);
+        const parsedArgs = yield this._def.args.parseAsync(args, params).catch((e) => {
+          error.addIssue(makeArgsIssue(args, e));
+          throw error;
+        });
+        const result = yield fn(...parsedArgs);
+        const parsedReturns = yield this._def.returns._def.type.parseAsync(result, params).catch((e) => {
+          error.addIssue(makeReturnsIssue(result, e));
+          throw error;
+        });
+        return parsedReturns;
+      }));
+    } else {
+      return OK((...args) => {
+        const parsedArgs = this._def.args.safeParse(args, params);
+        if (!parsedArgs.success) {
+          throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+        }
+        const result = fn(...parsedArgs.data);
+        const parsedReturns = this._def.returns.safeParse(result, params);
+        if (!parsedReturns.success) {
+          throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+        }
+        return parsedReturns.data;
+      });
+    }
+  }
+  parameters() {
+    return this._def.args;
+  }
+  returnType() {
+    return this._def.returns;
+  }
+  args(...items) {
+    return new ZodFunction(__spreadProps(__spreadValues({}, this._def), {
+      args: ZodTuple.create(items).rest(ZodUnknown.create())
+    }));
+  }
+  returns(returnType) {
+    return new ZodFunction(__spreadProps(__spreadValues({}, this._def), {
+      returns: returnType
+    }));
+  }
+  implement(func) {
+    const validatedFunc = this.parse(func);
+    return validatedFunc;
+  }
+  strictImplement(func) {
+    const validatedFunc = this.parse(func);
+    return validatedFunc;
+  }
+};
+__name(ZodFunction, "ZodFunction");
+ZodFunction.create = (args, returns, params) => {
+  return new ZodFunction(__spreadValues({
+    args: args ? args.rest(ZodUnknown.create()) : ZodTuple.create([]).rest(ZodUnknown.create()),
+    returns: returns || ZodUnknown.create(),
+    typeName: ZodFirstPartyTypeKind.ZodFunction
+  }, processCreateParams(params)));
+};
+var ZodLazy = class extends ZodType {
+  get schema() {
+    return this._def.getter();
+  }
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const lazySchema = this._def.getter();
+    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+  }
+};
+__name(ZodLazy, "ZodLazy");
+ZodLazy.create = (getter, params) => {
+  return new ZodLazy(__spreadValues({
+    getter,
+    typeName: ZodFirstPartyTypeKind.ZodLazy
+  }, processCreateParams(params)));
+};
+var ZodLiteral = class extends ZodType {
+  _parse(input) {
+    if (input.data !== this._def.value) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_literal,
+        expected: this._def.value
+      });
+      return INVALID;
+    }
+    return { status: "valid", value: input.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+};
+__name(ZodLiteral, "ZodLiteral");
+ZodLiteral.create = (value, params) => {
+  return new ZodLiteral(__spreadValues({
+    value,
+    typeName: ZodFirstPartyTypeKind.ZodLiteral
+  }, processCreateParams(params)));
+};
+function createZodEnum(values, params) {
+  return new ZodEnum(__spreadValues({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodEnum
+  }, processCreateParams(params)));
+}
+__name(createZodEnum, "createZodEnum");
+var ZodEnum = class extends ZodType {
+  _parse(input) {
+    if (typeof input.data !== "string") {
+      const ctx = this._getOrReturnCtx(input);
+      const expectedValues = this._def.values;
+      addIssueToContext(ctx, {
+        expected: util.joinValues(expectedValues),
+        received: ctx.parsedType,
+        code: ZodIssueCode.invalid_type
+      });
+      return INVALID;
+    }
+    if (this._def.values.indexOf(input.data) === -1) {
+      const ctx = this._getOrReturnCtx(input);
+      const expectedValues = this._def.values;
+      addIssueToContext(ctx, {
+        received: ctx.data,
+        code: ZodIssueCode.invalid_enum_value,
+        options: expectedValues
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
+    }
+    return enumValues;
+  }
+  get Values() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
+    }
+    return enumValues;
+  }
+  get Enum() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
+    }
+    return enumValues;
+  }
+};
+__name(ZodEnum, "ZodEnum");
+ZodEnum.create = createZodEnum;
+var ZodNativeEnum = class extends ZodType {
+  _parse(input) {
+    const nativeEnumValues = util.getValidEnumValues(this._def.values);
+    const ctx = this._getOrReturnCtx(input);
+    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
+      const expectedValues = util.objectValues(nativeEnumValues);
+      addIssueToContext(ctx, {
+        expected: util.joinValues(expectedValues),
+        received: ctx.parsedType,
+        code: ZodIssueCode.invalid_type
+      });
+      return INVALID;
+    }
+    if (nativeEnumValues.indexOf(input.data) === -1) {
+      const expectedValues = util.objectValues(nativeEnumValues);
+      addIssueToContext(ctx, {
+        received: ctx.data,
+        code: ZodIssueCode.invalid_enum_value,
+        options: expectedValues
+      });
+      return INVALID;
+    }
+    return OK(input.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+};
+__name(ZodNativeEnum, "ZodNativeEnum");
+ZodNativeEnum.create = (values, params) => {
+  return new ZodNativeEnum(__spreadValues({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodNativeEnum
+  }, processCreateParams(params)));
+};
+var ZodPromise = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.promise,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
+    return OK(promisified.then((data) => {
+      return this._def.type.parseAsync(data, {
+        path: ctx.path,
+        errorMap: ctx.common.contextualErrorMap
+      });
+    }));
+  }
+};
+__name(ZodPromise, "ZodPromise");
+ZodPromise.create = (schema, params) => {
+  return new ZodPromise(__spreadValues({
+    type: schema,
+    typeName: ZodFirstPartyTypeKind.ZodPromise
+  }, processCreateParams(params)));
+};
+var ZodEffects = class extends ZodType {
+  innerType() {
+    return this._def.schema;
+  }
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    const effect = this._def.effect || null;
+    if (effect.type === "preprocess") {
+      const processed = effect.transform(ctx.data);
+      if (ctx.common.async) {
+        return Promise.resolve(processed).then((processed2) => {
+          return this._def.schema._parseAsync({
+            data: processed2,
+            path: ctx.path,
+            parent: ctx
+          });
+        });
+      } else {
+        return this._def.schema._parseSync({
+          data: processed,
+          path: ctx.path,
+          parent: ctx
+        });
+      }
+    }
+    const checkCtx = {
+      addIssue: (arg) => {
+        addIssueToContext(ctx, arg);
+        if (arg.fatal) {
+          status.abort();
+        } else {
+          status.dirty();
+        }
+      },
+      get path() {
+        return ctx.path;
+      }
+    };
+    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+    if (effect.type === "refinement") {
+      const executeRefinement = /* @__PURE__ */ __name((acc) => {
+        const result = effect.refinement(acc, checkCtx);
+        if (ctx.common.async) {
+          return Promise.resolve(result);
+        }
+        if (result instanceof Promise) {
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+        }
+        return acc;
+      }, "executeRefinement");
+      if (ctx.common.async === false) {
+        const inner = this._def.schema._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inner.status === "aborted")
+          return INVALID;
+        if (inner.status === "dirty")
+          status.dirty();
+        executeRefinement(inner.value);
+        return { status: status.value, value: inner.value };
+      } else {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
+          if (inner.status === "aborted")
+            return INVALID;
+          if (inner.status === "dirty")
+            status.dirty();
+          return executeRefinement(inner.value).then(() => {
+            return { status: status.value, value: inner.value };
+          });
+        });
+      }
+    }
+    if (effect.type === "transform") {
+      if (ctx.common.async === false) {
+        const base4 = this._def.schema._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (!isValid(base4))
+          return base4;
+        const result = effect.transform(base4.value, checkCtx);
+        if (result instanceof Promise) {
+          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
+        }
+        return { status: status.value, value: result };
+      } else {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base4) => {
+          if (!isValid(base4))
+            return base4;
+          return Promise.resolve(effect.transform(base4.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
+        });
+      }
+    }
+    util.assertNever(effect);
+  }
+};
+__name(ZodEffects, "ZodEffects");
+ZodEffects.create = (schema, effect, params) => {
+  return new ZodEffects(__spreadValues({
+    schema,
+    typeName: ZodFirstPartyTypeKind.ZodEffects,
+    effect
+  }, processCreateParams(params)));
+};
+ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+  return new ZodEffects(__spreadValues({
+    schema,
+    effect: { type: "preprocess", transform: preprocess },
+    typeName: ZodFirstPartyTypeKind.ZodEffects
+  }, processCreateParams(params)));
+};
+var ZodOptional = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType === ZodParsedType.undefined) {
+      return OK(void 0);
+    }
+    return this._def.innerType._parse(input);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+};
+__name(ZodOptional, "ZodOptional");
+ZodOptional.create = (type, params) => {
+  return new ZodOptional(__spreadValues({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodOptional
+  }, processCreateParams(params)));
+};
+var ZodNullable = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType === ZodParsedType.null) {
+      return OK(null);
+    }
+    return this._def.innerType._parse(input);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+};
+__name(ZodNullable, "ZodNullable");
+ZodNullable.create = (type, params) => {
+  return new ZodNullable(__spreadValues({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodNullable
+  }, processCreateParams(params)));
+};
+var ZodDefault = class extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    let data = ctx.data;
+    if (ctx.parsedType === ZodParsedType.undefined) {
+      data = this._def.defaultValue();
+    }
+    return this._def.innerType._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+};
+__name(ZodDefault, "ZodDefault");
+ZodDefault.create = (type, params) => {
+  return new ZodOptional(__spreadValues({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodOptional
+  }, processCreateParams(params)));
+};
+var ZodNaN = class extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.nan) {
+      const ctx = this._getOrReturnCtx(input);
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.nan,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    return { status: "valid", value: input.data };
+  }
+};
+__name(ZodNaN, "ZodNaN");
+ZodNaN.create = (params) => {
+  return new ZodNaN(__spreadValues({
+    typeName: ZodFirstPartyTypeKind.ZodNaN
+  }, processCreateParams(params)));
+};
+var custom = /* @__PURE__ */ __name((check, params = {}, fatal) => {
+  if (check)
+    return ZodAny.create().superRefine((data, ctx) => {
+      if (!check(data)) {
+        const p = typeof params === "function" ? params(data) : params;
+        const p2 = typeof p === "string" ? { message: p } : p;
+        ctx.addIssue(__spreadProps(__spreadValues({ code: "custom" }, p2), { fatal }));
+      }
+    });
+  return ZodAny.create();
+}, "custom");
+var late = {
+  object: ZodObject.lazycreate
+};
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind2) {
+  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+var instanceOfType = /* @__PURE__ */ __name((cls, params = {
+  message: `Input not instance of ${cls.name}`
+}) => custom((data) => data instanceof cls, params, true), "instanceOfType");
+var stringType = ZodString.create;
+var numberType = ZodNumber.create;
+var nanType = ZodNaN.create;
+var bigIntType = ZodBigInt.create;
+var booleanType = ZodBoolean.create;
+var dateType = ZodDate.create;
+var undefinedType = ZodUndefined.create;
+var nullType = ZodNull.create;
+var anyType = ZodAny.create;
+var unknownType = ZodUnknown.create;
+var neverType = ZodNever.create;
+var voidType = ZodVoid.create;
+var arrayType = ZodArray.create;
+var objectType = ZodObject.create;
+var strictObjectType = ZodObject.strictCreate;
+var unionType = ZodUnion.create;
+var discriminatedUnionType = ZodDiscriminatedUnion.create;
+var intersectionType = ZodIntersection.create;
+var tupleType = ZodTuple.create;
+var recordType = ZodRecord.create;
+var mapType = ZodMap.create;
+var setType = ZodSet.create;
+var functionType = ZodFunction.create;
+var lazyType = ZodLazy.create;
+var literalType = ZodLiteral.create;
+var enumType = ZodEnum.create;
+var nativeEnumType = ZodNativeEnum.create;
+var promiseType = ZodPromise.create;
+var effectsType = ZodEffects.create;
+var optionalType = ZodOptional.create;
+var nullableType = ZodNullable.create;
+var preprocessType = ZodEffects.createWithPreprocess;
+var ostring = /* @__PURE__ */ __name(() => stringType().optional(), "ostring");
+var onumber = /* @__PURE__ */ __name(() => numberType().optional(), "onumber");
+var oboolean = /* @__PURE__ */ __name(() => booleanType().optional(), "oboolean");
+var mod = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  getParsedType,
+  ZodParsedType,
+  makeIssue,
+  EMPTY_PATH,
+  addIssueToContext,
+  ParseStatus,
+  INVALID,
+  DIRTY,
+  OK,
+  isAborted,
+  isDirty,
+  isValid,
+  isAsync,
+  ZodType,
+  ZodString,
+  ZodNumber,
+  ZodBigInt,
+  ZodBoolean,
+  ZodDate,
+  ZodUndefined,
+  ZodNull,
+  ZodAny,
+  ZodUnknown,
+  ZodNever,
+  ZodVoid,
+  ZodArray,
+  get objectUtil() {
+    return objectUtil;
+  },
+  ZodObject,
+  ZodUnion,
+  ZodDiscriminatedUnion,
+  ZodIntersection,
+  ZodTuple,
+  ZodRecord,
+  ZodMap,
+  ZodSet,
+  ZodFunction,
+  ZodLazy,
+  ZodLiteral,
+  ZodEnum,
+  ZodNativeEnum,
+  ZodPromise,
+  ZodEffects,
+  ZodTransformer: ZodEffects,
+  ZodOptional,
+  ZodNullable,
+  ZodDefault,
+  ZodNaN,
+  custom,
+  Schema: ZodType,
+  ZodSchema: ZodType,
+  late,
+  get ZodFirstPartyTypeKind() {
+    return ZodFirstPartyTypeKind;
+  },
+  any: anyType,
+  array: arrayType,
+  bigint: bigIntType,
+  boolean: booleanType,
+  date: dateType,
+  discriminatedUnion: discriminatedUnionType,
+  effect: effectsType,
+  "enum": enumType,
+  "function": functionType,
+  "instanceof": instanceOfType,
+  intersection: intersectionType,
+  lazy: lazyType,
+  literal: literalType,
+  map: mapType,
+  nan: nanType,
+  nativeEnum: nativeEnumType,
+  never: neverType,
+  "null": nullType,
+  nullable: nullableType,
+  number: numberType,
+  object: objectType,
+  oboolean,
+  onumber,
+  optional: optionalType,
+  ostring,
+  preprocess: preprocessType,
+  promise: promiseType,
+  record: recordType,
+  set: setType,
+  strictObject: strictObjectType,
+  string: stringType,
+  transformer: effectsType,
+  tuple: tupleType,
+  "undefined": undefinedType,
+  union: unionType,
+  unknown: unknownType,
+  "void": voidType,
+  ZodIssueCode,
+  quotelessJson,
+  ZodError,
+  defaultErrorMap,
+  get overrideErrorMap() {
+    return overrideErrorMap;
+  },
+  setErrorMap
+});
+
 // ../learn-card-types/dist/types.esm.js
-var VerificationStatus = /* @__PURE__ */ ((VerificationStatus2) => {
-  VerificationStatus2["Success"] = "Success";
-  VerificationStatus2["Failed"] = "Failed";
-  VerificationStatus2["Error"] = "Error";
-  return VerificationStatus2;
-})(VerificationStatus || {});
+var ContextValidator = mod.string().array();
+var AchievementCriteriaValidator = mod.object({
+  type: mod.string().optional(),
+  narrative: mod.string().optional()
+});
+var ImageValidator = mod.string().or(mod.object({
+  id: mod.string(),
+  type: mod.string(),
+  caption: mod.string().optional()
+}));
+var GeoCoordinatesValidator = mod.object({
+  type: mod.string().array().nonempty(),
+  latitude: mod.number(),
+  longitude: mod.number()
+});
+var AddressValidator = mod.object({
+  type: mod.string().array().nonempty(),
+  addressCountry: mod.string().optional(),
+  addressCountryCode: mod.string().optional(),
+  addressRegion: mod.string().optional(),
+  addressLocality: mod.string().optional(),
+  streetAddress: mod.string().optional(),
+  postOfficeBoxNumber: mod.string().optional(),
+  postalCode: mod.string().optional(),
+  geo: GeoCoordinatesValidator.optional()
+});
+var IdentifierTypeValidator = mod.enum([
+  "sourcedId",
+  "systemId",
+  "productId",
+  "userName",
+  "accountId",
+  "emailAddress",
+  "nationalIdentityNumber",
+  "isbn",
+  "issn",
+  "lisSourcedId",
+  "oneRosterSourcedId",
+  "sisSourcedId",
+  "ltiContextId",
+  "ltiDeploymentId",
+  "ltiToolId",
+  "ltiPlatformId",
+  "ltiUserId",
+  "identifier"
+]).or(mod.string());
+var IdentifierEntryValidator = mod.object({
+  type: mod.string().array().nonempty(),
+  identifier: mod.string(),
+  identifierType: IdentifierTypeValidator
+});
+var ProfileValidator = mod.string().or(mod.object({
+  id: mod.string().optional(),
+  type: mod.string().array().nonempty(),
+  name: mod.string().optional(),
+  url: mod.string().optional(),
+  phone: mod.string().optional(),
+  description: mod.string().optional(),
+  endorsement: mod.any().array().optional(),
+  image: ImageValidator.optional(),
+  email: mod.string().email().optional(),
+  address: AddressValidator.optional(),
+  otherIdentifier: IdentifierEntryValidator.array().optional(),
+  official: mod.string().optional(),
+  parentOrg: mod.any().optional(),
+  familyName: mod.string().optional(),
+  givenName: mod.string().optional(),
+  additionalName: mod.string().optional(),
+  patronymicName: mod.string().optional(),
+  honorificPrefix: mod.string().optional(),
+  honorificSuffix: mod.string().optional(),
+  familyNamePrefix: mod.string().optional(),
+  dateOfBirth: mod.string().optional()
+}).catchall(mod.any()));
+var CredentialSubjectValidator = mod.object({ id: mod.string().optional() }).catchall(mod.any());
+var CredentialStatusValidator = mod.object({ type: mod.string(), id: mod.string() });
+var CredentialSchemaValidator = mod.object({ id: mod.string(), type: mod.string() });
+var RefreshServiceValidator = mod.object({ id: mod.string(), type: mod.string() }).catchall(mod.any());
+var UnsignedVCValidator = mod.object({
+  "@context": ContextValidator,
+  id: mod.string().optional(),
+  type: mod.string().array().nonempty(),
+  issuer: ProfileValidator,
+  issuanceDate: mod.string(),
+  expirationDate: mod.string().optional(),
+  credentialSubject: CredentialSubjectValidator.or(CredentialSubjectValidator.array()),
+  credentialStatus: CredentialStatusValidator.optional(),
+  credentialSchema: CredentialSchemaValidator.array().optional(),
+  refreshService: RefreshServiceValidator.optional()
+}).catchall(mod.any());
+var ProofValidator = mod.object({
+  type: mod.string(),
+  created: mod.string(),
+  challenge: mod.string().optional(),
+  domain: mod.string().optional(),
+  nonce: mod.string().optional(),
+  proofPurpose: mod.literal("assertionMethod"),
+  verificationMethod: mod.string(),
+  jws: mod.string().optional()
+}).catchall(mod.any());
+var VCValidator = UnsignedVCValidator.extend({
+  proof: ProofValidator.or(ProofValidator.array())
+});
+var UnsignedVPValidator = mod.object({
+  "@context": ContextValidator,
+  id: mod.string().optional(),
+  type: mod.string().array().nonempty(),
+  verifiableCredential: VCValidator,
+  holder: mod.string().optional()
+}).catchall(mod.any());
+var VPValidator = UnsignedVPValidator.extend({
+  proof: ProofValidator.or(ProofValidator.array())
+});
+var AlignmentTargetTypeValidator = mod.enum([
+  "ceasn:Competency",
+  "ceterms:Credential",
+  "CFItem",
+  "CFRubric",
+  "CFRubricCriterion",
+  "CFRubricCriterionLevel",
+  "CTDL"
+]).or(mod.string());
+var AlignmentValidator = mod.object({
+  type: mod.string().array().nonempty(),
+  targetCode: mod.string().optional(),
+  targetDescription: mod.string().optional(),
+  targetName: mod.string(),
+  targetFramework: mod.string().optional(),
+  targetType: AlignmentTargetTypeValidator.optional(),
+  targetUrl: mod.string()
+});
+var AchievementTypeValidator = mod.enum([
+  "Achievement",
+  "ApprenticeshipCertificate",
+  "Assessment",
+  "Assignment",
+  "AssociateDegree",
+  "Award",
+  "Badge",
+  "BachelorDegree",
+  "Certificate",
+  "CertificateOfCompletion",
+  "Certification",
+  "CommunityService",
+  "Competency",
+  "Course",
+  "CoCurricular",
+  "Degree",
+  "Diploma",
+  "DoctoralDegree",
+  "Fieldwork",
+  "GeneralEducationDevelopment",
+  "JourneymanCertificate",
+  "LearningProgram",
+  "License",
+  "Membership",
+  "ProfessionalDoctorate",
+  "QualityAssuranceCredential",
+  "MasterCertificate",
+  "MasterDegree",
+  "MicroCredential",
+  "ResearchDoctorate",
+  "SecondarySchoolDiploma"
+]).or(mod.string());
+var CriteriaValidator = mod.object({ id: mod.string().optional(), narrative: mod.string().optional() }).catchall(mod.any());
+var EndorsementSubjectValidator = mod.object({
+  id: mod.string(),
+  type: mod.string().array().nonempty(),
+  endorsementComment: mod.string().optional()
+});
+var EndorsementCredentialValidator = UnsignedVCValidator.extend({
+  credentialSubject: EndorsementSubjectValidator,
+  proof: ProofValidator.or(ProofValidator.array()).optional()
+});
+var RelatedValidator = mod.object({
+  id: mod.string(),
+  "@language": mod.string().optional(),
+  version: mod.string().optional()
+});
+var ResultTypeValidator = mod.enum([
+  "GradePointAverage",
+  "LetterGrade",
+  "Percent",
+  "PerformanceLevel",
+  "PredictedScore",
+  "RawScore",
+  "Result",
+  "RubricCriterion",
+  "RubricCriterionLevel",
+  "RubricScore",
+  "ScaledScore",
+  "Status"
+]).or(mod.string());
+var RubricCriterionValidator = mod.object({
+  id: mod.string(),
+  type: mod.string().array().nonempty(),
+  alignment: AlignmentValidator.array().optional(),
+  description: mod.string().optional(),
+  level: mod.string().optional(),
+  name: mod.string(),
+  points: mod.string().optional()
+}).catchall(mod.any());
+var ResultDescriptionValidator = mod.object({
+  id: mod.string(),
+  type: mod.string().array().nonempty(),
+  alignment: AlignmentValidator.array().optional(),
+  allowedValue: mod.string().array().optional(),
+  name: mod.string(),
+  requiredLevel: mod.string().optional(),
+  requiredValue: mod.string().optional(),
+  resultType: ResultTypeValidator,
+  rubricCriterionLevel: RubricCriterionValidator.array().optional(),
+  valueMax: mod.string().optional(),
+  valueMin: mod.string().optional()
+}).catchall(mod.any());
+var AchievementValidator = mod.object({
+  id: mod.string().optional(),
+  type: mod.string().array().nonempty(),
+  alignment: AlignmentValidator.array().optional(),
+  achievementType: AchievementTypeValidator.optional(),
+  creator: ProfileValidator.optional(),
+  creditsAvailable: mod.number().optional(),
+  criteria: CriteriaValidator,
+  description: mod.string(),
+  endorsement: EndorsementCredentialValidator.array().optional(),
+  fieldOfStudy: mod.string().optional(),
+  humanCode: mod.string().optional(),
+  image: ImageValidator.optional(),
+  "@language": mod.string().optional(),
+  name: mod.string(),
+  otherIdentifier: IdentifierEntryValidator.array().optional(),
+  related: RelatedValidator.array().optional(),
+  resultDescription: ResultDescriptionValidator.array().optional(),
+  specialization: mod.string().optional(),
+  tag: mod.string().array().optional(),
+  version: mod.string().optional()
+}).catchall(mod.any());
+var IdentityObjectValidator = mod.object({
+  type: mod.string(),
+  hashed: mod.boolean(),
+  identityHash: mod.string(),
+  identityType: mod.string(),
+  salt: mod.string().optional()
+});
+var ResultStatusTypeValidator = mod.enum([
+  "Completed",
+  "Enrolled",
+  "Failed",
+  "InProgress",
+  "OnHold",
+  "Withdrew"
+]);
+var ResultValidator = mod.object({
+  type: mod.string().array().nonempty(),
+  achievedLevel: mod.string().optional(),
+  alignment: AlignmentValidator.array().optional(),
+  resultDescription: mod.string().optional(),
+  status: ResultStatusTypeValidator.optional(),
+  value: mod.string().optional()
+}).catchall(mod.any());
+var AchievementSubjectValidator = mod.object({
+  id: mod.string().optional(),
+  type: mod.string().array().nonempty(),
+  activityEndDate: mod.string().optional(),
+  activityStartDate: mod.string().optional(),
+  creditsEarned: mod.number().optional(),
+  achievement: AchievementValidator.optional(),
+  identifier: IdentityObjectValidator.optional(),
+  image: ImageValidator.optional(),
+  licenseNumber: mod.string().optional(),
+  narrative: mod.string().optional(),
+  result: ResultValidator.array().optional(),
+  role: mod.string().optional(),
+  source: ProfileValidator.optional(),
+  term: mod.string().optional()
+}).catchall(mod.any());
+var EvidenceValidator = mod.object({
+  id: mod.string().optional(),
+  type: mod.string().array().nonempty(),
+  narrative: mod.string().optional(),
+  name: mod.string().optional(),
+  description: mod.string().optional(),
+  genre: mod.string().optional(),
+  audience: mod.string().optional()
+}).catchall(mod.any());
+var UnsignedAchievementCredentialValidator = UnsignedVCValidator.extend({
+  name: mod.string().optional(),
+  description: mod.string().optional(),
+  image: mod.string().optional(),
+  credentialSubject: AchievementSubjectValidator.or(AchievementSubjectValidator.array()),
+  endorsement: UnsignedVCValidator.array().optional(),
+  evidence: EvidenceValidator.array().optional()
+});
+var AchievementCredentialValidator = UnsignedAchievementCredentialValidator.extend({
+  proof: ProofValidator.or(ProofValidator.array())
+});
+var VerificationStatusValidator = mod.enum(["Success", "Failed", "Error"]);
+var VerificationStatusEnum = VerificationStatusValidator.enum;
+var VerificationItemValidator = mod.object({
+  check: mod.string(),
+  status: VerificationStatusValidator,
+  message: mod.string().optional(),
+  details: mod.string().optional()
+});
+var CredentialInfoValidator = mod.object({
+  title: mod.string().optional(),
+  createdAt: mod.string().optional(),
+  issuer: ProfileValidator.optional(),
+  issuee: ProfileValidator.optional(),
+  credentialSubject: CredentialSubjectValidator.optional()
+});
 
 // ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/toInteger/index.js
 function toInteger(dirtyNumber) {
@@ -48604,7 +51641,7 @@ function isDate(value) {
 __name(isDate, "isDate");
 
 // ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/isValid/index.js
-function isValid(dirtyDate) {
+function isValid2(dirtyDate) {
   requiredArgs(1, arguments);
   if (!isDate(dirtyDate) && typeof dirtyDate !== "number") {
     return false;
@@ -48612,7 +51649,7 @@ function isValid(dirtyDate) {
   var date = toDate(dirtyDate);
   return !isNaN(Number(date));
 }
-__name(isValid, "isValid");
+__name(isValid2, "isValid");
 
 // ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/en-US/_lib/formatDistance/index.js
 var formatDistanceLocale = {
@@ -50053,7 +53090,7 @@ function format(dirtyDate, dirtyFormatStr, dirtyOptions) {
     throw new RangeError("locale must contain formatLong property");
   }
   var originalDate = toDate(dirtyDate);
-  if (!isValid(originalDate)) {
+  if (!isValid2(originalDate)) {
     throw new RangeError("Invalid time value");
   }
   var timezoneOffset = getTimezoneOffsetInMilliseconds(originalDate);
@@ -50121,21 +53158,21 @@ var verifyCredential3 = /* @__PURE__ */ __name((wallet) => {
     const verificationItems = [];
     rawVerificationCheck.errors.forEach((error) => {
       verificationItems.push({
-        status: VerificationStatus.Failed,
+        status: VerificationStatusEnum.Failed,
         check: "hmm",
         details: transformErrorMessage(error, credential)
       });
     });
     rawVerificationCheck.warnings.forEach((warning) => {
       verificationItems.push({
-        status: VerificationStatus.Error,
+        status: VerificationStatusEnum.Error,
         check: "hmm",
         message: warning
       });
     });
     rawVerificationCheck.checks.forEach((check) => {
       verificationItems.push({
-        status: VerificationStatus.Success,
+        status: VerificationStatusEnum.Success,
         check,
         message: transformCheckMessage(check, credential)
       });