vite-plugin-norg 0.1.0

package/dist/plugin/index.js

@@ -0,0 +1,2801 @@
+import { createFilter as be } from "vite";
+let rt;
+let __tla = (async () => {
+  var v;
+  (function(s) {
+    s.assertEqual = (a) => {
+    };
+    function e(a) {
+    }
+    s.assertIs = e;
+    function t(a) {
+      throw new Error();
+    }
+    s.assertNever = t, s.arrayToEnum = (a) => {
+      const n = {};
+      for (const i of a) n[i] = i;
+      return n;
+    }, s.getValidEnumValues = (a) => {
+      const n = s.objectKeys(a).filter((o) => typeof a[a[o]] != "number"), i = {};
+      for (const o of n) i[o] = a[o];
+      return s.objectValues(i);
+    }, s.objectValues = (a) => s.objectKeys(a).map(function(n) {
+      return a[n];
+    }), s.objectKeys = typeof Object.keys == "function" ? (a) => Object.keys(a) : (a) => {
+      const n = [];
+      for (const i in a) Object.prototype.hasOwnProperty.call(a, i) && n.push(i);
+      return n;
+    }, s.find = (a, n) => {
+      for (const i of a) if (n(i)) return i;
+    }, s.isInteger = typeof Number.isInteger == "function" ? (a) => Number.isInteger(a) : (a) => typeof a == "number" && Number.isFinite(a) && Math.floor(a) === a;
+    function r(a, n = " | ") {
+      return a.map((i) => typeof i == "string" ? `'${i}'` : i).join(n);
+    }
+    s.joinValues = r, s.jsonStringifyReplacer = (a, n) => typeof n == "bigint" ? n.toString() : n;
+  })(v || (v = {}));
+  var se;
+  (function(s) {
+    s.mergeShapes = (e, t) => ({
+      ...e,
+      ...t
+    });
+  })(se || (se = {}));
+  const f = v.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set"
+  ]), T = (s) => {
+    switch (typeof s) {
+      case "undefined":
+        return f.undefined;
+      case "string":
+        return f.string;
+      case "number":
+        return Number.isNaN(s) ? f.nan : f.number;
+      case "boolean":
+        return f.boolean;
+      case "function":
+        return f.function;
+      case "bigint":
+        return f.bigint;
+      case "symbol":
+        return f.symbol;
+      case "object":
+        return Array.isArray(s) ? f.array : s === null ? f.null : s.then && typeof s.then == "function" && s.catch && typeof s.catch == "function" ? f.promise : typeof Map < "u" && s instanceof Map ? f.map : typeof Set < "u" && s instanceof Set ? f.set : typeof Date < "u" && s instanceof Date ? f.date : f.object;
+      default:
+        return f.unknown;
+    }
+  }, d = v.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"
+  ]);
+  class O extends Error {
+    get errors() {
+      return this.issues;
+    }
+    constructor(e) {
+      super(), this.issues = [], this.addIssue = (r) => {
+        this.issues = [
+          ...this.issues,
+          r
+        ];
+      }, this.addIssues = (r = []) => {
+        this.issues = [
+          ...this.issues,
+          ...r
+        ];
+      };
+      const t = new.target.prototype;
+      Object.setPrototypeOf ? Object.setPrototypeOf(this, t) : this.__proto__ = t, this.name = "ZodError", this.issues = e;
+    }
+    format(e) {
+      const t = e || function(n) {
+        return n.message;
+      }, r = {
+        _errors: []
+      }, a = (n) => {
+        for (const i of n.issues) if (i.code === "invalid_union") i.unionErrors.map(a);
+        else if (i.code === "invalid_return_type") a(i.returnTypeError);
+        else if (i.code === "invalid_arguments") a(i.argumentsError);
+        else if (i.path.length === 0) r._errors.push(t(i));
+        else {
+          let o = r, u = 0;
+          for (; u < i.path.length; ) {
+            const l = i.path[u];
+            u === i.path.length - 1 ? (o[l] = o[l] || {
+              _errors: []
+            }, o[l]._errors.push(t(i))) : o[l] = o[l] || {
+              _errors: []
+            }, o = o[l], u++;
+          }
+        }
+      };
+      return a(this), r;
+    }
+    static assert(e) {
+      if (!(e instanceof O)) throw new Error(`Not a ZodError: ${e}`);
+    }
+    toString() {
+      return this.message;
+    }
+    get message() {
+      return JSON.stringify(this.issues, v.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+      return this.issues.length === 0;
+    }
+    flatten(e = (t) => t.message) {
+      const t = {}, r = [];
+      for (const a of this.issues) a.path.length > 0 ? (t[a.path[0]] = t[a.path[0]] || [], t[a.path[0]].push(e(a))) : r.push(e(a));
+      return {
+        formErrors: r,
+        fieldErrors: t
+      };
+    }
+    get formErrors() {
+      return this.flatten();
+    }
+  }
+  O.create = (s) => new O(s);
+  const Y = (s, e) => {
+    let t;
+    switch (s.code) {
+      case d.invalid_type:
+        s.received === f.undefined ? t = "Required" : t = `Expected ${s.expected}, received ${s.received}`;
+        break;
+      case d.invalid_literal:
+        t = `Invalid literal value, expected ${JSON.stringify(s.expected, v.jsonStringifyReplacer)}`;
+        break;
+      case d.unrecognized_keys:
+        t = `Unrecognized key(s) in object: ${v.joinValues(s.keys, ", ")}`;
+        break;
+      case d.invalid_union:
+        t = "Invalid input";
+        break;
+      case d.invalid_union_discriminator:
+        t = `Invalid discriminator value. Expected ${v.joinValues(s.options)}`;
+        break;
+      case d.invalid_enum_value:
+        t = `Invalid enum value. Expected ${v.joinValues(s.options)}, received '${s.received}'`;
+        break;
+      case d.invalid_arguments:
+        t = "Invalid function arguments";
+        break;
+      case d.invalid_return_type:
+        t = "Invalid function return type";
+        break;
+      case d.invalid_date:
+        t = "Invalid date";
+        break;
+      case d.invalid_string:
+        typeof s.validation == "object" ? "includes" in s.validation ? (t = `Invalid input: must include "${s.validation.includes}"`, typeof s.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${s.validation.position}`)) : "startsWith" in s.validation ? t = `Invalid input: must start with "${s.validation.startsWith}"` : "endsWith" in s.validation ? t = `Invalid input: must end with "${s.validation.endsWith}"` : v.assertNever(s.validation) : s.validation !== "regex" ? t = `Invalid ${s.validation}` : t = "Invalid";
+        break;
+      case d.too_small:
+        s.type === "array" ? t = `Array must contain ${s.exact ? "exactly" : s.inclusive ? "at least" : "more than"} ${s.minimum} element(s)` : s.type === "string" ? t = `String must contain ${s.exact ? "exactly" : s.inclusive ? "at least" : "over"} ${s.minimum} character(s)` : s.type === "number" ? t = `Number must be ${s.exact ? "exactly equal to " : s.inclusive ? "greater than or equal to " : "greater than "}${s.minimum}` : s.type === "date" ? t = `Date must be ${s.exact ? "exactly equal to " : s.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(s.minimum))}` : t = "Invalid input";
+        break;
+      case d.too_big:
+        s.type === "array" ? t = `Array must contain ${s.exact ? "exactly" : s.inclusive ? "at most" : "less than"} ${s.maximum} element(s)` : s.type === "string" ? t = `String must contain ${s.exact ? "exactly" : s.inclusive ? "at most" : "under"} ${s.maximum} character(s)` : s.type === "number" ? t = `Number must be ${s.exact ? "exactly" : s.inclusive ? "less than or equal to" : "less than"} ${s.maximum}` : s.type === "bigint" ? t = `BigInt must be ${s.exact ? "exactly" : s.inclusive ? "less than or equal to" : "less than"} ${s.maximum}` : s.type === "date" ? t = `Date must be ${s.exact ? "exactly" : s.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(s.maximum))}` : t = "Invalid input";
+        break;
+      case d.custom:
+        t = "Invalid input";
+        break;
+      case d.invalid_intersection_types:
+        t = "Intersection results could not be merged";
+        break;
+      case d.not_multiple_of:
+        t = `Number must be a multiple of ${s.multipleOf}`;
+        break;
+      case d.not_finite:
+        t = "Number must be finite";
+        break;
+      default:
+        t = e.defaultError, v.assertNever(s);
+    }
+    return {
+      message: t
+    };
+  };
+  let we = Y;
+  function Ce() {
+    return we;
+  }
+  const Oe = (s) => {
+    const { data: e, path: t, errorMaps: r, issueData: a } = s, n = [
+      ...t,
+      ...a.path || []
+    ], i = {
+      ...a,
+      path: n
+    };
+    if (a.message !== void 0) return {
+      ...a,
+      path: n,
+      message: a.message
+    };
+    let o = "";
+    const u = r.filter((l) => !!l).slice().reverse();
+    for (const l of u) o = l(i, {
+      data: e,
+      defaultError: o
+    }).message;
+    return {
+      ...a,
+      path: n,
+      message: o
+    };
+  };
+  function c(s, e) {
+    const t = Ce(), r = Oe({
+      issueData: e,
+      data: s.data,
+      path: s.path,
+      errorMaps: [
+        s.common.contextualErrorMap,
+        s.schemaErrorMap,
+        t,
+        t === Y ? void 0 : Y
+      ].filter((a) => !!a)
+    });
+    s.common.issues.push(r);
+  }
+  class k {
+    constructor() {
+      this.value = "valid";
+    }
+    dirty() {
+      this.value === "valid" && (this.value = "dirty");
+    }
+    abort() {
+      this.value !== "aborted" && (this.value = "aborted");
+    }
+    static mergeArray(e, t) {
+      const r = [];
+      for (const a of t) {
+        if (a.status === "aborted") return m;
+        a.status === "dirty" && e.dirty(), r.push(a.value);
+      }
+      return {
+        status: e.value,
+        value: r
+      };
+    }
+    static async mergeObjectAsync(e, t) {
+      const r = [];
+      for (const a of t) {
+        const n = await a.key, i = await a.value;
+        r.push({
+          key: n,
+          value: i
+        });
+      }
+      return k.mergeObjectSync(e, r);
+    }
+    static mergeObjectSync(e, t) {
+      const r = {};
+      for (const a of t) {
+        const { key: n, value: i } = a;
+        if (n.status === "aborted" || i.status === "aborted") return m;
+        n.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), n.value !== "__proto__" && (typeof i.value < "u" || a.alwaysSet) && (r[n.value] = i.value);
+      }
+      return {
+        status: e.value,
+        value: r
+      };
+    }
+  }
+  const m = Object.freeze({
+    status: "aborted"
+  }), M = (s) => ({
+    status: "dirty",
+    value: s
+  }), b = (s) => ({
+    status: "valid",
+    value: s
+  }), re = (s) => s.status === "aborted", ae = (s) => s.status === "dirty", I = (s) => s.status === "valid", U = (s) => typeof Promise < "u" && s instanceof Promise;
+  var h;
+  (function(s) {
+    s.errToObj = (e) => typeof e == "string" ? {
+      message: e
+    } : e || {}, s.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+  })(h || (h = {}));
+  class N {
+    constructor(e, t, r, a) {
+      this._cachedPath = [], this.parent = e, this.data = t, this._path = r, this._key = a;
+    }
+    get path() {
+      return this._cachedPath.length || (Array.isArray(this._key) ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+    }
+  }
+  const ne = (s, e) => {
+    if (I(e)) return {
+      success: true,
+      data: e.value
+    };
+    if (!s.common.issues.length) throw new Error("Validation failed but no issues detected.");
+    return {
+      success: false,
+      get error() {
+        if (this._error) return this._error;
+        const t = new O(s.common.issues);
+        return this._error = t, this._error;
+      }
+    };
+  };
+  function _(s) {
+    if (!s) return {};
+    const { errorMap: e, invalid_type_error: t, required_error: r, description: a } = s;
+    if (e && (t || r)) throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
+    return e ? {
+      errorMap: e,
+      description: a
+    } : {
+      errorMap: (i, o) => {
+        const { message: u } = s;
+        return i.code === "invalid_enum_value" ? {
+          message: u ?? o.defaultError
+        } : typeof o.data > "u" ? {
+          message: u ?? r ?? o.defaultError
+        } : i.code !== "invalid_type" ? {
+          message: o.defaultError
+        } : {
+          message: u ?? t ?? o.defaultError
+        };
+      },
+      description: a
+    };
+  }
+  class y {
+    get description() {
+      return this._def.description;
+    }
+    _getType(e) {
+      return T(e.data);
+    }
+    _getOrReturnCtx(e, t) {
+      return t || {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: T(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      };
+    }
+    _processInputParams(e) {
+      return {
+        status: new k(),
+        ctx: {
+          common: e.parent.common,
+          data: e.data,
+          parsedType: T(e.data),
+          schemaErrorMap: this._def.errorMap,
+          path: e.path,
+          parent: e.parent
+        }
+      };
+    }
+    _parseSync(e) {
+      const t = this._parse(e);
+      if (U(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 r = this.safeParse(e, t);
+      if (r.success) return r.data;
+      throw r.error;
+    }
+    safeParse(e, t) {
+      const r = {
+        common: {
+          issues: [],
+          async: (t == null ? void 0 : t.async) ?? false,
+          contextualErrorMap: t == null ? void 0 : t.errorMap
+        },
+        path: (t == null ? void 0 : t.path) || [],
+        schemaErrorMap: this._def.errorMap,
+        parent: null,
+        data: e,
+        parsedType: T(e)
+      }, a = this._parseSync({
+        data: e,
+        path: r.path,
+        parent: r
+      });
+      return ne(r, a);
+    }
+    "~validate"(e) {
+      var _a, _b;
+      const t = {
+        common: {
+          issues: [],
+          async: !!this["~standard"].async
+        },
+        path: [],
+        schemaErrorMap: this._def.errorMap,
+        parent: null,
+        data: e,
+        parsedType: T(e)
+      };
+      if (!this["~standard"].async) try {
+        const r = this._parseSync({
+          data: e,
+          path: [],
+          parent: t
+        });
+        return I(r) ? {
+          value: r.value
+        } : {
+          issues: t.common.issues
+        };
+      } catch (r) {
+        ((_b = (_a = r == null ? void 0 : r.message) == null ? void 0 : _a.toLowerCase()) == null ? void 0 : _b.includes("encountered")) && (this["~standard"].async = true), t.common = {
+          issues: [],
+          async: true
+        };
+      }
+      return this._parseAsync({
+        data: e,
+        path: [],
+        parent: t
+      }).then((r) => I(r) ? {
+        value: r.value
+      } : {
+        issues: t.common.issues
+      });
+    }
+    async parseAsync(e, t) {
+      const r = await this.safeParseAsync(e, t);
+      if (r.success) return r.data;
+      throw r.error;
+    }
+    async safeParseAsync(e, t) {
+      const r = {
+        common: {
+          issues: [],
+          contextualErrorMap: t == null ? void 0 : t.errorMap,
+          async: true
+        },
+        path: (t == null ? void 0 : t.path) || [],
+        schemaErrorMap: this._def.errorMap,
+        parent: null,
+        data: e,
+        parsedType: T(e)
+      }, a = this._parse({
+        data: e,
+        path: r.path,
+        parent: r
+      }), n = await (U(a) ? a : Promise.resolve(a));
+      return ne(r, n);
+    }
+    refine(e, t) {
+      const r = (a) => typeof t == "string" || typeof t > "u" ? {
+        message: t
+      } : typeof t == "function" ? t(a) : t;
+      return this._refinement((a, n) => {
+        const i = e(a), o = () => n.addIssue({
+          code: d.custom,
+          ...r(a)
+        });
+        return typeof Promise < "u" && i instanceof Promise ? i.then((u) => u ? true : (o(), false)) : i ? true : (o(), false);
+      });
+    }
+    refinement(e, t) {
+      return this._refinement((r, a) => e(r) ? true : (a.addIssue(typeof t == "function" ? t(r, a) : t), false));
+    }
+    _refinement(e) {
+      return new $({
+        schema: this,
+        typeName: p.ZodEffects,
+        effect: {
+          type: "refinement",
+          refinement: e
+        }
+      });
+    }
+    superRefine(e) {
+      return this._refinement(e);
+    }
+    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), this["~standard"] = {
+        version: 1,
+        vendor: "zod",
+        validate: (t) => this["~validate"](t)
+      };
+    }
+    optional() {
+      return S.create(this, this._def);
+    }
+    nullable() {
+      return V.create(this, this._def);
+    }
+    nullish() {
+      return this.nullable().optional();
+    }
+    array() {
+      return w.create(this);
+    }
+    promise() {
+      return J.create(this, this._def);
+    }
+    or(e) {
+      return F.create([
+        this,
+        e
+      ], this._def);
+    }
+    and(e) {
+      return W.create(this, e, this._def);
+    }
+    transform(e) {
+      return new $({
+        ..._(this._def),
+        schema: this,
+        typeName: p.ZodEffects,
+        effect: {
+          type: "transform",
+          transform: e
+        }
+      });
+    }
+    default(e) {
+      const t = typeof e == "function" ? e : () => e;
+      return new X({
+        ..._(this._def),
+        innerType: this,
+        defaultValue: t,
+        typeName: p.ZodDefault
+      });
+    }
+    brand() {
+      return new He({
+        typeName: p.ZodBranded,
+        type: this,
+        ..._(this._def)
+      });
+    }
+    catch(e) {
+      const t = typeof e == "function" ? e : () => e;
+      return new K({
+        ..._(this._def),
+        innerType: this,
+        catchValue: t,
+        typeName: p.ZodCatch
+      });
+    }
+    describe(e) {
+      const t = this.constructor;
+      return new t({
+        ...this._def,
+        description: e
+      });
+    }
+    pipe(e) {
+      return te.create(this, e);
+    }
+    readonly() {
+      return ee.create(this);
+    }
+    isOptional() {
+      return this.safeParse(void 0).success;
+    }
+    isNullable() {
+      return this.safeParse(null).success;
+    }
+  }
+  const Te = /^c[^\s-]{8,}$/i, Se = /^[0-9a-z]+$/, Ne = /^[0-9A-HJKMNP-TV-Z]{26}$/i, Ae = /^[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, Ze = /^[a-z0-9_-]{21}$/i, Re = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, je = /^[-+]?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)?)??$/, Ie = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, Ee = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+  let H;
+  const $e = /^(?:(?: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])$/, Ve = /^(?:(?: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])\/(3[0-2]|[12]?[0-9])$/, Me = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/, Pe = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, Le = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, ze = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, ve = "((\\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])))", De = new RegExp(`^${ve}$`);
+  function xe(s) {
+    let e = "[0-5]\\d";
+    s.precision ? e = `${e}\\.\\d{${s.precision}}` : s.precision == null && (e = `${e}(\\.\\d+)?`);
+    const t = s.precision ? "+" : "?";
+    return `([01]\\d|2[0-3]):[0-5]\\d(:${e})${t}`;
+  }
+  function Ue(s) {
+    return new RegExp(`^${xe(s)}$`);
+  }
+  function Be(s) {
+    let e = `${ve}T${xe(s)}`;
+    const t = [];
+    return t.push(s.local ? "Z?" : "Z"), s.offset && t.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${t.join("|")})`, new RegExp(`^${e}$`);
+  }
+  function Fe(s, e) {
+    return !!((e === "v4" || !e) && $e.test(s) || (e === "v6" || !e) && Me.test(s));
+  }
+  function We(s, e) {
+    if (!Re.test(s)) return false;
+    try {
+      const [t] = s.split("."), r = t.replace(/-/g, "+").replace(/_/g, "/").padEnd(t.length + (4 - t.length % 4) % 4, "="), a = JSON.parse(atob(r));
+      return !(typeof a != "object" || a === null || "typ" in a && (a == null ? void 0 : a.typ) !== "JWT" || !a.alg || e && a.alg !== e);
+    } catch {
+      return false;
+    }
+  }
+  function Je(s, e) {
+    return !!((e === "v4" || !e) && Ve.test(s) || (e === "v6" || !e) && Pe.test(s));
+  }
+  class Z extends y {
+    _parse(e) {
+      if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== f.string) {
+        const n = this._getOrReturnCtx(e);
+        return c(n, {
+          code: d.invalid_type,
+          expected: f.string,
+          received: n.parsedType
+        }), m;
+      }
+      const r = new k();
+      let a;
+      for (const n of this._def.checks) if (n.kind === "min") e.data.length < n.value && (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.too_small,
+        minimum: n.value,
+        type: "string",
+        inclusive: true,
+        exact: false,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "max") e.data.length > n.value && (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.too_big,
+        maximum: n.value,
+        type: "string",
+        inclusive: true,
+        exact: false,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "length") {
+        const i = e.data.length > n.value, o = e.data.length < n.value;
+        (i || o) && (a = this._getOrReturnCtx(e, a), i ? c(a, {
+          code: d.too_big,
+          maximum: n.value,
+          type: "string",
+          inclusive: true,
+          exact: true,
+          message: n.message
+        }) : o && c(a, {
+          code: d.too_small,
+          minimum: n.value,
+          type: "string",
+          inclusive: true,
+          exact: true,
+          message: n.message
+        }), r.dirty());
+      } else if (n.kind === "email") Ie.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "email",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "emoji") H || (H = new RegExp(Ee, "u")), H.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "emoji",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "uuid") Ae.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "uuid",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "nanoid") Ze.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "nanoid",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "cuid") Te.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "cuid",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "cuid2") Se.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "cuid2",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "ulid") Ne.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "ulid",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty());
+      else if (n.kind === "url") try {
+        new URL(e.data);
+      } catch {
+        a = this._getOrReturnCtx(e, a), c(a, {
+          validation: "url",
+          code: d.invalid_string,
+          message: n.message
+        }), r.dirty();
+      }
+      else n.kind === "regex" ? (n.regex.lastIndex = 0, n.regex.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "regex",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty())) : n.kind === "trim" ? e.data = e.data.trim() : n.kind === "includes" ? e.data.includes(n.value, n.position) || (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.invalid_string,
+        validation: {
+          includes: n.value,
+          position: n.position
+        },
+        message: n.message
+      }), r.dirty()) : n.kind === "toLowerCase" ? e.data = e.data.toLowerCase() : n.kind === "toUpperCase" ? e.data = e.data.toUpperCase() : n.kind === "startsWith" ? e.data.startsWith(n.value) || (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.invalid_string,
+        validation: {
+          startsWith: n.value
+        },
+        message: n.message
+      }), r.dirty()) : n.kind === "endsWith" ? e.data.endsWith(n.value) || (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.invalid_string,
+        validation: {
+          endsWith: n.value
+        },
+        message: n.message
+      }), r.dirty()) : n.kind === "datetime" ? Be(n).test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.invalid_string,
+        validation: "datetime",
+        message: n.message
+      }), r.dirty()) : n.kind === "date" ? De.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.invalid_string,
+        validation: "date",
+        message: n.message
+      }), r.dirty()) : n.kind === "time" ? Ue(n).test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.invalid_string,
+        validation: "time",
+        message: n.message
+      }), r.dirty()) : n.kind === "duration" ? je.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "duration",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty()) : n.kind === "ip" ? Fe(e.data, n.version) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "ip",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty()) : n.kind === "jwt" ? We(e.data, n.alg) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "jwt",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty()) : n.kind === "cidr" ? Je(e.data, n.version) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "cidr",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty()) : n.kind === "base64" ? Le.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "base64",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty()) : n.kind === "base64url" ? ze.test(e.data) || (a = this._getOrReturnCtx(e, a), c(a, {
+        validation: "base64url",
+        code: d.invalid_string,
+        message: n.message
+      }), r.dirty()) : v.assertNever(n);
+      return {
+        status: r.value,
+        value: e.data
+      };
+    }
+    _regex(e, t, r) {
+      return this.refinement((a) => e.test(a), {
+        validation: t,
+        code: d.invalid_string,
+        ...h.errToObj(r)
+      });
+    }
+    _addCheck(e) {
+      return new Z({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          e
+        ]
+      });
+    }
+    email(e) {
+      return this._addCheck({
+        kind: "email",
+        ...h.errToObj(e)
+      });
+    }
+    url(e) {
+      return this._addCheck({
+        kind: "url",
+        ...h.errToObj(e)
+      });
+    }
+    emoji(e) {
+      return this._addCheck({
+        kind: "emoji",
+        ...h.errToObj(e)
+      });
+    }
+    uuid(e) {
+      return this._addCheck({
+        kind: "uuid",
+        ...h.errToObj(e)
+      });
+    }
+    nanoid(e) {
+      return this._addCheck({
+        kind: "nanoid",
+        ...h.errToObj(e)
+      });
+    }
+    cuid(e) {
+      return this._addCheck({
+        kind: "cuid",
+        ...h.errToObj(e)
+      });
+    }
+    cuid2(e) {
+      return this._addCheck({
+        kind: "cuid2",
+        ...h.errToObj(e)
+      });
+    }
+    ulid(e) {
+      return this._addCheck({
+        kind: "ulid",
+        ...h.errToObj(e)
+      });
+    }
+    base64(e) {
+      return this._addCheck({
+        kind: "base64",
+        ...h.errToObj(e)
+      });
+    }
+    base64url(e) {
+      return this._addCheck({
+        kind: "base64url",
+        ...h.errToObj(e)
+      });
+    }
+    jwt(e) {
+      return this._addCheck({
+        kind: "jwt",
+        ...h.errToObj(e)
+      });
+    }
+    ip(e) {
+      return this._addCheck({
+        kind: "ip",
+        ...h.errToObj(e)
+      });
+    }
+    cidr(e) {
+      return this._addCheck({
+        kind: "cidr",
+        ...h.errToObj(e)
+      });
+    }
+    datetime(e) {
+      return typeof e == "string" ? this._addCheck({
+        kind: "datetime",
+        precision: null,
+        offset: false,
+        local: false,
+        message: e
+      }) : this._addCheck({
+        kind: "datetime",
+        precision: typeof (e == null ? void 0 : e.precision) > "u" ? null : e == null ? void 0 : e.precision,
+        offset: (e == null ? void 0 : e.offset) ?? false,
+        local: (e == null ? void 0 : e.local) ?? false,
+        ...h.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,
+        ...h.errToObj(e == null ? void 0 : e.message)
+      });
+    }
+    duration(e) {
+      return this._addCheck({
+        kind: "duration",
+        ...h.errToObj(e)
+      });
+    }
+    regex(e, t) {
+      return this._addCheck({
+        kind: "regex",
+        regex: e,
+        ...h.errToObj(t)
+      });
+    }
+    includes(e, t) {
+      return this._addCheck({
+        kind: "includes",
+        value: e,
+        position: t == null ? void 0 : t.position,
+        ...h.errToObj(t == null ? void 0 : t.message)
+      });
+    }
+    startsWith(e, t) {
+      return this._addCheck({
+        kind: "startsWith",
+        value: e,
+        ...h.errToObj(t)
+      });
+    }
+    endsWith(e, t) {
+      return this._addCheck({
+        kind: "endsWith",
+        value: e,
+        ...h.errToObj(t)
+      });
+    }
+    min(e, t) {
+      return this._addCheck({
+        kind: "min",
+        value: e,
+        ...h.errToObj(t)
+      });
+    }
+    max(e, t) {
+      return this._addCheck({
+        kind: "max",
+        value: e,
+        ...h.errToObj(t)
+      });
+    }
+    length(e, t) {
+      return this._addCheck({
+        kind: "length",
+        value: e,
+        ...h.errToObj(t)
+      });
+    }
+    nonempty(e) {
+      return this.min(1, h.errToObj(e));
+    }
+    trim() {
+      return new Z({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          {
+            kind: "trim"
+          }
+        ]
+      });
+    }
+    toLowerCase() {
+      return new Z({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          {
+            kind: "toLowerCase"
+          }
+        ]
+      });
+    }
+    toUpperCase() {
+      return new Z({
+        ...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 isCIDR() {
+      return !!this._def.checks.find((e) => e.kind === "cidr");
+    }
+    get isBase64() {
+      return !!this._def.checks.find((e) => e.kind === "base64");
+    }
+    get isBase64url() {
+      return !!this._def.checks.find((e) => e.kind === "base64url");
+    }
+    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;
+    }
+  }
+  Z.create = (s) => new Z({
+    checks: [],
+    typeName: p.ZodString,
+    coerce: (s == null ? void 0 : s.coerce) ?? false,
+    ..._(s)
+  });
+  function qe(s, e) {
+    const t = (s.toString().split(".")[1] || "").length, r = (e.toString().split(".")[1] || "").length, a = t > r ? t : r, n = Number.parseInt(s.toFixed(a).replace(".", "")), i = Number.parseInt(e.toFixed(a).replace(".", ""));
+    return n % i / 10 ** a;
+  }
+  class P extends y {
+    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) !== f.number) {
+        const n = this._getOrReturnCtx(e);
+        return c(n, {
+          code: d.invalid_type,
+          expected: f.number,
+          received: n.parsedType
+        }), m;
+      }
+      let r;
+      const a = new k();
+      for (const n of this._def.checks) n.kind === "int" ? v.isInteger(e.data) || (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: n.message
+      }), a.dirty()) : n.kind === "min" ? (n.inclusive ? e.data < n.value : e.data <= n.value) && (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.too_small,
+        minimum: n.value,
+        type: "number",
+        inclusive: n.inclusive,
+        exact: false,
+        message: n.message
+      }), a.dirty()) : n.kind === "max" ? (n.inclusive ? e.data > n.value : e.data >= n.value) && (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.too_big,
+        maximum: n.value,
+        type: "number",
+        inclusive: n.inclusive,
+        exact: false,
+        message: n.message
+      }), a.dirty()) : n.kind === "multipleOf" ? qe(e.data, n.value) !== 0 && (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.not_multiple_of,
+        multipleOf: n.value,
+        message: n.message
+      }), a.dirty()) : n.kind === "finite" ? Number.isFinite(e.data) || (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.not_finite,
+        message: n.message
+      }), a.dirty()) : v.assertNever(n);
+      return {
+        status: a.value,
+        value: e.data
+      };
+    }
+    gte(e, t) {
+      return this.setLimit("min", e, true, h.toString(t));
+    }
+    gt(e, t) {
+      return this.setLimit("min", e, false, h.toString(t));
+    }
+    lte(e, t) {
+      return this.setLimit("max", e, true, h.toString(t));
+    }
+    lt(e, t) {
+      return this.setLimit("max", e, false, h.toString(t));
+    }
+    setLimit(e, t, r, a) {
+      return new P({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          {
+            kind: e,
+            value: t,
+            inclusive: r,
+            message: h.toString(a)
+          }
+        ]
+      });
+    }
+    _addCheck(e) {
+      return new P({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          e
+        ]
+      });
+    }
+    int(e) {
+      return this._addCheck({
+        kind: "int",
+        message: h.toString(e)
+      });
+    }
+    positive(e) {
+      return this._addCheck({
+        kind: "min",
+        value: 0,
+        inclusive: false,
+        message: h.toString(e)
+      });
+    }
+    negative(e) {
+      return this._addCheck({
+        kind: "max",
+        value: 0,
+        inclusive: false,
+        message: h.toString(e)
+      });
+    }
+    nonpositive(e) {
+      return this._addCheck({
+        kind: "max",
+        value: 0,
+        inclusive: true,
+        message: h.toString(e)
+      });
+    }
+    nonnegative(e) {
+      return this._addCheck({
+        kind: "min",
+        value: 0,
+        inclusive: true,
+        message: h.toString(e)
+      });
+    }
+    multipleOf(e, t) {
+      return this._addCheck({
+        kind: "multipleOf",
+        value: e,
+        message: h.toString(t)
+      });
+    }
+    finite(e) {
+      return this._addCheck({
+        kind: "finite",
+        message: h.toString(e)
+      });
+    }
+    safe(e) {
+      return this._addCheck({
+        kind: "min",
+        inclusive: true,
+        value: Number.MIN_SAFE_INTEGER,
+        message: h.toString(e)
+      })._addCheck({
+        kind: "max",
+        inclusive: true,
+        value: Number.MAX_SAFE_INTEGER,
+        message: h.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" && v.isInteger(e.value));
+    }
+    get isFinite() {
+      let e = null, t = null;
+      for (const r of this._def.checks) {
+        if (r.kind === "finite" || r.kind === "int" || r.kind === "multipleOf") return true;
+        r.kind === "min" ? (t === null || r.value > t) && (t = r.value) : r.kind === "max" && (e === null || r.value < e) && (e = r.value);
+      }
+      return Number.isFinite(t) && Number.isFinite(e);
+    }
+  }
+  P.create = (s) => new P({
+    checks: [],
+    typeName: p.ZodNumber,
+    coerce: (s == null ? void 0 : s.coerce) || false,
+    ..._(s)
+  });
+  class L extends y {
+    constructor() {
+      super(...arguments), this.min = this.gte, this.max = this.lte;
+    }
+    _parse(e) {
+      if (this._def.coerce) try {
+        e.data = BigInt(e.data);
+      } catch {
+        return this._getInvalidInput(e);
+      }
+      if (this._getType(e) !== f.bigint) return this._getInvalidInput(e);
+      let r;
+      const a = new k();
+      for (const n of this._def.checks) n.kind === "min" ? (n.inclusive ? e.data < n.value : e.data <= n.value) && (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.too_small,
+        type: "bigint",
+        minimum: n.value,
+        inclusive: n.inclusive,
+        message: n.message
+      }), a.dirty()) : n.kind === "max" ? (n.inclusive ? e.data > n.value : e.data >= n.value) && (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.too_big,
+        type: "bigint",
+        maximum: n.value,
+        inclusive: n.inclusive,
+        message: n.message
+      }), a.dirty()) : n.kind === "multipleOf" ? e.data % n.value !== BigInt(0) && (r = this._getOrReturnCtx(e, r), c(r, {
+        code: d.not_multiple_of,
+        multipleOf: n.value,
+        message: n.message
+      }), a.dirty()) : v.assertNever(n);
+      return {
+        status: a.value,
+        value: e.data
+      };
+    }
+    _getInvalidInput(e) {
+      const t = this._getOrReturnCtx(e);
+      return c(t, {
+        code: d.invalid_type,
+        expected: f.bigint,
+        received: t.parsedType
+      }), m;
+    }
+    gte(e, t) {
+      return this.setLimit("min", e, true, h.toString(t));
+    }
+    gt(e, t) {
+      return this.setLimit("min", e, false, h.toString(t));
+    }
+    lte(e, t) {
+      return this.setLimit("max", e, true, h.toString(t));
+    }
+    lt(e, t) {
+      return this.setLimit("max", e, false, h.toString(t));
+    }
+    setLimit(e, t, r, a) {
+      return new L({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          {
+            kind: e,
+            value: t,
+            inclusive: r,
+            message: h.toString(a)
+          }
+        ]
+      });
+    }
+    _addCheck(e) {
+      return new L({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          e
+        ]
+      });
+    }
+    positive(e) {
+      return this._addCheck({
+        kind: "min",
+        value: BigInt(0),
+        inclusive: false,
+        message: h.toString(e)
+      });
+    }
+    negative(e) {
+      return this._addCheck({
+        kind: "max",
+        value: BigInt(0),
+        inclusive: false,
+        message: h.toString(e)
+      });
+    }
+    nonpositive(e) {
+      return this._addCheck({
+        kind: "max",
+        value: BigInt(0),
+        inclusive: true,
+        message: h.toString(e)
+      });
+    }
+    nonnegative(e) {
+      return this._addCheck({
+        kind: "min",
+        value: BigInt(0),
+        inclusive: true,
+        message: h.toString(e)
+      });
+    }
+    multipleOf(e, t) {
+      return this._addCheck({
+        kind: "multipleOf",
+        value: e,
+        message: h.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;
+    }
+  }
+  L.create = (s) => new L({
+    checks: [],
+    typeName: p.ZodBigInt,
+    coerce: (s == null ? void 0 : s.coerce) ?? false,
+    ..._(s)
+  });
+  class ie extends y {
+    _parse(e) {
+      if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== f.boolean) {
+        const r = this._getOrReturnCtx(e);
+        return c(r, {
+          code: d.invalid_type,
+          expected: f.boolean,
+          received: r.parsedType
+        }), m;
+      }
+      return b(e.data);
+    }
+  }
+  ie.create = (s) => new ie({
+    typeName: p.ZodBoolean,
+    coerce: (s == null ? void 0 : s.coerce) || false,
+    ..._(s)
+  });
+  class B extends y {
+    _parse(e) {
+      if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== f.date) {
+        const n = this._getOrReturnCtx(e);
+        return c(n, {
+          code: d.invalid_type,
+          expected: f.date,
+          received: n.parsedType
+        }), m;
+      }
+      if (Number.isNaN(e.data.getTime())) {
+        const n = this._getOrReturnCtx(e);
+        return c(n, {
+          code: d.invalid_date
+        }), m;
+      }
+      const r = new k();
+      let a;
+      for (const n of this._def.checks) n.kind === "min" ? e.data.getTime() < n.value && (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.too_small,
+        message: n.message,
+        inclusive: true,
+        exact: false,
+        minimum: n.value,
+        type: "date"
+      }), r.dirty()) : n.kind === "max" ? e.data.getTime() > n.value && (a = this._getOrReturnCtx(e, a), c(a, {
+        code: d.too_big,
+        message: n.message,
+        inclusive: true,
+        exact: false,
+        maximum: n.value,
+        type: "date"
+      }), r.dirty()) : v.assertNever(n);
+      return {
+        status: r.value,
+        value: new Date(e.data.getTime())
+      };
+    }
+    _addCheck(e) {
+      return new B({
+        ...this._def,
+        checks: [
+          ...this._def.checks,
+          e
+        ]
+      });
+    }
+    min(e, t) {
+      return this._addCheck({
+        kind: "min",
+        value: e.getTime(),
+        message: h.toString(t)
+      });
+    }
+    max(e, t) {
+      return this._addCheck({
+        kind: "max",
+        value: e.getTime(),
+        message: h.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;
+    }
+  }
+  B.create = (s) => new B({
+    checks: [],
+    coerce: (s == null ? void 0 : s.coerce) || false,
+    typeName: p.ZodDate,
+    ..._(s)
+  });
+  class oe extends y {
+    _parse(e) {
+      if (this._getType(e) !== f.symbol) {
+        const r = this._getOrReturnCtx(e);
+        return c(r, {
+          code: d.invalid_type,
+          expected: f.symbol,
+          received: r.parsedType
+        }), m;
+      }
+      return b(e.data);
+    }
+  }
+  oe.create = (s) => new oe({
+    typeName: p.ZodSymbol,
+    ..._(s)
+  });
+  class de extends y {
+    _parse(e) {
+      if (this._getType(e) !== f.undefined) {
+        const r = this._getOrReturnCtx(e);
+        return c(r, {
+          code: d.invalid_type,
+          expected: f.undefined,
+          received: r.parsedType
+        }), m;
+      }
+      return b(e.data);
+    }
+  }
+  de.create = (s) => new de({
+    typeName: p.ZodUndefined,
+    ..._(s)
+  });
+  class ce extends y {
+    _parse(e) {
+      if (this._getType(e) !== f.null) {
+        const r = this._getOrReturnCtx(e);
+        return c(r, {
+          code: d.invalid_type,
+          expected: f.null,
+          received: r.parsedType
+        }), m;
+      }
+      return b(e.data);
+    }
+  }
+  ce.create = (s) => new ce({
+    typeName: p.ZodNull,
+    ..._(s)
+  });
+  class G extends y {
+    constructor() {
+      super(...arguments), this._any = true;
+    }
+    _parse(e) {
+      return b(e.data);
+    }
+  }
+  G.create = (s) => new G({
+    typeName: p.ZodAny,
+    ..._(s)
+  });
+  class ue extends y {
+    constructor() {
+      super(...arguments), this._unknown = true;
+    }
+    _parse(e) {
+      return b(e.data);
+    }
+  }
+  ue.create = (s) => new ue({
+    typeName: p.ZodUnknown,
+    ..._(s)
+  });
+  class A extends y {
+    _parse(e) {
+      const t = this._getOrReturnCtx(e);
+      return c(t, {
+        code: d.invalid_type,
+        expected: f.never,
+        received: t.parsedType
+      }), m;
+    }
+  }
+  A.create = (s) => new A({
+    typeName: p.ZodNever,
+    ..._(s)
+  });
+  class le extends y {
+    _parse(e) {
+      if (this._getType(e) !== f.undefined) {
+        const r = this._getOrReturnCtx(e);
+        return c(r, {
+          code: d.invalid_type,
+          expected: f.void,
+          received: r.parsedType
+        }), m;
+      }
+      return b(e.data);
+    }
+  }
+  le.create = (s) => new le({
+    typeName: p.ZodVoid,
+    ..._(s)
+  });
+  class w extends y {
+    _parse(e) {
+      const { ctx: t, status: r } = this._processInputParams(e), a = this._def;
+      if (t.parsedType !== f.array) return c(t, {
+        code: d.invalid_type,
+        expected: f.array,
+        received: t.parsedType
+      }), m;
+      if (a.exactLength !== null) {
+        const i = t.data.length > a.exactLength.value, o = t.data.length < a.exactLength.value;
+        (i || o) && (c(t, {
+          code: i ? d.too_big : d.too_small,
+          minimum: o ? a.exactLength.value : void 0,
+          maximum: i ? a.exactLength.value : void 0,
+          type: "array",
+          inclusive: true,
+          exact: true,
+          message: a.exactLength.message
+        }), r.dirty());
+      }
+      if (a.minLength !== null && t.data.length < a.minLength.value && (c(t, {
+        code: d.too_small,
+        minimum: a.minLength.value,
+        type: "array",
+        inclusive: true,
+        exact: false,
+        message: a.minLength.message
+      }), r.dirty()), a.maxLength !== null && t.data.length > a.maxLength.value && (c(t, {
+        code: d.too_big,
+        maximum: a.maxLength.value,
+        type: "array",
+        inclusive: true,
+        exact: false,
+        message: a.maxLength.message
+      }), r.dirty()), t.common.async) return Promise.all([
+        ...t.data
+      ].map((i, o) => a.type._parseAsync(new N(t, i, t.path, o)))).then((i) => k.mergeArray(r, i));
+      const n = [
+        ...t.data
+      ].map((i, o) => a.type._parseSync(new N(t, i, t.path, o)));
+      return k.mergeArray(r, n);
+    }
+    get element() {
+      return this._def.type;
+    }
+    min(e, t) {
+      return new w({
+        ...this._def,
+        minLength: {
+          value: e,
+          message: h.toString(t)
+        }
+      });
+    }
+    max(e, t) {
+      return new w({
+        ...this._def,
+        maxLength: {
+          value: e,
+          message: h.toString(t)
+        }
+      });
+    }
+    length(e, t) {
+      return new w({
+        ...this._def,
+        exactLength: {
+          value: e,
+          message: h.toString(t)
+        }
+      });
+    }
+    nonempty(e) {
+      return this.min(1, e);
+    }
+  }
+  w.create = (s, e) => new w({
+    type: s,
+    minLength: null,
+    maxLength: null,
+    exactLength: null,
+    typeName: p.ZodArray,
+    ..._(e)
+  });
+  function j(s) {
+    if (s instanceof x) {
+      const e = {};
+      for (const t in s.shape) {
+        const r = s.shape[t];
+        e[t] = S.create(j(r));
+      }
+      return new x({
+        ...s._def,
+        shape: () => e
+      });
+    } else return s instanceof w ? new w({
+      ...s._def,
+      type: j(s.element)
+    }) : s instanceof S ? S.create(j(s.unwrap())) : s instanceof V ? V.create(j(s.unwrap())) : s instanceof R ? R.create(s.items.map((e) => j(e))) : s;
+  }
+  class x extends y {
+    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 = v.objectKeys(e);
+      return this._cached = {
+        shape: e,
+        keys: t
+      }, this._cached;
+    }
+    _parse(e) {
+      if (this._getType(e) !== f.object) {
+        const l = this._getOrReturnCtx(e);
+        return c(l, {
+          code: d.invalid_type,
+          expected: f.object,
+          received: l.parsedType
+        }), m;
+      }
+      const { status: r, ctx: a } = this._processInputParams(e), { shape: n, keys: i } = this._getCached(), o = [];
+      if (!(this._def.catchall instanceof A && this._def.unknownKeys === "strip")) for (const l in a.data) i.includes(l) || o.push(l);
+      const u = [];
+      for (const l of i) {
+        const g = n[l], C = a.data[l];
+        u.push({
+          key: {
+            status: "valid",
+            value: l
+          },
+          value: g._parse(new N(a, C, a.path, l)),
+          alwaysSet: l in a.data
+        });
+      }
+      if (this._def.catchall instanceof A) {
+        const l = this._def.unknownKeys;
+        if (l === "passthrough") for (const g of o) u.push({
+          key: {
+            status: "valid",
+            value: g
+          },
+          value: {
+            status: "valid",
+            value: a.data[g]
+          }
+        });
+        else if (l === "strict") o.length > 0 && (c(a, {
+          code: d.unrecognized_keys,
+          keys: o
+        }), r.dirty());
+        else if (l !== "strip") throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+      } else {
+        const l = this._def.catchall;
+        for (const g of o) {
+          const C = a.data[g];
+          u.push({
+            key: {
+              status: "valid",
+              value: g
+            },
+            value: l._parse(new N(a, C, a.path, g)),
+            alwaysSet: g in a.data
+          });
+        }
+      }
+      return a.common.async ? Promise.resolve().then(async () => {
+        const l = [];
+        for (const g of u) {
+          const C = await g.key, q = await g.value;
+          l.push({
+            key: C,
+            value: q,
+            alwaysSet: g.alwaysSet
+          });
+        }
+        return l;
+      }).then((l) => k.mergeObjectSync(r, l)) : k.mergeObjectSync(r, u);
+    }
+    get shape() {
+      return this._def.shape();
+    }
+    strict(e) {
+      return h.errToObj, new x({
+        ...this._def,
+        unknownKeys: "strict",
+        ...e !== void 0 ? {
+          errorMap: (t, r) => {
+            var _a, _b;
+            const a = ((_b = (_a = this._def).errorMap) == null ? void 0 : _b.call(_a, t, r).message) ?? r.defaultError;
+            return t.code === "unrecognized_keys" ? {
+              message: h.errToObj(e).message ?? a
+            } : {
+              message: a
+            };
+          }
+        } : {}
+      });
+    }
+    strip() {
+      return new x({
+        ...this._def,
+        unknownKeys: "strip"
+      });
+    }
+    passthrough() {
+      return new x({
+        ...this._def,
+        unknownKeys: "passthrough"
+      });
+    }
+    extend(e) {
+      return new x({
+        ...this._def,
+        shape: () => ({
+          ...this._def.shape(),
+          ...e
+        })
+      });
+    }
+    merge(e) {
+      return new x({
+        unknownKeys: e._def.unknownKeys,
+        catchall: e._def.catchall,
+        shape: () => ({
+          ...this._def.shape(),
+          ...e._def.shape()
+        }),
+        typeName: p.ZodObject
+      });
+    }
+    setKey(e, t) {
+      return this.augment({
+        [e]: t
+      });
+    }
+    catchall(e) {
+      return new x({
+        ...this._def,
+        catchall: e
+      });
+    }
+    pick(e) {
+      const t = {};
+      for (const r of v.objectKeys(e)) e[r] && this.shape[r] && (t[r] = this.shape[r]);
+      return new x({
+        ...this._def,
+        shape: () => t
+      });
+    }
+    omit(e) {
+      const t = {};
+      for (const r of v.objectKeys(this.shape)) e[r] || (t[r] = this.shape[r]);
+      return new x({
+        ...this._def,
+        shape: () => t
+      });
+    }
+    deepPartial() {
+      return j(this);
+    }
+    partial(e) {
+      const t = {};
+      for (const r of v.objectKeys(this.shape)) {
+        const a = this.shape[r];
+        e && !e[r] ? t[r] = a : t[r] = a.optional();
+      }
+      return new x({
+        ...this._def,
+        shape: () => t
+      });
+    }
+    required(e) {
+      const t = {};
+      for (const r of v.objectKeys(this.shape)) if (e && !e[r]) t[r] = this.shape[r];
+      else {
+        let n = this.shape[r];
+        for (; n instanceof S; ) n = n._def.innerType;
+        t[r] = n;
+      }
+      return new x({
+        ...this._def,
+        shape: () => t
+      });
+    }
+    keyof() {
+      return ke(v.objectKeys(this.shape));
+    }
+  }
+  x.create = (s, e) => new x({
+    shape: () => s,
+    unknownKeys: "strip",
+    catchall: A.create(),
+    typeName: p.ZodObject,
+    ..._(e)
+  });
+  x.strictCreate = (s, e) => new x({
+    shape: () => s,
+    unknownKeys: "strict",
+    catchall: A.create(),
+    typeName: p.ZodObject,
+    ..._(e)
+  });
+  x.lazycreate = (s, e) => new x({
+    shape: s,
+    unknownKeys: "strip",
+    catchall: A.create(),
+    typeName: p.ZodObject,
+    ..._(e)
+  });
+  class F extends y {
+    _parse(e) {
+      const { ctx: t } = this._processInputParams(e), r = this._def.options;
+      function a(n) {
+        for (const o of n) if (o.result.status === "valid") return o.result;
+        for (const o of n) if (o.result.status === "dirty") return t.common.issues.push(...o.ctx.common.issues), o.result;
+        const i = n.map((o) => new O(o.ctx.common.issues));
+        return c(t, {
+          code: d.invalid_union,
+          unionErrors: i
+        }), m;
+      }
+      if (t.common.async) return Promise.all(r.map(async (n) => {
+        const i = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        };
+        return {
+          result: await n._parseAsync({
+            data: t.data,
+            path: t.path,
+            parent: i
+          }),
+          ctx: i
+        };
+      })).then(a);
+      {
+        let n;
+        const i = [];
+        for (const u of r) {
+          const l = {
+            ...t,
+            common: {
+              ...t.common,
+              issues: []
+            },
+            parent: null
+          }, g = u._parseSync({
+            data: t.data,
+            path: t.path,
+            parent: l
+          });
+          if (g.status === "valid") return g;
+          g.status === "dirty" && !n && (n = {
+            result: g,
+            ctx: l
+          }), l.common.issues.length && i.push(l.common.issues);
+        }
+        if (n) return t.common.issues.push(...n.ctx.common.issues), n.result;
+        const o = i.map((u) => new O(u));
+        return c(t, {
+          code: d.invalid_union,
+          unionErrors: o
+        }), m;
+      }
+    }
+    get options() {
+      return this._def.options;
+    }
+  }
+  F.create = (s, e) => new F({
+    options: s,
+    typeName: p.ZodUnion,
+    ..._(e)
+  });
+  function Q(s, e) {
+    const t = T(s), r = T(e);
+    if (s === e) return {
+      valid: true,
+      data: s
+    };
+    if (t === f.object && r === f.object) {
+      const a = v.objectKeys(e), n = v.objectKeys(s).filter((o) => a.indexOf(o) !== -1), i = {
+        ...s,
+        ...e
+      };
+      for (const o of n) {
+        const u = Q(s[o], e[o]);
+        if (!u.valid) return {
+          valid: false
+        };
+        i[o] = u.data;
+      }
+      return {
+        valid: true,
+        data: i
+      };
+    } else if (t === f.array && r === f.array) {
+      if (s.length !== e.length) return {
+        valid: false
+      };
+      const a = [];
+      for (let n = 0; n < s.length; n++) {
+        const i = s[n], o = e[n], u = Q(i, o);
+        if (!u.valid) return {
+          valid: false
+        };
+        a.push(u.data);
+      }
+      return {
+        valid: true,
+        data: a
+      };
+    } else return t === f.date && r === f.date && +s == +e ? {
+      valid: true,
+      data: s
+    } : {
+      valid: false
+    };
+  }
+  class W extends y {
+    _parse(e) {
+      const { status: t, ctx: r } = this._processInputParams(e), a = (n, i) => {
+        if (re(n) || re(i)) return m;
+        const o = Q(n.value, i.value);
+        return o.valid ? ((ae(n) || ae(i)) && t.dirty(), {
+          status: t.value,
+          value: o.data
+        }) : (c(r, {
+          code: d.invalid_intersection_types
+        }), m);
+      };
+      return r.common.async ? Promise.all([
+        this._def.left._parseAsync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        }),
+        this._def.right._parseAsync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        })
+      ]).then(([n, i]) => a(n, i)) : a(this._def.left._parseSync({
+        data: r.data,
+        path: r.path,
+        parent: r
+      }), this._def.right._parseSync({
+        data: r.data,
+        path: r.path,
+        parent: r
+      }));
+    }
+  }
+  W.create = (s, e, t) => new W({
+    left: s,
+    right: e,
+    typeName: p.ZodIntersection,
+    ..._(t)
+  });
+  class R extends y {
+    _parse(e) {
+      const { status: t, ctx: r } = this._processInputParams(e);
+      if (r.parsedType !== f.array) return c(r, {
+        code: d.invalid_type,
+        expected: f.array,
+        received: r.parsedType
+      }), m;
+      if (r.data.length < this._def.items.length) return c(r, {
+        code: d.too_small,
+        minimum: this._def.items.length,
+        inclusive: true,
+        exact: false,
+        type: "array"
+      }), m;
+      !this._def.rest && r.data.length > this._def.items.length && (c(r, {
+        code: d.too_big,
+        maximum: this._def.items.length,
+        inclusive: true,
+        exact: false,
+        type: "array"
+      }), t.dirty());
+      const n = [
+        ...r.data
+      ].map((i, o) => {
+        const u = this._def.items[o] || this._def.rest;
+        return u ? u._parse(new N(r, i, r.path, o)) : null;
+      }).filter((i) => !!i);
+      return r.common.async ? Promise.all(n).then((i) => k.mergeArray(t, i)) : k.mergeArray(t, n);
+    }
+    get items() {
+      return this._def.items;
+    }
+    rest(e) {
+      return new R({
+        ...this._def,
+        rest: e
+      });
+    }
+  }
+  R.create = (s, e) => {
+    if (!Array.isArray(s)) throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+    return new R({
+      items: s,
+      typeName: p.ZodTuple,
+      rest: null,
+      ..._(e)
+    });
+  };
+  class fe extends y {
+    get keySchema() {
+      return this._def.keyType;
+    }
+    get valueSchema() {
+      return this._def.valueType;
+    }
+    _parse(e) {
+      const { status: t, ctx: r } = this._processInputParams(e);
+      if (r.parsedType !== f.map) return c(r, {
+        code: d.invalid_type,
+        expected: f.map,
+        received: r.parsedType
+      }), m;
+      const a = this._def.keyType, n = this._def.valueType, i = [
+        ...r.data.entries()
+      ].map(([o, u], l) => ({
+        key: a._parse(new N(r, o, r.path, [
+          l,
+          "key"
+        ])),
+        value: n._parse(new N(r, u, r.path, [
+          l,
+          "value"
+        ]))
+      }));
+      if (r.common.async) {
+        const o = /* @__PURE__ */ new Map();
+        return Promise.resolve().then(async () => {
+          for (const u of i) {
+            const l = await u.key, g = await u.value;
+            if (l.status === "aborted" || g.status === "aborted") return m;
+            (l.status === "dirty" || g.status === "dirty") && t.dirty(), o.set(l.value, g.value);
+          }
+          return {
+            status: t.value,
+            value: o
+          };
+        });
+      } else {
+        const o = /* @__PURE__ */ new Map();
+        for (const u of i) {
+          const l = u.key, g = u.value;
+          if (l.status === "aborted" || g.status === "aborted") return m;
+          (l.status === "dirty" || g.status === "dirty") && t.dirty(), o.set(l.value, g.value);
+        }
+        return {
+          status: t.value,
+          value: o
+        };
+      }
+    }
+  }
+  fe.create = (s, e, t) => new fe({
+    valueType: e,
+    keyType: s,
+    typeName: p.ZodMap,
+    ..._(t)
+  });
+  class z extends y {
+    _parse(e) {
+      const { status: t, ctx: r } = this._processInputParams(e);
+      if (r.parsedType !== f.set) return c(r, {
+        code: d.invalid_type,
+        expected: f.set,
+        received: r.parsedType
+      }), m;
+      const a = this._def;
+      a.minSize !== null && r.data.size < a.minSize.value && (c(r, {
+        code: d.too_small,
+        minimum: a.minSize.value,
+        type: "set",
+        inclusive: true,
+        exact: false,
+        message: a.minSize.message
+      }), t.dirty()), a.maxSize !== null && r.data.size > a.maxSize.value && (c(r, {
+        code: d.too_big,
+        maximum: a.maxSize.value,
+        type: "set",
+        inclusive: true,
+        exact: false,
+        message: a.maxSize.message
+      }), t.dirty());
+      const n = this._def.valueType;
+      function i(u) {
+        const l = /* @__PURE__ */ new Set();
+        for (const g of u) {
+          if (g.status === "aborted") return m;
+          g.status === "dirty" && t.dirty(), l.add(g.value);
+        }
+        return {
+          status: t.value,
+          value: l
+        };
+      }
+      const o = [
+        ...r.data.values()
+      ].map((u, l) => n._parse(new N(r, u, r.path, l)));
+      return r.common.async ? Promise.all(o).then((u) => i(u)) : i(o);
+    }
+    min(e, t) {
+      return new z({
+        ...this._def,
+        minSize: {
+          value: e,
+          message: h.toString(t)
+        }
+      });
+    }
+    max(e, t) {
+      return new z({
+        ...this._def,
+        maxSize: {
+          value: e,
+          message: h.toString(t)
+        }
+      });
+    }
+    size(e, t) {
+      return this.min(e, t).max(e, t);
+    }
+    nonempty(e) {
+      return this.min(1, e);
+    }
+  }
+  z.create = (s, e) => new z({
+    valueType: s,
+    minSize: null,
+    maxSize: null,
+    typeName: p.ZodSet,
+    ..._(e)
+  });
+  class he extends y {
+    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
+      });
+    }
+  }
+  he.create = (s, e) => new he({
+    getter: s,
+    typeName: p.ZodLazy,
+    ..._(e)
+  });
+  class me extends y {
+    _parse(e) {
+      if (e.data !== this._def.value) {
+        const t = this._getOrReturnCtx(e);
+        return c(t, {
+          received: t.data,
+          code: d.invalid_literal,
+          expected: this._def.value
+        }), m;
+      }
+      return {
+        status: "valid",
+        value: e.data
+      };
+    }
+    get value() {
+      return this._def.value;
+    }
+  }
+  me.create = (s, e) => new me({
+    value: s,
+    typeName: p.ZodLiteral,
+    ..._(e)
+  });
+  function ke(s, e) {
+    return new E({
+      values: s,
+      typeName: p.ZodEnum,
+      ..._(e)
+    });
+  }
+  class E extends y {
+    _parse(e) {
+      if (typeof e.data != "string") {
+        const t = this._getOrReturnCtx(e), r = this._def.values;
+        return c(t, {
+          expected: v.joinValues(r),
+          received: t.parsedType,
+          code: d.invalid_type
+        }), m;
+      }
+      if (this._cache || (this._cache = new Set(this._def.values)), !this._cache.has(e.data)) {
+        const t = this._getOrReturnCtx(e), r = this._def.values;
+        return c(t, {
+          received: t.data,
+          code: d.invalid_enum_value,
+          options: r
+        }), m;
+      }
+      return b(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 E.create(e, {
+        ...this._def,
+        ...t
+      });
+    }
+    exclude(e, t = this._def) {
+      return E.create(this.options.filter((r) => !e.includes(r)), {
+        ...this._def,
+        ...t
+      });
+    }
+  }
+  E.create = ke;
+  class pe extends y {
+    _parse(e) {
+      const t = v.getValidEnumValues(this._def.values), r = this._getOrReturnCtx(e);
+      if (r.parsedType !== f.string && r.parsedType !== f.number) {
+        const a = v.objectValues(t);
+        return c(r, {
+          expected: v.joinValues(a),
+          received: r.parsedType,
+          code: d.invalid_type
+        }), m;
+      }
+      if (this._cache || (this._cache = new Set(v.getValidEnumValues(this._def.values))), !this._cache.has(e.data)) {
+        const a = v.objectValues(t);
+        return c(r, {
+          received: r.data,
+          code: d.invalid_enum_value,
+          options: a
+        }), m;
+      }
+      return b(e.data);
+    }
+    get enum() {
+      return this._def.values;
+    }
+  }
+  pe.create = (s, e) => new pe({
+    values: s,
+    typeName: p.ZodNativeEnum,
+    ..._(e)
+  });
+  class J extends y {
+    unwrap() {
+      return this._def.type;
+    }
+    _parse(e) {
+      const { ctx: t } = this._processInputParams(e);
+      if (t.parsedType !== f.promise && t.common.async === false) return c(t, {
+        code: d.invalid_type,
+        expected: f.promise,
+        received: t.parsedType
+      }), m;
+      const r = t.parsedType === f.promise ? t.data : Promise.resolve(t.data);
+      return b(r.then((a) => this._def.type.parseAsync(a, {
+        path: t.path,
+        errorMap: t.common.contextualErrorMap
+      })));
+    }
+  }
+  J.create = (s, e) => new J({
+    type: s,
+    typeName: p.ZodPromise,
+    ..._(e)
+  });
+  class $ extends y {
+    innerType() {
+      return this._def.schema;
+    }
+    sourceType() {
+      return this._def.schema._def.typeName === p.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+    }
+    _parse(e) {
+      const { status: t, ctx: r } = this._processInputParams(e), a = this._def.effect || null, n = {
+        addIssue: (i) => {
+          c(r, i), i.fatal ? t.abort() : t.dirty();
+        },
+        get path() {
+          return r.path;
+        }
+      };
+      if (n.addIssue = n.addIssue.bind(n), a.type === "preprocess") {
+        const i = a.transform(r.data, n);
+        if (r.common.async) return Promise.resolve(i).then(async (o) => {
+          if (t.value === "aborted") return m;
+          const u = await this._def.schema._parseAsync({
+            data: o,
+            path: r.path,
+            parent: r
+          });
+          return u.status === "aborted" ? m : u.status === "dirty" || t.value === "dirty" ? M(u.value) : u;
+        });
+        {
+          if (t.value === "aborted") return m;
+          const o = this._def.schema._parseSync({
+            data: i,
+            path: r.path,
+            parent: r
+          });
+          return o.status === "aborted" ? m : o.status === "dirty" || t.value === "dirty" ? M(o.value) : o;
+        }
+      }
+      if (a.type === "refinement") {
+        const i = (o) => {
+          const u = a.refinement(o, n);
+          if (r.common.async) return Promise.resolve(u);
+          if (u instanceof Promise) throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+          return o;
+        };
+        if (r.common.async === false) {
+          const o = this._def.schema._parseSync({
+            data: r.data,
+            path: r.path,
+            parent: r
+          });
+          return o.status === "aborted" ? m : (o.status === "dirty" && t.dirty(), i(o.value), {
+            status: t.value,
+            value: o.value
+          });
+        } else return this._def.schema._parseAsync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        }).then((o) => o.status === "aborted" ? m : (o.status === "dirty" && t.dirty(), i(o.value).then(() => ({
+          status: t.value,
+          value: o.value
+        }))));
+      }
+      if (a.type === "transform") if (r.common.async === false) {
+        const i = this._def.schema._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        if (!I(i)) return m;
+        const o = a.transform(i.value, n);
+        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: r.data,
+        path: r.path,
+        parent: r
+      }).then((i) => I(i) ? Promise.resolve(a.transform(i.value, n)).then((o) => ({
+        status: t.value,
+        value: o
+      })) : m);
+      v.assertNever(a);
+    }
+  }
+  $.create = (s, e, t) => new $({
+    schema: s,
+    typeName: p.ZodEffects,
+    effect: e,
+    ..._(t)
+  });
+  $.createWithPreprocess = (s, e, t) => new $({
+    schema: e,
+    effect: {
+      type: "preprocess",
+      transform: s
+    },
+    typeName: p.ZodEffects,
+    ..._(t)
+  });
+  class S extends y {
+    _parse(e) {
+      return this._getType(e) === f.undefined ? b(void 0) : this._def.innerType._parse(e);
+    }
+    unwrap() {
+      return this._def.innerType;
+    }
+  }
+  S.create = (s, e) => new S({
+    innerType: s,
+    typeName: p.ZodOptional,
+    ..._(e)
+  });
+  class V extends y {
+    _parse(e) {
+      return this._getType(e) === f.null ? b(null) : this._def.innerType._parse(e);
+    }
+    unwrap() {
+      return this._def.innerType;
+    }
+  }
+  V.create = (s, e) => new V({
+    innerType: s,
+    typeName: p.ZodNullable,
+    ..._(e)
+  });
+  class X extends y {
+    _parse(e) {
+      const { ctx: t } = this._processInputParams(e);
+      let r = t.data;
+      return t.parsedType === f.undefined && (r = this._def.defaultValue()), this._def.innerType._parse({
+        data: r,
+        path: t.path,
+        parent: t
+      });
+    }
+    removeDefault() {
+      return this._def.innerType;
+    }
+  }
+  X.create = (s, e) => new X({
+    innerType: s,
+    typeName: p.ZodDefault,
+    defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+    ..._(e)
+  });
+  class K extends y {
+    _parse(e) {
+      const { ctx: t } = this._processInputParams(e), r = {
+        ...t,
+        common: {
+          ...t.common,
+          issues: []
+        }
+      }, a = this._def.innerType._parse({
+        data: r.data,
+        path: r.path,
+        parent: {
+          ...r
+        }
+      });
+      return U(a) ? a.then((n) => ({
+        status: "valid",
+        value: n.status === "valid" ? n.value : this._def.catchValue({
+          get error() {
+            return new O(r.common.issues);
+          },
+          input: r.data
+        })
+      })) : {
+        status: "valid",
+        value: a.status === "valid" ? a.value : this._def.catchValue({
+          get error() {
+            return new O(r.common.issues);
+          },
+          input: r.data
+        })
+      };
+    }
+    removeCatch() {
+      return this._def.innerType;
+    }
+  }
+  K.create = (s, e) => new K({
+    innerType: s,
+    typeName: p.ZodCatch,
+    catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+    ..._(e)
+  });
+  class ge extends y {
+    _parse(e) {
+      if (this._getType(e) !== f.nan) {
+        const r = this._getOrReturnCtx(e);
+        return c(r, {
+          code: d.invalid_type,
+          expected: f.nan,
+          received: r.parsedType
+        }), m;
+      }
+      return {
+        status: "valid",
+        value: e.data
+      };
+    }
+  }
+  ge.create = (s) => new ge({
+    typeName: p.ZodNaN,
+    ..._(s)
+  });
+  class He extends y {
+    _parse(e) {
+      const { ctx: t } = this._processInputParams(e), r = t.data;
+      return this._def.type._parse({
+        data: r,
+        path: t.path,
+        parent: t
+      });
+    }
+    unwrap() {
+      return this._def.type;
+    }
+  }
+  class te extends y {
+    _parse(e) {
+      const { status: t, ctx: r } = this._processInputParams(e);
+      if (r.common.async) return (async () => {
+        const n = await this._def.in._parseAsync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        return n.status === "aborted" ? m : n.status === "dirty" ? (t.dirty(), M(n.value)) : this._def.out._parseAsync({
+          data: n.value,
+          path: r.path,
+          parent: r
+        });
+      })();
+      {
+        const a = this._def.in._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        return a.status === "aborted" ? m : a.status === "dirty" ? (t.dirty(), {
+          status: "dirty",
+          value: a.value
+        }) : this._def.out._parseSync({
+          data: a.value,
+          path: r.path,
+          parent: r
+        });
+      }
+    }
+    static create(e, t) {
+      return new te({
+        in: e,
+        out: t,
+        typeName: p.ZodPipeline
+      });
+    }
+  }
+  class ee extends y {
+    _parse(e) {
+      const t = this._def.innerType._parse(e), r = (a) => (I(a) && (a.value = Object.freeze(a.value)), a);
+      return U(t) ? t.then((a) => r(a)) : r(t);
+    }
+    unwrap() {
+      return this._def.innerType;
+    }
+  }
+  ee.create = (s, e) => new ee({
+    innerType: s,
+    typeName: p.ZodReadonly,
+    ..._(e)
+  });
+  var p;
+  (function(s) {
+    s.ZodString = "ZodString", s.ZodNumber = "ZodNumber", s.ZodNaN = "ZodNaN", s.ZodBigInt = "ZodBigInt", s.ZodBoolean = "ZodBoolean", s.ZodDate = "ZodDate", s.ZodSymbol = "ZodSymbol", s.ZodUndefined = "ZodUndefined", s.ZodNull = "ZodNull", s.ZodAny = "ZodAny", s.ZodUnknown = "ZodUnknown", s.ZodNever = "ZodNever", s.ZodVoid = "ZodVoid", s.ZodArray = "ZodArray", s.ZodObject = "ZodObject", s.ZodUnion = "ZodUnion", s.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", s.ZodIntersection = "ZodIntersection", s.ZodTuple = "ZodTuple", s.ZodRecord = "ZodRecord", s.ZodMap = "ZodMap", s.ZodSet = "ZodSet", s.ZodFunction = "ZodFunction", s.ZodLazy = "ZodLazy", s.ZodLiteral = "ZodLiteral", s.ZodEnum = "ZodEnum", s.ZodEffects = "ZodEffects", s.ZodNativeEnum = "ZodNativeEnum", s.ZodOptional = "ZodOptional", s.ZodNullable = "ZodNullable", s.ZodDefault = "ZodDefault", s.ZodCatch = "ZodCatch", s.ZodPromise = "ZodPromise", s.ZodBranded = "ZodBranded", s.ZodPipeline = "ZodPipeline", s.ZodReadonly = "ZodReadonly";
+  })(p || (p = {}));
+  const _e = G.create;
+  A.create;
+  w.create;
+  const Ye = x.create;
+  F.create;
+  W.create;
+  R.create;
+  const Ge = E.create;
+  J.create;
+  S.create;
+  V.create;
+  let D = null;
+  async function Qe() {
+    if (D) return D;
+    try {
+      const s = await import("../vite_plugin_norg_parser-CNE0aFue.js");
+      return await s.default(), D = s.parse_norg, D;
+    } catch (s) {
+      throw new Error(`Failed to load norg parser: ${s}`);
+    }
+  }
+  const Xe = ({ html: s, metadata: e }) => {
+    const t = JSON.stringify(e ?? {}), r = JSON.stringify(s);
+    return [
+      `export const metadata = ${t};`,
+      `export const html = ${r};`,
+      "export default { metadata, html };"
+    ].join(`
+`);
+  };
+  function Ke({ html: s, metadata: e }) {
+    const t = JSON.stringify(e ?? {});
+    return [
+      "<script>",
+      `  const htmlContent = ${JSON.stringify(s)};`,
+      "<\/script>",
+      '<script context="module">',
+      `  export const metadata = ${t};`,
+      "<\/script>",
+      "{@html htmlContent}"
+    ].join(`
+`);
+  }
+  function et({ html: s, metadata: e }) {
+    const t = JSON.stringify(e ?? {}), r = JSON.stringify(s);
+    return [
+      'import React from "react";',
+      `export const metadata = ${t};`,
+      `const htmlContent = ${r};`,
+      'export const Component = () => React.createElement("div", { dangerouslySetInnerHTML: { __html: htmlContent } });',
+      "export default Component;"
+    ].join(`
+`);
+  }
+  const tt = Ye({
+    mode: Ge([
+      "html",
+      "svelte",
+      "react"
+    ]),
+    include: _e().optional(),
+    exclude: _e().optional()
+  }), ye = {
+    html: Xe,
+    svelte: Ke,
+    react: et
+  };
+  rt = function(s) {
+    const e = tt.parse(s), { include: t, exclude: r, mode: a } = e, n = be(t, r);
+    let i = null;
+    const o = async () => {
+      if (!i) try {
+        i = await Qe();
+      } catch (u) {
+        throw new Error(`Failed to load norg parser: ${u}`);
+      }
+      return i;
+    };
+    return {
+      name: "vite-plugin-norg",
+      enforce: "pre",
+      async resolveId(u, l) {
+        if (!u.endsWith(".norg")) return null;
+        const g = await this.resolve(u, l, {
+          skipSelf: true
+        });
+        return g ? g.id : null;
+      },
+      async load(u) {
+        if (n(u)) try {
+          const { readFile: l } = await import("node:fs/promises").then(async (m2) => {
+            await m2.__tla;
+            return m2;
+          }), g = await o(), C = await l(u, "utf-8"), q = g(C);
+          return ye[a](q);
+        } catch (l) {
+          this.error(new Error(`Failed to parse norg file ${u}: ${l}`));
+        }
+      },
+      async handleHotUpdate(u) {
+        if (!n(u.file) || !u.file.endsWith(".norg")) return;
+        const l = u.read;
+        u.read = async function() {
+          try {
+            const g = await l(), C = await o();
+            return ye[a](C(g));
+          } catch (g) {
+            throw new Error(`Failed to parse norg file ${u.file}: ${g}`);
+          }
+        };
+      }
+    };
+  };
+})();
+export {
+  __tla,
+  rt as default,
+  rt as norgPlugin
+};