authhero 0.0.1

package/dist/authhero.js

@@ -0,0 +1,4912 @@
+var yr = Object.defineProperty;
+var Mt = (r) => {
+  throw TypeError(r);
+};
+var _r = (r, e, t) => e in r ? yr(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var p = (r, e, t) => _r(r, typeof e != "symbol" ? e + "" : e, t), $t = (r, e, t) => e.has(r) || Mt("Cannot " + t);
+var h = (r, e, t) => ($t(r, e, "read from private field"), t ? t.call(r) : e.get(r)), N = (r, e, t) => e.has(r) ? Mt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t), T = (r, e, t, n) => ($t(r, e, "write to private field"), n ? n.call(r, t) : e.set(r, t), t);
+function Se(r, e) {
+  var t = {};
+  for (var n in r) Object.prototype.hasOwnProperty.call(r, n) && e.indexOf(n) < 0 && (t[n] = r[n]);
+  if (r != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var s = 0, n = Object.getOwnPropertySymbols(r); s < n.length; s++)
+      e.indexOf(n[s]) < 0 && Object.prototype.propertyIsEnumerable.call(r, n[s]) && (t[n[s]] = r[n[s]]);
+  return t;
+}
+function x(r, e) {
+  var t;
+  return ((t = r == null ? void 0 : r._def) === null || t === void 0 ? void 0 : t.typeName) === e;
+}
+function br(r) {
+  return "_def" in r;
+}
+function Pe(r, e) {
+  const t = r.ZodType.prototype[e];
+  r.ZodType.prototype[e] = function(...n) {
+    const s = t.apply(this, n);
+    return s._def.openapi = this._def.openapi, s;
+  };
+}
+function wr(r) {
+  if (typeof r.ZodType.prototype.openapi < "u")
+    return;
+  r.ZodType.prototype.openapi = function(s, a) {
+    var i, o, c, u, d, f;
+    const k = typeof s == "string" ? a : s, E = k ?? {}, { param: R } = E, b = Se(E, ["param"]), S = Object.assign(Object.assign({}, (i = this._def.openapi) === null || i === void 0 ? void 0 : i._internal), typeof s == "string" ? { refId: s } : void 0), D = Object.assign(Object.assign(Object.assign({}, (o = this._def.openapi) === null || o === void 0 ? void 0 : o.metadata), b), !((u = (c = this._def.openapi) === null || c === void 0 ? void 0 : c.metadata) === null || u === void 0) && u.param || R ? {
+      param: Object.assign(Object.assign({}, (f = (d = this._def.openapi) === null || d === void 0 ? void 0 : d.metadata) === null || f === void 0 ? void 0 : f.param), R)
+    } : void 0), G = new this.constructor(Object.assign(Object.assign({}, this._def), { openapi: Object.assign(Object.assign({}, Object.keys(S).length > 0 ? { _internal: S } : void 0), Object.keys(D).length > 0 ? { metadata: D } : void 0) }));
+    if (x(this, "ZodObject")) {
+      const V = this.extend;
+      G.extend = function(...ge) {
+        var ne, Q, K, ve, de, Ot;
+        const kt = V.apply(this, ge);
+        return kt._def.openapi = {
+          _internal: {
+            extendedFrom: !((Q = (ne = this._def.openapi) === null || ne === void 0 ? void 0 : ne._internal) === null || Q === void 0) && Q.refId ? { refId: (ve = (K = this._def.openapi) === null || K === void 0 ? void 0 : K._internal) === null || ve === void 0 ? void 0 : ve.refId, schema: this } : (de = this._def.openapi) === null || de === void 0 ? void 0 : de._internal.extendedFrom
+          },
+          metadata: (Ot = kt._def.openapi) === null || Ot === void 0 ? void 0 : Ot.metadata
+        }, kt;
+      };
+    }
+    return G;
+  }, Pe(r, "optional"), Pe(r, "nullable"), Pe(r, "default"), Pe(r, "transform"), Pe(r, "refine");
+  const e = r.ZodObject.prototype.deepPartial;
+  r.ZodObject.prototype.deepPartial = function() {
+    const s = this._def.shape(), a = e.apply(this), i = a._def.shape();
+    return Object.entries(i).forEach(([o, c]) => {
+      var u, d;
+      c._def.openapi = (d = (u = s[o]) === null || u === void 0 ? void 0 : u._def) === null || d === void 0 ? void 0 : d.openapi;
+    }), a._def.openapi = void 0, a;
+  };
+  const t = r.ZodObject.prototype.pick;
+  r.ZodObject.prototype.pick = function(...s) {
+    const a = t.apply(this, s);
+    return a._def.openapi = void 0, a;
+  };
+  const n = r.ZodObject.prototype.omit;
+  r.ZodObject.prototype.omit = function(...s) {
+    const a = n.apply(this, s);
+    return a._def.openapi = void 0, a;
+  };
+}
+function dt(r, e) {
+  if (r == null || e === null || e === void 0)
+    return r === e;
+  if (r === e || r.valueOf() === e.valueOf())
+    return !0;
+  if (Array.isArray(r) && (!Array.isArray(e) || r.length !== e.length) || !(r instanceof Object) || !(e instanceof Object))
+    return !1;
+  const t = Object.keys(r);
+  return Object.keys(e).every((n) => t.indexOf(n) !== -1) && t.every((n) => dt(r[n], e[n]));
+}
+class xr {
+  constructor() {
+    this.buckets = /* @__PURE__ */ new Map();
+  }
+  put(e) {
+    const t = this.hashCodeOf(e), n = this.buckets.get(t);
+    if (!n) {
+      this.buckets.set(t, [e]);
+      return;
+    }
+    n.some((a) => dt(a, e)) || n.push(e);
+  }
+  contains(e) {
+    const t = this.hashCodeOf(e), n = this.buckets.get(t);
+    return n ? n.some((s) => dt(s, e)) : !1;
+  }
+  values() {
+    return [...this.buckets.values()].flat();
+  }
+  stats() {
+    let e = 0, t = 0, n = 0;
+    for (const a of this.buckets.values())
+      e += 1, t += a.length, a.length > 1 && (n += 1);
+    const s = e / t;
+    return { totalBuckets: e, collisions: n, totalValues: t, hashEffectiveness: s };
+  }
+  hashCodeOf(e) {
+    let t = 0;
+    if (Array.isArray(e)) {
+      for (let n = 0; n < e.length; n++)
+        t ^= this.hashCodeOf(e[n]) * n;
+      return t;
+    }
+    if (typeof e == "string") {
+      for (let n = 0; n < e.length; n++)
+        t ^= e.charCodeAt(n) * n;
+      return t;
+    }
+    if (typeof e == "number")
+      return e;
+    if (typeof e == "object")
+      for (const [n, s] of Object.entries(e))
+        t ^= this.hashCodeOf(n) + this.hashCodeOf(s ?? "");
+    return t;
+  }
+}
+function Me(r) {
+  return r == null;
+}
+function $e(r, e) {
+  const t = {};
+  return Object.entries(r).forEach(([n, s]) => {
+    t[n] = e(s);
+  }), t;
+}
+function Or(r, e) {
+  const t = {};
+  return Object.entries(r).forEach(([n, s]) => {
+    e.some((a) => a === n) || (t[n] = s);
+  }), t;
+}
+function xe(r, e) {
+  const t = {};
+  return Object.entries(r).forEach(([n, s]) => {
+    e(s, n) || (t[n] = s);
+  }), t;
+}
+function Lt(r) {
+  return r.filter((e) => !Me(e));
+}
+const It = dt;
+function kr(r) {
+  const e = new xr();
+  return r.forEach((t) => e.put(t)), [...e.values()];
+}
+function Kt(r) {
+  return typeof r == "string";
+}
+class Tr {
+  constructor(e) {
+    this.parents = e, this._definitions = [];
+  }
+  get definitions() {
+    var e, t;
+    return [...(t = (e = this.parents) === null || e === void 0 ? void 0 : e.flatMap((s) => s.definitions)) !== null && t !== void 0 ? t : [], ...this._definitions];
+  }
+  /**
+   * Registers a new component schema under /components/schemas/${name}
+   */
+  register(e, t) {
+    const n = this.schemaWithRefId(e, t);
+    return this._definitions.push({ type: "schema", schema: n }), n;
+  }
+  /**
+   * Registers a new parameter schema under /components/parameters/${name}
+   */
+  registerParameter(e, t) {
+    var n, s, a;
+    const i = this.schemaWithRefId(e, t), o = (n = i._def.openapi) === null || n === void 0 ? void 0 : n.metadata, c = i.openapi(Object.assign(Object.assign({}, o), { param: Object.assign(Object.assign({}, o == null ? void 0 : o.param), { name: (a = (s = o == null ? void 0 : o.param) === null || s === void 0 ? void 0 : s.name) !== null && a !== void 0 ? a : e }) }));
+    return this._definitions.push({
+      type: "parameter",
+      schema: c
+    }), c;
+  }
+  /**
+   * Registers a new path that would be generated under paths:
+   */
+  registerPath(e) {
+    this._definitions.push({
+      type: "route",
+      route: e
+    });
+  }
+  /**
+   * Registers a new webhook that would be generated under webhooks:
+   */
+  registerWebhook(e) {
+    this._definitions.push({
+      type: "webhook",
+      webhook: e
+    });
+  }
+  /**
+   * Registers a raw OpenAPI component. Use this if you have a simple object instead of a Zod schema.
+   *
+   * @param type The component type, e.g. `schemas`, `responses`, `securitySchemes`, etc.
+   * @param name The name of the object, it is the key under the component
+   *             type in the resulting OpenAPI document
+   * @param component The actual object to put there
+   */
+  registerComponent(e, t, n) {
+    return this._definitions.push({
+      type: "component",
+      componentType: e,
+      name: t,
+      component: n
+    }), {
+      name: t,
+      ref: { $ref: `#/components/${e}/${t}` }
+    };
+  }
+  schemaWithRefId(e, t) {
+    return t.openapi(e);
+  }
+}
+class wt {
+  constructor(e) {
+    this.message = e;
+  }
+}
+class Ce extends wt {
+  constructor(e, t) {
+    super(e), this.data = t;
+  }
+}
+class lt extends wt {
+  constructor(e) {
+    super(`Missing parameter data, please specify \`${e.missingField}\` and other OpenAPI parameter props using the \`param\` field of \`ZodSchema.openapi\``), this.data = e;
+  }
+}
+function Ze(r, e) {
+  try {
+    return r();
+  } catch (t) {
+    throw t instanceof lt ? new lt(Object.assign(Object.assign({}, t.data), e)) : t;
+  }
+}
+class jr extends wt {
+  constructor(e) {
+    super("Unknown zod object type, please specify `type` and other OpenAPI props using `ZodSchema.openapi`."), this.data = e;
+  }
+}
+class I {
+  static getMetadata(e) {
+    var t;
+    const n = this.unwrapChained(e), s = e._def.openapi ? e._def.openapi : n._def.openapi, a = (t = e.description) !== null && t !== void 0 ? t : n.description;
+    return {
+      _internal: s == null ? void 0 : s._internal,
+      metadata: Object.assign({ description: a }, s == null ? void 0 : s.metadata)
+    };
+  }
+  static getInternalMetadata(e) {
+    const t = this.unwrapChained(e), n = e._def.openapi ? e._def.openapi : t._def.openapi;
+    return n == null ? void 0 : n._internal;
+  }
+  static getParamMetadata(e) {
+    var t, n;
+    const s = this.unwrapChained(e), a = e._def.openapi ? e._def.openapi : s._def.openapi, i = (t = e.description) !== null && t !== void 0 ? t : s.description;
+    return {
+      _internal: a == null ? void 0 : a._internal,
+      metadata: Object.assign(Object.assign({}, a == null ? void 0 : a.metadata), {
+        // A description provided from .openapi() should be taken with higher precedence
+        param: Object.assign({ description: i }, (n = a == null ? void 0 : a.metadata) === null || n === void 0 ? void 0 : n.param)
+      })
+    };
+  }
+  /**
+   * A method that omits all custom keys added to the regular OpenAPI
+   * metadata properties
+   */
+  static buildSchemaMetadata(e) {
+    return xe(Or(e, ["param"]), Me);
+  }
+  static buildParameterMetadata(e) {
+    return xe(e, Me);
+  }
+  static applySchemaMetadata(e, t) {
+    return xe(Object.assign(Object.assign({}, e), this.buildSchemaMetadata(t)), Me);
+  }
+  static getRefId(e) {
+    var t;
+    return (t = this.getInternalMetadata(e)) === null || t === void 0 ? void 0 : t.refId;
+  }
+  static unwrapChained(e) {
+    return this.unwrapUntil(e);
+  }
+  static getDefaultValue(e) {
+    const t = this.unwrapUntil(e, "ZodDefault");
+    return t == null ? void 0 : t._def.defaultValue();
+  }
+  static unwrapUntil(e, t) {
+    return t && x(e, t) ? e : x(e, "ZodOptional") || x(e, "ZodNullable") || x(e, "ZodBranded") ? this.unwrapUntil(e.unwrap(), t) : x(e, "ZodDefault") || x(e, "ZodReadonly") ? this.unwrapUntil(e._def.innerType, t) : x(e, "ZodEffects") ? this.unwrapUntil(e._def.schema, t) : x(e, "ZodPipeline") ? this.unwrapUntil(e._def.in, t) : t ? void 0 : e;
+  }
+  static isOptionalSchema(e) {
+    return x(e, "ZodEffects") ? this.isOptionalSchema(e._def.schema) : e.isOptional();
+  }
+}
+class Rr {
+  transform(e, t, n) {
+    var s, a;
+    const i = e._def.type;
+    return Object.assign(Object.assign({}, t("array")), { items: n(i), minItems: (s = e._def.minLength) === null || s === void 0 ? void 0 : s.value, maxItems: (a = e._def.maxLength) === null || a === void 0 ? void 0 : a.value });
+  }
+}
+class Er {
+  transform(e) {
+    return Object.assign(Object.assign({}, e("string")), { pattern: "^d+$" });
+  }
+}
+class Ir {
+  transform(e, t, n, s, a) {
+    const i = [...e.options.values()], o = i.map(s);
+    return t ? {
+      oneOf: n(o, t)
+    } : {
+      oneOf: o,
+      discriminator: this.mapDiscriminator(i, e.discriminator, a)
+    };
+  }
+  mapDiscriminator(e, t, n) {
+    if (e.some((a) => I.getRefId(a) === void 0))
+      return;
+    const s = {};
+    return e.forEach((a) => {
+      var i;
+      const o = I.getRefId(a), c = (i = a.shape) === null || i === void 0 ? void 0 : i[t];
+      if (x(c, "ZodEnum") || x(c, "ZodNativeEnum")) {
+        Object.values(c.enum).filter(Kt).forEach((f) => {
+          s[f] = n(o);
+        });
+        return;
+      }
+      const u = c == null ? void 0 : c._def.value;
+      if (typeof u != "string")
+        throw new Error(`Discriminator ${t} could not be found in one of the values of a discriminated union`);
+      s[u] = n(o);
+    }), {
+      propertyName: t,
+      mapping: s
+    };
+  }
+}
+class Pr {
+  transform(e, t) {
+    return Object.assign(Object.assign({}, t("string")), { enum: e._def.values });
+  }
+}
+class Cr {
+  transform(e, t, n, s) {
+    const i = {
+      allOf: this.flattenIntersectionTypes(e).map(s)
+    };
+    return t ? {
+      anyOf: n([i], t)
+    } : i;
+  }
+  flattenIntersectionTypes(e) {
+    if (!x(e, "ZodIntersection"))
+      return [e];
+    const t = this.flattenIntersectionTypes(e._def.left), n = this.flattenIntersectionTypes(e._def.right);
+    return [...t, ...n];
+  }
+}
+class Zr {
+  transform(e, t) {
+    return Object.assign(Object.assign({}, t(typeof e._def.value)), { enum: [e._def.value] });
+  }
+}
+function Sr(r) {
+  const t = Object.keys(r).filter((a) => typeof r[r[a]] != "number").map((a) => r[a]), n = t.filter((a) => typeof a == "number").length, s = n === 0 ? "string" : n === t.length ? "numeric" : "mixed";
+  return { values: t, type: s };
+}
+class Ar {
+  transform(e, t) {
+    const { type: n, values: s } = Sr(e._def.values);
+    if (n === "mixed")
+      throw new wt("Enum has mixed string and number values, please specify the OpenAPI type manually");
+    return Object.assign(Object.assign({}, t(n === "numeric" ? "integer" : "string")), { enum: s });
+  }
+}
+class Nr {
+  transform(e, t, n) {
+    return Object.assign(Object.assign({}, t(e.isInt ? "integer" : "number")), n(e._def.checks));
+  }
+}
+class Dr {
+  transform(e, t, n, s) {
+    var a;
+    const i = (a = I.getInternalMetadata(e)) === null || a === void 0 ? void 0 : a.extendedFrom, o = this.requiredKeysOf(e), c = $e(e._def.shape(), s);
+    if (!i)
+      return Object.assign(Object.assign(Object.assign(Object.assign({}, n("object")), { properties: c, default: t }), o.length > 0 ? { required: o } : {}), this.generateAdditionalProperties(e, s));
+    const u = i.schema;
+    s(u);
+    const d = this.requiredKeysOf(u), f = $e(u == null ? void 0 : u._def.shape(), s), k = Object.fromEntries(Object.entries(c).filter(([b, S]) => !It(f[b], S))), E = o.filter((b) => !d.includes(b)), R = Object.assign(Object.assign(Object.assign(Object.assign({}, n("object")), { default: t, properties: k }), E.length > 0 ? { required: E } : {}), this.generateAdditionalProperties(e, s));
+    return {
+      allOf: [
+        { $ref: `#/components/schemas/${i.refId}` },
+        R
+      ]
+    };
+  }
+  generateAdditionalProperties(e, t) {
+    const n = e._def.unknownKeys, s = e._def.catchall;
+    return x(s, "ZodNever") ? n === "strict" ? { additionalProperties: !1 } : {} : { additionalProperties: t(s) };
+  }
+  requiredKeysOf(e) {
+    return Object.entries(e._def.shape()).filter(([t, n]) => !I.isOptionalSchema(n)).map(([t, n]) => t);
+  }
+}
+class Mr {
+  transform(e, t, n) {
+    const s = e._def.valueType, a = e._def.keyType, i = n(s);
+    if (x(a, "ZodEnum") || x(a, "ZodNativeEnum")) {
+      const c = Object.values(a.enum).filter(Kt).reduce((u, d) => Object.assign(Object.assign({}, u), { [d]: i }), {});
+      return Object.assign(Object.assign({}, t("object")), { properties: c });
+    }
+    return Object.assign(Object.assign({}, t("object")), { additionalProperties: i });
+  }
+}
+class $r {
+  transform(e, t) {
+    var n, s, a;
+    const i = this.getZodStringCheck(e, "regex"), o = (n = this.getZodStringCheck(e, "length")) === null || n === void 0 ? void 0 : n.value, c = Number.isFinite(e.minLength) && (s = e.minLength) !== null && s !== void 0 ? s : void 0, u = Number.isFinite(e.maxLength) && (a = e.maxLength) !== null && a !== void 0 ? a : void 0;
+    return Object.assign(Object.assign({}, t("string")), {
+      // FIXME: https://github.com/colinhacks/zod/commit/d78047e9f44596a96d637abb0ce209cd2732d88c
+      minLength: o ?? c,
+      maxLength: o ?? u,
+      format: this.mapStringFormat(e),
+      pattern: i == null ? void 0 : i.regex.source
+    });
+  }
+  /**
+   * Attempts to map Zod strings to known formats
+   * https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
+   */
+  mapStringFormat(e) {
+    if (e.isUUID)
+      return "uuid";
+    if (e.isEmail)
+      return "email";
+    if (e.isURL)
+      return "uri";
+    if (e.isDatetime)
+      return "date-time";
+  }
+  getZodStringCheck(e, t) {
+    return e._def.checks.find((n) => n.kind === t);
+  }
+}
+class Lr {
+  constructor(e) {
+    this.versionSpecifics = e;
+  }
+  transform(e, t, n) {
+    const { items: s } = e._def, a = s.map(n);
+    return Object.assign(Object.assign({}, t("array")), this.versionSpecifics.mapTupleItems(a));
+  }
+}
+class Vr {
+  transform(e, t, n) {
+    const a = this.flattenUnionTypes(e).map((i) => {
+      const o = this.unwrapNullable(i);
+      return n(o);
+    });
+    return {
+      anyOf: t(a)
+    };
+  }
+  flattenUnionTypes(e) {
+    return x(e, "ZodUnion") ? e._def.options.flatMap((n) => this.flattenUnionTypes(n)) : [e];
+  }
+  unwrapNullable(e) {
+    return x(e, "ZodNullable") ? this.unwrapNullable(e.unwrap()) : e;
+  }
+}
+class Ur {
+  constructor(e) {
+    this.versionSpecifics = e, this.objectTransformer = new Dr(), this.stringTransformer = new $r(), this.numberTransformer = new Nr(), this.bigIntTransformer = new Er(), this.literalTransformer = new Zr(), this.enumTransformer = new Pr(), this.nativeEnumTransformer = new Ar(), this.arrayTransformer = new Rr(), this.unionTransformer = new Vr(), this.discriminatedUnionTransformer = new Ir(), this.intersectionTransformer = new Cr(), this.recordTransformer = new Mr(), this.tupleTransformer = new Lr(e);
+  }
+  transform(e, t, n, s, a) {
+    if (x(e, "ZodNull"))
+      return this.versionSpecifics.nullType;
+    if (x(e, "ZodUnknown") || x(e, "ZodAny"))
+      return this.versionSpecifics.mapNullableType(void 0, t);
+    if (x(e, "ZodObject"))
+      return this.objectTransformer.transform(
+        e,
+        a,
+        // verified on TS level from input
+        // verified on TS level from input
+        (o) => this.versionSpecifics.mapNullableType(o, t),
+        n
+      );
+    const i = this.transformSchemaWithoutDefault(e, t, n, s);
+    return Object.assign(Object.assign({}, i), { default: a });
+  }
+  transformSchemaWithoutDefault(e, t, n, s) {
+    if (x(e, "ZodUnknown") || x(e, "ZodAny"))
+      return this.versionSpecifics.mapNullableType(void 0, t);
+    if (x(e, "ZodString"))
+      return this.stringTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t));
+    if (x(e, "ZodNumber"))
+      return this.numberTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t), (i) => this.versionSpecifics.getNumberChecks(i));
+    if (x(e, "ZodBigInt"))
+      return this.bigIntTransformer.transform((i) => this.versionSpecifics.mapNullableType(i, t));
+    if (x(e, "ZodBoolean"))
+      return this.versionSpecifics.mapNullableType("boolean", t);
+    if (x(e, "ZodLiteral"))
+      return this.literalTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t));
+    if (x(e, "ZodEnum"))
+      return this.enumTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t));
+    if (x(e, "ZodNativeEnum"))
+      return this.nativeEnumTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t));
+    if (x(e, "ZodArray"))
+      return this.arrayTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t), n);
+    if (x(e, "ZodTuple"))
+      return this.tupleTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t), n);
+    if (x(e, "ZodUnion"))
+      return this.unionTransformer.transform(e, (i) => this.versionSpecifics.mapNullableOfArray(i, t), n);
+    if (x(e, "ZodDiscriminatedUnion"))
+      return this.discriminatedUnionTransformer.transform(e, t, (i) => this.versionSpecifics.mapNullableOfArray(i, t), n, s);
+    if (x(e, "ZodIntersection"))
+      return this.intersectionTransformer.transform(e, t, (i) => this.versionSpecifics.mapNullableOfArray(i, t), n);
+    if (x(e, "ZodRecord"))
+      return this.recordTransformer.transform(e, (i) => this.versionSpecifics.mapNullableType(i, t), n);
+    if (x(e, "ZodDate"))
+      return this.versionSpecifics.mapNullableType("string", t);
+    const a = I.getRefId(e);
+    throw new jr({
+      currentSchema: e._def,
+      schemaName: a
+    });
+  }
+}
+class Jt {
+  constructor(e, t) {
+    this.definitions = e, this.versionSpecifics = t, this.schemaRefs = {}, this.paramRefs = {}, this.pathRefs = {}, this.rawComponents = [], this.openApiTransformer = new Ur(t), this.sortDefinitions();
+  }
+  generateDocumentData() {
+    return this.definitions.forEach((e) => this.generateSingle(e)), {
+      components: this.buildComponents(),
+      paths: this.pathRefs
+    };
+  }
+  generateComponents() {
+    return this.definitions.forEach((e) => this.generateSingle(e)), {
+      components: this.buildComponents()
+    };
+  }
+  buildComponents() {
+    var e, t;
+    const n = {};
+    return this.rawComponents.forEach(({ componentType: s, name: a, component: i }) => {
+      var o;
+      (o = n[s]) !== null && o !== void 0 || (n[s] = {}), n[s][a] = i;
+    }), Object.assign(Object.assign({}, n), { schemas: Object.assign(Object.assign({}, (e = n.schemas) !== null && e !== void 0 ? e : {}), this.schemaRefs), parameters: Object.assign(Object.assign({}, (t = n.parameters) !== null && t !== void 0 ? t : {}), this.paramRefs) });
+  }
+  sortDefinitions() {
+    const e = [
+      "schema",
+      "parameter",
+      "component",
+      "route"
+    ];
+    this.definitions.sort((t, n) => {
+      if (!("type" in t))
+        return "type" in n ? -1 : 0;
+      if (!("type" in n))
+        return 1;
+      const s = e.findIndex((i) => i === t.type), a = e.findIndex((i) => i === n.type);
+      return s - a;
+    });
+  }
+  generateSingle(e) {
+    if (!("type" in e)) {
+      this.generateSchemaWithRef(e);
+      return;
+    }
+    switch (e.type) {
+      case "parameter":
+        this.generateParameterDefinition(e.schema);
+        return;
+      case "schema":
+        this.generateSchemaWithRef(e.schema);
+        return;
+      case "route":
+        this.generateSingleRoute(e.route);
+        return;
+      case "component":
+        this.rawComponents.push(e);
+        return;
+    }
+  }
+  generateParameterDefinition(e) {
+    const t = I.getRefId(e), n = this.generateParameter(e);
+    return t && (this.paramRefs[t] = n), n;
+  }
+  getParameterRef(e, t) {
+    var n, s, a, i, o;
+    const c = (n = e == null ? void 0 : e.metadata) === null || n === void 0 ? void 0 : n.param, u = !((s = e == null ? void 0 : e._internal) === null || s === void 0) && s.refId ? this.paramRefs[(a = e._internal) === null || a === void 0 ? void 0 : a.refId] : void 0;
+    if (!(!(!((i = e == null ? void 0 : e._internal) === null || i === void 0) && i.refId) || !u)) {
+      if (c && u.in !== c.in || t != null && t.in && u.in !== t.in)
+        throw new Ce(`Conflicting location for parameter ${u.name}`, {
+          key: "in",
+          values: Lt([
+            u.in,
+            t == null ? void 0 : t.in,
+            c == null ? void 0 : c.in
+          ])
+        });
+      if (c && u.name !== c.name || t != null && t.name && u.name !== (t == null ? void 0 : t.name))
+        throw new Ce("Conflicting names for parameter", {
+          key: "name",
+          values: Lt([
+            u.name,
+            t == null ? void 0 : t.name,
+            c == null ? void 0 : c.name
+          ])
+        });
+      return {
+        $ref: `#/components/parameters/${(o = e._internal) === null || o === void 0 ? void 0 : o.refId}`
+      };
+    }
+  }
+  generateInlineParameters(e, t) {
+    var n;
+    const s = I.getMetadata(e), a = (n = s == null ? void 0 : s.metadata) === null || n === void 0 ? void 0 : n.param, i = this.getParameterRef(s, { in: t });
+    if (i)
+      return [i];
+    if (x(e, "ZodObject")) {
+      const o = e._def.shape();
+      return Object.entries(o).map(([u, d]) => {
+        var f, k;
+        const E = I.getMetadata(d), R = this.getParameterRef(E, {
+          in: t,
+          name: u
+        });
+        if (R)
+          return R;
+        const b = (f = E == null ? void 0 : E.metadata) === null || f === void 0 ? void 0 : f.param;
+        if (b != null && b.name && b.name !== u)
+          throw new Ce("Conflicting names for parameter", {
+            key: "name",
+            values: [u, b.name]
+          });
+        if (b != null && b.in && b.in !== t)
+          throw new Ce(`Conflicting location for parameter ${(k = b.name) !== null && k !== void 0 ? k : u}`, {
+            key: "in",
+            values: [t, b.in]
+          });
+        return this.generateParameter(d.openapi({ param: { name: u, in: t } }));
+      });
+    }
+    if (a != null && a.in && a.in !== t)
+      throw new Ce(`Conflicting location for parameter ${a.name}`, {
+        key: "in",
+        values: [t, a.in]
+      });
+    return [
+      this.generateParameter(e.openapi({ param: { in: t } }))
+    ];
+  }
+  generateSimpleParameter(e) {
+    var t;
+    const n = I.getParamMetadata(e), s = (t = n == null ? void 0 : n.metadata) === null || t === void 0 ? void 0 : t.param, a = !I.isOptionalSchema(e) && !e.isNullable(), i = this.generateSchemaWithRef(e);
+    return Object.assign({
+      schema: i,
+      required: a
+    }, s ? I.buildParameterMetadata(s) : {});
+  }
+  generateParameter(e) {
+    var t;
+    const n = I.getMetadata(e), s = (t = n == null ? void 0 : n.metadata) === null || t === void 0 ? void 0 : t.param, a = s == null ? void 0 : s.name, i = s == null ? void 0 : s.in;
+    if (!a)
+      throw new lt({ missingField: "name" });
+    if (!i)
+      throw new lt({
+        missingField: "in",
+        paramName: a
+      });
+    const o = this.generateSimpleParameter(e);
+    return Object.assign(Object.assign({}, o), { in: i, name: a });
+  }
+  generateSchemaWithMetadata(e) {
+    var t;
+    const n = I.unwrapChained(e), s = I.getMetadata(e), a = I.getDefaultValue(e), i = !((t = s == null ? void 0 : s.metadata) === null || t === void 0) && t.type ? { type: s == null ? void 0 : s.metadata.type } : this.toOpenAPISchema(n, e.isNullable(), a);
+    return s != null && s.metadata ? I.applySchemaMetadata(i, s.metadata) : xe(i, Me);
+  }
+  /**
+   * Same as above but applies nullable
+   */
+  constructReferencedOpenAPISchema(e) {
+    var t;
+    const n = I.getMetadata(e), s = I.unwrapChained(e), a = I.getDefaultValue(e), i = e.isNullable();
+    return !((t = n == null ? void 0 : n.metadata) === null || t === void 0) && t.type ? this.versionSpecifics.mapNullableType(n.metadata.type, i) : this.toOpenAPISchema(s, i, a);
+  }
+  /**
+   * Generates an OpenAPI SchemaObject or a ReferenceObject with all the provided metadata applied
+   */
+  generateSimpleSchema(e) {
+    var t;
+    const n = I.getMetadata(e), s = I.getRefId(e);
+    if (!s || !this.schemaRefs[s])
+      return this.generateSchemaWithMetadata(e);
+    const a = this.schemaRefs[s], i = {
+      $ref: this.generateSchemaRef(s)
+    }, o = xe(I.buildSchemaMetadata((t = n == null ? void 0 : n.metadata) !== null && t !== void 0 ? t : {}), (d, f) => d === void 0 || It(d, a[f]));
+    if (o.type)
+      return {
+        allOf: [i, o]
+      };
+    const c = xe(this.constructReferencedOpenAPISchema(e), (d, f) => d === void 0 || It(d, a[f])), u = I.applySchemaMetadata(c, o);
+    return Object.keys(u).length > 0 ? {
+      allOf: [i, u]
+    } : i;
+  }
+  /**
+   * Same as `generateSchema` but if the new schema is added into the
+   * referenced schemas, it would return a ReferenceObject and not the
+   * whole result.
+   *
+   * Should be used for nested objects, arrays, etc.
+   */
+  generateSchemaWithRef(e) {
+    const t = I.getRefId(e), n = this.generateSimpleSchema(e);
+    return t && this.schemaRefs[t] === void 0 ? (this.schemaRefs[t] = n, { $ref: this.generateSchemaRef(t) }) : n;
+  }
+  generateSchemaRef(e) {
+    return `#/components/schemas/${e}`;
+  }
+  getRequestBody(e) {
+    if (!e)
+      return;
+    const { content: t } = e, n = Se(e, ["content"]), s = this.getBodyContent(t);
+    return Object.assign(Object.assign({}, n), { content: s });
+  }
+  getParameters(e) {
+    if (!e)
+      return [];
+    const { headers: t } = e, n = this.cleanParameter(e.query), s = this.cleanParameter(e.params), a = this.cleanParameter(e.cookies), i = Ze(() => n ? this.generateInlineParameters(n, "query") : [], { location: "query" }), o = Ze(() => s ? this.generateInlineParameters(s, "path") : [], { location: "path" }), c = Ze(() => a ? this.generateInlineParameters(a, "cookie") : [], { location: "cookie" }), u = Ze(() => {
+      if (Array.isArray(t))
+        return t.flatMap((f) => this.generateInlineParameters(f, "header"));
+      const d = this.cleanParameter(t);
+      return d ? this.generateInlineParameters(d, "header") : [];
+    }, { location: "header" });
+    return [
+      ...o,
+      ...i,
+      ...u,
+      ...c
+    ];
+  }
+  cleanParameter(e) {
+    if (e)
+      return x(e, "ZodEffects") ? this.cleanParameter(e._def.schema) : e;
+  }
+  generatePath(e) {
+    const { method: t, path: n, request: s, responses: a } = e, i = Se(e, ["method", "path", "request", "responses"]), o = $e(a, (f) => this.getResponse(f)), c = Ze(() => this.getParameters(s), { route: `${t} ${n}` }), u = this.getRequestBody(s == null ? void 0 : s.body);
+    return {
+      [t]: Object.assign(Object.assign(Object.assign(Object.assign({}, i), c.length > 0 ? {
+        parameters: [...i.parameters || [], ...c]
+      } : {}), u ? { requestBody: u } : {}), { responses: o })
+    };
+  }
+  generateSingleRoute(e) {
+    const t = this.generatePath(e);
+    return this.pathRefs[e.path] = Object.assign(Object.assign({}, this.pathRefs[e.path]), t), t;
+  }
+  getResponse(e) {
+    var { content: t, headers: n } = e, s = Se(e, ["content", "headers"]);
+    const a = t ? { content: this.getBodyContent(t) } : {};
+    if (!n)
+      return Object.assign(Object.assign({}, s), a);
+    const i = x(n, "ZodObject") ? this.getResponseHeaders(n) : (
+      // This is input data so it is okay to cast in the common generator
+      // since this is the user's responsibility to keep it correct
+      n
+    );
+    return Object.assign(Object.assign(Object.assign({}, s), { headers: i }), a);
+  }
+  getResponseHeaders(e) {
+    const t = e._def.shape();
+    return $e(t, (s) => this.generateSimpleParameter(s));
+  }
+  getBodyContent(e) {
+    return $e(e, (t) => {
+      if (!t || !br(t.schema))
+        return t;
+      const { schema: n } = t, s = Se(t, ["schema"]), a = this.generateSchemaWithRef(n);
+      return Object.assign({ schema: a }, s);
+    });
+  }
+  toOpenAPISchema(e, t, n) {
+    return this.openApiTransformer.transform(e, t, (s) => this.generateSchemaWithRef(s), (s) => this.generateSchemaRef(s), n);
+  }
+}
+class Hr {
+  get nullType() {
+    return { nullable: !0 };
+  }
+  mapNullableOfArray(e, t) {
+    return t ? [...e, this.nullType] : e;
+  }
+  mapNullableType(e, t) {
+    return Object.assign(Object.assign({}, e ? { type: e } : void 0), t ? this.nullType : void 0);
+  }
+  mapTupleItems(e) {
+    const t = kr(e);
+    return {
+      items: t.length === 1 ? t[0] : { anyOf: t },
+      minItems: e.length,
+      maxItems: e.length
+    };
+  }
+  getNumberChecks(e) {
+    return Object.assign({}, ...e.map((t) => {
+      switch (t.kind) {
+        case "min":
+          return t.inclusive ? { minimum: Number(t.value) } : { minimum: Number(t.value), exclusiveMinimum: !0 };
+        case "max":
+          return t.inclusive ? { maximum: Number(t.value) } : { maximum: Number(t.value), exclusiveMaximum: !0 };
+        default:
+          return {};
+      }
+    }));
+  }
+}
+class qr {
+  constructor(e) {
+    const t = new Hr();
+    this.generator = new Jt(e, t);
+  }
+  generateDocument(e) {
+    const t = this.generator.generateDocumentData();
+    return Object.assign(Object.assign({}, e), t);
+  }
+  generateComponents() {
+    return this.generator.generateComponents();
+  }
+}
+class Br {
+  get nullType() {
+    return { type: "null" };
+  }
+  mapNullableOfArray(e, t) {
+    return t ? [...e, this.nullType] : e;
+  }
+  mapNullableType(e, t) {
+    return e ? t ? {
+      type: Array.isArray(e) ? [...e, "null"] : [e, "null"]
+    } : {
+      type: e
+    } : {};
+  }
+  mapTupleItems(e) {
+    return {
+      prefixItems: e
+    };
+  }
+  getNumberChecks(e) {
+    return Object.assign({}, ...e.map((t) => {
+      switch (t.kind) {
+        case "min":
+          return t.inclusive ? { minimum: Number(t.value) } : { exclusiveMinimum: Number(t.value) };
+        case "max":
+          return t.inclusive ? { maximum: Number(t.value) } : { exclusiveMaximum: Number(t.value) };
+        default:
+          return {};
+      }
+    }));
+  }
+}
+function Wr(r) {
+  return "type" in r && r.type === "webhook";
+}
+class Fr {
+  constructor(e) {
+    this.definitions = e, this.webhookRefs = {};
+    const t = new Br();
+    this.generator = new Jt(this.definitions, t);
+  }
+  generateDocument(e) {
+    const t = this.generator.generateDocumentData();
+    return this.definitions.filter(Wr).forEach((n) => this.generateSingleWebhook(n.webhook)), Object.assign(Object.assign(Object.assign({}, e), t), { webhooks: this.webhookRefs });
+  }
+  generateComponents() {
+    return this.generator.generateComponents();
+  }
+  generateSingleWebhook(e) {
+    const t = this.generator.generatePath(e);
+    return this.webhookRefs[e.path] = Object.assign(Object.assign({}, this.webhookRefs[e.path]), t), t;
+  }
+}
+var Yt = (r) => {
+  const e = r.split("/");
+  return e[0] === "" && e.shift(), e;
+}, Gr = (r) => {
+  const { groups: e, path: t } = Kr(r), n = Yt(t);
+  return Jr(n, e);
+}, Kr = (r) => {
+  const e = [];
+  return r = r.replace(/\{[^}]+\}/g, (t, n) => {
+    const s = `@${n}`;
+    return e.push([s, t]), s;
+  }), { groups: e, path: r };
+}, Jr = (r, e) => {
+  for (let t = e.length - 1; t >= 0; t--) {
+    const [n] = e[t];
+    for (let s = r.length - 1; s >= 0; s--)
+      if (r[s].includes(n)) {
+        r[s] = r[s].replace(n, e[t][1]);
+        break;
+      }
+  }
+  return r;
+}, ot = {}, Vt = (r) => {
+  if (r === "*")
+    return "*";
+  const e = r.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  return e ? (ot[r] || (e[2] ? ot[r] = [r, e[1], new RegExp("^" + e[2] + "$")] : ot[r] = [r, e[1], !0]), ot[r]) : null;
+}, Yr = (r) => {
+  try {
+    return decodeURI(r);
+  } catch {
+    return r.replace(/(?:%[0-9A-Fa-f]{2})+/g, (e) => {
+      try {
+        return decodeURI(e);
+      } catch {
+        return e;
+      }
+    });
+  }
+}, Xt = (r) => {
+  const e = r.url, t = e.indexOf("/", 8);
+  let n = t;
+  for (; n < e.length; n++) {
+    const s = e.charCodeAt(n);
+    if (s === 37) {
+      const a = e.indexOf("?", n), i = e.slice(t, a === -1 ? void 0 : a);
+      return Yr(i.includes("%25") ? i.replace(/%25/g, "%2525") : i);
+    } else if (s === 63)
+      break;
+  }
+  return e.slice(t, n);
+}, Xr = (r) => {
+  const e = Xt(r);
+  return e.length > 1 && e[e.length - 1] === "/" ? e.slice(0, -1) : e;
+}, le = (...r) => {
+  let e = "", t = !1;
+  for (let n of r)
+    e[e.length - 1] === "/" && (e = e.slice(0, -1), t = !0), n[0] !== "/" && (n = `/${n}`), n === "/" && t ? e = `${e}/` : n !== "/" && (e = `${e}${n}`), n === "/" && e === "" && (e = "/");
+  return e;
+}, Qt = (r) => {
+  if (!r.match(/\:.+\?$/))
+    return null;
+  const e = r.split("/"), t = [];
+  let n = "";
+  return e.forEach((s) => {
+    if (s !== "" && !/\:/.test(s))
+      n += "/" + s;
+    else if (/\:/.test(s))
+      if (/\?/.test(s)) {
+        t.length === 0 && n === "" ? t.push("/") : t.push(n);
+        const a = s.replace("?", "");
+        n += "/" + a, t.push(n);
+      } else
+        n += "/" + s;
+  }), t.filter((s, a, i) => i.indexOf(s) === a);
+}, Tt = (r) => /[%+]/.test(r) ? (r.indexOf("+") !== -1 && (r = r.replace(/\+/g, " ")), /%/.test(r) ? ft(r) : r) : r, zt = (r, e, t) => {
+  let n;
+  if (!t && e && !/[%+]/.test(e)) {
+    let i = r.indexOf(`?${e}`, 8);
+    for (i === -1 && (i = r.indexOf(`&${e}`, 8)); i !== -1; ) {
+      const o = r.charCodeAt(i + e.length + 1);
+      if (o === 61) {
+        const c = i + e.length + 2, u = r.indexOf("&", c);
+        return Tt(r.slice(c, u === -1 ? void 0 : u));
+      } else if (o == 38 || isNaN(o))
+        return "";
+      i = r.indexOf(`&${e}`, i + 1);
+    }
+    if (n = /[%+]/.test(r), !n)
+      return;
+  }
+  const s = {};
+  n ?? (n = /[%+]/.test(r));
+  let a = r.indexOf("?", 8);
+  for (; a !== -1; ) {
+    const i = r.indexOf("&", a + 1);
+    let o = r.indexOf("=", a);
+    o > i && i !== -1 && (o = -1);
+    let c = r.slice(
+      a + 1,
+      o === -1 ? i === -1 ? void 0 : i : o
+    );
+    if (n && (c = Tt(c)), a = i, c === "")
+      continue;
+    let u;
+    o === -1 ? u = "" : (u = r.slice(o + 1, i === -1 ? void 0 : i), n && (u = Tt(u))), t ? (s[c] && Array.isArray(s[c]) || (s[c] = []), s[c].push(u)) : s[c] ?? (s[c] = u);
+  }
+  return e ? s[e] : s;
+}, Qr = zt, zr = (r, e) => zt(r, e, !0), ft = decodeURIComponent, en = /^[\w!#$%&'*.^`|~+-]+$/, tn = /^[ !#-:<-[\]-~]*$/, rn = (r, e) => r.trim().split(";").reduce((n, s) => {
+  s = s.trim();
+  const a = s.indexOf("=");
+  if (a === -1)
+    return n;
+  const i = s.substring(0, a).trim();
+  if (!en.test(i))
+    return n;
+  let o = s.substring(a + 1).trim();
+  return o.startsWith('"') && o.endsWith('"') && (o = o.slice(1, -1)), tn.test(o) && (n[i] = ft(o)), n;
+}, {}), nn = (r, e, t) => {
+  const n = r.req.raw.headers.get("Cookie");
+  return n ? rn(n) : {};
+}, jt = class extends Error {
+  constructor(e = 500, t) {
+    super(t == null ? void 0 : t.message, { cause: t == null ? void 0 : t.cause });
+    p(this, "res");
+    p(this, "status");
+    this.res = t == null ? void 0 : t.res, this.status = e;
+  }
+  getResponse() {
+    return this.res ? new Response(this.res.body, {
+      status: this.status,
+      headers: this.res.headers
+    }) : new Response(this.message, {
+      status: this.status
+    });
+  }
+}, sn = (r, e) => new Response(r, {
+  headers: {
+    "Content-Type": e
+  }
+}).formData(), an = (r, e) => async (t, n) => {
+  let s = {};
+  const a = t.req.header("Content-Type");
+  switch (r) {
+    case "json":
+      if (!a || !/^application\/([a-z-\.]+\+)?json/.test(a)) {
+        const o = `Invalid HTTP header: Content-Type=${a}`;
+        throw new jt(400, { message: o });
+      }
+      try {
+        s = await t.req.json();
+      } catch {
+        const o = "Malformed JSON in request body";
+        throw new jt(400, { message: o });
+      }
+      break;
+    case "form": {
+      if (!a)
+        break;
+      if (t.req.bodyCache.formData) {
+        s = await t.req.bodyCache.formData;
+        break;
+      }
+      try {
+        const o = await t.req.arrayBuffer(), c = await sn(o, a), u = {};
+        c.forEach((d, f) => {
+          f.endsWith("[]") ? u[f] === void 0 ? u[f] = [d] : Array.isArray(u[f]) && u[f].push(d) : u[f] = d;
+        }), s = u, t.req.bodyCache.formData = c;
+      } catch (o) {
+        let c = "Malformed FormData request.";
+        throw c += o instanceof Error ? ` ${o.message}` : ` ${String(o)}`, new jt(400, { message: c });
+      }
+      break;
+    }
+    case "query":
+      s = Object.fromEntries(
+        Object.entries(t.req.queries()).map(([o, c]) => c.length === 1 ? [o, c[0]] : [o, c])
+      );
+      break;
+    case "param":
+      s = t.req.param();
+      break;
+    case "header":
+      s = t.req.header();
+      break;
+    case "cookie":
+      s = nn(t);
+      break;
+  }
+  const i = await e(s, t);
+  if (i instanceof Response)
+    return i;
+  t.req.addValidatedData(r, i), await n();
+};
+const ye = (r, e, t) => (
+  // @ts-expect-error not typed well
+  an(r, async (n, s) => {
+    const a = await e.safeParseAsync(n);
+    if (t) {
+      const i = await t({ data: n, ...a }, s);
+      if (i) {
+        if (i instanceof Response)
+          return i;
+        if ("response" in i)
+          return i.response;
+      }
+    }
+    return a.success ? a.data : s.json(a, 400);
+  })
+);
+var on = async (r, e = /* @__PURE__ */ Object.create(null)) => {
+  const { all: t = !1, dot: n = !1 } = e, a = (r instanceof er ? r.raw.headers : r.headers).get("Content-Type");
+  return a !== null && a.startsWith("multipart/form-data") || a !== null && a.startsWith("application/x-www-form-urlencoded") ? cn(r, { all: t, dot: n }) : {};
+};
+async function cn(r, e) {
+  const t = await r.formData();
+  return t ? un(t, e) : {};
+}
+function un(r, e) {
+  const t = /* @__PURE__ */ Object.create(null);
+  return r.forEach((n, s) => {
+    e.all || s.endsWith("[]") ? dn(t, s, n) : t[s] = n;
+  }), e.dot && Object.entries(t).forEach(([n, s]) => {
+    n.includes(".") && (ln(t, n, s), delete t[n]);
+  }), t;
+}
+var dn = (r, e, t) => {
+  r[e] !== void 0 ? Array.isArray(r[e]) ? r[e].push(t) : r[e] = [r[e], t] : r[e] = t;
+}, ln = (r, e, t) => {
+  let n = r;
+  const s = e.split(".");
+  s.forEach((a, i) => {
+    i === s.length - 1 ? n[a] = t : ((!n[a] || typeof n[a] != "object" || Array.isArray(n[a]) || n[a] instanceof File) && (n[a] = /* @__PURE__ */ Object.create(null)), n = n[a]);
+  });
+}, ke, U, Wt, er = (Wt = class {
+  constructor(r, e = "/", t = [[]]) {
+    p(this, "raw");
+    N(this, ke);
+    N(this, U);
+    p(this, "routeIndex", 0);
+    p(this, "path");
+    p(this, "bodyCache", {});
+    p(this, "cachedBody", (r) => {
+      const { bodyCache: e, raw: t } = this, n = e[r];
+      if (n)
+        return n;
+      const s = Object.keys(e)[0];
+      return s ? e[s].then((a) => (s === "json" && (a = JSON.stringify(a)), new Response(a)[r]())) : e[r] = t[r]();
+    });
+    this.raw = r, this.path = e, T(this, U, t), T(this, ke, {});
+  }
+  param(r) {
+    return r ? this.getDecodedParam(r) : this.getAllDecodedParams();
+  }
+  getDecodedParam(r) {
+    const e = h(this, U)[0][this.routeIndex][1][r], t = this.getParamValue(e);
+    return t ? /\%/.test(t) ? ft(t) : t : void 0;
+  }
+  getAllDecodedParams() {
+    const r = {}, e = Object.keys(h(this, U)[0][this.routeIndex][1]);
+    for (const t of e) {
+      const n = this.getParamValue(h(this, U)[0][this.routeIndex][1][t]);
+      n && typeof n == "string" && (r[t] = /\%/.test(n) ? ft(n) : n);
+    }
+    return r;
+  }
+  getParamValue(r) {
+    return h(this, U)[1] ? h(this, U)[1][r] : r;
+  }
+  query(r) {
+    return Qr(this.url, r);
+  }
+  queries(r) {
+    return zr(this.url, r);
+  }
+  header(r) {
+    if (r)
+      return this.raw.headers.get(r.toLowerCase()) ?? void 0;
+    const e = {};
+    return this.raw.headers.forEach((t, n) => {
+      e[n] = t;
+    }), e;
+  }
+  async parseBody(r) {
+    var e;
+    return (e = this.bodyCache).parsedBody ?? (e.parsedBody = await on(this, r));
+  }
+  json() {
+    return this.cachedBody("json");
+  }
+  text() {
+    return this.cachedBody("text");
+  }
+  arrayBuffer() {
+    return this.cachedBody("arrayBuffer");
+  }
+  blob() {
+    return this.cachedBody("blob");
+  }
+  formData() {
+    return this.cachedBody("formData");
+  }
+  addValidatedData(r, e) {
+    h(this, ke)[r] = e;
+  }
+  valid(r) {
+    return h(this, ke)[r];
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get matchedRoutes() {
+    return h(this, U)[0].map(([[, r]]) => r);
+  }
+  get routePath() {
+    return h(this, U)[0].map(([[, r]]) => r)[this.routeIndex].path;
+  }
+}, ke = new WeakMap(), U = new WeakMap(), Wt), fn = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+}, tr = async (r, e, t, n, s) => {
+  const a = r.callbacks;
+  return a != null && a.length ? (s ? s[0] += r : s = [r], Promise.all(a.map((o) => o({ phase: e, buffer: s, context: n }))).then(
+    (o) => Promise.all(
+      o.filter(Boolean).map((c) => tr(c, e, !1, n, s))
+    ).then(() => s[0])
+  )) : Promise.resolve(r);
+}, hn = "text/plain; charset=UTF-8", Rt = (r, e = {}) => (Object.entries(e).forEach(([t, n]) => r.set(t, n)), r), tt, rt, ae, fe, ee, P, Z, H, te, nt, Te, je, st, at, Ft, ct = (Ft = class {
+  constructor(r, e) {
+    N(this, tt);
+    N(this, rt);
+    p(this, "env", {});
+    N(this, ae);
+    p(this, "finalized", !1);
+    p(this, "error");
+    N(this, fe, 200);
+    N(this, ee);
+    N(this, P);
+    N(this, Z);
+    N(this, H);
+    N(this, te, !0);
+    N(this, nt);
+    N(this, Te);
+    N(this, je);
+    N(this, st);
+    N(this, at);
+    p(this, "render", (...r) => (h(this, Te) ?? T(this, Te, (e) => this.html(e)), h(this, Te).call(this, ...r)));
+    p(this, "setLayout", (r) => T(this, nt, r));
+    p(this, "getLayout", () => h(this, nt));
+    p(this, "setRenderer", (r) => {
+      T(this, Te, r);
+    });
+    p(this, "header", (r, e, t) => {
+      if (e === void 0) {
+        h(this, P) ? h(this, P).delete(r) : h(this, Z) && delete h(this, Z)[r.toLocaleLowerCase()], this.finalized && this.res.headers.delete(r);
+        return;
+      }
+      t != null && t.append ? (h(this, P) || (T(this, te, !1), T(this, P, new Headers(h(this, Z))), T(this, Z, {})), h(this, P).append(r, e)) : h(this, P) ? h(this, P).set(r, e) : (h(this, Z) ?? T(this, Z, {}), h(this, Z)[r.toLowerCase()] = e), this.finalized && (t != null && t.append ? this.res.headers.append(r, e) : this.res.headers.set(r, e));
+    });
+    p(this, "status", (r) => {
+      T(this, te, !1), T(this, fe, r);
+    });
+    p(this, "set", (r, e) => {
+      h(this, ae) ?? T(this, ae, {}), h(this, ae)[r] = e;
+    });
+    p(this, "get", (r) => h(this, ae) ? h(this, ae)[r] : void 0);
+    p(this, "newResponse", (r, e, t) => {
+      if (h(this, te) && !t && !e && h(this, fe) === 200)
+        return new Response(r, {
+          headers: h(this, Z)
+        });
+      if (e && typeof e != "number") {
+        const s = new Headers(e.headers);
+        h(this, P) && h(this, P).forEach((i, o) => {
+          o === "set-cookie" ? s.append(o, i) : s.set(o, i);
+        });
+        const a = Rt(s, h(this, Z));
+        return new Response(r, {
+          headers: a,
+          status: e.status ?? h(this, fe)
+        });
+      }
+      const n = typeof e == "number" ? e : h(this, fe);
+      h(this, Z) ?? T(this, Z, {}), h(this, P) ?? T(this, P, new Headers()), Rt(h(this, P), h(this, Z)), h(this, H) && (h(this, H).headers.forEach((s, a) => {
+        var i, o;
+        a === "set-cookie" ? (i = h(this, P)) == null || i.append(a, s) : (o = h(this, P)) == null || o.set(a, s);
+      }), Rt(h(this, P), h(this, Z))), t ?? (t = {});
+      for (const [s, a] of Object.entries(t))
+        if (typeof a == "string")
+          h(this, P).set(s, a);
+        else {
+          h(this, P).delete(s);
+          for (const i of a)
+            h(this, P).append(s, i);
+        }
+      return new Response(r, {
+        status: n,
+        headers: h(this, P)
+      });
+    });
+    p(this, "body", (r, e, t) => typeof e == "number" ? this.newResponse(r, e, t) : this.newResponse(r, e));
+    p(this, "text", (r, e, t) => {
+      if (!h(this, Z)) {
+        if (h(this, te) && !t && !e)
+          return new Response(r);
+        T(this, Z, {});
+      }
+      return h(this, Z)["content-type"] = hn, typeof e == "number" ? this.newResponse(r, e, t) : this.newResponse(r, e);
+    });
+    p(this, "json", (r, e, t) => {
+      const n = JSON.stringify(r);
+      return h(this, Z) ?? T(this, Z, {}), h(this, Z)["content-type"] = "application/json; charset=UTF-8", typeof e == "number" ? this.newResponse(n, e, t) : this.newResponse(n, e);
+    });
+    p(this, "html", (r, e, t) => (h(this, Z) ?? T(this, Z, {}), h(this, Z)["content-type"] = "text/html; charset=UTF-8", typeof r == "object" && (r instanceof Promise || (r = r.toString()), r instanceof Promise) ? r.then((n) => tr(n, fn.Stringify, !1, {})).then((n) => typeof e == "number" ? this.newResponse(n, e, t) : this.newResponse(n, e)) : typeof e == "number" ? this.newResponse(r, e, t) : this.newResponse(r, e)));
+    p(this, "redirect", (r, e) => (h(this, P) ?? T(this, P, new Headers()), h(this, P).set("Location", r), this.newResponse(null, e ?? 302)));
+    p(this, "notFound", () => (h(this, je) ?? T(this, je, () => new Response()), h(this, je).call(this, this)));
+    T(this, tt, r), e && (T(this, ee, e.executionCtx), this.env = e.env, T(this, je, e.notFoundHandler), T(this, at, e.path), T(this, st, e.matchResult));
+  }
+  get req() {
+    return h(this, rt) ?? T(this, rt, new er(h(this, tt), h(this, at), h(this, st))), h(this, rt);
+  }
+  get event() {
+    if (h(this, ee) && "respondWith" in h(this, ee))
+      return h(this, ee);
+    throw Error("This context has no FetchEvent");
+  }
+  get executionCtx() {
+    if (h(this, ee))
+      return h(this, ee);
+    throw Error("This context has no ExecutionContext");
+  }
+  get res() {
+    return T(this, te, !1), h(this, H) || T(this, H, new Response("404 Not Found", { status: 404 }));
+  }
+  set res(r) {
+    if (T(this, te, !1), h(this, H) && r) {
+      h(this, H).headers.delete("content-type");
+      for (const [e, t] of h(this, H).headers.entries())
+        if (e === "set-cookie") {
+          const n = h(this, H).headers.getSetCookie();
+          r.headers.delete("set-cookie");
+          for (const s of n)
+            r.headers.append("set-cookie", s);
+        } else
+          r.headers.set(e, t);
+    }
+    T(this, H, r), this.finalized = !0;
+  }
+  get var() {
+    return { ...h(this, ae) };
+  }
+}, tt = new WeakMap(), rt = new WeakMap(), ae = new WeakMap(), fe = new WeakMap(), ee = new WeakMap(), P = new WeakMap(), Z = new WeakMap(), H = new WeakMap(), te = new WeakMap(), nt = new WeakMap(), Te = new WeakMap(), je = new WeakMap(), st = new WeakMap(), at = new WeakMap(), Ft), Ut = (r, e, t) => (n, s) => {
+  let a = -1;
+  return i(0);
+  async function i(o) {
+    if (o <= a)
+      throw new Error("next() called multiple times");
+    a = o;
+    let c, u = !1, d;
+    if (r[o] ? (d = r[o][0][0], n instanceof ct && (n.req.routeIndex = o)) : d = o === r.length && s || void 0, !d)
+      n instanceof ct && n.finalized === !1 && t && (c = await t(n));
+    else
+      try {
+        c = await d(n, () => i(o + 1));
+      } catch (f) {
+        if (f instanceof Error && n instanceof ct && e)
+          n.error = f, c = await e(f, n), u = !0;
+        else
+          throw f;
+      }
+    return c && (n.finalized === !1 || u) && (n.res = c), n;
+  }
+}, A = "ALL", pn = "all", mn = ["get", "post", "put", "delete", "options", "patch"], rr = "Can not add a route since the matcher is already built.", nr = class extends Error {
+}, gn = Symbol("composedHandler"), vn = (r) => r.text("404 Not Found", 404), Ht = (r, e) => "getResponse" in r ? r.getResponse() : (console.error(r), e.text("Internal Server Error", 500)), q, Gt, sr = (Gt = class {
+  constructor(e = {}) {
+    p(this, "get");
+    p(this, "post");
+    p(this, "put");
+    p(this, "delete");
+    p(this, "options");
+    p(this, "patch");
+    p(this, "all");
+    p(this, "on");
+    p(this, "use");
+    p(this, "router");
+    p(this, "getPath");
+    p(this, "_basePath", "/");
+    N(this, q, "/");
+    p(this, "routes", []);
+    p(this, "notFoundHandler", vn);
+    p(this, "errorHandler", Ht);
+    p(this, "onError", (e) => (this.errorHandler = e, this));
+    p(this, "notFound", (e) => (this.notFoundHandler = e, this));
+    p(this, "fetch", (e, ...t) => this.dispatch(e, t[1], t[0], e.method));
+    p(this, "request", (e, t, n, s) => {
+      if (e instanceof Request)
+        return t !== void 0 && (e = new Request(e, t)), this.fetch(e, n, s);
+      e = e.toString();
+      const a = /^https?:\/\//.test(e) ? e : `http://localhost${le("/", e)}`, i = new Request(a, t);
+      return this.fetch(i, n, s);
+    });
+    p(this, "fire", () => {
+      addEventListener("fetch", (e) => {
+        e.respondWith(this.dispatch(e.request, e, void 0, e.request.method));
+      });
+    });
+    [...mn, pn].forEach((s) => {
+      this[s] = (a, ...i) => (typeof a == "string" ? T(this, q, a) : this.addRoute(s, h(this, q), a), i.forEach((o) => {
+        typeof o != "string" && this.addRoute(s, h(this, q), o);
+      }), this);
+    }), this.on = (s, a, ...i) => {
+      for (const o of [a].flat()) {
+        T(this, q, o);
+        for (const c of [s].flat())
+          i.map((u) => {
+            this.addRoute(c.toUpperCase(), h(this, q), u);
+          });
+      }
+      return this;
+    }, this.use = (s, ...a) => (typeof s == "string" ? T(this, q, s) : (T(this, q, "*"), a.unshift(s)), a.forEach((i) => {
+      this.addRoute(A, h(this, q), i);
+    }), this);
+    const n = e.strict ?? !0;
+    delete e.strict, Object.assign(this, e), this.getPath = n ? e.getPath ?? Xt : Xr;
+  }
+  clone() {
+    const e = new sr({
+      router: this.router,
+      getPath: this.getPath
+    });
+    return e.routes = this.routes, e;
+  }
+  route(e, t) {
+    const n = this.basePath(e);
+    return t.routes.map((s) => {
+      let a;
+      t.errorHandler === Ht ? a = s.handler : (a = async (i, o) => (await Ut([], t.errorHandler)(i, () => s.handler(i, o))).res, a[gn] = s.handler), n.addRoute(s.method, s.path, a);
+    }), this;
+  }
+  basePath(e) {
+    const t = this.clone();
+    return t._basePath = le(this._basePath, e), t;
+  }
+  mount(e, t, n) {
+    let s, a;
+    n && (typeof n == "function" ? a = n : (a = n.optionHandler, s = n.replaceRequest));
+    const i = a ? (c) => {
+      const u = a(c);
+      return Array.isArray(u) ? u : [u];
+    } : (c) => {
+      let u;
+      try {
+        u = c.executionCtx;
+      } catch {
+      }
+      return [c.env, u];
+    };
+    s || (s = (() => {
+      const c = le(this._basePath, e), u = c === "/" ? 0 : c.length;
+      return (d) => {
+        const f = new URL(d.url);
+        return f.pathname = f.pathname.slice(u) || "/", new Request(f, d);
+      };
+    })());
+    const o = async (c, u) => {
+      const d = await t(s(c.req.raw), ...i(c));
+      if (d)
+        return d;
+      await u();
+    };
+    return this.addRoute(A, le(e, "*"), o), this;
+  }
+  addRoute(e, t, n) {
+    e = e.toUpperCase(), t = le(this._basePath, t);
+    const s = { path: t, method: e, handler: n };
+    this.router.add(e, t, [n, s]), this.routes.push(s);
+  }
+  matchRoute(e, t) {
+    return this.router.match(e, t);
+  }
+  handleError(e, t) {
+    if (e instanceof Error)
+      return this.errorHandler(e, t);
+    throw e;
+  }
+  dispatch(e, t, n, s) {
+    if (s === "HEAD")
+      return (async () => new Response(null, await this.dispatch(e, t, n, "GET")))();
+    const a = this.getPath(e, { env: n }), i = this.matchRoute(s, a), o = new ct(e, {
+      path: a,
+      matchResult: i,
+      env: n,
+      executionCtx: t,
+      notFoundHandler: this.notFoundHandler
+    });
+    if (i[0].length === 1) {
+      let u;
+      try {
+        u = i[0][0][0][0](o, async () => {
+          o.res = await this.notFoundHandler(o);
+        });
+      } catch (d) {
+        return this.handleError(d, o);
+      }
+      return u instanceof Promise ? u.then(
+        (d) => d || (o.finalized ? o.res : this.notFoundHandler(o))
+      ).catch((d) => this.handleError(d, o)) : u ?? this.notFoundHandler(o);
+    }
+    const c = Ut(i[0], this.errorHandler, this.notFoundHandler);
+    return (async () => {
+      try {
+        const u = await c(o);
+        if (!u.finalized)
+          throw new Error(
+            "Context is not finalized. Did you forget to return a Response object or `await next()`?"
+          );
+        return u.res;
+      } catch (u) {
+        return this.handleError(u, o);
+      }
+    })();
+  }
+}, q = new WeakMap(), Gt), ht = "[^/]+", Le = ".*", Ve = "(?:|/.*)", Ae = Symbol(), yn = new Set(".\\+*[^]$()");
+function _n(r, e) {
+  return r.length === 1 ? e.length === 1 ? r < e ? -1 : 1 : -1 : e.length === 1 || r === Le || r === Ve ? 1 : e === Le || e === Ve ? -1 : r === ht ? 1 : e === ht ? -1 : r.length === e.length ? r < e ? -1 : 1 : e.length - r.length;
+}
+var Pt = class {
+  constructor() {
+    p(this, "index");
+    p(this, "varIndex");
+    p(this, "children", /* @__PURE__ */ Object.create(null));
+  }
+  insert(e, t, n, s, a) {
+    if (e.length === 0) {
+      if (this.index !== void 0)
+        throw Ae;
+      if (a)
+        return;
+      this.index = t;
+      return;
+    }
+    const [i, ...o] = e, c = i === "*" ? o.length === 0 ? ["", "", Le] : ["", "", ht] : i === "/*" ? ["", "", Ve] : i.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let u;
+    if (c) {
+      const d = c[1];
+      let f = c[2] || ht;
+      if (d && c[2] && (f = f.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:"), /\((?!\?:)/.test(f)))
+        throw Ae;
+      if (u = this.children[f], !u) {
+        if (Object.keys(this.children).some(
+          (k) => k !== Le && k !== Ve
+        ))
+          throw Ae;
+        if (a)
+          return;
+        u = this.children[f] = new Pt(), d !== "" && (u.varIndex = s.varIndex++);
+      }
+      !a && d !== "" && n.push([d, u.varIndex]);
+    } else if (u = this.children[i], !u) {
+      if (Object.keys(this.children).some(
+        (d) => d.length > 1 && d !== Le && d !== Ve
+      ))
+        throw Ae;
+      if (a)
+        return;
+      u = this.children[i] = new Pt();
+    }
+    u.insert(o, t, n, s, a);
+  }
+  buildRegExpStr() {
+    const t = Object.keys(this.children).sort(_n).map((n) => {
+      const s = this.children[n];
+      return (typeof s.varIndex == "number" ? `(${n})@${s.varIndex}` : yn.has(n) ? `\\${n}` : n) + s.buildRegExpStr();
+    });
+    return typeof this.index == "number" && t.unshift(`#${this.index}`), t.length === 0 ? "" : t.length === 1 ? t[0] : "(?:" + t.join("|") + ")";
+  }
+}, bn = class {
+  constructor() {
+    p(this, "context", { varIndex: 0 });
+    p(this, "root", new Pt());
+  }
+  insert(r, e, t) {
+    const n = [], s = [];
+    for (let i = 0; ; ) {
+      let o = !1;
+      if (r = r.replace(/\{[^}]+\}/g, (c) => {
+        const u = `@\\${i}`;
+        return s[i] = [u, c], i++, o = !0, u;
+      }), !o)
+        break;
+    }
+    const a = r.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = s.length - 1; i >= 0; i--) {
+      const [o] = s[i];
+      for (let c = a.length - 1; c >= 0; c--)
+        if (a[c].indexOf(o) !== -1) {
+          a[c] = a[c].replace(o, s[i][1]);
+          break;
+        }
+    }
+    return this.root.insert(a, e, n, this.context, t), n;
+  }
+  buildRegExp() {
+    let r = this.root.buildRegExpStr();
+    if (r === "")
+      return [/^$/, [], []];
+    let e = 0;
+    const t = [], n = [];
+    return r = r.replace(/#(\d+)|@(\d+)|\.\*\$/g, (s, a, i) => typeof a < "u" ? (t[++e] = Number(a), "$()") : (typeof i < "u" && (n[Number(i)] = ++e), "")), [new RegExp(`^${r}`), t, n];
+  }
+}, ar = [], wn = [/^$/, [], /* @__PURE__ */ Object.create(null)], ut = /* @__PURE__ */ Object.create(null);
+function ir(r) {
+  return ut[r] ?? (ut[r] = new RegExp(
+    r === "*" ? "" : `^${r.replace(
+      /\/\*$|([.\\+*[^\]$()])/g,
+      (e, t) => t ? `\\${t}` : "(?:|/.*)"
+    )}$`
+  ));
+}
+function xn() {
+  ut = /* @__PURE__ */ Object.create(null);
+}
+function On(r) {
+  var u;
+  const e = new bn(), t = [];
+  if (r.length === 0)
+    return wn;
+  const n = r.map(
+    (d) => [!/\*|\/:/.test(d[0]), ...d]
+  ).sort(
+    ([d, f], [k, E]) => d ? 1 : k ? -1 : f.length - E.length
+  ), s = /* @__PURE__ */ Object.create(null);
+  for (let d = 0, f = -1, k = n.length; d < k; d++) {
+    const [E, R, b] = n[d];
+    E ? s[R] = [b.map(([D]) => [D, /* @__PURE__ */ Object.create(null)]), ar] : f++;
+    let S;
+    try {
+      S = e.insert(R, f, E);
+    } catch (D) {
+      throw D === Ae ? new nr(R) : D;
+    }
+    E || (t[f] = b.map(([D, G]) => {
+      const V = /* @__PURE__ */ Object.create(null);
+      for (G -= 1; G >= 0; G--) {
+        const [ge, ne] = S[G];
+        V[ge] = ne;
+      }
+      return [D, V];
+    }));
+  }
+  const [a, i, o] = e.buildRegExp();
+  for (let d = 0, f = t.length; d < f; d++)
+    for (let k = 0, E = t[d].length; k < E; k++) {
+      const R = (u = t[d][k]) == null ? void 0 : u[1];
+      if (!R)
+        continue;
+      const b = Object.keys(R);
+      for (let S = 0, D = b.length; S < D; S++)
+        R[b[S]] = o[R[b[S]]];
+    }
+  const c = [];
+  for (const d in i)
+    c[d] = t[i[d]];
+  return [a, c, s];
+}
+function _e(r, e) {
+  if (r) {
+    for (const t of Object.keys(r).sort((n, s) => s.length - n.length))
+      if (ir(t).test(e))
+        return [...r[t]];
+  }
+}
+var kn = class {
+  constructor() {
+    p(this, "name", "RegExpRouter");
+    p(this, "middleware");
+    p(this, "routes");
+    this.middleware = { [A]: /* @__PURE__ */ Object.create(null) }, this.routes = { [A]: /* @__PURE__ */ Object.create(null) };
+  }
+  add(r, e, t) {
+    var o;
+    const { middleware: n, routes: s } = this;
+    if (!n || !s)
+      throw new Error(rr);
+    n[r] || [n, s].forEach((c) => {
+      c[r] = /* @__PURE__ */ Object.create(null), Object.keys(c[A]).forEach((u) => {
+        c[r][u] = [...c[A][u]];
+      });
+    }), e === "/*" && (e = "*");
+    const a = (e.match(/\/:/g) || []).length;
+    if (/\*$/.test(e)) {
+      const c = ir(e);
+      r === A ? Object.keys(n).forEach((u) => {
+        var d;
+        (d = n[u])[e] || (d[e] = _e(n[u], e) || _e(n[A], e) || []);
+      }) : (o = n[r])[e] || (o[e] = _e(n[r], e) || _e(n[A], e) || []), Object.keys(n).forEach((u) => {
+        (r === A || r === u) && Object.keys(n[u]).forEach((d) => {
+          c.test(d) && n[u][d].push([t, a]);
+        });
+      }), Object.keys(s).forEach((u) => {
+        (r === A || r === u) && Object.keys(s[u]).forEach(
+          (d) => c.test(d) && s[u][d].push([t, a])
+        );
+      });
+      return;
+    }
+    const i = Qt(e) || [e];
+    for (let c = 0, u = i.length; c < u; c++) {
+      const d = i[c];
+      Object.keys(s).forEach((f) => {
+        var k;
+        (r === A || r === f) && ((k = s[f])[d] || (k[d] = [
+          ..._e(n[f], d) || _e(n[A], d) || []
+        ]), s[f][d].push([t, a - u + c + 1]));
+      });
+    }
+  }
+  match(r, e) {
+    xn();
+    const t = this.buildAllMatchers();
+    return this.match = (n, s) => {
+      const a = t[n] || t[A], i = a[2][s];
+      if (i)
+        return i;
+      const o = s.match(a[0]);
+      if (!o)
+        return [[], ar];
+      const c = o.indexOf("", 1);
+      return [a[1][c], o];
+    }, this.match(r, e);
+  }
+  buildAllMatchers() {
+    const r = /* @__PURE__ */ Object.create(null);
+    return [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((e) => {
+      r[e] || (r[e] = this.buildMatcher(e));
+    }), this.middleware = this.routes = void 0, r;
+  }
+  buildMatcher(r) {
+    const e = [];
+    let t = r === A;
+    return [this.middleware, this.routes].forEach((n) => {
+      const s = n[r] ? Object.keys(n[r]).map((a) => [a, n[r][a]]) : [];
+      s.length !== 0 ? (t || (t = !0), e.push(...s)) : r !== A && e.push(
+        ...Object.keys(n[A]).map((a) => [a, n[A][a]])
+      );
+    }), t ? On(e) : null;
+  }
+}, Tn = class {
+  constructor(r) {
+    p(this, "name", "SmartRouter");
+    p(this, "routers", []);
+    p(this, "routes", []);
+    Object.assign(this, r);
+  }
+  add(r, e, t) {
+    if (!this.routes)
+      throw new Error(rr);
+    this.routes.push([r, e, t]);
+  }
+  match(r, e) {
+    if (!this.routes)
+      throw new Error("Fatal error");
+    const { routers: t, routes: n } = this, s = t.length;
+    let a = 0, i;
+    for (; a < s; a++) {
+      const o = t[a];
+      try {
+        n.forEach((c) => {
+          o.add(...c);
+        }), i = o.match(r, e);
+      } catch (c) {
+        if (c instanceof nr)
+          continue;
+        throw c;
+      }
+      this.match = o.match.bind(o), this.routers = [o], this.routes = void 0;
+      break;
+    }
+    if (a === s)
+      throw new Error("Fatal error");
+    return this.name = `SmartRouter + ${this.activeRouter.name}`, i;
+  }
+  get activeRouter() {
+    if (this.routes || this.routers.length !== 1)
+      throw new Error("No active router has been determined yet.");
+    return this.routers[0];
+  }
+}, or = class {
+  constructor(r, e, t) {
+    p(this, "methods");
+    p(this, "children");
+    p(this, "patterns");
+    p(this, "order", 0);
+    p(this, "name");
+    p(this, "params", /* @__PURE__ */ Object.create(null));
+    if (this.children = t || /* @__PURE__ */ Object.create(null), this.methods = [], this.name = "", r && e) {
+      const n = /* @__PURE__ */ Object.create(null);
+      n[r] = { handler: e, possibleKeys: [], score: 0, name: this.name }, this.methods = [n];
+    }
+    this.patterns = [];
+  }
+  insert(r, e, t) {
+    this.name = `${r} ${e}`, this.order = ++this.order;
+    let n = this;
+    const s = Gr(e), a = [];
+    for (let c = 0, u = s.length; c < u; c++) {
+      const d = s[c];
+      if (Object.keys(n.children).includes(d)) {
+        n = n.children[d];
+        const k = Vt(d);
+        k && a.push(k[1]);
+        continue;
+      }
+      n.children[d] = new or();
+      const f = Vt(d);
+      f && (n.patterns.push(f), a.push(f[1])), n = n.children[d];
+    }
+    n.methods.length || (n.methods = []);
+    const i = /* @__PURE__ */ Object.create(null), o = {
+      handler: t,
+      possibleKeys: a.filter((c, u, d) => d.indexOf(c) === u),
+      name: this.name,
+      score: this.order
+    };
+    return i[r] = o, n.methods.push(i), n;
+  }
+  gHSets(r, e, t, n) {
+    const s = [];
+    for (let a = 0, i = r.methods.length; a < i; a++) {
+      const o = r.methods[a], c = o[e] || o[A], u = /* @__PURE__ */ Object.create(null);
+      c !== void 0 && (c.params = /* @__PURE__ */ Object.create(null), c.possibleKeys.forEach((d) => {
+        const f = u[c.name];
+        c.params[d] = n[d] && !f ? n[d] : t[d] ?? n[d], u[c.name] = !0;
+      }), s.push(c));
+    }
+    return s;
+  }
+  search(r, e) {
+    const t = [];
+    this.params = /* @__PURE__ */ Object.create(null);
+    let s = [this];
+    const a = Yt(e);
+    for (let o = 0, c = a.length; o < c; o++) {
+      const u = a[o], d = o === c - 1, f = [];
+      for (let k = 0, E = s.length; k < E; k++) {
+        const R = s[k], b = R.children[u];
+        b && (b.params = R.params, d === !0 ? (b.children["*"] && t.push(
+          ...this.gHSets(b.children["*"], r, R.params, /* @__PURE__ */ Object.create(null))
+        ), t.push(...this.gHSets(b, r, R.params, /* @__PURE__ */ Object.create(null)))) : f.push(b));
+        for (let S = 0, D = R.patterns.length; S < D; S++) {
+          const G = R.patterns[S], V = { ...R.params };
+          if (G === "*") {
+            const de = R.children["*"];
+            de && (t.push(...this.gHSets(de, r, R.params, /* @__PURE__ */ Object.create(null))), f.push(de));
+            continue;
+          }
+          if (u === "")
+            continue;
+          const [ge, ne, Q] = G, K = R.children[ge], ve = a.slice(o).join("/");
+          if (Q instanceof RegExp && Q.test(ve)) {
+            V[ne] = ve, t.push(...this.gHSets(K, r, R.params, V));
+            continue;
+          }
+          (Q === !0 || Q instanceof RegExp && Q.test(u)) && typeof ge == "string" && (V[ne] = u, d === !0 ? (t.push(...this.gHSets(K, r, V, R.params)), K.children["*"] && t.push(...this.gHSets(K.children["*"], r, V, R.params))) : (K.params = V, f.push(K)));
+        }
+      }
+      s = f;
+    }
+    return [t.sort((o, c) => o.score - c.score).map(({ handler: o, params: c }) => [o, c])];
+  }
+}, jn = class {
+  constructor() {
+    p(this, "name", "TrieRouter");
+    p(this, "node");
+    this.node = new or();
+  }
+  add(r, e, t) {
+    const n = Qt(e);
+    if (n) {
+      for (const s of n)
+        this.node.insert(r, s, t);
+      return;
+    }
+    this.node.insert(r, e, t);
+  }
+  match(r, e) {
+    return this.node.search(r, e);
+  }
+}, Rn = class extends sr {
+  constructor(r = {}) {
+    super(r), this.router = r.router ?? new Tn({
+      routers: [new kn(), new jn()]
+    });
+  }
+}, j;
+(function(r) {
+  r.assertEqual = (s) => s;
+  function e(s) {
+  }
+  r.assertIs = e;
+  function t(s) {
+    throw new Error();
+  }
+  r.assertNever = t, r.arrayToEnum = (s) => {
+    const a = {};
+    for (const i of s)
+      a[i] = i;
+    return a;
+  }, r.getValidEnumValues = (s) => {
+    const a = r.objectKeys(s).filter((o) => typeof s[s[o]] != "number"), i = {};
+    for (const o of a)
+      i[o] = s[o];
+    return r.objectValues(i);
+  }, r.objectValues = (s) => r.objectKeys(s).map(function(a) {
+    return s[a];
+  }), r.objectKeys = typeof Object.keys == "function" ? (s) => Object.keys(s) : (s) => {
+    const a = [];
+    for (const i in s)
+      Object.prototype.hasOwnProperty.call(s, i) && a.push(i);
+    return a;
+  }, r.find = (s, a) => {
+    for (const i of s)
+      if (a(i))
+        return i;
+  }, r.isInteger = typeof Number.isInteger == "function" ? (s) => Number.isInteger(s) : (s) => typeof s == "number" && isFinite(s) && Math.floor(s) === s;
+  function n(s, a = " | ") {
+    return s.map((i) => typeof i == "string" ? `'${i}'` : i).join(a);
+  }
+  r.joinValues = n, r.jsonStringifyReplacer = (s, a) => typeof a == "bigint" ? a.toString() : a;
+})(j || (j = {}));
+var Ct;
+(function(r) {
+  r.mergeShapes = (e, t) => ({
+    ...e,
+    ...t
+    // second overwrites first
+  });
+})(Ct || (Ct = {}));
+const g = j.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]), se = (r) => {
+  switch (typeof r) {
+    case "undefined":
+      return g.undefined;
+    case "string":
+      return g.string;
+    case "number":
+      return isNaN(r) ? g.nan : g.number;
+    case "boolean":
+      return g.boolean;
+    case "function":
+      return g.function;
+    case "bigint":
+      return g.bigint;
+    case "symbol":
+      return g.symbol;
+    case "object":
+      return Array.isArray(r) ? g.array : r === null ? g.null : r.then && typeof r.then == "function" && r.catch && typeof r.catch == "function" ? g.promise : typeof Map < "u" && r instanceof Map ? g.map : typeof Set < "u" && r instanceof Set ? g.set : typeof Date < "u" && r instanceof Date ? g.date : g.object;
+    default:
+      return g.unknown;
+  }
+}, l = j.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",
+  "not_finite"
+]), En = (r) => JSON.stringify(r, null, 2).replace(/"([^"]+)":/g, "$1:");
+class L extends Error {
+  constructor(e) {
+    super(), this.issues = [], this.addIssue = (n) => {
+      this.issues = [...this.issues, n];
+    }, this.addIssues = (n = []) => {
+      this.issues = [...this.issues, ...n];
+    };
+    const t = new.target.prototype;
+    Object.setPrototypeOf ? Object.setPrototypeOf(this, t) : this.__proto__ = t, this.name = "ZodError", this.issues = e;
+  }
+  get errors() {
+    return this.issues;
+  }
+  format(e) {
+    const t = e || function(a) {
+      return a.message;
+    }, n = { _errors: [] }, s = (a) => {
+      for (const i of a.issues)
+        if (i.code === "invalid_union")
+          i.unionErrors.map(s);
+        else if (i.code === "invalid_return_type")
+          s(i.returnTypeError);
+        else if (i.code === "invalid_arguments")
+          s(i.argumentsError);
+        else if (i.path.length === 0)
+          n._errors.push(t(i));
+        else {
+          let o = n, c = 0;
+          for (; c < i.path.length; ) {
+            const u = i.path[c];
+            c === i.path.length - 1 ? (o[u] = o[u] || { _errors: [] }, o[u]._errors.push(t(i))) : o[u] = o[u] || { _errors: [] }, o = o[u], c++;
+          }
+        }
+    };
+    return s(this), n;
+  }
+  static assert(e) {
+    if (!(e instanceof L))
+      throw new Error(`Not a ZodError: ${e}`);
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, j.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(e = (t) => t.message) {
+    const t = {}, n = [];
+    for (const s of this.issues)
+      s.path.length > 0 ? (t[s.path[0]] = t[s.path[0]] || [], t[s.path[0]].push(e(s))) : n.push(e(s));
+    return { formErrors: n, fieldErrors: t };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+}
+L.create = (r) => new L(r);
+const Re = (r, e) => {
+  let t;
+  switch (r.code) {
+    case l.invalid_type:
+      r.received === g.undefined ? t = "Required" : t = `Expected ${r.expected}, received ${r.received}`;
+      break;
+    case l.invalid_literal:
+      t = `Invalid literal value, expected ${JSON.stringify(r.expected, j.jsonStringifyReplacer)}`;
+      break;
+    case l.unrecognized_keys:
+      t = `Unrecognized key(s) in object: ${j.joinValues(r.keys, ", ")}`;
+      break;
+    case l.invalid_union:
+      t = "Invalid input";
+      break;
+    case l.invalid_union_discriminator:
+      t = `Invalid discriminator value. Expected ${j.joinValues(r.options)}`;
+      break;
+    case l.invalid_enum_value:
+      t = `Invalid enum value. Expected ${j.joinValues(r.options)}, received '${r.received}'`;
+      break;
+    case l.invalid_arguments:
+      t = "Invalid function arguments";
+      break;
+    case l.invalid_return_type:
+      t = "Invalid function return type";
+      break;
+    case l.invalid_date:
+      t = "Invalid date";
+      break;
+    case l.invalid_string:
+      typeof r.validation == "object" ? "includes" in r.validation ? (t = `Invalid input: must include "${r.validation.includes}"`, typeof r.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${r.validation.position}`)) : "startsWith" in r.validation ? t = `Invalid input: must start with "${r.validation.startsWith}"` : "endsWith" in r.validation ? t = `Invalid input: must end with "${r.validation.endsWith}"` : j.assertNever(r.validation) : r.validation !== "regex" ? t = `Invalid ${r.validation}` : t = "Invalid";
+      break;
+    case l.too_small:
+      r.type === "array" ? t = `Array must contain ${r.exact ? "exactly" : r.inclusive ? "at least" : "more than"} ${r.minimum} element(s)` : r.type === "string" ? t = `String must contain ${r.exact ? "exactly" : r.inclusive ? "at least" : "over"} ${r.minimum} character(s)` : r.type === "number" ? t = `Number must be ${r.exact ? "exactly equal to " : r.inclusive ? "greater than or equal to " : "greater than "}${r.minimum}` : r.type === "date" ? t = `Date must be ${r.exact ? "exactly equal to " : r.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(r.minimum))}` : t = "Invalid input";
+      break;
+    case l.too_big:
+      r.type === "array" ? t = `Array must contain ${r.exact ? "exactly" : r.inclusive ? "at most" : "less than"} ${r.maximum} element(s)` : r.type === "string" ? t = `String must contain ${r.exact ? "exactly" : r.inclusive ? "at most" : "under"} ${r.maximum} character(s)` : r.type === "number" ? t = `Number must be ${r.exact ? "exactly" : r.inclusive ? "less than or equal to" : "less than"} ${r.maximum}` : r.type === "bigint" ? t = `BigInt must be ${r.exact ? "exactly" : r.inclusive ? "less than or equal to" : "less than"} ${r.maximum}` : r.type === "date" ? t = `Date must be ${r.exact ? "exactly" : r.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(r.maximum))}` : t = "Invalid input";
+      break;
+    case l.custom:
+      t = "Invalid input";
+      break;
+    case l.invalid_intersection_types:
+      t = "Intersection results could not be merged";
+      break;
+    case l.not_multiple_of:
+      t = `Number must be a multiple of ${r.multipleOf}`;
+      break;
+    case l.not_finite:
+      t = "Number must be finite";
+      break;
+    default:
+      t = e.defaultError, j.assertNever(r);
+  }
+  return { message: t };
+};
+let cr = Re;
+function In(r) {
+  cr = r;
+}
+function pt() {
+  return cr;
+}
+const mt = (r) => {
+  const { data: e, path: t, errorMaps: n, issueData: s } = r, a = [...t, ...s.path || []], i = {
+    ...s,
+    path: a
+  };
+  if (s.message !== void 0)
+    return {
+      ...s,
+      path: a,
+      message: s.message
+    };
+  let o = "";
+  const c = n.filter((u) => !!u).slice().reverse();
+  for (const u of c)
+    o = u(i, { data: e, defaultError: o }).message;
+  return {
+    ...s,
+    path: a,
+    message: o
+  };
+}, Pn = [];
+function m(r, e) {
+  const t = pt(), n = mt({
+    issueData: e,
+    data: r.data,
+    path: r.path,
+    errorMaps: [
+      r.common.contextualErrorMap,
+      r.schemaErrorMap,
+      t,
+      t === Re ? void 0 : Re
+      // then global default map
+    ].filter((s) => !!s)
+  });
+  r.common.issues.push(n);
+}
+class M {
+  constructor() {
+    this.value = "valid";
+  }
+  dirty() {
+    this.value === "valid" && (this.value = "dirty");
+  }
+  abort() {
+    this.value !== "aborted" && (this.value = "aborted");
+  }
+  static mergeArray(e, t) {
+    const n = [];
+    for (const s of t) {
+      if (s.status === "aborted")
+        return _;
+      s.status === "dirty" && e.dirty(), n.push(s.value);
+    }
+    return { status: e.value, value: n };
+  }
+  static async mergeObjectAsync(e, t) {
+    const n = [];
+    for (const s of t) {
+      const a = await s.key, i = await s.value;
+      n.push({
+        key: a,
+        value: i
+      });
+    }
+    return M.mergeObjectSync(e, n);
+  }
+  static mergeObjectSync(e, t) {
+    const n = {};
+    for (const s of t) {
+      const { key: a, value: i } = s;
+      if (a.status === "aborted" || i.status === "aborted")
+        return _;
+      a.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), a.value !== "__proto__" && (typeof i.value < "u" || s.alwaysSet) && (n[a.value] = i.value);
+    }
+    return { status: e.value, value: n };
+  }
+}
+const _ = Object.freeze({
+  status: "aborted"
+}), we = (r) => ({ status: "dirty", value: r }), $ = (r) => ({ status: "valid", value: r }), Zt = (r) => r.status === "aborted", St = (r) => r.status === "dirty", Ue = (r) => r.status === "valid", He = (r) => typeof Promise < "u" && r instanceof Promise;
+function gt(r, e, t, n) {
+  if (typeof e == "function" ? r !== e || !n : !e.has(r)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return e.get(r);
+}
+function ur(r, e, t, n, s) {
+  if (typeof e == "function" ? r !== e || !s : !e.has(r)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return e.set(r, t), t;
+}
+var v;
+(function(r) {
+  r.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, r.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+})(v || (v = {}));
+var Ne, De;
+class Y {
+  constructor(e, t, n, s) {
+    this._cachedPath = [], this.parent = e, this.data = t, this._path = n, this._key = s;
+  }
+  get path() {
+    return this._cachedPath.length || (this._key instanceof Array ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+  }
+}
+const qt = (r, e) => {
+  if (Ue(e))
+    return { success: !0, data: e.value };
+  if (!r.common.issues.length)
+    throw new Error("Validation failed but no issues detected.");
+  return {
+    success: !1,
+    get error() {
+      if (this._error)
+        return this._error;
+      const t = new L(r.common.issues);
+      return this._error = t, this._error;
+    }
+  };
+};
+function w(r) {
+  if (!r)
+    return {};
+  const { errorMap: e, invalid_type_error: t, required_error: n, description: s } = r;
+  if (e && (t || n))
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+  return e ? { errorMap: e, description: s } : { errorMap: (i, o) => {
+    var c, u;
+    const { message: d } = r;
+    return i.code === "invalid_enum_value" ? { message: d ?? o.defaultError } : typeof o.data > "u" ? { message: (c = d ?? n) !== null && c !== void 0 ? c : o.defaultError } : i.code !== "invalid_type" ? { message: o.defaultError } : { message: (u = d ?? t) !== null && u !== void 0 ? u : o.defaultError };
+  }, description: s };
+}
+class O {
+  constructor(e) {
+    this.spa = this.safeParseAsync, this._def = e, 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.brand = this.brand.bind(this), this.default = this.default.bind(this), this.catch = this.catch.bind(this), this.describe = this.describe.bind(this), this.pipe = this.pipe.bind(this), this.readonly = this.readonly.bind(this), this.isNullable = this.isNullable.bind(this), this.isOptional = this.isOptional.bind(this);
+  }
+  get description() {
+    return this._def.description;
+  }
+  _getType(e) {
+    return se(e.data);
+  }
+  _getOrReturnCtx(e, t) {
+    return t || {
+      common: e.parent.common,
+      data: e.data,
+      parsedType: se(e.data),
+      schemaErrorMap: this._def.errorMap,
+      path: e.path,
+      parent: e.parent
+    };
+  }
+  _processInputParams(e) {
+    return {
+      status: new M(),
+      ctx: {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: se(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      }
+    };
+  }
+  _parseSync(e) {
+    const t = this._parse(e);
+    if (He(t))
+      throw new Error("Synchronous parse encountered promise.");
+    return t;
+  }
+  _parseAsync(e) {
+    const t = this._parse(e);
+    return Promise.resolve(t);
+  }
+  parse(e, t) {
+    const n = this.safeParse(e, t);
+    if (n.success)
+      return n.data;
+    throw n.error;
+  }
+  safeParse(e, t) {
+    var n;
+    const s = {
+      common: {
+        issues: [],
+        async: (n = t == null ? void 0 : t.async) !== null && n !== void 0 ? n : !1,
+        contextualErrorMap: t == null ? void 0 : t.errorMap
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: se(e)
+    }, a = this._parseSync({ data: e, path: s.path, parent: s });
+    return qt(s, a);
+  }
+  async parseAsync(e, t) {
+    const n = await this.safeParseAsync(e, t);
+    if (n.success)
+      return n.data;
+    throw n.error;
+  }
+  async safeParseAsync(e, t) {
+    const n = {
+      common: {
+        issues: [],
+        contextualErrorMap: t == null ? void 0 : t.errorMap,
+        async: !0
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: se(e)
+    }, s = this._parse({ data: e, path: n.path, parent: n }), a = await (He(s) ? s : Promise.resolve(s));
+    return qt(n, a);
+  }
+  refine(e, t) {
+    const n = (s) => typeof t == "string" || typeof t > "u" ? { message: t } : typeof t == "function" ? t(s) : t;
+    return this._refinement((s, a) => {
+      const i = e(s), o = () => a.addIssue({
+        code: l.custom,
+        ...n(s)
+      });
+      return typeof Promise < "u" && i instanceof Promise ? i.then((c) => c ? !0 : (o(), !1)) : i ? !0 : (o(), !1);
+    });
+  }
+  refinement(e, t) {
+    return this._refinement((n, s) => e(n) ? !0 : (s.addIssue(typeof t == "function" ? t(n, s) : t), !1));
+  }
+  _refinement(e) {
+    return new F({
+      schema: this,
+      typeName: y.ZodEffects,
+      effect: { type: "refinement", refinement: e }
+    });
+  }
+  superRefine(e) {
+    return this._refinement(e);
+  }
+  optional() {
+    return J.create(this, this._def);
+  }
+  nullable() {
+    return ue.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return W.create(this, this._def);
+  }
+  promise() {
+    return Ie.create(this, this._def);
+  }
+  or(e) {
+    return Fe.create([this, e], this._def);
+  }
+  and(e) {
+    return Ge.create(this, e, this._def);
+  }
+  transform(e) {
+    return new F({
+      ...w(this._def),
+      schema: this,
+      typeName: y.ZodEffects,
+      effect: { type: "transform", transform: e }
+    });
+  }
+  default(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new Qe({
+      ...w(this._def),
+      innerType: this,
+      defaultValue: t,
+      typeName: y.ZodDefault
+    });
+  }
+  brand() {
+    return new Dt({
+      typeName: y.ZodBranded,
+      type: this,
+      ...w(this._def)
+    });
+  }
+  catch(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new ze({
+      ...w(this._def),
+      innerType: this,
+      catchValue: t,
+      typeName: y.ZodCatch
+    });
+  }
+  describe(e) {
+    const t = this.constructor;
+    return new t({
+      ...this._def,
+      description: e
+    });
+  }
+  pipe(e) {
+    return it.create(this, e);
+  }
+  readonly() {
+    return et.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+}
+const Cn = /^c[^\s-]{8,}$/i, Zn = /^[0-9a-z]+$/, Sn = /^[0-9A-HJKMNP-TV-Z]{26}$/, An = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i, Nn = /^[a-z0-9_-]{21}$/i, Dn = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/, Mn = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, $n = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+let Et;
+const Ln = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, Vn = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/, Un = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, dr = "((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))", Hn = new RegExp(`^${dr}$`);
+function lr(r) {
+  let e = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
+  return r.precision ? e = `${e}\\.\\d{${r.precision}}` : r.precision == null && (e = `${e}(\\.\\d+)?`), e;
+}
+function qn(r) {
+  return new RegExp(`^${lr(r)}$`);
+}
+function fr(r) {
+  let e = `${dr}T${lr(r)}`;
+  const t = [];
+  return t.push(r.local ? "Z?" : "Z"), r.offset && t.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${t.join("|")})`, new RegExp(`^${e}$`);
+}
+function Bn(r, e) {
+  return !!((e === "v4" || !e) && Ln.test(r) || (e === "v6" || !e) && Vn.test(r));
+}
+class B extends O {
+  _parse(e) {
+    if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== g.string) {
+      const a = this._getOrReturnCtx(e);
+      return m(a, {
+        code: l.invalid_type,
+        expected: g.string,
+        received: a.parsedType
+      }), _;
+    }
+    const n = new M();
+    let s;
+    for (const a of this._def.checks)
+      if (a.kind === "min")
+        e.data.length < a.value && (s = this._getOrReturnCtx(e, s), m(s, {
+          code: l.too_small,
+          minimum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "max")
+        e.data.length > a.value && (s = this._getOrReturnCtx(e, s), m(s, {
+          code: l.too_big,
+          maximum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "length") {
+        const i = e.data.length > a.value, o = e.data.length < a.value;
+        (i || o) && (s = this._getOrReturnCtx(e, s), i ? m(s, {
+          code: l.too_big,
+          maximum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: a.message
+        }) : o && m(s, {
+          code: l.too_small,
+          minimum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: a.message
+        }), n.dirty());
+      } else if (a.kind === "email")
+        Mn.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+          validation: "email",
+          code: l.invalid_string,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "emoji")
+        Et || (Et = new RegExp($n, "u")), Et.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+          validation: "emoji",
+          code: l.invalid_string,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "uuid")
+        An.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+          validation: "uuid",
+          code: l.invalid_string,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "nanoid")
+        Nn.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+          validation: "nanoid",
+          code: l.invalid_string,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "cuid")
+        Cn.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+          validation: "cuid",
+          code: l.invalid_string,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "cuid2")
+        Zn.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+          validation: "cuid2",
+          code: l.invalid_string,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "ulid")
+        Sn.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+          validation: "ulid",
+          code: l.invalid_string,
+          message: a.message
+        }), n.dirty());
+      else if (a.kind === "url")
+        try {
+          new URL(e.data);
+        } catch {
+          s = this._getOrReturnCtx(e, s), m(s, {
+            validation: "url",
+            code: l.invalid_string,
+            message: a.message
+          }), n.dirty();
+        }
+      else a.kind === "regex" ? (a.regex.lastIndex = 0, a.regex.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+        validation: "regex",
+        code: l.invalid_string,
+        message: a.message
+      }), n.dirty())) : a.kind === "trim" ? e.data = e.data.trim() : a.kind === "includes" ? e.data.includes(a.value, a.position) || (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.invalid_string,
+        validation: { includes: a.value, position: a.position },
+        message: a.message
+      }), n.dirty()) : a.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : a.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : a.kind === "startsWith" ? e.data.startsWith(a.value) || (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.invalid_string,
+        validation: { startsWith: a.value },
+        message: a.message
+      }), n.dirty()) : a.kind === "endsWith" ? e.data.endsWith(a.value) || (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.invalid_string,
+        validation: { endsWith: a.value },
+        message: a.message
+      }), n.dirty()) : a.kind === "datetime" ? fr(a).test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.invalid_string,
+        validation: "datetime",
+        message: a.message
+      }), n.dirty()) : a.kind === "date" ? Hn.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.invalid_string,
+        validation: "date",
+        message: a.message
+      }), n.dirty()) : a.kind === "time" ? qn(a).test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.invalid_string,
+        validation: "time",
+        message: a.message
+      }), n.dirty()) : a.kind === "duration" ? Dn.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+        validation: "duration",
+        code: l.invalid_string,
+        message: a.message
+      }), n.dirty()) : a.kind === "ip" ? Bn(e.data, a.version) || (s = this._getOrReturnCtx(e, s), m(s, {
+        validation: "ip",
+        code: l.invalid_string,
+        message: a.message
+      }), n.dirty()) : a.kind === "base64" ? Un.test(e.data) || (s = this._getOrReturnCtx(e, s), m(s, {
+        validation: "base64",
+        code: l.invalid_string,
+        message: a.message
+      }), n.dirty()) : j.assertNever(a);
+    return { status: n.value, value: e.data };
+  }
+  _regex(e, t, n) {
+    return this.refinement((s) => e.test(s), {
+      validation: t,
+      code: l.invalid_string,
+      ...v.errToObj(n)
+    });
+  }
+  _addCheck(e) {
+    return new B({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  email(e) {
+    return this._addCheck({ kind: "email", ...v.errToObj(e) });
+  }
+  url(e) {
+    return this._addCheck({ kind: "url", ...v.errToObj(e) });
+  }
+  emoji(e) {
+    return this._addCheck({ kind: "emoji", ...v.errToObj(e) });
+  }
+  uuid(e) {
+    return this._addCheck({ kind: "uuid", ...v.errToObj(e) });
+  }
+  nanoid(e) {
+    return this._addCheck({ kind: "nanoid", ...v.errToObj(e) });
+  }
+  cuid(e) {
+    return this._addCheck({ kind: "cuid", ...v.errToObj(e) });
+  }
+  cuid2(e) {
+    return this._addCheck({ kind: "cuid2", ...v.errToObj(e) });
+  }
+  ulid(e) {
+    return this._addCheck({ kind: "ulid", ...v.errToObj(e) });
+  }
+  base64(e) {
+    return this._addCheck({ kind: "base64", ...v.errToObj(e) });
+  }
+  ip(e) {
+    return this._addCheck({ kind: "ip", ...v.errToObj(e) });
+  }
+  datetime(e) {
+    var t, n;
+    return typeof e == "string" ? this._addCheck({
+      kind: "datetime",
+      precision: null,
+      offset: !1,
+      local: !1,
+      message: e
+    }) : this._addCheck({
+      kind: "datetime",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      offset: (t = e == null ? void 0 : e.offset) !== null && t !== void 0 ? t : !1,
+      local: (n = e == null ? void 0 : e.local) !== null && n !== void 0 ? n : !1,
+      ...v.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  date(e) {
+    return this._addCheck({ kind: "date", message: e });
+  }
+  time(e) {
+    return typeof e == "string" ? this._addCheck({
+      kind: "time",
+      precision: null,
+      message: e
+    }) : this._addCheck({
+      kind: "time",
+      precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+      ...v.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  duration(e) {
+    return this._addCheck({ kind: "duration", ...v.errToObj(e) });
+  }
+  regex(e, t) {
+    return this._addCheck({
+      kind: "regex",
+      regex: e,
+      ...v.errToObj(t)
+    });
+  }
+  includes(e, t) {
+    return this._addCheck({
+      kind: "includes",
+      value: e,
+      position: t == null ? void 0 : t.position,
+      ...v.errToObj(t == null ? void 0 : t.message)
+    });
+  }
+  startsWith(e, t) {
+    return this._addCheck({
+      kind: "startsWith",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  endsWith(e, t) {
+    return this._addCheck({
+      kind: "endsWith",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  length(e, t) {
+    return this._addCheck({
+      kind: "length",
+      value: e,
+      ...v.errToObj(t)
+    });
+  }
+  /**
+   * @deprecated Use z.string().min(1) instead.
+   * @see {@link ZodString.min}
+   */
+  nonempty(e) {
+    return this.min(1, v.errToObj(e));
+  }
+  trim() {
+    return new B({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new B({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new B({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toUpperCase" }]
+    });
+  }
+  get isDatetime() {
+    return !!this._def.checks.find((e) => e.kind === "datetime");
+  }
+  get isDate() {
+    return !!this._def.checks.find((e) => e.kind === "date");
+  }
+  get isTime() {
+    return !!this._def.checks.find((e) => e.kind === "time");
+  }
+  get isDuration() {
+    return !!this._def.checks.find((e) => e.kind === "duration");
+  }
+  get isEmail() {
+    return !!this._def.checks.find((e) => e.kind === "email");
+  }
+  get isURL() {
+    return !!this._def.checks.find((e) => e.kind === "url");
+  }
+  get isEmoji() {
+    return !!this._def.checks.find((e) => e.kind === "emoji");
+  }
+  get isUUID() {
+    return !!this._def.checks.find((e) => e.kind === "uuid");
+  }
+  get isNANOID() {
+    return !!this._def.checks.find((e) => e.kind === "nanoid");
+  }
+  get isCUID() {
+    return !!this._def.checks.find((e) => e.kind === "cuid");
+  }
+  get isCUID2() {
+    return !!this._def.checks.find((e) => e.kind === "cuid2");
+  }
+  get isULID() {
+    return !!this._def.checks.find((e) => e.kind === "ulid");
+  }
+  get isIP() {
+    return !!this._def.checks.find((e) => e.kind === "ip");
+  }
+  get isBase64() {
+    return !!this._def.checks.find((e) => e.kind === "base64");
+  }
+  get minLength() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxLength() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+}
+B.create = (r) => {
+  var e;
+  return new B({
+    checks: [],
+    typeName: y.ZodString,
+    coerce: (e = r == null ? void 0 : r.coerce) !== null && e !== void 0 ? e : !1,
+    ...w(r)
+  });
+};
+function Wn(r, e) {
+  const t = (r.toString().split(".")[1] || "").length, n = (e.toString().split(".")[1] || "").length, s = t > n ? t : n, a = parseInt(r.toFixed(s).replace(".", "")), i = parseInt(e.toFixed(s).replace(".", ""));
+  return a % i / Math.pow(10, s);
+}
+class ie extends O {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf;
+  }
+  _parse(e) {
+    if (this._def.coerce && (e.data = Number(e.data)), this._getType(e) !== g.number) {
+      const a = this._getOrReturnCtx(e);
+      return m(a, {
+        code: l.invalid_type,
+        expected: g.number,
+        received: a.parsedType
+      }), _;
+    }
+    let n;
+    const s = new M();
+    for (const a of this._def.checks)
+      a.kind === "int" ? j.isInteger(e.data) || (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: a.message
+      }), s.dirty()) : a.kind === "min" ? (a.inclusive ? e.data < a.value : e.data <= a.value) && (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.too_small,
+        minimum: a.value,
+        type: "number",
+        inclusive: a.inclusive,
+        exact: !1,
+        message: a.message
+      }), s.dirty()) : a.kind === "max" ? (a.inclusive ? e.data > a.value : e.data >= a.value) && (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.too_big,
+        maximum: a.value,
+        type: "number",
+        inclusive: a.inclusive,
+        exact: !1,
+        message: a.message
+      }), s.dirty()) : a.kind === "multipleOf" ? Wn(e.data, a.value) !== 0 && (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.not_multiple_of,
+        multipleOf: a.value,
+        message: a.message
+      }), s.dirty()) : a.kind === "finite" ? Number.isFinite(e.data) || (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.not_finite,
+        message: a.message
+      }), s.dirty()) : j.assertNever(a);
+    return { status: s.value, value: e.data };
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, v.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, v.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, v.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, v.toString(t));
+  }
+  setLimit(e, t, n, s) {
+    return new ie({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: n,
+          message: v.toString(s)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new ie({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  int(e) {
+    return this._addCheck({
+      kind: "int",
+      message: v.toString(e)
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: v.toString(t)
+    });
+  }
+  finite(e) {
+    return this._addCheck({
+      kind: "finite",
+      message: v.toString(e)
+    });
+  }
+  safe(e) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: !0,
+      value: Number.MIN_SAFE_INTEGER,
+      message: v.toString(e)
+    })._addCheck({
+      kind: "max",
+      inclusive: !0,
+      value: Number.MAX_SAFE_INTEGER,
+      message: v.toString(e)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+  get isInt() {
+    return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && j.isInteger(e.value));
+  }
+  get isFinite() {
+    let e = null, t = null;
+    for (const n of this._def.checks) {
+      if (n.kind === "finite" || n.kind === "int" || n.kind === "multipleOf")
+        return !0;
+      n.kind === "min" ? (t === null || n.value > t) && (t = n.value) : n.kind === "max" && (e === null || n.value < e) && (e = n.value);
+    }
+    return Number.isFinite(t) && Number.isFinite(e);
+  }
+}
+ie.create = (r) => new ie({
+  checks: [],
+  typeName: y.ZodNumber,
+  coerce: (r == null ? void 0 : r.coerce) || !1,
+  ...w(r)
+});
+class oe extends O {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte;
+  }
+  _parse(e) {
+    if (this._def.coerce && (e.data = BigInt(e.data)), this._getType(e) !== g.bigint) {
+      const a = this._getOrReturnCtx(e);
+      return m(a, {
+        code: l.invalid_type,
+        expected: g.bigint,
+        received: a.parsedType
+      }), _;
+    }
+    let n;
+    const s = new M();
+    for (const a of this._def.checks)
+      a.kind === "min" ? (a.inclusive ? e.data < a.value : e.data <= a.value) && (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.too_small,
+        type: "bigint",
+        minimum: a.value,
+        inclusive: a.inclusive,
+        message: a.message
+      }), s.dirty()) : a.kind === "max" ? (a.inclusive ? e.data > a.value : e.data >= a.value) && (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.too_big,
+        type: "bigint",
+        maximum: a.value,
+        inclusive: a.inclusive,
+        message: a.message
+      }), s.dirty()) : a.kind === "multipleOf" ? e.data % a.value !== BigInt(0) && (n = this._getOrReturnCtx(e, n), m(n, {
+        code: l.not_multiple_of,
+        multipleOf: a.value,
+        message: a.message
+      }), s.dirty()) : j.assertNever(a);
+    return { status: s.value, value: e.data };
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, v.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, v.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, v.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, v.toString(t));
+  }
+  setLimit(e, t, n, s) {
+    return new oe({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: n,
+          message: v.toString(s)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new oe({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !1,
+      message: v.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !0,
+      message: v.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: v.toString(t)
+    });
+  }
+  get minValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e;
+  }
+  get maxValue() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e;
+  }
+}
+oe.create = (r) => {
+  var e;
+  return new oe({
+    checks: [],
+    typeName: y.ZodBigInt,
+    coerce: (e = r == null ? void 0 : r.coerce) !== null && e !== void 0 ? e : !1,
+    ...w(r)
+  });
+};
+class qe extends O {
+  _parse(e) {
+    if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== g.boolean) {
+      const n = this._getOrReturnCtx(e);
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.boolean,
+        received: n.parsedType
+      }), _;
+    }
+    return $(e.data);
+  }
+}
+qe.create = (r) => new qe({
+  typeName: y.ZodBoolean,
+  coerce: (r == null ? void 0 : r.coerce) || !1,
+  ...w(r)
+});
+class pe extends O {
+  _parse(e) {
+    if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== g.date) {
+      const a = this._getOrReturnCtx(e);
+      return m(a, {
+        code: l.invalid_type,
+        expected: g.date,
+        received: a.parsedType
+      }), _;
+    }
+    if (isNaN(e.data.getTime())) {
+      const a = this._getOrReturnCtx(e);
+      return m(a, {
+        code: l.invalid_date
+      }), _;
+    }
+    const n = new M();
+    let s;
+    for (const a of this._def.checks)
+      a.kind === "min" ? e.data.getTime() < a.value && (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.too_small,
+        message: a.message,
+        inclusive: !0,
+        exact: !1,
+        minimum: a.value,
+        type: "date"
+      }), n.dirty()) : a.kind === "max" ? e.data.getTime() > a.value && (s = this._getOrReturnCtx(e, s), m(s, {
+        code: l.too_big,
+        message: a.message,
+        inclusive: !0,
+        exact: !1,
+        maximum: a.value,
+        type: "date"
+      }), n.dirty()) : j.assertNever(a);
+    return {
+      status: n.value,
+      value: new Date(e.data.getTime())
+    };
+  }
+  _addCheck(e) {
+    return new pe({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e.getTime(),
+      message: v.toString(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e.getTime(),
+      message: v.toString(t)
+    });
+  }
+  get minDate() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+    return e != null ? new Date(e) : null;
+  }
+  get maxDate() {
+    let e = null;
+    for (const t of this._def.checks)
+      t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+    return e != null ? new Date(e) : null;
+  }
+}
+pe.create = (r) => new pe({
+  checks: [],
+  coerce: (r == null ? void 0 : r.coerce) || !1,
+  typeName: y.ZodDate,
+  ...w(r)
+});
+class vt extends O {
+  _parse(e) {
+    if (this._getType(e) !== g.symbol) {
+      const n = this._getOrReturnCtx(e);
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.symbol,
+        received: n.parsedType
+      }), _;
+    }
+    return $(e.data);
+  }
+}
+vt.create = (r) => new vt({
+  typeName: y.ZodSymbol,
+  ...w(r)
+});
+class Be extends O {
+  _parse(e) {
+    if (this._getType(e) !== g.undefined) {
+      const n = this._getOrReturnCtx(e);
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.undefined,
+        received: n.parsedType
+      }), _;
+    }
+    return $(e.data);
+  }
+}
+Be.create = (r) => new Be({
+  typeName: y.ZodUndefined,
+  ...w(r)
+});
+class We extends O {
+  _parse(e) {
+    if (this._getType(e) !== g.null) {
+      const n = this._getOrReturnCtx(e);
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.null,
+        received: n.parsedType
+      }), _;
+    }
+    return $(e.data);
+  }
+}
+We.create = (r) => new We({
+  typeName: y.ZodNull,
+  ...w(r)
+});
+class Ee extends O {
+  constructor() {
+    super(...arguments), this._any = !0;
+  }
+  _parse(e) {
+    return $(e.data);
+  }
+}
+Ee.create = (r) => new Ee({
+  typeName: y.ZodAny,
+  ...w(r)
+});
+class he extends O {
+  constructor() {
+    super(...arguments), this._unknown = !0;
+  }
+  _parse(e) {
+    return $(e.data);
+  }
+}
+he.create = (r) => new he({
+  typeName: y.ZodUnknown,
+  ...w(r)
+});
+class re extends O {
+  _parse(e) {
+    const t = this._getOrReturnCtx(e);
+    return m(t, {
+      code: l.invalid_type,
+      expected: g.never,
+      received: t.parsedType
+    }), _;
+  }
+}
+re.create = (r) => new re({
+  typeName: y.ZodNever,
+  ...w(r)
+});
+class yt extends O {
+  _parse(e) {
+    if (this._getType(e) !== g.undefined) {
+      const n = this._getOrReturnCtx(e);
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.void,
+        received: n.parsedType
+      }), _;
+    }
+    return $(e.data);
+  }
+}
+yt.create = (r) => new yt({
+  typeName: y.ZodVoid,
+  ...w(r)
+});
+class W extends O {
+  _parse(e) {
+    const { ctx: t, status: n } = this._processInputParams(e), s = this._def;
+    if (t.parsedType !== g.array)
+      return m(t, {
+        code: l.invalid_type,
+        expected: g.array,
+        received: t.parsedType
+      }), _;
+    if (s.exactLength !== null) {
+      const i = t.data.length > s.exactLength.value, o = t.data.length < s.exactLength.value;
+      (i || o) && (m(t, {
+        code: i ? l.too_big : l.too_small,
+        minimum: o ? s.exactLength.value : void 0,
+        maximum: i ? s.exactLength.value : void 0,
+        type: "array",
+        inclusive: !0,
+        exact: !0,
+        message: s.exactLength.message
+      }), n.dirty());
+    }
+    if (s.minLength !== null && t.data.length < s.minLength.value && (m(t, {
+      code: l.too_small,
+      minimum: s.minLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: s.minLength.message
+    }), n.dirty()), s.maxLength !== null && t.data.length > s.maxLength.value && (m(t, {
+      code: l.too_big,
+      maximum: s.maxLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: s.maxLength.message
+    }), n.dirty()), t.common.async)
+      return Promise.all([...t.data].map((i, o) => s.type._parseAsync(new Y(t, i, t.path, o)))).then((i) => M.mergeArray(n, i));
+    const a = [...t.data].map((i, o) => s.type._parseSync(new Y(t, i, t.path, o)));
+    return M.mergeArray(n, a);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(e, t) {
+    return new W({
+      ...this._def,
+      minLength: { value: e, message: v.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new W({
+      ...this._def,
+      maxLength: { value: e, message: v.toString(t) }
+    });
+  }
+  length(e, t) {
+    return new W({
+      ...this._def,
+      exactLength: { value: e, message: v.toString(t) }
+    });
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+W.create = (r, e) => new W({
+  type: r,
+  minLength: null,
+  maxLength: null,
+  exactLength: null,
+  typeName: y.ZodArray,
+  ...w(e)
+});
+function be(r) {
+  if (r instanceof C) {
+    const e = {};
+    for (const t in r.shape) {
+      const n = r.shape[t];
+      e[t] = J.create(be(n));
+    }
+    return new C({
+      ...r._def,
+      shape: () => e
+    });
+  } else return r instanceof W ? new W({
+    ...r._def,
+    type: be(r.element)
+  }) : r instanceof J ? J.create(be(r.unwrap())) : r instanceof ue ? ue.create(be(r.unwrap())) : r instanceof X ? X.create(r.items.map((e) => be(e))) : r;
+}
+class C extends O {
+  constructor() {
+    super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend;
+  }
+  _getCached() {
+    if (this._cached !== null)
+      return this._cached;
+    const e = this._def.shape(), t = j.objectKeys(e);
+    return this._cached = { shape: e, keys: t };
+  }
+  _parse(e) {
+    if (this._getType(e) !== g.object) {
+      const u = this._getOrReturnCtx(e);
+      return m(u, {
+        code: l.invalid_type,
+        expected: g.object,
+        received: u.parsedType
+      }), _;
+    }
+    const { status: n, ctx: s } = this._processInputParams(e), { shape: a, keys: i } = this._getCached(), o = [];
+    if (!(this._def.catchall instanceof re && this._def.unknownKeys === "strip"))
+      for (const u in s.data)
+        i.includes(u) || o.push(u);
+    const c = [];
+    for (const u of i) {
+      const d = a[u], f = s.data[u];
+      c.push({
+        key: { status: "valid", value: u },
+        value: d._parse(new Y(s, f, s.path, u)),
+        alwaysSet: u in s.data
+      });
+    }
+    if (this._def.catchall instanceof re) {
+      const u = this._def.unknownKeys;
+      if (u === "passthrough")
+        for (const d of o)
+          c.push({
+            key: { status: "valid", value: d },
+            value: { status: "valid", value: s.data[d] }
+          });
+      else if (u === "strict")
+        o.length > 0 && (m(s, {
+          code: l.unrecognized_keys,
+          keys: o
+        }), n.dirty());
+      else if (u !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+    } else {
+      const u = this._def.catchall;
+      for (const d of o) {
+        const f = s.data[d];
+        c.push({
+          key: { status: "valid", value: d },
+          value: u._parse(
+            new Y(s, f, s.path, d)
+            //, ctx.child(key), value, getParsedType(value)
+          ),
+          alwaysSet: d in s.data
+        });
+      }
+    }
+    return s.common.async ? Promise.resolve().then(async () => {
+      const u = [];
+      for (const d of c) {
+        const f = await d.key, k = await d.value;
+        u.push({
+          key: f,
+          value: k,
+          alwaysSet: d.alwaysSet
+        });
+      }
+      return u;
+    }).then((u) => M.mergeObjectSync(n, u)) : M.mergeObjectSync(n, c);
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(e) {
+    return v.errToObj, new C({
+      ...this._def,
+      unknownKeys: "strict",
+      ...e !== void 0 ? {
+        errorMap: (t, n) => {
+          var s, a, i, o;
+          const c = (i = (a = (s = this._def).errorMap) === null || a === void 0 ? void 0 : a.call(s, t, n).message) !== null && i !== void 0 ? i : n.defaultError;
+          return t.code === "unrecognized_keys" ? {
+            message: (o = v.errToObj(e).message) !== null && o !== void 0 ? o : c
+          } : {
+            message: c
+          };
+        }
+      } : {}
+    });
+  }
+  strip() {
+    return new C({
+      ...this._def,
+      unknownKeys: "strip"
+    });
+  }
+  passthrough() {
+    return new C({
+      ...this._def,
+      unknownKeys: "passthrough"
+    });
+  }
+  // const AugmentFactory =
+  //   <Def extends ZodObjectDef>(def: Def) =>
+  //   <Augmentation extends ZodRawShape>(
+  //     augmentation: Augmentation
+  //   ): ZodObject<
+  //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
+  //     Def["unknownKeys"],
+  //     Def["catchall"]
+  //   > => {
+  //     return new ZodObject({
+  //       ...def,
+  //       shape: () => ({
+  //         ...def.shape(),
+  //         ...augmentation,
+  //       }),
+  //     }) as any;
+  //   };
+  extend(e) {
+    return new C({
+      ...this._def,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e
+      })
+    });
+  }
+  /**
+   * Prior to zod@1.0.12 there was a bug in the
+   * inferred type of merged objects. Please
+   * upgrade if you are experiencing issues.
+   */
+  merge(e) {
+    return new C({
+      unknownKeys: e._def.unknownKeys,
+      catchall: e._def.catchall,
+      shape: () => ({
+        ...this._def.shape(),
+        ...e._def.shape()
+      }),
+      typeName: y.ZodObject
+    });
+  }
+  // merge<
+  //   Incoming extends AnyZodObject,
+  //   Augmentation extends Incoming["shape"],
+  //   NewOutput extends {
+  //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
+  //       ? Augmentation[k]["_output"]
+  //       : k extends keyof Output
+  //       ? Output[k]
+  //       : never;
+  //   },
+  //   NewInput extends {
+  //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
+  //       ? Augmentation[k]["_input"]
+  //       : k extends keyof Input
+  //       ? Input[k]
+  //       : never;
+  //   }
+  // >(
+  //   merging: Incoming
+  // ): ZodObject<
+  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+  //   Incoming["_def"]["unknownKeys"],
+  //   Incoming["_def"]["catchall"],
+  //   NewOutput,
+  //   NewInput
+  // > {
+  //   const merged: any = new ZodObject({
+  //     unknownKeys: merging._def.unknownKeys,
+  //     catchall: merging._def.catchall,
+  //     shape: () =>
+  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+  //     typeName: ZodFirstPartyTypeKind.ZodObject,
+  //   }) as any;
+  //   return merged;
+  // }
+  setKey(e, t) {
+    return this.augment({ [e]: t });
+  }
+  // merge<Incoming extends AnyZodObject>(
+  //   merging: Incoming
+  // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
+  // ZodObject<
+  //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
+  //   Incoming["_def"]["unknownKeys"],
+  //   Incoming["_def"]["catchall"]
+  // > {
+  //   // const mergedShape = objectUtil.mergeShapes(
+  //   //   this._def.shape(),
+  //   //   merging._def.shape()
+  //   // );
+  //   const merged: any = new ZodObject({
+  //     unknownKeys: merging._def.unknownKeys,
+  //     catchall: merging._def.catchall,
+  //     shape: () =>
+  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
+  //     typeName: ZodFirstPartyTypeKind.ZodObject,
+  //   }) as any;
+  //   return merged;
+  // }
+  catchall(e) {
+    return new C({
+      ...this._def,
+      catchall: e
+    });
+  }
+  pick(e) {
+    const t = {};
+    return j.objectKeys(e).forEach((n) => {
+      e[n] && this.shape[n] && (t[n] = this.shape[n]);
+    }), new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  omit(e) {
+    const t = {};
+    return j.objectKeys(this.shape).forEach((n) => {
+      e[n] || (t[n] = this.shape[n]);
+    }), new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  /**
+   * @deprecated
+   */
+  deepPartial() {
+    return be(this);
+  }
+  partial(e) {
+    const t = {};
+    return j.objectKeys(this.shape).forEach((n) => {
+      const s = this.shape[n];
+      e && !e[n] ? t[n] = s : t[n] = s.optional();
+    }), new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  required(e) {
+    const t = {};
+    return j.objectKeys(this.shape).forEach((n) => {
+      if (e && !e[n])
+        t[n] = this.shape[n];
+      else {
+        let a = this.shape[n];
+        for (; a instanceof J; )
+          a = a._def.innerType;
+        t[n] = a;
+      }
+    }), new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  keyof() {
+    return hr(j.objectKeys(this.shape));
+  }
+}
+C.create = (r, e) => new C({
+  shape: () => r,
+  unknownKeys: "strip",
+  catchall: re.create(),
+  typeName: y.ZodObject,
+  ...w(e)
+});
+C.strictCreate = (r, e) => new C({
+  shape: () => r,
+  unknownKeys: "strict",
+  catchall: re.create(),
+  typeName: y.ZodObject,
+  ...w(e)
+});
+C.lazycreate = (r, e) => new C({
+  shape: r,
+  unknownKeys: "strip",
+  catchall: re.create(),
+  typeName: y.ZodObject,
+  ...w(e)
+});
+class Fe extends O {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), n = this._def.options;
+    function s(a) {
+      for (const o of a)
+        if (o.result.status === "valid")
+          return o.result;
+      for (const o of a)
+        if (o.result.status === "dirty")
+          return t.common.issues.push(...o.ctx.common.issues), o.result;
+      const i = a.map((o) => new L(o.ctx.common.issues));
+      return m(t, {
+        code: l.invalid_union,
+        unionErrors: i
+      }), _;
+    }
+    if (t.common.async)
+      return Promise.all(n.map(async (a) => {
+        const i = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        };
+        return {
+          result: await a._parseAsync({
+            data: t.data,
+            path: t.path,
+            parent: i
+          }),
+          ctx: i
+        };
+      })).then(s);
+    {
+      let a;
+      const i = [];
+      for (const c of n) {
+        const u = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        }, d = c._parseSync({
+          data: t.data,
+          path: t.path,
+          parent: u
+        });
+        if (d.status === "valid")
+          return d;
+        d.status === "dirty" && !a && (a = { result: d, ctx: u }), u.common.issues.length && i.push(u.common.issues);
+      }
+      if (a)
+        return t.common.issues.push(...a.ctx.common.issues), a.result;
+      const o = i.map((c) => new L(c));
+      return m(t, {
+        code: l.invalid_union,
+        unionErrors: o
+      }), _;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+}
+Fe.create = (r, e) => new Fe({
+  options: r,
+  typeName: y.ZodUnion,
+  ...w(e)
+});
+const z = (r) => r instanceof Je ? z(r.schema) : r instanceof F ? z(r.innerType()) : r instanceof Ye ? [r.value] : r instanceof ce ? r.options : r instanceof Xe ? j.objectValues(r.enum) : r instanceof Qe ? z(r._def.innerType) : r instanceof Be ? [void 0] : r instanceof We ? [null] : r instanceof J ? [void 0, ...z(r.unwrap())] : r instanceof ue ? [null, ...z(r.unwrap())] : r instanceof Dt || r instanceof et ? z(r.unwrap()) : r instanceof ze ? z(r._def.innerType) : [];
+class xt extends O {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== g.object)
+      return m(t, {
+        code: l.invalid_type,
+        expected: g.object,
+        received: t.parsedType
+      }), _;
+    const n = this.discriminator, s = t.data[n], a = this.optionsMap.get(s);
+    return a ? t.common.async ? a._parseAsync({
+      data: t.data,
+      path: t.path,
+      parent: t
+    }) : a._parseSync({
+      data: t.data,
+      path: t.path,
+      parent: t
+    }) : (m(t, {
+      code: l.invalid_union_discriminator,
+      options: Array.from(this.optionsMap.keys()),
+      path: [n]
+    }), _);
+  }
+  get discriminator() {
+    return this._def.discriminator;
+  }
+  get options() {
+    return this._def.options;
+  }
+  get optionsMap() {
+    return this._def.optionsMap;
+  }
+  /**
+   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+   * have a different value for each object in the union.
+   * @param discriminator the name of the discriminator property
+   * @param types an array of object schemas
+   * @param params
+   */
+  static create(e, t, n) {
+    const s = /* @__PURE__ */ new Map();
+    for (const a of t) {
+      const i = z(a.shape[e]);
+      if (!i.length)
+        throw new Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`);
+      for (const o of i) {
+        if (s.has(o))
+          throw new Error(`Discriminator property ${String(e)} has duplicate value ${String(o)}`);
+        s.set(o, a);
+      }
+    }
+    return new xt({
+      typeName: y.ZodDiscriminatedUnion,
+      discriminator: e,
+      options: t,
+      optionsMap: s,
+      ...w(n)
+    });
+  }
+}
+function At(r, e) {
+  const t = se(r), n = se(e);
+  if (r === e)
+    return { valid: !0, data: r };
+  if (t === g.object && n === g.object) {
+    const s = j.objectKeys(e), a = j.objectKeys(r).filter((o) => s.indexOf(o) !== -1), i = { ...r, ...e };
+    for (const o of a) {
+      const c = At(r[o], e[o]);
+      if (!c.valid)
+        return { valid: !1 };
+      i[o] = c.data;
+    }
+    return { valid: !0, data: i };
+  } else if (t === g.array && n === g.array) {
+    if (r.length !== e.length)
+      return { valid: !1 };
+    const s = [];
+    for (let a = 0; a < r.length; a++) {
+      const i = r[a], o = e[a], c = At(i, o);
+      if (!c.valid)
+        return { valid: !1 };
+      s.push(c.data);
+    }
+    return { valid: !0, data: s };
+  } else return t === g.date && n === g.date && +r == +e ? { valid: !0, data: r } : { valid: !1 };
+}
+class Ge extends O {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e), s = (a, i) => {
+      if (Zt(a) || Zt(i))
+        return _;
+      const o = At(a.value, i.value);
+      return o.valid ? ((St(a) || St(i)) && t.dirty(), { status: t.value, value: o.data }) : (m(n, {
+        code: l.invalid_intersection_types
+      }), _);
+    };
+    return n.common.async ? Promise.all([
+      this._def.left._parseAsync({
+        data: n.data,
+        path: n.path,
+        parent: n
+      }),
+      this._def.right._parseAsync({
+        data: n.data,
+        path: n.path,
+        parent: n
+      })
+    ]).then(([a, i]) => s(a, i)) : s(this._def.left._parseSync({
+      data: n.data,
+      path: n.path,
+      parent: n
+    }), this._def.right._parseSync({
+      data: n.data,
+      path: n.path,
+      parent: n
+    }));
+  }
+}
+Ge.create = (r, e, t) => new Ge({
+  left: r,
+  right: e,
+  typeName: y.ZodIntersection,
+  ...w(t)
+});
+class X extends O {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== g.array)
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.array,
+        received: n.parsedType
+      }), _;
+    if (n.data.length < this._def.items.length)
+      return m(n, {
+        code: l.too_small,
+        minimum: this._def.items.length,
+        inclusive: !0,
+        exact: !1,
+        type: "array"
+      }), _;
+    !this._def.rest && n.data.length > this._def.items.length && (m(n, {
+      code: l.too_big,
+      maximum: this._def.items.length,
+      inclusive: !0,
+      exact: !1,
+      type: "array"
+    }), t.dirty());
+    const a = [...n.data].map((i, o) => {
+      const c = this._def.items[o] || this._def.rest;
+      return c ? c._parse(new Y(n, i, n.path, o)) : null;
+    }).filter((i) => !!i);
+    return n.common.async ? Promise.all(a).then((i) => M.mergeArray(t, i)) : M.mergeArray(t, a);
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(e) {
+    return new X({
+      ...this._def,
+      rest: e
+    });
+  }
+}
+X.create = (r, e) => {
+  if (!Array.isArray(r))
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  return new X({
+    items: r,
+    typeName: y.ZodTuple,
+    rest: null,
+    ...w(e)
+  });
+};
+class Ke extends O {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== g.object)
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.object,
+        received: n.parsedType
+      }), _;
+    const s = [], a = this._def.keyType, i = this._def.valueType;
+    for (const o in n.data)
+      s.push({
+        key: a._parse(new Y(n, o, n.path, o)),
+        value: i._parse(new Y(n, n.data[o], n.path, o)),
+        alwaysSet: o in n.data
+      });
+    return n.common.async ? M.mergeObjectAsync(t, s) : M.mergeObjectSync(t, s);
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(e, t, n) {
+    return t instanceof O ? new Ke({
+      keyType: e,
+      valueType: t,
+      typeName: y.ZodRecord,
+      ...w(n)
+    }) : new Ke({
+      keyType: B.create(),
+      valueType: e,
+      typeName: y.ZodRecord,
+      ...w(t)
+    });
+  }
+}
+class _t extends O {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== g.map)
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.map,
+        received: n.parsedType
+      }), _;
+    const s = this._def.keyType, a = this._def.valueType, i = [...n.data.entries()].map(([o, c], u) => ({
+      key: s._parse(new Y(n, o, n.path, [u, "key"])),
+      value: a._parse(new Y(n, c, n.path, [u, "value"]))
+    }));
+    if (n.common.async) {
+      const o = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(async () => {
+        for (const c of i) {
+          const u = await c.key, d = await c.value;
+          if (u.status === "aborted" || d.status === "aborted")
+            return _;
+          (u.status === "dirty" || d.status === "dirty") && t.dirty(), o.set(u.value, d.value);
+        }
+        return { status: t.value, value: o };
+      });
+    } else {
+      const o = /* @__PURE__ */ new Map();
+      for (const c of i) {
+        const u = c.key, d = c.value;
+        if (u.status === "aborted" || d.status === "aborted")
+          return _;
+        (u.status === "dirty" || d.status === "dirty") && t.dirty(), o.set(u.value, d.value);
+      }
+      return { status: t.value, value: o };
+    }
+  }
+}
+_t.create = (r, e, t) => new _t({
+  valueType: e,
+  keyType: r,
+  typeName: y.ZodMap,
+  ...w(t)
+});
+class me extends O {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.parsedType !== g.set)
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.set,
+        received: n.parsedType
+      }), _;
+    const s = this._def;
+    s.minSize !== null && n.data.size < s.minSize.value && (m(n, {
+      code: l.too_small,
+      minimum: s.minSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: s.minSize.message
+    }), t.dirty()), s.maxSize !== null && n.data.size > s.maxSize.value && (m(n, {
+      code: l.too_big,
+      maximum: s.maxSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: s.maxSize.message
+    }), t.dirty());
+    const a = this._def.valueType;
+    function i(c) {
+      const u = /* @__PURE__ */ new Set();
+      for (const d of c) {
+        if (d.status === "aborted")
+          return _;
+        d.status === "dirty" && t.dirty(), u.add(d.value);
+      }
+      return { status: t.value, value: u };
+    }
+    const o = [...n.data.values()].map((c, u) => a._parse(new Y(n, c, n.path, u)));
+    return n.common.async ? Promise.all(o).then((c) => i(c)) : i(o);
+  }
+  min(e, t) {
+    return new me({
+      ...this._def,
+      minSize: { value: e, message: v.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new me({
+      ...this._def,
+      maxSize: { value: e, message: v.toString(t) }
+    });
+  }
+  size(e, t) {
+    return this.min(e, t).max(e, t);
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+me.create = (r, e) => new me({
+  valueType: r,
+  minSize: null,
+  maxSize: null,
+  typeName: y.ZodSet,
+  ...w(e)
+});
+class Oe extends O {
+  constructor() {
+    super(...arguments), this.validate = this.implement;
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== g.function)
+      return m(t, {
+        code: l.invalid_type,
+        expected: g.function,
+        received: t.parsedType
+      }), _;
+    function n(o, c) {
+      return mt({
+        data: o,
+        path: t.path,
+        errorMaps: [
+          t.common.contextualErrorMap,
+          t.schemaErrorMap,
+          pt(),
+          Re
+        ].filter((u) => !!u),
+        issueData: {
+          code: l.invalid_arguments,
+          argumentsError: c
+        }
+      });
+    }
+    function s(o, c) {
+      return mt({
+        data: o,
+        path: t.path,
+        errorMaps: [
+          t.common.contextualErrorMap,
+          t.schemaErrorMap,
+          pt(),
+          Re
+        ].filter((u) => !!u),
+        issueData: {
+          code: l.invalid_return_type,
+          returnTypeError: c
+        }
+      });
+    }
+    const a = { errorMap: t.common.contextualErrorMap }, i = t.data;
+    if (this._def.returns instanceof Ie) {
+      const o = this;
+      return $(async function(...c) {
+        const u = new L([]), d = await o._def.args.parseAsync(c, a).catch((E) => {
+          throw u.addIssue(n(c, E)), u;
+        }), f = await Reflect.apply(i, this, d);
+        return await o._def.returns._def.type.parseAsync(f, a).catch((E) => {
+          throw u.addIssue(s(f, E)), u;
+        });
+      });
+    } else {
+      const o = this;
+      return $(function(...c) {
+        const u = o._def.args.safeParse(c, a);
+        if (!u.success)
+          throw new L([n(c, u.error)]);
+        const d = Reflect.apply(i, this, u.data), f = o._def.returns.safeParse(d, a);
+        if (!f.success)
+          throw new L([s(d, f.error)]);
+        return f.data;
+      });
+    }
+  }
+  parameters() {
+    return this._def.args;
+  }
+  returnType() {
+    return this._def.returns;
+  }
+  args(...e) {
+    return new Oe({
+      ...this._def,
+      args: X.create(e).rest(he.create())
+    });
+  }
+  returns(e) {
+    return new Oe({
+      ...this._def,
+      returns: e
+    });
+  }
+  implement(e) {
+    return this.parse(e);
+  }
+  strictImplement(e) {
+    return this.parse(e);
+  }
+  static create(e, t, n) {
+    return new Oe({
+      args: e || X.create([]).rest(he.create()),
+      returns: t || he.create(),
+      typeName: y.ZodFunction,
+      ...w(n)
+    });
+  }
+}
+class Je extends O {
+  get schema() {
+    return this._def.getter();
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    return this._def.getter()._parse({ data: t.data, path: t.path, parent: t });
+  }
+}
+Je.create = (r, e) => new Je({
+  getter: r,
+  typeName: y.ZodLazy,
+  ...w(e)
+});
+class Ye extends O {
+  _parse(e) {
+    if (e.data !== this._def.value) {
+      const t = this._getOrReturnCtx(e);
+      return m(t, {
+        received: t.data,
+        code: l.invalid_literal,
+        expected: this._def.value
+      }), _;
+    }
+    return { status: "valid", value: e.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+}
+Ye.create = (r, e) => new Ye({
+  value: r,
+  typeName: y.ZodLiteral,
+  ...w(e)
+});
+function hr(r, e) {
+  return new ce({
+    values: r,
+    typeName: y.ZodEnum,
+    ...w(e)
+  });
+}
+class ce extends O {
+  constructor() {
+    super(...arguments), Ne.set(this, void 0);
+  }
+  _parse(e) {
+    if (typeof e.data != "string") {
+      const t = this._getOrReturnCtx(e), n = this._def.values;
+      return m(t, {
+        expected: j.joinValues(n),
+        received: t.parsedType,
+        code: l.invalid_type
+      }), _;
+    }
+    if (gt(this, Ne) || ur(this, Ne, new Set(this._def.values)), !gt(this, Ne).has(e.data)) {
+      const t = this._getOrReturnCtx(e), n = this._def.values;
+      return m(t, {
+        received: t.data,
+        code: l.invalid_enum_value,
+        options: n
+      }), _;
+    }
+    return $(e.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  get Values() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  get Enum() {
+    const e = {};
+    for (const t of this._def.values)
+      e[t] = t;
+    return e;
+  }
+  extract(e, t = this._def) {
+    return ce.create(e, {
+      ...this._def,
+      ...t
+    });
+  }
+  exclude(e, t = this._def) {
+    return ce.create(this.options.filter((n) => !e.includes(n)), {
+      ...this._def,
+      ...t
+    });
+  }
+}
+Ne = /* @__PURE__ */ new WeakMap();
+ce.create = hr;
+class Xe extends O {
+  constructor() {
+    super(...arguments), De.set(this, void 0);
+  }
+  _parse(e) {
+    const t = j.getValidEnumValues(this._def.values), n = this._getOrReturnCtx(e);
+    if (n.parsedType !== g.string && n.parsedType !== g.number) {
+      const s = j.objectValues(t);
+      return m(n, {
+        expected: j.joinValues(s),
+        received: n.parsedType,
+        code: l.invalid_type
+      }), _;
+    }
+    if (gt(this, De) || ur(this, De, new Set(j.getValidEnumValues(this._def.values))), !gt(this, De).has(e.data)) {
+      const s = j.objectValues(t);
+      return m(n, {
+        received: n.data,
+        code: l.invalid_enum_value,
+        options: s
+      }), _;
+    }
+    return $(e.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+}
+De = /* @__PURE__ */ new WeakMap();
+Xe.create = (r, e) => new Xe({
+  values: r,
+  typeName: y.ZodNativeEnum,
+  ...w(e)
+});
+class Ie extends O {
+  unwrap() {
+    return this._def.type;
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== g.promise && t.common.async === !1)
+      return m(t, {
+        code: l.invalid_type,
+        expected: g.promise,
+        received: t.parsedType
+      }), _;
+    const n = t.parsedType === g.promise ? t.data : Promise.resolve(t.data);
+    return $(n.then((s) => this._def.type.parseAsync(s, {
+      path: t.path,
+      errorMap: t.common.contextualErrorMap
+    })));
+  }
+}
+Ie.create = (r, e) => new Ie({
+  type: r,
+  typeName: y.ZodPromise,
+  ...w(e)
+});
+class F extends O {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === y.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e), s = this._def.effect || null, a = {
+      addIssue: (i) => {
+        m(n, i), i.fatal ? t.abort() : t.dirty();
+      },
+      get path() {
+        return n.path;
+      }
+    };
+    if (a.addIssue = a.addIssue.bind(a), s.type === "preprocess") {
+      const i = s.transform(n.data, a);
+      if (n.common.async)
+        return Promise.resolve(i).then(async (o) => {
+          if (t.value === "aborted")
+            return _;
+          const c = await this._def.schema._parseAsync({
+            data: o,
+            path: n.path,
+            parent: n
+          });
+          return c.status === "aborted" ? _ : c.status === "dirty" || t.value === "dirty" ? we(c.value) : c;
+        });
+      {
+        if (t.value === "aborted")
+          return _;
+        const o = this._def.schema._parseSync({
+          data: i,
+          path: n.path,
+          parent: n
+        });
+        return o.status === "aborted" ? _ : o.status === "dirty" || t.value === "dirty" ? we(o.value) : o;
+      }
+    }
+    if (s.type === "refinement") {
+      const i = (o) => {
+        const c = s.refinement(o, a);
+        if (n.common.async)
+          return Promise.resolve(c);
+        if (c instanceof Promise)
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+        return o;
+      };
+      if (n.common.async === !1) {
+        const o = this._def.schema._parseSync({
+          data: n.data,
+          path: n.path,
+          parent: n
+        });
+        return o.status === "aborted" ? _ : (o.status === "dirty" && t.dirty(), i(o.value), { status: t.value, value: o.value });
+      } else
+        return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((o) => o.status === "aborted" ? _ : (o.status === "dirty" && t.dirty(), i(o.value).then(() => ({ status: t.value, value: o.value }))));
+    }
+    if (s.type === "transform")
+      if (n.common.async === !1) {
+        const i = this._def.schema._parseSync({
+          data: n.data,
+          path: n.path,
+          parent: n
+        });
+        if (!Ue(i))
+          return i;
+        const o = s.transform(i.value, a);
+        if (o instanceof Promise)
+          throw new Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+        return { status: t.value, value: o };
+      } else
+        return this._def.schema._parseAsync({ data: n.data, path: n.path, parent: n }).then((i) => Ue(i) ? Promise.resolve(s.transform(i.value, a)).then((o) => ({ status: t.value, value: o })) : i);
+    j.assertNever(s);
+  }
+}
+F.create = (r, e, t) => new F({
+  schema: r,
+  typeName: y.ZodEffects,
+  effect: e,
+  ...w(t)
+});
+F.createWithPreprocess = (r, e, t) => new F({
+  schema: e,
+  effect: { type: "preprocess", transform: r },
+  typeName: y.ZodEffects,
+  ...w(t)
+});
+class J extends O {
+  _parse(e) {
+    return this._getType(e) === g.undefined ? $(void 0) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+J.create = (r, e) => new J({
+  innerType: r,
+  typeName: y.ZodOptional,
+  ...w(e)
+});
+class ue extends O {
+  _parse(e) {
+    return this._getType(e) === g.null ? $(null) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+ue.create = (r, e) => new ue({
+  innerType: r,
+  typeName: y.ZodNullable,
+  ...w(e)
+});
+class Qe extends O {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    let n = t.data;
+    return t.parsedType === g.undefined && (n = this._def.defaultValue()), this._def.innerType._parse({
+      data: n,
+      path: t.path,
+      parent: t
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+}
+Qe.create = (r, e) => new Qe({
+  innerType: r,
+  typeName: y.ZodDefault,
+  defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+  ...w(e)
+});
+class ze extends O {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), n = {
+      ...t,
+      common: {
+        ...t.common,
+        issues: []
+      }
+    }, s = this._def.innerType._parse({
+      data: n.data,
+      path: n.path,
+      parent: {
+        ...n
+      }
+    });
+    return He(s) ? s.then((a) => ({
+      status: "valid",
+      value: a.status === "valid" ? a.value : this._def.catchValue({
+        get error() {
+          return new L(n.common.issues);
+        },
+        input: n.data
+      })
+    })) : {
+      status: "valid",
+      value: s.status === "valid" ? s.value : this._def.catchValue({
+        get error() {
+          return new L(n.common.issues);
+        },
+        input: n.data
+      })
+    };
+  }
+  removeCatch() {
+    return this._def.innerType;
+  }
+}
+ze.create = (r, e) => new ze({
+  innerType: r,
+  typeName: y.ZodCatch,
+  catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+  ...w(e)
+});
+class bt extends O {
+  _parse(e) {
+    if (this._getType(e) !== g.nan) {
+      const n = this._getOrReturnCtx(e);
+      return m(n, {
+        code: l.invalid_type,
+        expected: g.nan,
+        received: n.parsedType
+      }), _;
+    }
+    return { status: "valid", value: e.data };
+  }
+}
+bt.create = (r) => new bt({
+  typeName: y.ZodNaN,
+  ...w(r)
+});
+const Fn = Symbol("zod_brand");
+class Dt extends O {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), n = t.data;
+    return this._def.type._parse({
+      data: n,
+      path: t.path,
+      parent: t
+    });
+  }
+  unwrap() {
+    return this._def.type;
+  }
+}
+class it extends O {
+  _parse(e) {
+    const { status: t, ctx: n } = this._processInputParams(e);
+    if (n.common.async)
+      return (async () => {
+        const a = await this._def.in._parseAsync({
+          data: n.data,
+          path: n.path,
+          parent: n
+        });
+        return a.status === "aborted" ? _ : a.status === "dirty" ? (t.dirty(), we(a.value)) : this._def.out._parseAsync({
+          data: a.value,
+          path: n.path,
+          parent: n
+        });
+      })();
+    {
+      const s = this._def.in._parseSync({
+        data: n.data,
+        path: n.path,
+        parent: n
+      });
+      return s.status === "aborted" ? _ : s.status === "dirty" ? (t.dirty(), {
+        status: "dirty",
+        value: s.value
+      }) : this._def.out._parseSync({
+        data: s.value,
+        path: n.path,
+        parent: n
+      });
+    }
+  }
+  static create(e, t) {
+    return new it({
+      in: e,
+      out: t,
+      typeName: y.ZodPipeline
+    });
+  }
+}
+class et extends O {
+  _parse(e) {
+    const t = this._def.innerType._parse(e), n = (s) => (Ue(s) && (s.value = Object.freeze(s.value)), s);
+    return He(t) ? t.then((s) => n(s)) : n(t);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+et.create = (r, e) => new et({
+  innerType: r,
+  typeName: y.ZodReadonly,
+  ...w(e)
+});
+function pr(r, e = {}, t) {
+  return r ? Ee.create().superRefine((n, s) => {
+    var a, i;
+    if (!r(n)) {
+      const o = typeof e == "function" ? e(n) : typeof e == "string" ? { message: e } : e, c = (i = (a = o.fatal) !== null && a !== void 0 ? a : t) !== null && i !== void 0 ? i : !0, u = typeof o == "string" ? { message: o } : o;
+      s.addIssue({ code: "custom", ...u, fatal: c });
+    }
+  }) : Ee.create();
+}
+const Gn = {
+  object: C.lazycreate
+};
+var y;
+(function(r) {
+  r.ZodString = "ZodString", r.ZodNumber = "ZodNumber", r.ZodNaN = "ZodNaN", r.ZodBigInt = "ZodBigInt", r.ZodBoolean = "ZodBoolean", r.ZodDate = "ZodDate", r.ZodSymbol = "ZodSymbol", r.ZodUndefined = "ZodUndefined", r.ZodNull = "ZodNull", r.ZodAny = "ZodAny", r.ZodUnknown = "ZodUnknown", r.ZodNever = "ZodNever", r.ZodVoid = "ZodVoid", r.ZodArray = "ZodArray", r.ZodObject = "ZodObject", r.ZodUnion = "ZodUnion", r.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", r.ZodIntersection = "ZodIntersection", r.ZodTuple = "ZodTuple", r.ZodRecord = "ZodRecord", r.ZodMap = "ZodMap", r.ZodSet = "ZodSet", r.ZodFunction = "ZodFunction", r.ZodLazy = "ZodLazy", r.ZodLiteral = "ZodLiteral", r.ZodEnum = "ZodEnum", r.ZodEffects = "ZodEffects", r.ZodNativeEnum = "ZodNativeEnum", r.ZodOptional = "ZodOptional", r.ZodNullable = "ZodNullable", r.ZodDefault = "ZodDefault", r.ZodCatch = "ZodCatch", r.ZodPromise = "ZodPromise", r.ZodBranded = "ZodBranded", r.ZodPipeline = "ZodPipeline", r.ZodReadonly = "ZodReadonly";
+})(y || (y = {}));
+const Kn = (r, e = {
+  message: `Input not instance of ${r.name}`
+}) => pr((t) => t instanceof r, e), mr = B.create, gr = ie.create, Jn = bt.create, Yn = oe.create, vr = qe.create, Xn = pe.create, Qn = vt.create, zn = Be.create, es = We.create, ts = Ee.create, rs = he.create, ns = re.create, ss = yt.create, as = W.create, is = C.create, os = C.strictCreate, cs = Fe.create, us = xt.create, ds = Ge.create, ls = X.create, fs = Ke.create, hs = _t.create, ps = me.create, ms = Oe.create, gs = Je.create, vs = Ye.create, ys = ce.create, _s = Xe.create, bs = Ie.create, Bt = F.create, ws = J.create, xs = ue.create, Os = F.createWithPreprocess, ks = it.create, Ts = () => mr().optional(), js = () => gr().optional(), Rs = () => vr().optional(), Es = {
+  string: (r) => B.create({ ...r, coerce: !0 }),
+  number: (r) => ie.create({ ...r, coerce: !0 }),
+  boolean: (r) => qe.create({
+    ...r,
+    coerce: !0
+  }),
+  bigint: (r) => oe.create({ ...r, coerce: !0 }),
+  date: (r) => pe.create({ ...r, coerce: !0 })
+}, Is = _;
+var Ps = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  defaultErrorMap: Re,
+  setErrorMap: In,
+  getErrorMap: pt,
+  makeIssue: mt,
+  EMPTY_PATH: Pn,
+  addIssueToContext: m,
+  ParseStatus: M,
+  INVALID: _,
+  DIRTY: we,
+  OK: $,
+  isAborted: Zt,
+  isDirty: St,
+  isValid: Ue,
+  isAsync: He,
+  get util() {
+    return j;
+  },
+  get objectUtil() {
+    return Ct;
+  },
+  ZodParsedType: g,
+  getParsedType: se,
+  ZodType: O,
+  datetimeRegex: fr,
+  ZodString: B,
+  ZodNumber: ie,
+  ZodBigInt: oe,
+  ZodBoolean: qe,
+  ZodDate: pe,
+  ZodSymbol: vt,
+  ZodUndefined: Be,
+  ZodNull: We,
+  ZodAny: Ee,
+  ZodUnknown: he,
+  ZodNever: re,
+  ZodVoid: yt,
+  ZodArray: W,
+  ZodObject: C,
+  ZodUnion: Fe,
+  ZodDiscriminatedUnion: xt,
+  ZodIntersection: Ge,
+  ZodTuple: X,
+  ZodRecord: Ke,
+  ZodMap: _t,
+  ZodSet: me,
+  ZodFunction: Oe,
+  ZodLazy: Je,
+  ZodLiteral: Ye,
+  ZodEnum: ce,
+  ZodNativeEnum: Xe,
+  ZodPromise: Ie,
+  ZodEffects: F,
+  ZodTransformer: F,
+  ZodOptional: J,
+  ZodNullable: ue,
+  ZodDefault: Qe,
+  ZodCatch: ze,
+  ZodNaN: bt,
+  BRAND: Fn,
+  ZodBranded: Dt,
+  ZodPipeline: it,
+  ZodReadonly: et,
+  custom: pr,
+  Schema: O,
+  ZodSchema: O,
+  late: Gn,
+  get ZodFirstPartyTypeKind() {
+    return y;
+  },
+  coerce: Es,
+  any: ts,
+  array: as,
+  bigint: Yn,
+  boolean: vr,
+  date: Xn,
+  discriminatedUnion: us,
+  effect: Bt,
+  enum: ys,
+  function: ms,
+  instanceof: Kn,
+  intersection: ds,
+  lazy: gs,
+  literal: vs,
+  map: hs,
+  nan: Jn,
+  nativeEnum: _s,
+  never: ns,
+  null: es,
+  nullable: xs,
+  number: gr,
+  object: is,
+  oboolean: Rs,
+  onumber: js,
+  optional: ws,
+  ostring: Ts,
+  pipeline: ks,
+  preprocess: Os,
+  promise: bs,
+  record: fs,
+  set: ps,
+  strictObject: os,
+  string: mr,
+  symbol: Qn,
+  transformer: Bt,
+  tuple: ls,
+  undefined: zn,
+  union: cs,
+  unknown: rs,
+  void: ss,
+  NEVER: Is,
+  ZodIssueCode: l,
+  quotelessJson: En,
+  ZodError: L
+}), Cs = class Nt extends Rn {
+  constructor(t) {
+    super(t);
+    p(this, "openAPIRegistry");
+    p(this, "defaultHook");
+    /**
+     *
+     * @param {RouteConfig} route - The route definition which you create with `createRoute()`.
+     * @param {Handler} handler - The handler. If you want to return a JSON object, you should specify the status code with `c.json()`.
+     * @param {Hook} hook - Optional. The hook method defines what it should do after validation.
+     * @example
+     * app.openapi(
+     *   route,
+     *   (c) => {
+     *     // ...
+     *     return c.json(
+     *       {
+     *         age: 20,
+     *         name: 'Young man',
+     *       },
+     *       200 // You should specify the status code even if it's 200.
+     *     )
+     *   },
+     *  (result, c) => {
+     *    if (!result.success) {
+     *      return c.json(
+     *        {
+     *          code: 400,
+     *          message: 'Custom Message',
+     *        },
+     *        400
+     *      )
+     *    }
+     *  }
+     *)
+     */
+    p(this, "openapi", ({ middleware: t, ...n }, s, a = this.defaultHook) => {
+      var u, d, f, k, E, R;
+      this.openAPIRegistry.registerPath(n);
+      const i = [];
+      if ((u = n.request) != null && u.query) {
+        const b = ye("query", n.request.query, a);
+        i.push(b);
+      }
+      if ((d = n.request) != null && d.params) {
+        const b = ye("param", n.request.params, a);
+        i.push(b);
+      }
+      if ((f = n.request) != null && f.headers) {
+        const b = ye("header", n.request.headers, a);
+        i.push(b);
+      }
+      if ((k = n.request) != null && k.cookies) {
+        const b = ye("cookie", n.request.cookies, a);
+        i.push(b);
+      }
+      const o = (R = (E = n.request) == null ? void 0 : E.body) == null ? void 0 : R.content;
+      if (o)
+        for (const b of Object.keys(o)) {
+          if (!o[b])
+            continue;
+          const S = o[b].schema;
+          if (S instanceof O) {
+            if (b.startsWith("application/json")) {
+              const D = ye("json", S, a);
+              i.push(D);
+            }
+            if (b.startsWith("multipart/form-data") || b.startsWith("application/x-www-form-urlencoded")) {
+              const D = ye("form", S, a);
+              i.push(D);
+            }
+          }
+        }
+      const c = t ? Array.isArray(t) ? t : [t] : [];
+      return this.on(
+        [n.method],
+        n.path.replaceAll(/\/{(.+?)}/g, "/:$1"),
+        ...c,
+        ...i,
+        s
+      ), this;
+    });
+    p(this, "getOpenAPIDocument", (t) => new qr(this.openAPIRegistry.definitions).generateDocument(t));
+    p(this, "getOpenAPI31Document", (t) => new Fr(this.openAPIRegistry.definitions).generateDocument(t));
+    p(this, "doc", (t, n) => this.get(t, (s) => {
+      const a = typeof n == "function" ? n(s) : n;
+      try {
+        const i = this.getOpenAPIDocument(a);
+        return s.json(i);
+      } catch (i) {
+        return s.json(i, 500);
+      }
+    }));
+    p(this, "doc31", (t, n) => this.get(t, (s) => {
+      const a = typeof n == "function" ? n(s) : n;
+      try {
+        const i = this.getOpenAPI31Document(a);
+        return s.json(i);
+      } catch (i) {
+        return s.json(i, 500);
+      }
+    }));
+    this.openAPIRegistry = new Tr(), this.defaultHook = t == null ? void 0 : t.defaultHook;
+  }
+  route(t, n) {
+    const s = t.replaceAll(/:([^\/]+)/g, "{$1}");
+    return super.route(t, n), n instanceof Nt ? (n.openAPIRegistry.definitions.forEach((a) => {
+      switch (a.type) {
+        case "component":
+          return this.openAPIRegistry.registerComponent(a.componentType, a.name, a.component);
+        case "route":
+          return this.openAPIRegistry.registerPath({
+            ...a.route,
+            path: le(s, a.route.path)
+          });
+        case "webhook":
+          return this.openAPIRegistry.registerWebhook({
+            ...a.webhook,
+            path: le(s, a.webhook.path)
+          });
+        case "schema":
+          return this.openAPIRegistry.register(a.schema._def.openapi._internal.refId, a.schema);
+        case "parameter":
+          return this.openAPIRegistry.registerParameter(
+            a.schema._def.openapi._internal.refId,
+            a.schema
+          );
+        default: {
+          const i = a;
+          throw new Error(`Unknown registry type: ${i}`);
+        }
+      }
+    }), this) : this;
+  }
+  basePath(t) {
+    return new Nt({ ...super.basePath(t), defaultHook: this.defaultHook });
+  }
+};
+wr(Ps);
+function Ns() {
+  new Cs().get("/test", (e) => e.text("Hello, world!"));
+}
+export {
+  Ns as init
+};