@touchvue/chat 1.0.0-beta.5 → 1.0.0-beta.50

package/lib/node_modules/.pnpm/@touchvue_a2ui@1.0.0-beta.46/node_modules/@touchvue/a2ui/dist/index.js

@@ -0,0 +1,4819 @@
+'use strict';
+
+var vue = require('vue');
+
+var k;
+(function(n) {
+  n.assertEqual = (s) => {
+  };
+  function e(s) {
+  }
+  n.assertIs = e;
+  function t(s) {
+    throw new Error();
+  }
+  n.assertNever = t, n.arrayToEnum = (s) => {
+    const a = {};
+    for (const i of s)
+      a[i] = i;
+    return a;
+  }, n.getValidEnumValues = (s) => {
+    const a = n.objectKeys(s).filter((o) => typeof s[s[o]] != "number"), i = {};
+    for (const o of a)
+      i[o] = s[o];
+    return n.objectValues(i);
+  }, n.objectValues = (s) => n.objectKeys(s).map(function(a) {
+    return s[a];
+  }), n.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;
+  }, n.find = (s, a) => {
+    for (const i of s)
+      if (a(i))
+        return i;
+  }, n.isInteger = typeof Number.isInteger == "function" ? (s) => Number.isInteger(s) : (s) => typeof s == "number" && Number.isFinite(s) && Math.floor(s) === s;
+  function r(s, a = " | ") {
+    return s.map((i) => typeof i == "string" ? `'${i}'` : i).join(a);
+  }
+  n.joinValues = r, n.jsonStringifyReplacer = (s, a) => typeof a == "bigint" ? a.toString() : a;
+})(k || (k = {}));
+var mt;
+(function(n) {
+  n.mergeShapes = (e, t) => ({
+    ...e,
+    ...t
+    // second overwrites first
+  });
+})(mt || (mt = {}));
+const h = k.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]), q = (n) => {
+  switch (typeof n) {
+    case "undefined":
+      return h.undefined;
+    case "string":
+      return h.string;
+    case "number":
+      return Number.isNaN(n) ? h.nan : h.number;
+    case "boolean":
+      return h.boolean;
+    case "function":
+      return h.function;
+    case "bigint":
+      return h.bigint;
+    case "symbol":
+      return h.symbol;
+    case "object":
+      return Array.isArray(n) ? h.array : n === null ? h.null : n.then && typeof n.then == "function" && n.catch && typeof n.catch == "function" ? h.promise : typeof Map != "undefined" && n instanceof Map ? h.map : typeof Set != "undefined" && n instanceof Set ? h.set : typeof Date != "undefined" && n instanceof Date ? h.date : h.object;
+    default:
+      return h.unknown;
+  }
+}, d = k.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 z 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(a) {
+      return a.message;
+    }, r = { _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)
+          r._errors.push(t(i));
+        else {
+          let o = r, 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), r;
+  }
+  static assert(e) {
+    if (!(e instanceof z))
+      throw new Error(`Not a ZodError: ${e}`);
+  }
+  toString() {
+    return this.message;
+  }
+  get message() {
+    return JSON.stringify(this.issues, k.jsonStringifyReplacer, 2);
+  }
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(e = (t) => t.message) {
+    const t = {}, r = [];
+    for (const s of this.issues)
+      if (s.path.length > 0) {
+        const a = s.path[0];
+        t[a] = t[a] || [], t[a].push(e(s));
+      } else
+        r.push(e(s));
+    return { formErrors: r, fieldErrors: t };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+}
+z.create = (n) => new z(n);
+const an = (n, e) => {
+  let t;
+  switch (n.code) {
+    case d.invalid_type:
+      n.received === h.undefined ? t = "Required" : t = `Expected ${n.expected}, received ${n.received}`;
+      break;
+    case d.invalid_literal:
+      t = `Invalid literal value, expected ${JSON.stringify(n.expected, k.jsonStringifyReplacer)}`;
+      break;
+    case d.unrecognized_keys:
+      t = `Unrecognized key(s) in object: ${k.joinValues(n.keys, ", ")}`;
+      break;
+    case d.invalid_union:
+      t = "Invalid input";
+      break;
+    case d.invalid_union_discriminator:
+      t = `Invalid discriminator value. Expected ${k.joinValues(n.options)}`;
+      break;
+    case d.invalid_enum_value:
+      t = `Invalid enum value. Expected ${k.joinValues(n.options)}, received '${n.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 n.validation == "object" ? "includes" in n.validation ? (t = `Invalid input: must include "${n.validation.includes}"`, typeof n.validation.position == "number" && (t = `${t} at one or more positions greater than or equal to ${n.validation.position}`)) : "startsWith" in n.validation ? t = `Invalid input: must start with "${n.validation.startsWith}"` : "endsWith" in n.validation ? t = `Invalid input: must end with "${n.validation.endsWith}"` : k.assertNever(n.validation) : n.validation !== "regex" ? t = `Invalid ${n.validation}` : t = "Invalid";
+      break;
+    case d.too_small:
+      n.type === "array" ? t = `Array must contain ${n.exact ? "exactly" : n.inclusive ? "at least" : "more than"} ${n.minimum} element(s)` : n.type === "string" ? t = `String must contain ${n.exact ? "exactly" : n.inclusive ? "at least" : "over"} ${n.minimum} character(s)` : n.type === "number" ? t = `Number must be ${n.exact ? "exactly equal to " : n.inclusive ? "greater than or equal to " : "greater than "}${n.minimum}` : n.type === "bigint" ? t = `Number must be ${n.exact ? "exactly equal to " : n.inclusive ? "greater than or equal to " : "greater than "}${n.minimum}` : n.type === "date" ? t = `Date must be ${n.exact ? "exactly equal to " : n.inclusive ? "greater than or equal to " : "greater than "}${new Date(Number(n.minimum))}` : t = "Invalid input";
+      break;
+    case d.too_big:
+      n.type === "array" ? t = `Array must contain ${n.exact ? "exactly" : n.inclusive ? "at most" : "less than"} ${n.maximum} element(s)` : n.type === "string" ? t = `String must contain ${n.exact ? "exactly" : n.inclusive ? "at most" : "under"} ${n.maximum} character(s)` : n.type === "number" ? t = `Number must be ${n.exact ? "exactly" : n.inclusive ? "less than or equal to" : "less than"} ${n.maximum}` : n.type === "bigint" ? t = `BigInt must be ${n.exact ? "exactly" : n.inclusive ? "less than or equal to" : "less than"} ${n.maximum}` : n.type === "date" ? t = `Date must be ${n.exact ? "exactly" : n.inclusive ? "smaller than or equal to" : "smaller than"} ${new Date(Number(n.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 ${n.multipleOf}`;
+      break;
+    case d.not_finite:
+      t = "Number must be finite";
+      break;
+    default:
+      t = e.defaultError, k.assertNever(n);
+  }
+  return { message: t };
+}, Fe = an;
+let on = Fe;
+function cn() {
+  return on;
+}
+const un = (n) => {
+  const { data: e, path: t, errorMaps: r, issueData: s } = n, a = [...t, ...s.path || []], i = {
+    ...s,
+    path: a
+  };
+  if (s.message !== void 0)
+    return {
+      ...s,
+      path: a,
+      message: s.message
+    };
+  let o = "";
+  const c = r.filter((u) => !!u).slice().reverse();
+  for (const u of c)
+    o = u(i, { data: e, defaultError: o }).message;
+  return {
+    ...s,
+    path: a,
+    message: o
+  };
+};
+function f(n, e) {
+  const t = cn(), r = un({
+    issueData: e,
+    data: n.data,
+    path: n.path,
+    errorMaps: [
+      n.common.contextualErrorMap,
+      // contextual error map is first priority
+      n.schemaErrorMap,
+      // then schema-bound map if available
+      t,
+      // then global override map
+      t === Fe ? void 0 : Fe
+      // then global default map
+    ].filter((s) => !!s)
+  });
+  n.common.issues.push(r);
+}
+class P {
+  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 s of t) {
+      if (s.status === "aborted")
+        return g;
+      s.status === "dirty" && e.dirty(), r.push(s.value);
+    }
+    return { status: e.value, value: r };
+  }
+  static async mergeObjectAsync(e, t) {
+    const r = [];
+    for (const s of t) {
+      const a = await s.key, i = await s.value;
+      r.push({
+        key: a,
+        value: i
+      });
+    }
+    return P.mergeObjectSync(e, r);
+  }
+  static mergeObjectSync(e, t) {
+    const r = {};
+    for (const s of t) {
+      const { key: a, value: i } = s;
+      if (a.status === "aborted" || i.status === "aborted")
+        return g;
+      a.status === "dirty" && e.dirty(), i.status === "dirty" && e.dirty(), a.value !== "__proto__" && (typeof i.value != "undefined" || s.alwaysSet) && (r[a.value] = i.value);
+    }
+    return { status: e.value, value: r };
+  }
+}
+const g = Object.freeze({
+  status: "aborted"
+}), fe = (n) => ({ status: "dirty", value: n }), E = (n) => ({ status: "valid", value: n }), yt = (n) => n.status === "aborted", gt = (n) => n.status === "dirty", re = (n) => n.status === "valid", ke = (n) => typeof Promise != "undefined" && n instanceof Promise;
+var p;
+(function(n) {
+  n.errToObj = (e) => typeof e == "string" ? { message: e } : e || {}, n.toString = (e) => typeof e == "string" ? e : e == null ? void 0 : e.message;
+})(p || (p = {}));
+class V {
+  constructor(e, t, r, s) {
+    this._cachedPath = [], this.parent = e, this.data = t, this._path = r, this._key = s;
+  }
+  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 vt = (n, e) => {
+  if (re(e))
+    return { success: !0, data: e.value };
+  if (!n.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 z(n.common.issues);
+      return this._error = t, this._error;
+    }
+  };
+};
+function _(n) {
+  if (!n)
+    return {};
+  const { errorMap: e, invalid_type_error: t, required_error: r, description: s } = n;
+  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: s } : { errorMap: (i, o) => {
+    var u, y;
+    const { message: c } = n;
+    return i.code === "invalid_enum_value" ? { message: c != null ? c : o.defaultError } : typeof o.data == "undefined" ? { message: (u = c != null ? c : r) != null ? u : o.defaultError } : i.code !== "invalid_type" ? { message: o.defaultError } : { message: (y = c != null ? c : t) != null ? y : o.defaultError };
+  }, description: s };
+}
+class b {
+  get description() {
+    return this._def.description;
+  }
+  _getType(e) {
+    return q(e.data);
+  }
+  _getOrReturnCtx(e, t) {
+    return t || {
+      common: e.parent.common,
+      data: e.data,
+      parsedType: q(e.data),
+      schemaErrorMap: this._def.errorMap,
+      path: e.path,
+      parent: e.parent
+    };
+  }
+  _processInputParams(e) {
+    return {
+      status: new P(),
+      ctx: {
+        common: e.parent.common,
+        data: e.data,
+        parsedType: q(e.data),
+        schemaErrorMap: this._def.errorMap,
+        path: e.path,
+        parent: e.parent
+      }
+    };
+  }
+  _parseSync(e) {
+    const t = this._parse(e);
+    if (ke(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) {
+    var a;
+    const r = {
+      common: {
+        issues: [],
+        async: (a = t == null ? void 0 : t.async) != null ? a : !1,
+        contextualErrorMap: t == null ? void 0 : t.errorMap
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: q(e)
+    }, s = this._parseSync({ data: e, path: r.path, parent: r });
+    return vt(r, s);
+  }
+  "~validate"(e) {
+    var r, s;
+    const t = {
+      common: {
+        issues: [],
+        async: !!this["~standard"].async
+      },
+      path: [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: q(e)
+    };
+    if (!this["~standard"].async)
+      try {
+        const a = this._parseSync({ data: e, path: [], parent: t });
+        return re(a) ? {
+          value: a.value
+        } : {
+          issues: t.common.issues
+        };
+      } catch (a) {
+        (s = (r = a == null ? void 0 : a.message) == null ? void 0 : r.toLowerCase()) != null && s.includes("encountered") && (this["~standard"].async = !0), t.common = {
+          issues: [],
+          async: !0
+        };
+      }
+    return this._parseAsync({ data: e, path: [], parent: t }).then((a) => re(a) ? {
+      value: a.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: !0
+      },
+      path: (t == null ? void 0 : t.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data: e,
+      parsedType: q(e)
+    }, s = this._parse({ data: e, path: r.path, parent: r }), a = await (ke(s) ? s : Promise.resolve(s));
+    return vt(r, a);
+  }
+  refine(e, t) {
+    const r = (s) => typeof t == "string" || typeof t == "undefined" ? { message: t } : typeof t == "function" ? t(s) : t;
+    return this._refinement((s, a) => {
+      const i = e(s), o = () => a.addIssue({
+        code: d.custom,
+        ...r(s)
+      });
+      return typeof Promise != "undefined" && i instanceof Promise ? i.then((c) => c ? !0 : (o(), !1)) : i ? !0 : (o(), !1);
+    });
+  }
+  refinement(e, t) {
+    return this._refinement((r, s) => e(r) ? !0 : (s.addIssue(typeof t == "function" ? t(r, s) : t), !1));
+  }
+  _refinement(e) {
+    return new K({
+      schema: this,
+      typeName: l.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 H.create(this, this._def);
+  }
+  nullable() {
+    return ce.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return L.create(this);
+  }
+  promise() {
+    return Ae.create(this, this._def);
+  }
+  or(e) {
+    return xe.create([this, e], this._def);
+  }
+  and(e) {
+    return we.create(this, e, this._def);
+  }
+  transform(e) {
+    return new K({
+      ..._(this._def),
+      schema: this,
+      typeName: l.ZodEffects,
+      effect: { type: "transform", transform: e }
+    });
+  }
+  default(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new nt({
+      ..._(this._def),
+      innerType: this,
+      defaultValue: t,
+      typeName: l.ZodDefault
+    });
+  }
+  brand() {
+    return new jn({
+      typeName: l.ZodBranded,
+      type: this,
+      ..._(this._def)
+    });
+  }
+  catch(e) {
+    const t = typeof e == "function" ? e : () => e;
+    return new rt({
+      ..._(this._def),
+      innerType: this,
+      catchValue: t,
+      typeName: l.ZodCatch
+    });
+  }
+  describe(e) {
+    const t = this.constructor;
+    return new t({
+      ...this._def,
+      description: e
+    });
+  }
+  pipe(e) {
+    return ot.create(this, e);
+  }
+  readonly() {
+    return at.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+}
+const dn = /^c[^\s-]{8,}$/i, ln = /^[0-9a-z]+$/, fn = /^[0-9A-HJKMNP-TV-Z]{26}$/i, hn = /^[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, pn = /^[a-z0-9_-]{21}$/i, mn = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, yn = /^[-+]?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)?)??$/, gn = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, vn = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+let Ee;
+const _n = /^(?:(?: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])$/, bn = /^(?:(?: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])$/, kn = /^(([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]))$/, xn = /^(([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])$/, wn = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, Sn = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, jt = "((\\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])))", An = new RegExp(`^${jt}$`);
+function It(n) {
+  let e = "[0-5]\\d";
+  n.precision ? e = `${e}\\.\\d{${n.precision}}` : n.precision == null && (e = `${e}(\\.\\d+)?`);
+  const t = n.precision ? "+" : "?";
+  return `([01]\\d|2[0-3]):[0-5]\\d(:${e})${t}`;
+}
+function Tn(n) {
+  return new RegExp(`^${It(n)}$`);
+}
+function Cn(n) {
+  let e = `${jt}T${It(n)}`;
+  const t = [];
+  return t.push(n.local ? "Z?" : "Z"), n.offset && t.push("([+-]\\d{2}:?\\d{2})"), e = `${e}(${t.join("|")})`, new RegExp(`^${e}$`);
+}
+function On(n, e) {
+  return !!((e === "v4" || !e) && _n.test(n) || (e === "v6" || !e) && kn.test(n));
+}
+function Nn(n, e) {
+  if (!mn.test(n))
+    return !1;
+  try {
+    const [t] = n.split(".");
+    if (!t)
+      return !1;
+    const r = t.replace(/-/g, "+").replace(/_/g, "/").padEnd(t.length + (4 - t.length % 4) % 4, "="), s = JSON.parse(atob(r));
+    return !(typeof s != "object" || s === null || "typ" in s && (s == null ? void 0 : s.typ) !== "JWT" || !s.alg || e && s.alg !== e);
+  } catch (t) {
+    return !1;
+  }
+}
+function Zn(n, e) {
+  return !!((e === "v4" || !e) && bn.test(n) || (e === "v6" || !e) && xn.test(n));
+}
+class F extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = String(e.data)), this._getType(e) !== h.string) {
+      const a = this._getOrReturnCtx(e);
+      return f(a, {
+        code: d.invalid_type,
+        expected: h.string,
+        received: a.parsedType
+      }), g;
+    }
+    const r = new P();
+    let s;
+    for (const a of this._def.checks)
+      if (a.kind === "min")
+        e.data.length < a.value && (s = this._getOrReturnCtx(e, s), f(s, {
+          code: d.too_small,
+          minimum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "max")
+        e.data.length > a.value && (s = this._getOrReturnCtx(e, s), f(s, {
+          code: d.too_big,
+          maximum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !1,
+          message: a.message
+        }), r.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 ? f(s, {
+          code: d.too_big,
+          maximum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: a.message
+        }) : o && f(s, {
+          code: d.too_small,
+          minimum: a.value,
+          type: "string",
+          inclusive: !0,
+          exact: !0,
+          message: a.message
+        }), r.dirty());
+      } else if (a.kind === "email")
+        gn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "email",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "emoji")
+        Ee || (Ee = new RegExp(vn, "u")), Ee.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "emoji",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "uuid")
+        hn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "uuid",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "nanoid")
+        pn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "nanoid",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "cuid")
+        dn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "cuid",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "cuid2")
+        ln.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "cuid2",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "ulid")
+        fn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "ulid",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty());
+      else if (a.kind === "url")
+        try {
+          new URL(e.data);
+        } catch (i) {
+          s = this._getOrReturnCtx(e, s), f(s, {
+            validation: "url",
+            code: d.invalid_string,
+            message: a.message
+          }), r.dirty();
+        }
+      else
+        a.kind === "regex" ? (a.regex.lastIndex = 0, a.regex.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "regex",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty())) : a.kind === "trim" ? e.data = e.data.trim() : a.kind === "includes" ? e.data.includes(a.value, a.position) || (s = this._getOrReturnCtx(e, s), f(s, {
+          code: d.invalid_string,
+          validation: { includes: a.value, position: a.position },
+          message: a.message
+        }), r.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), f(s, {
+          code: d.invalid_string,
+          validation: { startsWith: a.value },
+          message: a.message
+        }), r.dirty()) : a.kind === "endsWith" ? e.data.endsWith(a.value) || (s = this._getOrReturnCtx(e, s), f(s, {
+          code: d.invalid_string,
+          validation: { endsWith: a.value },
+          message: a.message
+        }), r.dirty()) : a.kind === "datetime" ? Cn(a).test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          code: d.invalid_string,
+          validation: "datetime",
+          message: a.message
+        }), r.dirty()) : a.kind === "date" ? An.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          code: d.invalid_string,
+          validation: "date",
+          message: a.message
+        }), r.dirty()) : a.kind === "time" ? Tn(a).test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          code: d.invalid_string,
+          validation: "time",
+          message: a.message
+        }), r.dirty()) : a.kind === "duration" ? yn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "duration",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty()) : a.kind === "ip" ? On(e.data, a.version) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "ip",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty()) : a.kind === "jwt" ? Nn(e.data, a.alg) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "jwt",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty()) : a.kind === "cidr" ? Zn(e.data, a.version) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "cidr",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty()) : a.kind === "base64" ? wn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "base64",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty()) : a.kind === "base64url" ? Sn.test(e.data) || (s = this._getOrReturnCtx(e, s), f(s, {
+          validation: "base64url",
+          code: d.invalid_string,
+          message: a.message
+        }), r.dirty()) : k.assertNever(a);
+    return { status: r.value, value: e.data };
+  }
+  _regex(e, t, r) {
+    return this.refinement((s) => e.test(s), {
+      validation: t,
+      code: d.invalid_string,
+      ...p.errToObj(r)
+    });
+  }
+  _addCheck(e) {
+    return new F({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  email(e) {
+    return this._addCheck({ kind: "email", ...p.errToObj(e) });
+  }
+  url(e) {
+    return this._addCheck({ kind: "url", ...p.errToObj(e) });
+  }
+  emoji(e) {
+    return this._addCheck({ kind: "emoji", ...p.errToObj(e) });
+  }
+  uuid(e) {
+    return this._addCheck({ kind: "uuid", ...p.errToObj(e) });
+  }
+  nanoid(e) {
+    return this._addCheck({ kind: "nanoid", ...p.errToObj(e) });
+  }
+  cuid(e) {
+    return this._addCheck({ kind: "cuid", ...p.errToObj(e) });
+  }
+  cuid2(e) {
+    return this._addCheck({ kind: "cuid2", ...p.errToObj(e) });
+  }
+  ulid(e) {
+    return this._addCheck({ kind: "ulid", ...p.errToObj(e) });
+  }
+  base64(e) {
+    return this._addCheck({ kind: "base64", ...p.errToObj(e) });
+  }
+  base64url(e) {
+    return this._addCheck({
+      kind: "base64url",
+      ...p.errToObj(e)
+    });
+  }
+  jwt(e) {
+    return this._addCheck({ kind: "jwt", ...p.errToObj(e) });
+  }
+  ip(e) {
+    return this._addCheck({ kind: "ip", ...p.errToObj(e) });
+  }
+  cidr(e) {
+    return this._addCheck({ kind: "cidr", ...p.errToObj(e) });
+  }
+  datetime(e) {
+    var t, r;
+    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) == "undefined" ? null : e == null ? void 0 : e.precision,
+      offset: (t = e == null ? void 0 : e.offset) != null ? t : !1,
+      local: (r = e == null ? void 0 : e.local) != null ? r : !1,
+      ...p.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) == "undefined" ? null : e == null ? void 0 : e.precision,
+      ...p.errToObj(e == null ? void 0 : e.message)
+    });
+  }
+  duration(e) {
+    return this._addCheck({ kind: "duration", ...p.errToObj(e) });
+  }
+  regex(e, t) {
+    return this._addCheck({
+      kind: "regex",
+      regex: e,
+      ...p.errToObj(t)
+    });
+  }
+  includes(e, t) {
+    return this._addCheck({
+      kind: "includes",
+      value: e,
+      position: t == null ? void 0 : t.position,
+      ...p.errToObj(t == null ? void 0 : t.message)
+    });
+  }
+  startsWith(e, t) {
+    return this._addCheck({
+      kind: "startsWith",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  endsWith(e, t) {
+    return this._addCheck({
+      kind: "endsWith",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  length(e, t) {
+    return this._addCheck({
+      kind: "length",
+      value: e,
+      ...p.errToObj(t)
+    });
+  }
+  /**
+   * Equivalent to `.min(1)`
+   */
+  nonempty(e) {
+    return this.min(1, p.errToObj(e));
+  }
+  trim() {
+    return new F({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "trim" }]
+    });
+  }
+  toLowerCase() {
+    return new F({
+      ...this._def,
+      checks: [...this._def.checks, { kind: "toLowerCase" }]
+    });
+  }
+  toUpperCase() {
+    return new F({
+      ...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;
+  }
+}
+F.create = (n) => {
+  var e;
+  return new F({
+    checks: [],
+    typeName: l.ZodString,
+    coerce: (e = n == null ? void 0 : n.coerce) != null ? e : !1,
+    ..._(n)
+  });
+};
+function Pn(n, e) {
+  const t = (n.toString().split(".")[1] || "").length, r = (e.toString().split(".")[1] || "").length, s = t > r ? t : r, a = Number.parseInt(n.toFixed(s).replace(".", "")), i = Number.parseInt(e.toFixed(s).replace(".", ""));
+  return a % i / 10 ** s;
+}
+class se extends b {
+  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) !== h.number) {
+      const a = this._getOrReturnCtx(e);
+      return f(a, {
+        code: d.invalid_type,
+        expected: h.number,
+        received: a.parsedType
+      }), g;
+    }
+    let r;
+    const s = new P();
+    for (const a of this._def.checks)
+      a.kind === "int" ? k.isInteger(e.data) || (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.invalid_type,
+        expected: "integer",
+        received: "float",
+        message: a.message
+      }), s.dirty()) : a.kind === "min" ? (a.inclusive ? e.data < a.value : e.data <= a.value) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.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) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.too_big,
+        maximum: a.value,
+        type: "number",
+        inclusive: a.inclusive,
+        exact: !1,
+        message: a.message
+      }), s.dirty()) : a.kind === "multipleOf" ? Pn(e.data, a.value) !== 0 && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.not_multiple_of,
+        multipleOf: a.value,
+        message: a.message
+      }), s.dirty()) : a.kind === "finite" ? Number.isFinite(e.data) || (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.not_finite,
+        message: a.message
+      }), s.dirty()) : k.assertNever(a);
+    return { status: s.value, value: e.data };
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, p.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, p.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, p.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, p.toString(t));
+  }
+  setLimit(e, t, r, s) {
+    return new se({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: r,
+          message: p.toString(s)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new se({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  int(e) {
+    return this._addCheck({
+      kind: "int",
+      message: p.toString(e)
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: 0,
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: 0,
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: p.toString(t)
+    });
+  }
+  finite(e) {
+    return this._addCheck({
+      kind: "finite",
+      message: p.toString(e)
+    });
+  }
+  safe(e) {
+    return this._addCheck({
+      kind: "min",
+      inclusive: !0,
+      value: Number.MIN_SAFE_INTEGER,
+      message: p.toString(e)
+    })._addCheck({
+      kind: "max",
+      inclusive: !0,
+      value: Number.MAX_SAFE_INTEGER,
+      message: p.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" && k.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 !0;
+      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);
+  }
+}
+se.create = (n) => new se({
+  checks: [],
+  typeName: l.ZodNumber,
+  coerce: (n == null ? void 0 : n.coerce) || !1,
+  ..._(n)
+});
+class ae extends b {
+  constructor() {
+    super(...arguments), this.min = this.gte, this.max = this.lte;
+  }
+  _parse(e) {
+    if (this._def.coerce)
+      try {
+        e.data = BigInt(e.data);
+      } catch (a) {
+        return this._getInvalidInput(e);
+      }
+    if (this._getType(e) !== h.bigint)
+      return this._getInvalidInput(e);
+    let r;
+    const s = new P();
+    for (const a of this._def.checks)
+      a.kind === "min" ? (a.inclusive ? e.data < a.value : e.data <= a.value) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.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) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.too_big,
+        type: "bigint",
+        maximum: a.value,
+        inclusive: a.inclusive,
+        message: a.message
+      }), s.dirty()) : a.kind === "multipleOf" ? e.data % a.value !== BigInt(0) && (r = this._getOrReturnCtx(e, r), f(r, {
+        code: d.not_multiple_of,
+        multipleOf: a.value,
+        message: a.message
+      }), s.dirty()) : k.assertNever(a);
+    return { status: s.value, value: e.data };
+  }
+  _getInvalidInput(e) {
+    const t = this._getOrReturnCtx(e);
+    return f(t, {
+      code: d.invalid_type,
+      expected: h.bigint,
+      received: t.parsedType
+    }), g;
+  }
+  gte(e, t) {
+    return this.setLimit("min", e, !0, p.toString(t));
+  }
+  gt(e, t) {
+    return this.setLimit("min", e, !1, p.toString(t));
+  }
+  lte(e, t) {
+    return this.setLimit("max", e, !0, p.toString(t));
+  }
+  lt(e, t) {
+    return this.setLimit("max", e, !1, p.toString(t));
+  }
+  setLimit(e, t, r, s) {
+    return new ae({
+      ...this._def,
+      checks: [
+        ...this._def.checks,
+        {
+          kind: e,
+          value: t,
+          inclusive: r,
+          message: p.toString(s)
+        }
+      ]
+    });
+  }
+  _addCheck(e) {
+    return new ae({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  positive(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  negative(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !1,
+      message: p.toString(e)
+    });
+  }
+  nonpositive(e) {
+    return this._addCheck({
+      kind: "max",
+      value: BigInt(0),
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  nonnegative(e) {
+    return this._addCheck({
+      kind: "min",
+      value: BigInt(0),
+      inclusive: !0,
+      message: p.toString(e)
+    });
+  }
+  multipleOf(e, t) {
+    return this._addCheck({
+      kind: "multipleOf",
+      value: e,
+      message: p.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;
+  }
+}
+ae.create = (n) => {
+  var e;
+  return new ae({
+    checks: [],
+    typeName: l.ZodBigInt,
+    coerce: (e = n == null ? void 0 : n.coerce) != null ? e : !1,
+    ..._(n)
+  });
+};
+class Be extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = !!e.data), this._getType(e) !== h.boolean) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.boolean,
+        received: r.parsedType
+      }), g;
+    }
+    return E(e.data);
+  }
+}
+Be.create = (n) => new Be({
+  typeName: l.ZodBoolean,
+  coerce: (n == null ? void 0 : n.coerce) || !1,
+  ..._(n)
+});
+class ge extends b {
+  _parse(e) {
+    if (this._def.coerce && (e.data = new Date(e.data)), this._getType(e) !== h.date) {
+      const a = this._getOrReturnCtx(e);
+      return f(a, {
+        code: d.invalid_type,
+        expected: h.date,
+        received: a.parsedType
+      }), g;
+    }
+    if (Number.isNaN(e.data.getTime())) {
+      const a = this._getOrReturnCtx(e);
+      return f(a, {
+        code: d.invalid_date
+      }), g;
+    }
+    const r = new P();
+    let s;
+    for (const a of this._def.checks)
+      a.kind === "min" ? e.data.getTime() < a.value && (s = this._getOrReturnCtx(e, s), f(s, {
+        code: d.too_small,
+        message: a.message,
+        inclusive: !0,
+        exact: !1,
+        minimum: a.value,
+        type: "date"
+      }), r.dirty()) : a.kind === "max" ? e.data.getTime() > a.value && (s = this._getOrReturnCtx(e, s), f(s, {
+        code: d.too_big,
+        message: a.message,
+        inclusive: !0,
+        exact: !1,
+        maximum: a.value,
+        type: "date"
+      }), r.dirty()) : k.assertNever(a);
+    return {
+      status: r.value,
+      value: new Date(e.data.getTime())
+    };
+  }
+  _addCheck(e) {
+    return new ge({
+      ...this._def,
+      checks: [...this._def.checks, e]
+    });
+  }
+  min(e, t) {
+    return this._addCheck({
+      kind: "min",
+      value: e.getTime(),
+      message: p.toString(t)
+    });
+  }
+  max(e, t) {
+    return this._addCheck({
+      kind: "max",
+      value: e.getTime(),
+      message: p.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;
+  }
+}
+ge.create = (n) => new ge({
+  checks: [],
+  coerce: (n == null ? void 0 : n.coerce) || !1,
+  typeName: l.ZodDate,
+  ..._(n)
+});
+class We extends b {
+  _parse(e) {
+    if (this._getType(e) !== h.symbol) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.symbol,
+        received: r.parsedType
+      }), g;
+    }
+    return E(e.data);
+  }
+}
+We.create = (n) => new We({
+  typeName: l.ZodSymbol,
+  ..._(n)
+});
+class qe extends b {
+  _parse(e) {
+    if (this._getType(e) !== h.undefined) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.undefined,
+        received: r.parsedType
+      }), g;
+    }
+    return E(e.data);
+  }
+}
+qe.create = (n) => new qe({
+  typeName: l.ZodUndefined,
+  ..._(n)
+});
+class Je extends b {
+  _parse(e) {
+    if (this._getType(e) !== h.null) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.null,
+        received: r.parsedType
+      }), g;
+    }
+    return E(e.data);
+  }
+}
+Je.create = (n) => new Je({
+  typeName: l.ZodNull,
+  ..._(n)
+});
+class He extends b {
+  constructor() {
+    super(...arguments), this._any = !0;
+  }
+  _parse(e) {
+    return E(e.data);
+  }
+}
+He.create = (n) => new He({
+  typeName: l.ZodAny,
+  ..._(n)
+});
+class Ge extends b {
+  constructor() {
+    super(...arguments), this._unknown = !0;
+  }
+  _parse(e) {
+    return E(e.data);
+  }
+}
+Ge.create = (n) => new Ge({
+  typeName: l.ZodUnknown,
+  ..._(n)
+});
+class Y extends b {
+  _parse(e) {
+    const t = this._getOrReturnCtx(e);
+    return f(t, {
+      code: d.invalid_type,
+      expected: h.never,
+      received: t.parsedType
+    }), g;
+  }
+}
+Y.create = (n) => new Y({
+  typeName: l.ZodNever,
+  ..._(n)
+});
+class Ye extends b {
+  _parse(e) {
+    if (this._getType(e) !== h.undefined) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.void,
+        received: r.parsedType
+      }), g;
+    }
+    return E(e.data);
+  }
+}
+Ye.create = (n) => new Ye({
+  typeName: l.ZodVoid,
+  ..._(n)
+});
+class L extends b {
+  _parse(e) {
+    const { ctx: t, status: r } = this._processInputParams(e), s = this._def;
+    if (t.parsedType !== h.array)
+      return f(t, {
+        code: d.invalid_type,
+        expected: h.array,
+        received: t.parsedType
+      }), g;
+    if (s.exactLength !== null) {
+      const i = t.data.length > s.exactLength.value, o = t.data.length < s.exactLength.value;
+      (i || o) && (f(t, {
+        code: i ? d.too_big : d.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
+      }), r.dirty());
+    }
+    if (s.minLength !== null && t.data.length < s.minLength.value && (f(t, {
+      code: d.too_small,
+      minimum: s.minLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: s.minLength.message
+    }), r.dirty()), s.maxLength !== null && t.data.length > s.maxLength.value && (f(t, {
+      code: d.too_big,
+      maximum: s.maxLength.value,
+      type: "array",
+      inclusive: !0,
+      exact: !1,
+      message: s.maxLength.message
+    }), r.dirty()), t.common.async)
+      return Promise.all([...t.data].map((i, o) => s.type._parseAsync(new V(t, i, t.path, o)))).then((i) => P.mergeArray(r, i));
+    const a = [...t.data].map((i, o) => s.type._parseSync(new V(t, i, t.path, o)));
+    return P.mergeArray(r, a);
+  }
+  get element() {
+    return this._def.type;
+  }
+  min(e, t) {
+    return new L({
+      ...this._def,
+      minLength: { value: e, message: p.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new L({
+      ...this._def,
+      maxLength: { value: e, message: p.toString(t) }
+    });
+  }
+  length(e, t) {
+    return new L({
+      ...this._def,
+      exactLength: { value: e, message: p.toString(t) }
+    });
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+L.create = (n, e) => new L({
+  type: n,
+  minLength: null,
+  maxLength: null,
+  exactLength: null,
+  typeName: l.ZodArray,
+  ..._(e)
+});
+function te(n) {
+  if (n instanceof C) {
+    const e = {};
+    for (const t in n.shape) {
+      const r = n.shape[t];
+      e[t] = H.create(te(r));
+    }
+    return new C({
+      ...n._def,
+      shape: () => e
+    });
+  } else
+    return n instanceof L ? new L({
+      ...n._def,
+      type: te(n.element)
+    }) : n instanceof H ? H.create(te(n.unwrap())) : n instanceof ce ? ce.create(te(n.unwrap())) : n instanceof Q ? Q.create(n.items.map((e) => te(e))) : n;
+}
+class C extends b {
+  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 = k.objectKeys(e);
+    return this._cached = { shape: e, keys: t }, this._cached;
+  }
+  _parse(e) {
+    if (this._getType(e) !== h.object) {
+      const u = this._getOrReturnCtx(e);
+      return f(u, {
+        code: d.invalid_type,
+        expected: h.object,
+        received: u.parsedType
+      }), g;
+    }
+    const { status: r, ctx: s } = this._processInputParams(e), { shape: a, keys: i } = this._getCached(), o = [];
+    if (!(this._def.catchall instanceof Y && this._def.unknownKeys === "strip"))
+      for (const u in s.data)
+        i.includes(u) || o.push(u);
+    const c = [];
+    for (const u of i) {
+      const y = a[u], T = s.data[u];
+      c.push({
+        key: { status: "valid", value: u },
+        value: y._parse(new V(s, T, s.path, u)),
+        alwaysSet: u in s.data
+      });
+    }
+    if (this._def.catchall instanceof Y) {
+      const u = this._def.unknownKeys;
+      if (u === "passthrough")
+        for (const y of o)
+          c.push({
+            key: { status: "valid", value: y },
+            value: { status: "valid", value: s.data[y] }
+          });
+      else if (u === "strict")
+        o.length > 0 && (f(s, {
+          code: d.unrecognized_keys,
+          keys: o
+        }), r.dirty());
+      else if (u !== "strip")
+        throw new Error("Internal ZodObject error: invalid unknownKeys value.");
+    } else {
+      const u = this._def.catchall;
+      for (const y of o) {
+        const T = s.data[y];
+        c.push({
+          key: { status: "valid", value: y },
+          value: u._parse(
+            new V(s, T, s.path, y)
+            //, ctx.child(key), value, getParsedType(value)
+          ),
+          alwaysSet: y in s.data
+        });
+      }
+    }
+    return s.common.async ? Promise.resolve().then(async () => {
+      const u = [];
+      for (const y of c) {
+        const T = await y.key, v = await y.value;
+        u.push({
+          key: T,
+          value: v,
+          alwaysSet: y.alwaysSet
+        });
+      }
+      return u;
+    }).then((u) => P.mergeObjectSync(r, u)) : P.mergeObjectSync(r, c);
+  }
+  get shape() {
+    return this._def.shape();
+  }
+  strict(e) {
+    return p.errToObj, new C({
+      ...this._def,
+      unknownKeys: "strict",
+      ...e !== void 0 ? {
+        errorMap: (t, r) => {
+          var a, i, o, c;
+          const s = (o = (i = (a = this._def).errorMap) == null ? void 0 : i.call(a, t, r).message) != null ? o : r.defaultError;
+          return t.code === "unrecognized_keys" ? {
+            message: (c = p.errToObj(e).message) != null ? c : s
+          } : {
+            message: s
+          };
+        }
+      } : {}
+    });
+  }
+  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: l.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 = {};
+    for (const r of k.objectKeys(e))
+      e[r] && this.shape[r] && (t[r] = this.shape[r]);
+    return new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  omit(e) {
+    const t = {};
+    for (const r of k.objectKeys(this.shape))
+      e[r] || (t[r] = this.shape[r]);
+    return new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  /**
+   * @deprecated
+   */
+  deepPartial() {
+    return te(this);
+  }
+  partial(e) {
+    const t = {};
+    for (const r of k.objectKeys(this.shape)) {
+      const s = this.shape[r];
+      e && !e[r] ? t[r] = s : t[r] = s.optional();
+    }
+    return new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  required(e) {
+    const t = {};
+    for (const r of k.objectKeys(this.shape))
+      if (e && !e[r])
+        t[r] = this.shape[r];
+      else {
+        let a = this.shape[r];
+        for (; a instanceof H; )
+          a = a._def.innerType;
+        t[r] = a;
+      }
+    return new C({
+      ...this._def,
+      shape: () => t
+    });
+  }
+  keyof() {
+    return Mt(k.objectKeys(this.shape));
+  }
+}
+C.create = (n, e) => new C({
+  shape: () => n,
+  unknownKeys: "strip",
+  catchall: Y.create(),
+  typeName: l.ZodObject,
+  ..._(e)
+});
+C.strictCreate = (n, e) => new C({
+  shape: () => n,
+  unknownKeys: "strict",
+  catchall: Y.create(),
+  typeName: l.ZodObject,
+  ..._(e)
+});
+C.lazycreate = (n, e) => new C({
+  shape: n,
+  unknownKeys: "strip",
+  catchall: Y.create(),
+  typeName: l.ZodObject,
+  ..._(e)
+});
+class xe extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), r = 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 z(o.ctx.common.issues));
+      return f(t, {
+        code: d.invalid_union,
+        unionErrors: i
+      }), g;
+    }
+    if (t.common.async)
+      return Promise.all(r.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 r) {
+        const u = {
+          ...t,
+          common: {
+            ...t.common,
+            issues: []
+          },
+          parent: null
+        }, y = c._parseSync({
+          data: t.data,
+          path: t.path,
+          parent: u
+        });
+        if (y.status === "valid")
+          return y;
+        y.status === "dirty" && !a && (a = { result: y, 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 z(c));
+      return f(t, {
+        code: d.invalid_union,
+        unionErrors: o
+      }), g;
+    }
+  }
+  get options() {
+    return this._def.options;
+  }
+}
+xe.create = (n, e) => new xe({
+  options: n,
+  typeName: l.ZodUnion,
+  ..._(e)
+});
+function Ke(n, e) {
+  const t = q(n), r = q(e);
+  if (n === e)
+    return { valid: !0, data: n };
+  if (t === h.object && r === h.object) {
+    const s = k.objectKeys(e), a = k.objectKeys(n).filter((o) => s.indexOf(o) !== -1), i = { ...n, ...e };
+    for (const o of a) {
+      const c = Ke(n[o], e[o]);
+      if (!c.valid)
+        return { valid: !1 };
+      i[o] = c.data;
+    }
+    return { valid: !0, data: i };
+  } else if (t === h.array && r === h.array) {
+    if (n.length !== e.length)
+      return { valid: !1 };
+    const s = [];
+    for (let a = 0; a < n.length; a++) {
+      const i = n[a], o = e[a], c = Ke(i, o);
+      if (!c.valid)
+        return { valid: !1 };
+      s.push(c.data);
+    }
+    return { valid: !0, data: s };
+  } else
+    return t === h.date && r === h.date && +n == +e ? { valid: !0, data: n } : { valid: !1 };
+}
+class we extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e), s = (a, i) => {
+      if (yt(a) || yt(i))
+        return g;
+      const o = Ke(a.value, i.value);
+      return o.valid ? ((gt(a) || gt(i)) && t.dirty(), { status: t.value, value: o.data }) : (f(r, {
+        code: d.invalid_intersection_types
+      }), g);
+    };
+    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(([a, i]) => s(a, i)) : s(this._def.left._parseSync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }), this._def.right._parseSync({
+      data: r.data,
+      path: r.path,
+      parent: r
+    }));
+  }
+}
+we.create = (n, e, t) => new we({
+  left: n,
+  right: e,
+  typeName: l.ZodIntersection,
+  ..._(t)
+});
+class Q extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== h.array)
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.array,
+        received: r.parsedType
+      }), g;
+    if (r.data.length < this._def.items.length)
+      return f(r, {
+        code: d.too_small,
+        minimum: this._def.items.length,
+        inclusive: !0,
+        exact: !1,
+        type: "array"
+      }), g;
+    !this._def.rest && r.data.length > this._def.items.length && (f(r, {
+      code: d.too_big,
+      maximum: this._def.items.length,
+      inclusive: !0,
+      exact: !1,
+      type: "array"
+    }), t.dirty());
+    const a = [...r.data].map((i, o) => {
+      const c = this._def.items[o] || this._def.rest;
+      return c ? c._parse(new V(r, i, r.path, o)) : null;
+    }).filter((i) => !!i);
+    return r.common.async ? Promise.all(a).then((i) => P.mergeArray(t, i)) : P.mergeArray(t, a);
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(e) {
+    return new Q({
+      ...this._def,
+      rest: e
+    });
+  }
+}
+Q.create = (n, e) => {
+  if (!Array.isArray(n))
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  return new Q({
+    items: n,
+    typeName: l.ZodTuple,
+    rest: null,
+    ..._(e)
+  });
+};
+class Se extends b {
+  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 !== h.object)
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.object,
+        received: r.parsedType
+      }), g;
+    const s = [], a = this._def.keyType, i = this._def.valueType;
+    for (const o in r.data)
+      s.push({
+        key: a._parse(new V(r, o, r.path, o)),
+        value: i._parse(new V(r, r.data[o], r.path, o)),
+        alwaysSet: o in r.data
+      });
+    return r.common.async ? P.mergeObjectAsync(t, s) : P.mergeObjectSync(t, s);
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(e, t, r) {
+    return t instanceof b ? new Se({
+      keyType: e,
+      valueType: t,
+      typeName: l.ZodRecord,
+      ..._(r)
+    }) : new Se({
+      keyType: F.create(),
+      valueType: e,
+      typeName: l.ZodRecord,
+      ..._(t)
+    });
+  }
+}
+class Xe extends b {
+  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 !== h.map)
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.map,
+        received: r.parsedType
+      }), g;
+    const s = this._def.keyType, a = this._def.valueType, i = [...r.data.entries()].map(([o, c], u) => ({
+      key: s._parse(new V(r, o, r.path, [u, "key"])),
+      value: a._parse(new V(r, c, r.path, [u, "value"]))
+    }));
+    if (r.common.async) {
+      const o = /* @__PURE__ */ new Map();
+      return Promise.resolve().then(async () => {
+        for (const c of i) {
+          const u = await c.key, y = await c.value;
+          if (u.status === "aborted" || y.status === "aborted")
+            return g;
+          (u.status === "dirty" || y.status === "dirty") && t.dirty(), o.set(u.value, y.value);
+        }
+        return { status: t.value, value: o };
+      });
+    } else {
+      const o = /* @__PURE__ */ new Map();
+      for (const c of i) {
+        const u = c.key, y = c.value;
+        if (u.status === "aborted" || y.status === "aborted")
+          return g;
+        (u.status === "dirty" || y.status === "dirty") && t.dirty(), o.set(u.value, y.value);
+      }
+      return { status: t.value, value: o };
+    }
+  }
+}
+Xe.create = (n, e, t) => new Xe({
+  valueType: e,
+  keyType: n,
+  typeName: l.ZodMap,
+  ..._(t)
+});
+class ie extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.parsedType !== h.set)
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.set,
+        received: r.parsedType
+      }), g;
+    const s = this._def;
+    s.minSize !== null && r.data.size < s.minSize.value && (f(r, {
+      code: d.too_small,
+      minimum: s.minSize.value,
+      type: "set",
+      inclusive: !0,
+      exact: !1,
+      message: s.minSize.message
+    }), t.dirty()), s.maxSize !== null && r.data.size > s.maxSize.value && (f(r, {
+      code: d.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 y of c) {
+        if (y.status === "aborted")
+          return g;
+        y.status === "dirty" && t.dirty(), u.add(y.value);
+      }
+      return { status: t.value, value: u };
+    }
+    const o = [...r.data.values()].map((c, u) => a._parse(new V(r, c, r.path, u)));
+    return r.common.async ? Promise.all(o).then((c) => i(c)) : i(o);
+  }
+  min(e, t) {
+    return new ie({
+      ...this._def,
+      minSize: { value: e, message: p.toString(t) }
+    });
+  }
+  max(e, t) {
+    return new ie({
+      ...this._def,
+      maxSize: { value: e, message: p.toString(t) }
+    });
+  }
+  size(e, t) {
+    return this.min(e, t).max(e, t);
+  }
+  nonempty(e) {
+    return this.min(1, e);
+  }
+}
+ie.create = (n, e) => new ie({
+  valueType: n,
+  minSize: null,
+  maxSize: null,
+  typeName: l.ZodSet,
+  ..._(e)
+});
+class Qe extends b {
+  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 });
+  }
+}
+Qe.create = (n, e) => new Qe({
+  getter: n,
+  typeName: l.ZodLazy,
+  ..._(e)
+});
+class et extends b {
+  _parse(e) {
+    if (e.data !== this._def.value) {
+      const t = this._getOrReturnCtx(e);
+      return f(t, {
+        received: t.data,
+        code: d.invalid_literal,
+        expected: this._def.value
+      }), g;
+    }
+    return { status: "valid", value: e.data };
+  }
+  get value() {
+    return this._def.value;
+  }
+}
+et.create = (n, e) => new et({
+  value: n,
+  typeName: l.ZodLiteral,
+  ..._(e)
+});
+function Mt(n, e) {
+  return new oe({
+    values: n,
+    typeName: l.ZodEnum,
+    ..._(e)
+  });
+}
+class oe extends b {
+  _parse(e) {
+    if (typeof e.data != "string") {
+      const t = this._getOrReturnCtx(e), r = this._def.values;
+      return f(t, {
+        expected: k.joinValues(r),
+        received: t.parsedType,
+        code: d.invalid_type
+      }), g;
+    }
+    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 f(t, {
+        received: t.data,
+        code: d.invalid_enum_value,
+        options: r
+      }), g;
+    }
+    return E(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 oe.create(e, {
+      ...this._def,
+      ...t
+    });
+  }
+  exclude(e, t = this._def) {
+    return oe.create(this.options.filter((r) => !e.includes(r)), {
+      ...this._def,
+      ...t
+    });
+  }
+}
+oe.create = Mt;
+class tt extends b {
+  _parse(e) {
+    const t = k.getValidEnumValues(this._def.values), r = this._getOrReturnCtx(e);
+    if (r.parsedType !== h.string && r.parsedType !== h.number) {
+      const s = k.objectValues(t);
+      return f(r, {
+        expected: k.joinValues(s),
+        received: r.parsedType,
+        code: d.invalid_type
+      }), g;
+    }
+    if (this._cache || (this._cache = new Set(k.getValidEnumValues(this._def.values))), !this._cache.has(e.data)) {
+      const s = k.objectValues(t);
+      return f(r, {
+        received: r.data,
+        code: d.invalid_enum_value,
+        options: s
+      }), g;
+    }
+    return E(e.data);
+  }
+  get enum() {
+    return this._def.values;
+  }
+}
+tt.create = (n, e) => new tt({
+  values: n,
+  typeName: l.ZodNativeEnum,
+  ..._(e)
+});
+class Ae extends b {
+  unwrap() {
+    return this._def.type;
+  }
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    if (t.parsedType !== h.promise && t.common.async === !1)
+      return f(t, {
+        code: d.invalid_type,
+        expected: h.promise,
+        received: t.parsedType
+      }), g;
+    const r = t.parsedType === h.promise ? t.data : Promise.resolve(t.data);
+    return E(r.then((s) => this._def.type.parseAsync(s, {
+      path: t.path,
+      errorMap: t.common.contextualErrorMap
+    })));
+  }
+}
+Ae.create = (n, e) => new Ae({
+  type: n,
+  typeName: l.ZodPromise,
+  ..._(e)
+});
+class K extends b {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === l.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e), s = this._def.effect || null, a = {
+      addIssue: (i) => {
+        f(r, i), i.fatal ? t.abort() : t.dirty();
+      },
+      get path() {
+        return r.path;
+      }
+    };
+    if (a.addIssue = a.addIssue.bind(a), s.type === "preprocess") {
+      const i = s.transform(r.data, a);
+      if (r.common.async)
+        return Promise.resolve(i).then(async (o) => {
+          if (t.value === "aborted")
+            return g;
+          const c = await this._def.schema._parseAsync({
+            data: o,
+            path: r.path,
+            parent: r
+          });
+          return c.status === "aborted" ? g : c.status === "dirty" || t.value === "dirty" ? fe(c.value) : c;
+        });
+      {
+        if (t.value === "aborted")
+          return g;
+        const o = this._def.schema._parseSync({
+          data: i,
+          path: r.path,
+          parent: r
+        });
+        return o.status === "aborted" ? g : o.status === "dirty" || t.value === "dirty" ? fe(o.value) : o;
+      }
+    }
+    if (s.type === "refinement") {
+      const i = (o) => {
+        const c = s.refinement(o, a);
+        if (r.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 (r.common.async === !1) {
+        const o = this._def.schema._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        return o.status === "aborted" ? g : (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" ? g : (o.status === "dirty" && t.dirty(), i(o.value).then(() => ({ status: t.value, value: o.value }))));
+    }
+    if (s.type === "transform")
+      if (r.common.async === !1) {
+        const i = this._def.schema._parseSync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        if (!re(i))
+          return g;
+        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: r.data, path: r.path, parent: r }).then((i) => re(i) ? Promise.resolve(s.transform(i.value, a)).then((o) => ({
+          status: t.value,
+          value: o
+        })) : g);
+    k.assertNever(s);
+  }
+}
+K.create = (n, e, t) => new K({
+  schema: n,
+  typeName: l.ZodEffects,
+  effect: e,
+  ..._(t)
+});
+K.createWithPreprocess = (n, e, t) => new K({
+  schema: e,
+  effect: { type: "preprocess", transform: n },
+  typeName: l.ZodEffects,
+  ..._(t)
+});
+class H extends b {
+  _parse(e) {
+    return this._getType(e) === h.undefined ? E(void 0) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+H.create = (n, e) => new H({
+  innerType: n,
+  typeName: l.ZodOptional,
+  ..._(e)
+});
+class ce extends b {
+  _parse(e) {
+    return this._getType(e) === h.null ? E(null) : this._def.innerType._parse(e);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+ce.create = (n, e) => new ce({
+  innerType: n,
+  typeName: l.ZodNullable,
+  ..._(e)
+});
+class nt extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e);
+    let r = t.data;
+    return t.parsedType === h.undefined && (r = this._def.defaultValue()), this._def.innerType._parse({
+      data: r,
+      path: t.path,
+      parent: t
+    });
+  }
+  removeDefault() {
+    return this._def.innerType;
+  }
+}
+nt.create = (n, e) => new nt({
+  innerType: n,
+  typeName: l.ZodDefault,
+  defaultValue: typeof e.default == "function" ? e.default : () => e.default,
+  ..._(e)
+});
+class rt extends b {
+  _parse(e) {
+    const { ctx: t } = this._processInputParams(e), r = {
+      ...t,
+      common: {
+        ...t.common,
+        issues: []
+      }
+    }, s = this._def.innerType._parse({
+      data: r.data,
+      path: r.path,
+      parent: {
+        ...r
+      }
+    });
+    return ke(s) ? s.then((a) => ({
+      status: "valid",
+      value: a.status === "valid" ? a.value : this._def.catchValue({
+        get error() {
+          return new z(r.common.issues);
+        },
+        input: r.data
+      })
+    })) : {
+      status: "valid",
+      value: s.status === "valid" ? s.value : this._def.catchValue({
+        get error() {
+          return new z(r.common.issues);
+        },
+        input: r.data
+      })
+    };
+  }
+  removeCatch() {
+    return this._def.innerType;
+  }
+}
+rt.create = (n, e) => new rt({
+  innerType: n,
+  typeName: l.ZodCatch,
+  catchValue: typeof e.catch == "function" ? e.catch : () => e.catch,
+  ..._(e)
+});
+class st extends b {
+  _parse(e) {
+    if (this._getType(e) !== h.nan) {
+      const r = this._getOrReturnCtx(e);
+      return f(r, {
+        code: d.invalid_type,
+        expected: h.nan,
+        received: r.parsedType
+      }), g;
+    }
+    return { status: "valid", value: e.data };
+  }
+}
+st.create = (n) => new st({
+  typeName: l.ZodNaN,
+  ..._(n)
+});
+class jn extends b {
+  _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 ot extends b {
+  _parse(e) {
+    const { status: t, ctx: r } = this._processInputParams(e);
+    if (r.common.async)
+      return (async () => {
+        const a = await this._def.in._parseAsync({
+          data: r.data,
+          path: r.path,
+          parent: r
+        });
+        return a.status === "aborted" ? g : a.status === "dirty" ? (t.dirty(), fe(a.value)) : this._def.out._parseAsync({
+          data: a.value,
+          path: r.path,
+          parent: r
+        });
+      })();
+    {
+      const s = this._def.in._parseSync({
+        data: r.data,
+        path: r.path,
+        parent: r
+      });
+      return s.status === "aborted" ? g : s.status === "dirty" ? (t.dirty(), {
+        status: "dirty",
+        value: s.value
+      }) : this._def.out._parseSync({
+        data: s.value,
+        path: r.path,
+        parent: r
+      });
+    }
+  }
+  static create(e, t) {
+    return new ot({
+      in: e,
+      out: t,
+      typeName: l.ZodPipeline
+    });
+  }
+}
+class at extends b {
+  _parse(e) {
+    const t = this._def.innerType._parse(e), r = (s) => (re(s) && (s.value = Object.freeze(s.value)), s);
+    return ke(t) ? t.then((s) => r(s)) : r(t);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+at.create = (n, e) => new at({
+  innerType: n,
+  typeName: l.ZodReadonly,
+  ..._(e)
+});
+C.lazycreate;
+var l;
+(function(n) {
+  n.ZodString = "ZodString", n.ZodNumber = "ZodNumber", n.ZodNaN = "ZodNaN", n.ZodBigInt = "ZodBigInt", n.ZodBoolean = "ZodBoolean", n.ZodDate = "ZodDate", n.ZodSymbol = "ZodSymbol", n.ZodUndefined = "ZodUndefined", n.ZodNull = "ZodNull", n.ZodAny = "ZodAny", n.ZodUnknown = "ZodUnknown", n.ZodNever = "ZodNever", n.ZodVoid = "ZodVoid", n.ZodArray = "ZodArray", n.ZodObject = "ZodObject", n.ZodUnion = "ZodUnion", n.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", n.ZodIntersection = "ZodIntersection", n.ZodTuple = "ZodTuple", n.ZodRecord = "ZodRecord", n.ZodMap = "ZodMap", n.ZodSet = "ZodSet", n.ZodFunction = "ZodFunction", n.ZodLazy = "ZodLazy", n.ZodLiteral = "ZodLiteral", n.ZodEnum = "ZodEnum", n.ZodEffects = "ZodEffects", n.ZodNativeEnum = "ZodNativeEnum", n.ZodOptional = "ZodOptional", n.ZodNullable = "ZodNullable", n.ZodDefault = "ZodDefault", n.ZodCatch = "ZodCatch", n.ZodPromise = "ZodPromise", n.ZodBranded = "ZodBranded", n.ZodPipeline = "ZodPipeline", n.ZodReadonly = "ZodReadonly";
+})(l || (l = {}));
+const D = F.create, _t = se.create;
+st.create;
+ae.create;
+const In = Be.create;
+ge.create;
+We.create;
+qe.create;
+const Mn = Je.create, ne = He.create;
+Ge.create;
+Y.create;
+Ye.create;
+const Et = L.create, B = C.create;
+C.strictCreate;
+const Ze = xe.create;
+we.create;
+Q.create;
+const ct = Se.create;
+Xe.create;
+ie.create;
+Qe.create;
+const Pe = et.create;
+oe.create;
+tt.create;
+Ae.create;
+K.create;
+H.create;
+ce.create;
+K.createWithPreprocess;
+class je extends Error {
+  constructor(e, t = "UNKNOWN_ERROR") {
+    super(e), this.name = this.constructor.name, this.code = t, Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  }
+}
+class Re extends je {
+  constructor(e, t) {
+    super(e, "VALIDATION_ERROR"), this.details = t;
+  }
+}
+class le extends je {
+  constructor(e, t) {
+    super(e, "DATA_ERROR"), this.path = t;
+  }
+}
+class bt extends je {
+  constructor(e, t, r) {
+    super(e, "EXPRESSION_ERROR"), this.expression = t, this.details = r;
+  }
+}
+class he extends je {
+  constructor(e) {
+    super(e, "STATE_ERROR");
+  }
+}
+class En {
+  constructor(e, t, r = [], s) {
+    this.id = e;
+    const a = /* @__PURE__ */ new Map();
+    for (const o of t)
+      a.set(o.name, o);
+    this.components = a;
+    const i = /* @__PURE__ */ new Map();
+    for (const o of r)
+      i.set(o.name, o);
+    this.functions = i, this.themeSchema = s, this.invoker = (o, c, u, y) => {
+      var v;
+      const T = this.functions.get(o);
+      if (!T)
+        throw new bt(`Function not found in catalog '${this.id}': ${o}`, o);
+      try {
+        const w = T.schema.parse(c);
+        return T.execute(w, u, y);
+      } catch (w) {
+        throw (w == null ? void 0 : w.name) === "ZodError" || w instanceof z ? new bt(`Validation failed for function '${o}': ${w.message}`, o, (v = w.errors) != null ? v : w.issues) : w;
+      }
+    };
+  }
+}
+class G {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Subscribes to the event.
+   *
+   * @param listener The listener function to call when the event is emitted.
+   * @returns A subscription object that can be used to unsubscribe.
+   */
+  subscribe(e) {
+    return this.listeners.add(e), {
+      unsubscribe: () => this.listeners.delete(e)
+    };
+  }
+  /**
+   * Emits an event to all subscribers.
+   *
+   * @param data The data to pass to subscribers.
+   */
+  async emit(e) {
+    for (const t of this.listeners)
+      try {
+        await t(e);
+      } catch (r) {
+        console.error("EventEmitter error:", r);
+      }
+  }
+  /**
+   * Removes all listeners.
+   */
+  dispose() {
+    this.listeners.clear();
+  }
+}
+var Rn = Symbol.for("preact-signals");
+function Ie() {
+  if (W > 1)
+    W--;
+  else {
+    var n, e = !1;
+    for (function() {
+      var s = Ce;
+      for (Ce = void 0; s !== void 0; )
+        s.S.v === s.v && (s.S.i = s.i), s = s.o;
+    }(); ye !== void 0; ) {
+      var t = ye;
+      for (ye = void 0, Te++; t !== void 0; ) {
+        var r = t.u;
+        if (t.u = void 0, t.f &= -3, !(8 & t.f) && Dt(t))
+          try {
+            t.c();
+          } catch (s) {
+            e || (n = s, e = !0);
+          }
+        t = r;
+      }
+    }
+    if (Te = 0, W--, e)
+      throw n;
+  }
+}
+function kt(n) {
+  if (W > 0)
+    return n();
+  it = ++$n, W++;
+  try {
+    return n();
+  } finally {
+    Ie();
+  }
+}
+var S = void 0;
+function Rt(n) {
+  var e = S;
+  S = void 0;
+  try {
+    return n();
+  } finally {
+    S = e;
+  }
+}
+var ye = void 0, W = 0, Te = 0, $n = 0, it = 0, Ce = void 0, Oe = 0;
+function $t(n) {
+  if (S !== void 0) {
+    var e = n.n;
+    if (e === void 0 || e.t !== S)
+      return e = { i: 0, S: n, p: S.s, n: void 0, t: S, e: void 0, x: void 0, r: e }, S.s !== void 0 && (S.s.n = e), S.s = e, n.n = e, 32 & S.f && n.S(e), e;
+    if (e.i === -1)
+      return e.i = 0, e.n !== void 0 && (e.n.p = e.p, e.p !== void 0 && (e.p.n = e.n), e.p = S.s, e.n = void 0, S.s.n = e, S.s = e), e;
+  }
+}
+function j(n, e) {
+  this.v = n, this.i = 0, this.n = void 0, this.t = void 0, this.l = 0, this.W = e == null ? void 0 : e.watched, this.Z = e == null ? void 0 : e.unwatched, this.name = e == null ? void 0 : e.name;
+}
+j.prototype.brand = Rn;
+j.prototype.h = function() {
+  return !0;
+};
+j.prototype.S = function(n) {
+  var e = this, t = this.t;
+  t !== n && n.e === void 0 && (n.x = t, this.t = n, t !== void 0 ? t.e = n : Rt(function() {
+    var r;
+    (r = e.W) == null || r.call(e);
+  }));
+};
+j.prototype.U = function(n) {
+  var e = this;
+  if (this.t !== void 0) {
+    var t = n.e, r = n.x;
+    t !== void 0 && (t.x = r, n.e = void 0), r !== void 0 && (r.e = t, n.x = void 0), n === this.t && (this.t = r, r === void 0 && Rt(function() {
+      var s;
+      (s = e.Z) == null || s.call(e);
+    }));
+  }
+};
+j.prototype.subscribe = function(n) {
+  var e = this;
+  return Ut(function() {
+    var t = e.value, r = S;
+    S = void 0;
+    try {
+      n(t);
+    } finally {
+      S = r;
+    }
+  }, { name: "sub" });
+};
+j.prototype.valueOf = function() {
+  return this.value;
+};
+j.prototype.toString = function() {
+  return this.value + "";
+};
+j.prototype.toJSON = function() {
+  return this.value;
+};
+j.prototype.peek = function() {
+  var n = S;
+  S = void 0;
+  try {
+    return this.value;
+  } finally {
+    S = n;
+  }
+};
+Object.defineProperty(j.prototype, "value", { get: function() {
+  var n = $t(this);
+  return n !== void 0 && (n.i = this.i), this.v;
+}, set: function(n) {
+  if (n !== this.v) {
+    if (Te > 100)
+      throw new Error("Cycle detected");
+    ((function(t) {
+      W !== 0 && Te === 0 && t.l !== it && (t.l = it, Ce = { S: t, v: t.v, i: t.i, o: Ce });
+    }))(this), this.v = n, this.i++, Oe++, W++;
+    try {
+      for (var e = this.t; e !== void 0; e = e.x)
+        e.t.N();
+    } finally {
+      Ie();
+    }
+  }
+} });
+function Dn(n, e) {
+  return new j(n, e);
+}
+function Dt(n) {
+  for (var e = n.s; e !== void 0; e = e.n)
+    if (e.S.i !== e.i || !e.S.h() || e.S.i !== e.i)
+      return !0;
+  return !1;
+}
+function Lt(n) {
+  for (var e = n.s; e !== void 0; e = e.n) {
+    var t = e.S.n;
+    if (t !== void 0 && (e.r = t), e.S.n = e, e.i = -1, e.n === void 0) {
+      n.s = e;
+      break;
+    }
+  }
+}
+function zt(n) {
+  for (var e = n.s, t = void 0; e !== void 0; ) {
+    var r = e.p;
+    e.i === -1 ? (e.S.U(e), r !== void 0 && (r.n = e.n), e.n !== void 0 && (e.n.p = r)) : t = e, e.S.n = e.r, e.r !== void 0 && (e.r = void 0), e = r;
+  }
+  n.s = t;
+}
+function ue(n, e) {
+  j.call(this, void 0), this.x = n, this.s = void 0, this.g = Oe - 1, this.f = 4, this.W = e == null ? void 0 : e.watched, this.Z = e == null ? void 0 : e.unwatched, this.name = e == null ? void 0 : e.name;
+}
+ue.prototype = new j();
+ue.prototype.h = function() {
+  if (this.f &= -3, 1 & this.f)
+    return !1;
+  if ((36 & this.f) == 32 || (this.f &= -5, this.g === Oe))
+    return !0;
+  if (this.g = Oe, this.f |= 1, this.i > 0 && !Dt(this))
+    return this.f &= -2, !0;
+  var n = S;
+  try {
+    Lt(this), S = this;
+    var e = this.x();
+    (16 & this.f || this.v !== e || this.i === 0) && (this.v = e, this.f &= -17, this.i++);
+  } catch (t) {
+    this.v = t, this.f |= 16, this.i++;
+  }
+  return S = n, zt(this), this.f &= -2, !0;
+};
+ue.prototype.S = function(n) {
+  if (this.t === void 0) {
+    this.f |= 36;
+    for (var e = this.s; e !== void 0; e = e.n)
+      e.S.S(e);
+  }
+  j.prototype.S.call(this, n);
+};
+ue.prototype.U = function(n) {
+  if (this.t !== void 0 && (j.prototype.U.call(this, n), this.t === void 0)) {
+    this.f &= -33;
+    for (var e = this.s; e !== void 0; e = e.n)
+      e.S.U(e);
+  }
+};
+ue.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var n = this.t; n !== void 0; n = n.x)
+      n.t.N();
+  }
+};
+Object.defineProperty(ue.prototype, "value", { get: function() {
+  if (1 & this.f)
+    throw new Error("Cycle detected");
+  var n = $t(this);
+  if (this.h(), n !== void 0 && (n.i = this.i), 16 & this.f)
+    throw this.v;
+  return this.v;
+} });
+function Vt(n) {
+  var e = n.m;
+  if (n.m = void 0, typeof e == "function") {
+    W++;
+    var t = S;
+    S = void 0;
+    try {
+      e();
+    } catch (r) {
+      throw n.f &= -2, n.f |= 8, ut(n), r;
+    } finally {
+      S = t, Ie();
+    }
+  }
+}
+function ut(n) {
+  for (var e = n.s; e !== void 0; e = e.n)
+    e.S.U(e);
+  n.x = void 0, n.s = void 0, Vt(n);
+}
+function Ln(n) {
+  if (S !== this)
+    throw new Error("Out-of-order effect");
+  zt(this), S = n, this.f &= -2, 8 & this.f && ut(this), Ie();
+}
+function de(n, e) {
+  this.x = n, this.m = void 0, this.s = void 0, this.u = void 0, this.f = 32, this.name = e == null ? void 0 : e.name;
+}
+de.prototype.c = function() {
+  var n = this.S();
+  try {
+    if (8 & this.f || this.x === void 0)
+      return;
+    var e = this.x();
+    typeof e == "function" && (this.m = e);
+  } finally {
+    n();
+  }
+};
+de.prototype.S = function() {
+  if (1 & this.f)
+    throw new Error("Cycle detected");
+  this.f |= 1, this.f &= -9, Vt(this), Lt(this), W++;
+  var n = S;
+  return S = this, Ln.bind(this, n);
+};
+de.prototype.N = function() {
+  2 & this.f || (this.f |= 2, this.u = ye, ye = this);
+};
+de.prototype.d = function() {
+  this.f |= 8, 1 & this.f || ut(this);
+};
+de.prototype.dispose = function() {
+  this.d();
+};
+function Ut(n, e) {
+  var t = new de(n, e);
+  try {
+    t.c();
+  } catch (s) {
+    throw t.d(), s;
+  }
+  var r = t.d.bind(t);
+  return r[Symbol.dispose] = r, r;
+}
+function $e(n) {
+  return /^\d+$/.test(n);
+}
+class zn {
+  /**
+   * Creates a new data model.
+   *
+   * @param initialData The initial data for the model. Defaults to an empty object.
+   */
+  constructor(e = {}) {
+    this.data = {}, this.signals = /* @__PURE__ */ new Map(), this.subscriptions = /* @__PURE__ */ new Set(), this.data = e;
+  }
+  /**
+   * Retrieves a Preact Signal for a specific data path.
+   *
+   * This provides a reactive way to access a value. If the value at the path changes via `set()`,
+   * the signal will automatically be updated.
+   *
+   * @param path The JSON pointer path to create or retrieve a signal for.
+   * @returns A Preact Signal representing the value at the specified path.
+   */
+  getSignal(e) {
+    const t = this.normalizePath(e);
+    return this.signals.has(t) || this.signals.set(t, Dn(this.get(t))), this.signals.get(t);
+  }
+  /**
+   * Updates the model at the specific path and notifies all relevant signals.
+   * If path is '/' or empty, replaces the entire root.
+   *
+   * Note on `undefined` values:
+   * - For objects: Setting a property to `undefined` removes the key from the object.
+   * - For arrays: Setting an index to `undefined` sets that index to `undefined` but preserves the array length (sparse array).
+   */
+  set(e, t) {
+    if (e == null)
+      throw new le("Path cannot be null or undefined.");
+    if (e === "/" || e === "")
+      return this.data = t, this.notifyAllSignals(), this;
+    const r = this.parsePath(e), s = r.pop();
+    this.data || (this.data = {});
+    let a = this.data;
+    for (let i = 0; i < r.length; i++) {
+      const o = r[i];
+      if (Array.isArray(a) && !$e(o))
+        throw new le(`Cannot use non-numeric segment '${o}' on an array in path '${e}'.`, e);
+      if (a[o] !== void 0 && a[o] !== null && typeof a[o] != "object")
+        throw new le(`Cannot set path '${e}': segment '${o}' is a primitive value.`, e);
+      if (a[o] === void 0 || a[o] === null) {
+        const c = i < r.length - 1 ? r[i + 1] : s;
+        a[o] = $e(c) ? [] : {};
+      }
+      a = a[o];
+    }
+    if (Array.isArray(a) && !$e(s))
+      throw new le(`Cannot use non-numeric segment '${s}' on an array in path '${e}'.`, e);
+    return t === void 0 ? Array.isArray(a) ? a[parseInt(s, 10)] = void 0 : delete a[s] : a[s] = t, this.notifySignals(e), this;
+  }
+  /**
+   * Retrieves data at a specific JSON pointer path.
+   *
+   * @param path The JSON pointer path to read from.
+   * @returns The value at the specified path, or undefined if not found.
+   */
+  get(e) {
+    if (e == null)
+      throw new le("Path cannot be null or undefined.");
+    if (e === "/" || e === "")
+      return this.data;
+    const t = this.parsePath(e);
+    let r = this.data;
+    for (const s of t) {
+      if (r == null)
+        return;
+      r = r[s];
+    }
+    return r;
+  }
+  /**
+   * Subscribes to changes at the specified data path.
+   *
+   * This is a backwards-compatible layer using Preact Signals internally. It allows
+   * listeners to be notified whenever the value at the specified path (or any of its
+   * ancestors/descendants) changes.
+   *
+   * @param path The JSON pointer path to observe.
+   * @param onChange A callback fired whenever the value changes.
+   * @returns A `DataSubscription` containing the initial value and an `unsubscribe` method.
+   */
+  subscribe(e, t) {
+    const r = this.getSignal(e);
+    let s = !0, a = r.peek();
+    const i = Ut(() => {
+      const o = r.value;
+      a = o, s || t(o);
+    });
+    return s = !1, this.subscriptions.add(i), {
+      get value() {
+        return a;
+      },
+      unsubscribe: () => {
+        i(), this.subscriptions.delete(i);
+      }
+    };
+  }
+  /**
+   * Clears all internal subscriptions.
+   */
+  dispose() {
+    for (const e of this.subscriptions)
+      e();
+    this.subscriptions.clear(), this.signals.clear();
+  }
+  normalizePath(e) {
+    return e.length > 1 && e.endsWith("/") ? e.slice(0, -1) : e || "/";
+  }
+  parsePath(e) {
+    return e.split("/").filter((t) => t.length > 0);
+  }
+  notifySignals(e) {
+    const t = this.normalizePath(e);
+    kt(() => {
+      this.updateSignal(t);
+      let r = t;
+      for (; r !== "/" && r !== ""; )
+        r = r.substring(0, r.lastIndexOf("/")) || "/", this.updateSignal(r);
+      for (const s of this.signals.keys())
+        this.isDescendant(s, t) && this.updateSignal(s);
+    });
+  }
+  updateSignal(e) {
+    const t = this.signals.get(e);
+    if (t) {
+      const r = this.get(e);
+      Array.isArray(r) ? t.value = [...r] : typeof r == "object" && r !== null ? t.value = { ...r } : t.value = r;
+    }
+  }
+  notifyAllSignals() {
+    kt(() => {
+      for (const e of this.signals.keys())
+        this.updateSignal(e);
+    });
+  }
+  isDescendant(e, t) {
+    return t === "/" || t === "" ? e !== "/" : e.startsWith(t + "/");
+  }
+}
+class Vn {
+  constructor() {
+    this.components = /* @__PURE__ */ new Map(), this._onCreated = new G(), this._onDeleted = new G(), this.onCreated = this._onCreated, this.onDeleted = this._onDeleted;
+  }
+  /**
+   * Retrieves a component by its ID.
+   *
+   *
+   * @param id The ID of the component to retrieve.
+   * @returns The component model, or undefined if not found.
+   */
+  get(e) {
+    return this.components.get(e);
+  }
+  /**
+   * Returns an iterator over the components in the model.
+   */
+  get entries() {
+    return this.components.entries();
+  }
+  /**
+   * Adds a component to the model.
+   * Throws an error if a component with the same ID already exists.
+   *
+   * @param component The component to add.
+   */
+  addComponent(e) {
+    if (this.components.has(e.id))
+      throw new he(`Component with id '${e.id}' already exists.`);
+    this.components.set(e.id, e), this._onCreated.emit(e);
+  }
+  /**
+   * Removes a component from the model by its ID.
+   * Disposes of the component upon removal.
+   *
+   * @param id The ID of the component to remove.
+   */
+  removeComponent(e) {
+    const t = this.components.get(e);
+    t && (this.components.delete(e), t.dispose(), this._onDeleted.emit(e));
+  }
+  /**
+   * Disposes of the model and all its components.
+   */
+  dispose() {
+    for (const e of this.components.values())
+      e.dispose();
+    this.components.clear(), this._onCreated.dispose(), this._onDeleted.dispose();
+  }
+}
+const Ft = B({
+  name: D().describe("The name of the action, taken from the component's action.event.name property."),
+  surfaceId: D().describe("The id of the surface where the event originated."),
+  sourceComponentId: D().describe("The id of the component that triggered the event."),
+  timestamp: D().datetime().describe("An ISO 8601 timestamp of when the event occurred."),
+  context: ct(ne()).describe("A JSON object containing the key-value pairs from the component's action.event.context, after resolving all data bindings.")
+}).strict(), Un = B({
+  code: Pe("VALIDATION_FAILED"),
+  surfaceId: D().describe("The id of the surface where the error occurred."),
+  path: D().describe("The JSON pointer to the field that failed validation (e.g. '/components/0/text')."),
+  message: D().describe("A short one or two sentence description of why validation failed.")
+}).strict(), Fn = B({
+  code: D().refine((n) => n !== "VALIDATION_FAILED"),
+  message: D().describe("A short one or two sentence description of why the error occurred."),
+  surfaceId: D().describe("The id of the surface where the error occurred.")
+}).passthrough(), Bn = Ze([
+  Un,
+  Fn
+]);
+B({
+  version: Pe("v0.9")
+}).and(Ze([
+  B({ action: Ft }),
+  B({ error: Bn })
+]));
+B({
+  version: Pe("v0.9"),
+  surfaces: ct(B({}).passthrough()).describe("A map of surface IDs to their current data models.")
+}).strict();
+class Wn {
+  /**
+   * Creates a new surface model.
+   *
+   * @param id The unique identifier for this surface.
+   * @param catalog The component catalog used by this surface.
+   * @param theme The theme to apply to this surface.
+   * @param sendDataModel If true, the client will send the full data model.
+   */
+  constructor(e, t, r = {}, s = !1) {
+    this.id = e, this.catalog = t, this.theme = r, this.sendDataModel = s, this._onAction = new G(), this._onError = new G(), this.onAction = this._onAction, this.onError = this._onError, this.dataModel = new zn({}), this.componentsModel = new Vn();
+  }
+  /**
+   * Dispatches an action from this surface to listeners.
+   *
+   * @param payload The action payload (name and context) to dispatch.
+   * @param sourceComponentId The ID of the component that triggered the action.
+   */
+  async dispatchAction(e, t) {
+    if (e && typeof e == "object" && "event" in e && e.event) {
+      const r = {
+        name: e.event.name,
+        surfaceId: this.id,
+        sourceComponentId: t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        context: e.event.context || {}
+      }, s = Ft.safeParse(r);
+      s.success ? await this._onAction.emit(s.data) : console.error("A2UI: Invalid action payload dispatched.", s.error.format());
+    }
+  }
+  /**
+   * Dispatches an error from this surface to listeners.
+   *
+   * @param error The error object to dispatch, conforming to client_to_server schema.
+   */
+  async dispatchError(e) {
+    await this._onError.emit({
+      ...e,
+      surfaceId: this.id
+    });
+  }
+  /**
+   * Disposes of the surface and its resources.
+   */
+  dispose() {
+    this.dataModel.dispose(), this.componentsModel.dispose(), this._onAction.dispose(), this._onError.dispose();
+  }
+}
+class qn {
+  constructor() {
+    this.surfaces = /* @__PURE__ */ new Map(), this.surfaceUnsubscribers = /* @__PURE__ */ new Map(), this._onSurfaceCreated = new G(), this._onSurfaceDeleted = new G(), this._onAction = new G(), this.onSurfaceCreated = this._onSurfaceCreated, this.onSurfaceDeleted = this._onSurfaceDeleted, this.onAction = this._onAction;
+  }
+  /**
+   * Adds a surface to the group.
+   * Ignores if a surface with the same ID already exists.
+   *
+   * @param surface The surface model to add.
+   */
+  addSurface(e) {
+    if (this.surfaces.has(e.id)) {
+      console.warn(`Surface ${e.id} already exists. Ignoring.`);
+      return;
+    }
+    this.surfaces.set(e.id, e);
+    const t = e.onAction.subscribe((r) => this._onAction.emit(r));
+    this.surfaceUnsubscribers.set(e.id, t), this._onSurfaceCreated.emit(e);
+  }
+  /**
+   * Removes a surface from the group by its ID.
+   * Disposes of the surface upon removal.
+   *
+   * @param id The ID of the surface to remove.
+   */
+  deleteSurface(e) {
+    const t = this.surfaces.get(e);
+    if (t) {
+      const r = this.surfaceUnsubscribers.get(e);
+      r && (r.unsubscribe(), this.surfaceUnsubscribers.delete(e)), this.surfaces.delete(e), t.dispose(), this._onSurfaceDeleted.emit(e);
+    }
+  }
+  /**
+   * Retrieves a surface by its ID.
+   *
+   *
+   * @param id The ID of the surface to retrieve.
+   * @returns The surface model, or undefined if not found.
+   */
+  getSurface(e) {
+    return this.surfaces.get(e);
+  }
+  /**
+   * Returns a readonly map of all active surfaces.
+   */
+  get surfacesMap() {
+    return this.surfaces;
+  }
+  /**
+   * Disposes of the group and all its surfaces.
+   */
+  dispose() {
+    for (const e of Array.from(this.surfaces.keys()))
+      this.deleteSurface(e);
+    this._onSurfaceCreated.dispose(), this._onSurfaceDeleted.dispose(), this._onAction.dispose();
+  }
+}
+class xt {
+  /**
+   * Creates a new component model.
+   *
+   * @param id The unique identifier for this component.
+   * @param type The component type name.
+   * @param initialProperties The initial properties for the component.
+   */
+  constructor(e, t, r) {
+    this.id = e, this.type = t, this._onUpdated = new G(), this.onUpdated = this._onUpdated, this._properties = r;
+  }
+  /**
+   * The current properties of the component.
+   */
+  get properties() {
+    return this._properties;
+  }
+  set properties(e) {
+    this._properties = e, this._onUpdated.emit(this);
+  }
+  /**
+   * Disposes of the component and its resources.
+   */
+  dispose() {
+    this._onUpdated.dispose();
+  }
+  /**
+   * Returns a JSON representation of the component tree.
+   */
+  get componentTree() {
+    return {
+      id: this.id,
+      type: this.type,
+      ...this._properties
+    };
+  }
+}
+const Jn = Symbol("Let zodToJsonSchema decide on which parser to use"), wt = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: !0,
+  rejectedAdditionalProperties: !1,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: !1,
+  definitions: {},
+  errorMessages: !1,
+  markdownDescription: !1,
+  patternStrategy: "escape",
+  applyRegexFlags: !1,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+}, Hn = (n) => typeof n == "string" ? {
+  ...wt,
+  name: n
+} : {
+  ...wt,
+  ...n
+}, Gn = (n) => {
+  const e = Hn(n), t = e.name !== void 0 ? [...e.basePath, e.definitionPath, e.name] : e.basePath;
+  return {
+    ...e,
+    flags: { hasReferencedOpenAiAnyType: !1 },
+    currentPath: t,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(e.definitions).map(([r, s]) => [
+      s._def,
+      {
+        def: s._def,
+        path: [...e.basePath, e.definitionPath, r],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+function Bt(n, e, t, r) {
+  r != null && r.errorMessages && t && (n.errorMessage = {
+    ...n.errorMessage,
+    [e]: t
+  });
+}
+function A(n, e, t, r, s) {
+  n[e] = t, Bt(n, e, r, s);
+}
+const Wt = (n, e) => {
+  let t = 0;
+  for (; t < n.length && t < e.length && n[t] === e[t]; t++)
+    ;
+  return [(n.length - t).toString(), ...e.slice(t)].join("/");
+};
+function M(n) {
+  if (n.target !== "openAi")
+    return {};
+  const e = [
+    ...n.basePath,
+    n.definitionPath,
+    n.openAiAnyTypeName
+  ];
+  return n.flags.hasReferencedOpenAiAnyType = !0, {
+    $ref: n.$refStrategy === "relative" ? Wt(e, n.currentPath) : e.join("/")
+  };
+}
+function Yn(n, e) {
+  var r, s, a;
+  const t = {
+    type: "array"
+  };
+  return (r = n.type) != null && r._def && ((a = (s = n.type) == null ? void 0 : s._def) == null ? void 0 : a.typeName) !== l.ZodAny && (t.items = x(n.type._def, {
+    ...e,
+    currentPath: [...e.currentPath, "items"]
+  })), n.minLength && A(t, "minItems", n.minLength.value, n.minLength.message, e), n.maxLength && A(t, "maxItems", n.maxLength.value, n.maxLength.message, e), n.exactLength && (A(t, "minItems", n.exactLength.value, n.exactLength.message, e), A(t, "maxItems", n.exactLength.value, n.exactLength.message, e)), t;
+}
+function Kn(n, e) {
+  const t = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!n.checks)
+    return t;
+  for (const r of n.checks)
+    switch (r.kind) {
+      case "min":
+        e.target === "jsonSchema7" ? r.inclusive ? A(t, "minimum", r.value, r.message, e) : A(t, "exclusiveMinimum", r.value, r.message, e) : (r.inclusive || (t.exclusiveMinimum = !0), A(t, "minimum", r.value, r.message, e));
+        break;
+      case "max":
+        e.target === "jsonSchema7" ? r.inclusive ? A(t, "maximum", r.value, r.message, e) : A(t, "exclusiveMaximum", r.value, r.message, e) : (r.inclusive || (t.exclusiveMaximum = !0), A(t, "maximum", r.value, r.message, e));
+        break;
+      case "multipleOf":
+        A(t, "multipleOf", r.value, r.message, e);
+        break;
+    }
+  return t;
+}
+function Xn() {
+  return {
+    type: "boolean"
+  };
+}
+function qt(n, e) {
+  return x(n.type._def, e);
+}
+const Qn = (n, e) => x(n.innerType._def, e);
+function Jt(n, e, t) {
+  const r = t != null ? t : e.dateStrategy;
+  if (Array.isArray(r))
+    return {
+      anyOf: r.map((s, a) => Jt(n, e, s))
+    };
+  switch (r) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return er(n, e);
+  }
+}
+const er = (n, e) => {
+  const t = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (e.target === "openApi3")
+    return t;
+  for (const r of n.checks)
+    switch (r.kind) {
+      case "min":
+        A(
+          t,
+          "minimum",
+          r.value,
+          // This is in milliseconds
+          r.message,
+          e
+        );
+        break;
+      case "max":
+        A(
+          t,
+          "maximum",
+          r.value,
+          // This is in milliseconds
+          r.message,
+          e
+        );
+        break;
+    }
+  return t;
+};
+function tr(n, e) {
+  return {
+    ...x(n.innerType._def, e),
+    default: n.defaultValue()
+  };
+}
+function nr(n, e) {
+  return e.effectStrategy === "input" ? x(n.schema._def, e) : M(e);
+}
+function rr(n) {
+  return {
+    type: "string",
+    enum: Array.from(n.values)
+  };
+}
+const sr = (n) => "type" in n && n.type === "string" ? !1 : "allOf" in n;
+function ar(n, e) {
+  const t = [
+    x(n.left._def, {
+      ...e,
+      currentPath: [...e.currentPath, "allOf", "0"]
+    }),
+    x(n.right._def, {
+      ...e,
+      currentPath: [...e.currentPath, "allOf", "1"]
+    })
+  ].filter((a) => !!a);
+  let r = e.target === "jsonSchema2019-09" ? { unevaluatedProperties: !1 } : void 0;
+  const s = [];
+  return t.forEach((a) => {
+    if (sr(a))
+      s.push(...a.allOf), a.unevaluatedProperties === void 0 && (r = void 0);
+    else {
+      let i = a;
+      if ("additionalProperties" in a && a.additionalProperties === !1) {
+        const { additionalProperties: o, ...c } = a;
+        i = c;
+      } else
+        r = void 0;
+      s.push(i);
+    }
+  }), s.length ? {
+    allOf: s,
+    ...r
+  } : void 0;
+}
+function ir(n, e) {
+  const t = typeof n.value;
+  return t !== "bigint" && t !== "number" && t !== "boolean" && t !== "string" ? {
+    type: Array.isArray(n.value) ? "array" : "object"
+  } : e.target === "openApi3" ? {
+    type: t === "bigint" ? "integer" : t,
+    enum: [n.value]
+  } : {
+    type: t === "bigint" ? "integer" : t,
+    const: n.value
+  };
+}
+let De;
+const R = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => (De === void 0 && (De = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u")), De),
+  /**
+   * Unused
+   */
+  uuid: /^[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}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?: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])$/,
+  ipv4Cidr: /^(?:(?: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])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([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})))$/,
+  ipv6Cidr: /^(([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])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function Ht(n, e) {
+  const t = {
+    type: "string"
+  };
+  if (n.checks)
+    for (const r of n.checks)
+      switch (r.kind) {
+        case "min":
+          A(t, "minLength", typeof t.minLength == "number" ? Math.max(t.minLength, r.value) : r.value, r.message, e);
+          break;
+        case "max":
+          A(t, "maxLength", typeof t.maxLength == "number" ? Math.min(t.maxLength, r.value) : r.value, r.message, e);
+          break;
+        case "email":
+          switch (e.emailStrategy) {
+            case "format:email":
+              $(t, "email", r.message, e);
+              break;
+            case "format:idn-email":
+              $(t, "idn-email", r.message, e);
+              break;
+            case "pattern:zod":
+              Z(t, R.email, r.message, e);
+              break;
+          }
+          break;
+        case "url":
+          $(t, "uri", r.message, e);
+          break;
+        case "uuid":
+          $(t, "uuid", r.message, e);
+          break;
+        case "regex":
+          Z(t, r.regex, r.message, e);
+          break;
+        case "cuid":
+          Z(t, R.cuid, r.message, e);
+          break;
+        case "cuid2":
+          Z(t, R.cuid2, r.message, e);
+          break;
+        case "startsWith":
+          Z(t, RegExp(`^${Le(r.value, e)}`), r.message, e);
+          break;
+        case "endsWith":
+          Z(t, RegExp(`${Le(r.value, e)}$`), r.message, e);
+          break;
+        case "datetime":
+          $(t, "date-time", r.message, e);
+          break;
+        case "date":
+          $(t, "date", r.message, e);
+          break;
+        case "time":
+          $(t, "time", r.message, e);
+          break;
+        case "duration":
+          $(t, "duration", r.message, e);
+          break;
+        case "length":
+          A(t, "minLength", typeof t.minLength == "number" ? Math.max(t.minLength, r.value) : r.value, r.message, e), A(t, "maxLength", typeof t.maxLength == "number" ? Math.min(t.maxLength, r.value) : r.value, r.message, e);
+          break;
+        case "includes": {
+          Z(t, RegExp(Le(r.value, e)), r.message, e);
+          break;
+        }
+        case "ip": {
+          r.version !== "v6" && $(t, "ipv4", r.message, e), r.version !== "v4" && $(t, "ipv6", r.message, e);
+          break;
+        }
+        case "base64url":
+          Z(t, R.base64url, r.message, e);
+          break;
+        case "jwt":
+          Z(t, R.jwt, r.message, e);
+          break;
+        case "cidr": {
+          r.version !== "v6" && Z(t, R.ipv4Cidr, r.message, e), r.version !== "v4" && Z(t, R.ipv6Cidr, r.message, e);
+          break;
+        }
+        case "emoji":
+          Z(t, R.emoji(), r.message, e);
+          break;
+        case "ulid": {
+          Z(t, R.ulid, r.message, e);
+          break;
+        }
+        case "base64": {
+          switch (e.base64Strategy) {
+            case "format:binary": {
+              $(t, "binary", r.message, e);
+              break;
+            }
+            case "contentEncoding:base64": {
+              A(t, "contentEncoding", "base64", r.message, e);
+              break;
+            }
+            case "pattern:zod": {
+              Z(t, R.base64, r.message, e);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid":
+          Z(t, R.nanoid, r.message, e);
+      }
+  return t;
+}
+function Le(n, e) {
+  return e.patternStrategy === "escape" ? cr(n) : n;
+}
+const or = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function cr(n) {
+  let e = "";
+  for (let t = 0; t < n.length; t++)
+    or.has(n[t]) || (e += "\\"), e += n[t];
+  return e;
+}
+function $(n, e, t, r) {
+  var s;
+  n.format || (s = n.anyOf) != null && s.some((a) => a.format) ? (n.anyOf || (n.anyOf = []), n.format && (n.anyOf.push({
+    format: n.format,
+    ...n.errorMessage && r.errorMessages && {
+      errorMessage: { format: n.errorMessage.format }
+    }
+  }), delete n.format, n.errorMessage && (delete n.errorMessage.format, Object.keys(n.errorMessage).length === 0 && delete n.errorMessage)), n.anyOf.push({
+    format: e,
+    ...t && r.errorMessages && { errorMessage: { format: t } }
+  })) : A(n, "format", e, t, r);
+}
+function Z(n, e, t, r) {
+  var s;
+  n.pattern || (s = n.allOf) != null && s.some((a) => a.pattern) ? (n.allOf || (n.allOf = []), n.pattern && (n.allOf.push({
+    pattern: n.pattern,
+    ...n.errorMessage && r.errorMessages && {
+      errorMessage: { pattern: n.errorMessage.pattern }
+    }
+  }), delete n.pattern, n.errorMessage && (delete n.errorMessage.pattern, Object.keys(n.errorMessage).length === 0 && delete n.errorMessage)), n.allOf.push({
+    pattern: St(e, r),
+    ...t && r.errorMessages && { errorMessage: { pattern: t } }
+  })) : A(n, "pattern", St(e, r), t, r);
+}
+function St(n, e) {
+  var c;
+  if (!e.applyRegexFlags || !n.flags)
+    return n.source;
+  const t = {
+    i: n.flags.includes("i"),
+    m: n.flags.includes("m"),
+    s: n.flags.includes("s")
+    // `.` matches newlines
+  }, r = t.i ? n.source.toLowerCase() : n.source;
+  let s = "", a = !1, i = !1, o = !1;
+  for (let u = 0; u < r.length; u++) {
+    if (a) {
+      s += r[u], a = !1;
+      continue;
+    }
+    if (t.i) {
+      if (i) {
+        if (r[u].match(/[a-z]/)) {
+          o ? (s += r[u], s += `${r[u - 2]}-${r[u]}`.toUpperCase(), o = !1) : r[u + 1] === "-" && ((c = r[u + 2]) != null && c.match(/[a-z]/)) ? (s += r[u], o = !0) : s += `${r[u]}${r[u].toUpperCase()}`;
+          continue;
+        }
+      } else if (r[u].match(/[a-z]/)) {
+        s += `[${r[u]}${r[u].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (t.m) {
+      if (r[u] === "^") {
+        s += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (r[u] === "$") {
+        s += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (t.s && r[u] === ".") {
+      s += i ? `${r[u]}\r
+` : `[${r[u]}\r
+]`;
+      continue;
+    }
+    s += r[u], r[u] === "\\" ? a = !0 : i && r[u] === "]" ? i = !1 : !i && r[u] === "[" && (i = !0);
+  }
+  try {
+    new RegExp(s);
+  } catch (u) {
+    return console.warn(`Could not convert regex pattern at ${e.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`), n.source;
+  }
+  return s;
+}
+function Gt(n, e) {
+  var r, s, a, i, o, c, u;
+  if (e.target === "openAi" && console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead."), e.target === "openApi3" && ((r = n.keyType) == null ? void 0 : r._def.typeName) === l.ZodEnum)
+    return {
+      type: "object",
+      required: n.keyType._def.values,
+      properties: n.keyType._def.values.reduce((y, T) => {
+        var v;
+        return {
+          ...y,
+          [T]: (v = x(n.valueType._def, {
+            ...e,
+            currentPath: [...e.currentPath, "properties", T]
+          })) != null ? v : M(e)
+        };
+      }, {}),
+      additionalProperties: e.rejectedAdditionalProperties
+    };
+  const t = {
+    type: "object",
+    additionalProperties: (s = x(n.valueType._def, {
+      ...e,
+      currentPath: [...e.currentPath, "additionalProperties"]
+    })) != null ? s : e.allowedAdditionalProperties
+  };
+  if (e.target === "openApi3")
+    return t;
+  if (((a = n.keyType) == null ? void 0 : a._def.typeName) === l.ZodString && ((i = n.keyType._def.checks) != null && i.length)) {
+    const { type: y, ...T } = Ht(n.keyType._def, e);
+    return {
+      ...t,
+      propertyNames: T
+    };
+  } else {
+    if (((o = n.keyType) == null ? void 0 : o._def.typeName) === l.ZodEnum)
+      return {
+        ...t,
+        propertyNames: {
+          enum: n.keyType._def.values
+        }
+      };
+    if (((c = n.keyType) == null ? void 0 : c._def.typeName) === l.ZodBranded && n.keyType._def.type._def.typeName === l.ZodString && ((u = n.keyType._def.type._def.checks) != null && u.length)) {
+      const { type: y, ...T } = qt(n.keyType._def, e);
+      return {
+        ...t,
+        propertyNames: T
+      };
+    }
+  }
+  return t;
+}
+function ur(n, e) {
+  if (e.mapStrategy === "record")
+    return Gt(n, e);
+  const t = x(n.keyType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "items", "items", "0"]
+  }) || M(e), r = x(n.valueType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "items", "items", "1"]
+  }) || M(e);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [t, r],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function dr(n) {
+  const e = n.values, r = Object.keys(n.values).filter((a) => typeof e[e[a]] != "number").map((a) => e[a]), s = Array.from(new Set(r.map((a) => typeof a)));
+  return {
+    type: s.length === 1 ? s[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: r
+  };
+}
+function lr(n) {
+  return n.target === "openAi" ? void 0 : {
+    not: M({
+      ...n,
+      currentPath: [...n.currentPath, "not"]
+    })
+  };
+}
+function fr(n) {
+  return n.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: !0
+  } : {
+    type: "null"
+  };
+}
+const Ne = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function hr(n, e) {
+  if (e.target === "openApi3")
+    return At(n, e);
+  const t = n.options instanceof Map ? Array.from(n.options.values()) : n.options;
+  if (t.every((r) => r._def.typeName in Ne && (!r._def.checks || !r._def.checks.length))) {
+    const r = t.reduce((s, a) => {
+      const i = Ne[a._def.typeName];
+      return i && !s.includes(i) ? [...s, i] : s;
+    }, []);
+    return {
+      type: r.length > 1 ? r : r[0]
+    };
+  } else if (t.every((r) => r._def.typeName === "ZodLiteral" && !r.description)) {
+    const r = t.reduce((s, a) => {
+      const i = typeof a._def.value;
+      switch (i) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...s, i];
+        case "bigint":
+          return [...s, "integer"];
+        case "object":
+          if (a._def.value === null)
+            return [...s, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return s;
+      }
+    }, []);
+    if (r.length === t.length) {
+      const s = r.filter((a, i, o) => o.indexOf(a) === i);
+      return {
+        type: s.length > 1 ? s : s[0],
+        enum: t.reduce((a, i) => a.includes(i._def.value) ? a : [...a, i._def.value], [])
+      };
+    }
+  } else if (t.every((r) => r._def.typeName === "ZodEnum"))
+    return {
+      type: "string",
+      enum: t.reduce((r, s) => [
+        ...r,
+        ...s._def.values.filter((a) => !r.includes(a))
+      ], [])
+    };
+  return At(n, e);
+}
+const At = (n, e) => {
+  const t = (n.options instanceof Map ? Array.from(n.options.values()) : n.options).map((r, s) => x(r._def, {
+    ...e,
+    currentPath: [...e.currentPath, "anyOf", `${s}`]
+  })).filter((r) => !!r && (!e.strictUnions || typeof r == "object" && Object.keys(r).length > 0));
+  return t.length ? { anyOf: t } : void 0;
+};
+function pr(n, e) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(n.innerType._def.typeName) && (!n.innerType._def.checks || !n.innerType._def.checks.length))
+    return e.target === "openApi3" ? {
+      type: Ne[n.innerType._def.typeName],
+      nullable: !0
+    } : {
+      type: [
+        Ne[n.innerType._def.typeName],
+        "null"
+      ]
+    };
+  if (e.target === "openApi3") {
+    const r = x(n.innerType._def, {
+      ...e,
+      currentPath: [...e.currentPath]
+    });
+    return r && "$ref" in r ? { allOf: [r], nullable: !0 } : r && { ...r, nullable: !0 };
+  }
+  const t = x(n.innerType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "anyOf", "0"]
+  });
+  return t && { anyOf: [t, { type: "null" }] };
+}
+function mr(n, e) {
+  const t = {
+    type: "number"
+  };
+  if (!n.checks)
+    return t;
+  for (const r of n.checks)
+    switch (r.kind) {
+      case "int":
+        t.type = "integer", Bt(t, "type", r.message, e);
+        break;
+      case "min":
+        e.target === "jsonSchema7" ? r.inclusive ? A(t, "minimum", r.value, r.message, e) : A(t, "exclusiveMinimum", r.value, r.message, e) : (r.inclusive || (t.exclusiveMinimum = !0), A(t, "minimum", r.value, r.message, e));
+        break;
+      case "max":
+        e.target === "jsonSchema7" ? r.inclusive ? A(t, "maximum", r.value, r.message, e) : A(t, "exclusiveMaximum", r.value, r.message, e) : (r.inclusive || (t.exclusiveMaximum = !0), A(t, "maximum", r.value, r.message, e));
+        break;
+      case "multipleOf":
+        A(t, "multipleOf", r.value, r.message, e);
+        break;
+    }
+  return t;
+}
+function yr(n, e) {
+  const t = e.target === "openAi", r = {
+    type: "object",
+    properties: {}
+  }, s = [], a = n.shape();
+  for (const o in a) {
+    let c = a[o];
+    if (c === void 0 || c._def === void 0)
+      continue;
+    let u = vr(c);
+    u && t && (c._def.typeName === "ZodOptional" && (c = c._def.innerType), c.isNullable() || (c = c.nullable()), u = !1);
+    const y = x(c._def, {
+      ...e,
+      currentPath: [...e.currentPath, "properties", o],
+      propertyPath: [...e.currentPath, "properties", o]
+    });
+    y !== void 0 && (r.properties[o] = y, u || s.push(o));
+  }
+  s.length && (r.required = s);
+  const i = gr(n, e);
+  return i !== void 0 && (r.additionalProperties = i), r;
+}
+function gr(n, e) {
+  if (n.catchall._def.typeName !== "ZodNever")
+    return x(n.catchall._def, {
+      ...e,
+      currentPath: [...e.currentPath, "additionalProperties"]
+    });
+  switch (n.unknownKeys) {
+    case "passthrough":
+      return e.allowedAdditionalProperties;
+    case "strict":
+      return e.rejectedAdditionalProperties;
+    case "strip":
+      return e.removeAdditionalStrategy === "strict" ? e.allowedAdditionalProperties : e.rejectedAdditionalProperties;
+  }
+}
+function vr(n) {
+  try {
+    return n.isOptional();
+  } catch (e) {
+    return !0;
+  }
+}
+const _r = (n, e) => {
+  var r;
+  if (e.currentPath.toString() === ((r = e.propertyPath) == null ? void 0 : r.toString()))
+    return x(n.innerType._def, e);
+  const t = x(n.innerType._def, {
+    ...e,
+    currentPath: [...e.currentPath, "anyOf", "1"]
+  });
+  return t ? {
+    anyOf: [
+      {
+        not: M(e)
+      },
+      t
+    ]
+  } : M(e);
+}, br = (n, e) => {
+  if (e.pipeStrategy === "input")
+    return x(n.in._def, e);
+  if (e.pipeStrategy === "output")
+    return x(n.out._def, e);
+  const t = x(n.in._def, {
+    ...e,
+    currentPath: [...e.currentPath, "allOf", "0"]
+  }), r = x(n.out._def, {
+    ...e,
+    currentPath: [...e.currentPath, "allOf", t ? "1" : "0"]
+  });
+  return {
+    allOf: [t, r].filter((s) => s !== void 0)
+  };
+};
+function kr(n, e) {
+  return x(n.type._def, e);
+}
+function xr(n, e) {
+  const r = {
+    type: "array",
+    uniqueItems: !0,
+    items: x(n.valueType._def, {
+      ...e,
+      currentPath: [...e.currentPath, "items"]
+    })
+  };
+  return n.minSize && A(r, "minItems", n.minSize.value, n.minSize.message, e), n.maxSize && A(r, "maxItems", n.maxSize.value, n.maxSize.message, e), r;
+}
+function wr(n, e) {
+  return n.rest ? {
+    type: "array",
+    minItems: n.items.length,
+    items: n.items.map((t, r) => x(t._def, {
+      ...e,
+      currentPath: [...e.currentPath, "items", `${r}`]
+    })).reduce((t, r) => r === void 0 ? t : [...t, r], []),
+    additionalItems: x(n.rest._def, {
+      ...e,
+      currentPath: [...e.currentPath, "additionalItems"]
+    })
+  } : {
+    type: "array",
+    minItems: n.items.length,
+    maxItems: n.items.length,
+    items: n.items.map((t, r) => x(t._def, {
+      ...e,
+      currentPath: [...e.currentPath, "items", `${r}`]
+    })).reduce((t, r) => r === void 0 ? t : [...t, r], [])
+  };
+}
+function Sr(n) {
+  return {
+    not: M(n)
+  };
+}
+function Ar(n) {
+  return M(n);
+}
+const Tr = (n, e) => x(n.innerType._def, e), Cr = (n, e, t) => {
+  switch (e) {
+    case l.ZodString:
+      return Ht(n, t);
+    case l.ZodNumber:
+      return mr(n, t);
+    case l.ZodObject:
+      return yr(n, t);
+    case l.ZodBigInt:
+      return Kn(n, t);
+    case l.ZodBoolean:
+      return Xn();
+    case l.ZodDate:
+      return Jt(n, t);
+    case l.ZodUndefined:
+      return Sr(t);
+    case l.ZodNull:
+      return fr(t);
+    case l.ZodArray:
+      return Yn(n, t);
+    case l.ZodUnion:
+    case l.ZodDiscriminatedUnion:
+      return hr(n, t);
+    case l.ZodIntersection:
+      return ar(n, t);
+    case l.ZodTuple:
+      return wr(n, t);
+    case l.ZodRecord:
+      return Gt(n, t);
+    case l.ZodLiteral:
+      return ir(n, t);
+    case l.ZodEnum:
+      return rr(n);
+    case l.ZodNativeEnum:
+      return dr(n);
+    case l.ZodNullable:
+      return pr(n, t);
+    case l.ZodOptional:
+      return _r(n, t);
+    case l.ZodMap:
+      return ur(n, t);
+    case l.ZodSet:
+      return xr(n, t);
+    case l.ZodLazy:
+      return () => n.getter()._def;
+    case l.ZodPromise:
+      return kr(n, t);
+    case l.ZodNaN:
+    case l.ZodNever:
+      return lr(t);
+    case l.ZodEffects:
+      return nr(n, t);
+    case l.ZodAny:
+      return M(t);
+    case l.ZodUnknown:
+      return Ar(t);
+    case l.ZodDefault:
+      return tr(n, t);
+    case l.ZodBranded:
+      return qt(n, t);
+    case l.ZodReadonly:
+      return Tr(n, t);
+    case l.ZodCatch:
+      return Qn(n, t);
+    case l.ZodPipeline:
+      return br(n, t);
+    case l.ZodFunction:
+    case l.ZodVoid:
+    case l.ZodSymbol:
+      return;
+    default:
+      return /* @__PURE__ */ ((r) => {
+      })();
+  }
+};
+function x(n, e, t = !1) {
+  var o;
+  const r = e.seen.get(n);
+  if (e.override) {
+    const c = (o = e.override) == null ? void 0 : o.call(e, n, e, r, t);
+    if (c !== Jn)
+      return c;
+  }
+  if (r && !t) {
+    const c = Or(r, e);
+    if (c !== void 0)
+      return c;
+  }
+  const s = { def: n, path: e.currentPath, jsonSchema: void 0 };
+  e.seen.set(n, s);
+  const a = Cr(n, n.typeName, e), i = typeof a == "function" ? x(a(), e) : a;
+  if (i && Nr(n, e, i), e.postProcess) {
+    const c = e.postProcess(i, n, e);
+    return s.jsonSchema = i, c;
+  }
+  return s.jsonSchema = i, i;
+}
+const Or = (n, e) => {
+  switch (e.$refStrategy) {
+    case "root":
+      return { $ref: n.path.join("/") };
+    case "relative":
+      return { $ref: Wt(e.currentPath, n.path) };
+    case "none":
+    case "seen":
+      return n.path.length < e.currentPath.length && n.path.every((t, r) => e.currentPath[r] === t) ? (console.warn(`Recursive reference detected at ${e.currentPath.join("/")}! Defaulting to any`), M(e)) : e.$refStrategy === "seen" ? M(e) : void 0;
+  }
+}, Nr = (n, e, t) => (n.description && (t.description = n.description, e.markdownDescription && (t.markdownDescription = n.description)), t), ze = (n, e) => {
+  var c;
+  const t = Gn(e);
+  let r = typeof e == "object" && e.definitions ? Object.entries(e.definitions).reduce((u, [y, T]) => {
+    var v;
+    return {
+      ...u,
+      [y]: (v = x(T._def, {
+        ...t,
+        currentPath: [...t.basePath, t.definitionPath, y]
+      }, !0)) != null ? v : M(t)
+    };
+  }, {}) : void 0;
+  const s = typeof e == "string" ? e : (e == null ? void 0 : e.nameStrategy) === "title" || e == null ? void 0 : e.name, a = (c = x(n._def, s === void 0 ? t : {
+    ...t,
+    currentPath: [...t.basePath, t.definitionPath, s]
+  }, !1)) != null ? c : M(t), i = typeof e == "object" && e.name !== void 0 && e.nameStrategy === "title" ? e.name : void 0;
+  i !== void 0 && (a.title = i), t.flags.hasReferencedOpenAiAnyType && (r || (r = {}), r[t.openAiAnyTypeName] || (r[t.openAiAnyTypeName] = {
+    // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+    type: ["string", "number", "integer", "boolean", "array", "null"],
+    items: {
+      $ref: t.$refStrategy === "relative" ? "1" : [
+        ...t.basePath,
+        t.definitionPath,
+        t.openAiAnyTypeName
+      ].join("/")
+    }
+  }));
+  const o = s === void 0 ? r ? {
+    ...a,
+    [t.definitionPath]: r
+  } : a : {
+    $ref: [
+      ...t.$refStrategy === "relative" ? [] : t.basePath,
+      t.definitionPath,
+      s
+    ].join("/"),
+    [t.definitionPath]: {
+      ...r,
+      [s]: a
+    }
+  };
+  return t.target === "jsonSchema7" ? o.$schema = "http://json-schema.org/draft-07/schema#" : (t.target === "jsonSchema2019-09" || t.target === "openAi") && (o.$schema = "https://json-schema.org/draft/2019-09/schema#"), t.target === "openAi" && ("anyOf" in o || "oneOf" in o || "allOf" in o || "type" in o && Array.isArray(o.type)) && console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property."), o;
+};
+class Zr {
+  /**
+   * Creates a new message processor.
+   *
+   * @param catalogs A list of available catalogs.
+   * @param actionHandler A global handler for actions from all surfaces.
+   */
+  constructor(e, t) {
+    this.catalogs = e, this.actionHandler = t, this.model = new qn(), this.actionHandler && this.model.onAction.subscribe(this.actionHandler);
+  }
+  /**
+   * Generates the a2uiClientCapabilities object for the current processor.
+   *
+   * @param options Configuration for capability generation.
+   * @returns The capabilities object.
+   */
+  getClientCapabilities(e) {
+    const t = {
+      "v0.9": {
+        supportedCatalogIds: this.catalogs.map((r) => r.id)
+      }
+    };
+    return e != null && e.includeInlineCatalogs && (t["v0.9"].inlineCatalogs = this.catalogs.map((r) => this.generateInlineCatalog(r))), t;
+  }
+  generateInlineCatalog(e) {
+    const t = {};
+    for (const [a, i] of e.components.entries()) {
+      const o = ze(i.schema, {
+        target: "jsonSchema2019-09"
+      });
+      this.processRefs(o), t[a] = {
+        allOf: [
+          { $ref: "common_types.json#/$defs/ComponentCommon" },
+          {
+            properties: {
+              component: { const: a },
+              ...o.properties
+            },
+            required: ["component", ...o.required || []]
+          }
+        ]
+      };
+    }
+    const r = [];
+    for (const a of e.functions.values()) {
+      const i = ze(a.schema, {
+        target: "jsonSchema2019-09"
+      });
+      this.processRefs(i), r.push({
+        name: a.name,
+        description: a.schema.description,
+        returnType: a.returnType,
+        parameters: i
+      });
+    }
+    let s;
+    if (e.themeSchema) {
+      const a = ze(e.themeSchema, {
+        target: "jsonSchema2019-09"
+      });
+      this.processRefs(a), s = a.properties;
+    }
+    return {
+      catalogId: e.id,
+      components: t,
+      functions: r.length > 0 ? r : void 0,
+      theme: s
+    };
+  }
+  processRefs(e) {
+    if (!(typeof e != "object" || e === null)) {
+      if (typeof e.description == "string" && e.description.startsWith("REF:")) {
+        const t = e.description.substring(4).split("|"), r = t[0], s = t[1] || "";
+        for (const a of Object.keys(e))
+          delete e[a];
+        e.$ref = r, s && (e.description = s);
+        return;
+      }
+      if (Array.isArray(e))
+        for (const t of e)
+          this.processRefs(t);
+      else
+        for (const t of Object.keys(e))
+          this.processRefs(e[t]);
+    }
+  }
+  /**
+   * Returns the aggregated data model for all surfaces that have 'sendDataModel' enabled.
+   */
+  getClientDataModel() {
+    const e = {};
+    for (const t of this.model.surfacesMap.values())
+      t.sendDataModel && (e[t.id] = t.dataModel.get("/"));
+    if (Object.keys(e).length !== 0)
+      return {
+        version: "v0.9",
+        surfaces: e
+      };
+  }
+  /**
+   * Subscribes to surface creation events.
+   */
+  onSurfaceCreated(e) {
+    return this.model.onSurfaceCreated.subscribe(e);
+  }
+  /**
+   * Subscribes to surface deletion events.
+   */
+  onSurfaceDeleted(e) {
+    return this.model.onSurfaceDeleted.subscribe(e);
+  }
+  /**
+   * Processes a list of messages.
+   *
+   * @param messages The messages to process.
+   */
+  processMessages(e) {
+    for (const t of e)
+      this.processMessage(t);
+  }
+  processMessage(e) {
+    const t = [
+      "createSurface",
+      "updateComponents",
+      "updateDataModel",
+      "deleteSurface"
+    ].filter((r) => r in e);
+    if (t.length > 1)
+      throw new Re(`Message contains multiple update types: ${t.join(", ")}.`);
+    if ("createSurface" in e) {
+      this.processCreateSurfaceMessage(e);
+      return;
+    }
+    if ("deleteSurface" in e) {
+      this.processDeleteSurfaceMessage(e);
+      return;
+    }
+    if ("updateComponents" in e) {
+      this.processUpdateComponentsMessage(e);
+      return;
+    }
+    if ("updateDataModel" in e) {
+      this.processUpdateDataModelMessage(e);
+      return;
+    }
+  }
+  processCreateSurfaceMessage(e) {
+    const t = e.createSurface, { surfaceId: r, catalogId: s, theme: a, sendDataModel: i } = t, o = this.catalogs.find((u) => u.id === s);
+    if (!o)
+      throw new he(`Catalog not found: ${s}`);
+    if (this.model.getSurface(r))
+      throw new he(`Surface ${r} already exists.`);
+    const c = new Wn(r, o, a, i != null ? i : !1);
+    this.model.addSurface(c);
+  }
+  processDeleteSurfaceMessage(e) {
+    const t = e.deleteSurface;
+    t.surfaceId && this.model.deleteSurface(t.surfaceId);
+  }
+  processUpdateComponentsMessage(e) {
+    const t = e.updateComponents;
+    if (!t.surfaceId)
+      return;
+    const r = this.model.getSurface(t.surfaceId);
+    if (!r)
+      throw new he(`Surface not found for message: ${t.surfaceId}`);
+    for (const s of t.components) {
+      const { id: a, component: i, ...o } = s;
+      if (!a)
+        throw new Re(`Component '${i}' is missing an 'id'.`);
+      const c = r.componentsModel.get(a);
+      if (c)
+        if (i && i !== c.type) {
+          r.componentsModel.removeComponent(a);
+          const u = new xt(a, i, o);
+          r.componentsModel.addComponent(u);
+        } else
+          c.properties = o;
+      else {
+        if (!i)
+          throw new Re(`Cannot create component ${a} without a type.`);
+        const u = new xt(a, i, o);
+        r.componentsModel.addComponent(u);
+      }
+    }
+  }
+  processUpdateDataModelMessage(e) {
+    const t = e.updateDataModel;
+    if (!t.surfaceId)
+      return;
+    const r = this.model.getSurface(t.surfaceId);
+    if (!r)
+      throw new he(`Surface not found for message: ${t.surfaceId}`);
+    const s = t.path || "/", a = t.value;
+    r.dataModel.set(s, a);
+  }
+  /**
+   * Resolves a relative path against a context path.
+   *
+   * @param path The path to resolve.
+   * @param contextPath The base path (optional).
+   */
+  resolvePath(e, t) {
+    return e.startsWith("/") ? e : t ? `${t.endsWith("/") ? t : `${t}/`}${e}` : `/${e}`;
+  }
+}
+function Pr(n) {
+  const e = new Zr(n.catalogs, n.onAction), t = vue.shallowRef(/* @__PURE__ */ new Map());
+  let r = 0;
+  function s(o) {
+    if (o.length <= r)
+      return;
+    const c = o.slice(r);
+    try {
+      e.processMessages(c);
+    } catch (u) {
+      return;
+    }
+    r = o.length, t.value = new Map(e.model.surfacesMap);
+  }
+  function a() {
+    e.model.dispose(), r = 0, t.value = /* @__PURE__ */ new Map();
+  }
+  function i() {
+    e.model.dispose();
+  }
+  return vue.onUnmounted(i), { processor: e, surfaces: t, processMessages: s, reset: a, dispose: i };
+}
+function jr(n) {
+  switch (n) {
+    case "string":
+      return D();
+    case "number":
+      return _t();
+    case "integer":
+      return _t().int();
+    case "boolean":
+      return In();
+    case "null":
+      return Mn();
+    case "array":
+      return Et(ne());
+    case "object":
+      return ct(ne());
+    default:
+      return ne();
+  }
+}
+function Ve(n, e) {
+  let t = n;
+  if (e.enum && e.enum.length > 0) {
+    const r = e.enum.map((s) => Pe(s));
+    return r.length === 1 ? r[0] : Ze([r[0], r[1], ...r.slice(2)]);
+  }
+  return e.type === "string" && (typeof e.minLength == "number" && (t = t.min(e.minLength)), typeof e.maxLength == "number" && (t = t.max(e.maxLength))), (e.type === "number" || e.type === "integer") && (typeof e.minimum == "number" && (t = t.min(e.minimum)), typeof e.maximum == "number" && (t = t.max(e.maximum))), Object.prototype.hasOwnProperty.call(e, "default") && (t = t.default(e.default)), t;
+}
+function pe(n) {
+  var r, s;
+  if (!n)
+    return ne();
+  const e = n.type;
+  if (Array.isArray(e) && e.length > 0) {
+    const i = Array.from(new Set(e)).map((o) => pe({ ...n, type: o }));
+    return i.length === 1 ? i[0] : Ze(i);
+  }
+  if (e === "array") {
+    const a = pe(n.items);
+    return Ve(Et(a), n);
+  }
+  if (e === "object" || n.properties) {
+    const a = new Set((r = n.required) != null ? r : []), i = Object.entries((s = n.properties) != null ? s : {}).reduce((c, [u, y]) => {
+      const T = pe(y);
+      return c[u] = a.has(u) ? T : T.optional(), c;
+    }, {});
+    let o = B(i);
+    return n.additionalProperties === !0 ? o = o.catchall(ne()) : n.additionalProperties && typeof n.additionalProperties == "object" && (o = o.catchall(pe(n.additionalProperties))), Ve(o, n);
+  }
+  return Ve(jr(typeof e == "string" ? e : "object"), n);
+}
+function Ir(n, e) {
+  var r;
+  const t = pe({
+    type: (r = e.type) != null ? r : "object",
+    properties: e.properties,
+    required: e.required,
+    additionalProperties: e.additionalProperties
+  });
+  return {
+    name: n,
+    schema: t
+  };
+}
+function Mr(n) {
+  const e = Object.entries(n.components).map(([t, r]) => Ir(t, r));
+  return new En(n.catalogId, e);
+}
+const Er = /* @__PURE__ */ vue.defineComponent({
+  __name: "ComponentNode",
+  props: {
+    componentModel: {},
+    surface: {},
+    components: {},
+    componentEvents: {},
+    componentPropAllowlist: {}
+  },
+  setup(n) {
+    const e = n, t = vue.computed(() => {
+      const v = e.components[e.componentModel.type];
+      return v != null ? v : e.componentModel.type;
+    }), r = vue.shallowRef({});
+    let s = [];
+    function a() {
+      s.forEach((v) => v.unsubscribe()), s = [];
+    }
+    function i(v, w) {
+      if (w && typeof w == "object" && !Array.isArray(w) && "path" in w) {
+        const I = w.path, m = w.default;
+        if (typeof I == "string") {
+          const O = I.startsWith("/") ? I : `/${I}`, N = e.surface.dataModel.subscribe(O, (U) => {
+            r.value = {
+              ...r.value,
+              [v]: U === void 0 ? m : U
+            };
+          });
+          return s.push(N), N.value === void 0 ? m : N.value;
+        }
+      }
+      return w;
+    }
+    function o() {
+      a();
+      const v = { ...e.componentModel.properties };
+      delete v.children;
+      const w = e.componentPropAllowlist[e.componentModel.type], I = w && w.length > 0 ? new Set(w) : void 0, m = I ? Object.fromEntries(Object.entries(v).filter(([N]) => I.has(N))) : v, O = Object.fromEntries(Object.entries(m).map(([N, U]) => [N, i(N, U)]));
+      r.value = O;
+    }
+    let c;
+    vue.onMounted(() => {
+      o(), c = e.componentModel.onUpdated.subscribe(() => {
+        o();
+      }).unsubscribe;
+    }), vue.onUnmounted(() => {
+      c == null || c(), a();
+    });
+    const u = vue.computed(() => {
+      var w;
+      const v = (w = e.componentModel.properties) == null ? void 0 : w.children;
+      return v ? Array.isArray(v) ? v : typeof v == "string" ? [v] : [] : [];
+    });
+    function y(v) {
+      return e.surface.componentsModel.get(v);
+    }
+    const T = vue.computed(() => {
+      var I;
+      const v = {}, w = (I = e.componentEvents[e.componentModel.type]) != null ? I : [];
+      for (const m of w)
+        v[m] = (...O) => {
+          e.surface.dispatchAction(
+            {
+              event: {
+                name: m,
+                context: {
+                  ...r.value,
+                  value: O[0],
+                  args: O
+                }
+              }
+            },
+            e.componentModel.id
+          );
+        };
+      return v;
+    });
+    return (v, w) => {
+      const I = vue.resolveComponent("ComponentNode", !0);
+      return t.value ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(t.value), vue.mergeProps({ key: 0 }, r.value, vue.toHandlers(T.value)), {
+        default: vue.withCtx(() => [
+          (vue.openBlock(!0), vue.createElementBlock(vue.Fragment, null, vue.renderList(u.value, (m) => (vue.openBlock(), vue.createBlock(I, {
+            key: m,
+            "component-model": y(m),
+            surface: v.surface,
+            components: v.components,
+            "component-events": v.componentEvents,
+            "component-prop-allowlist": v.componentPropAllowlist
+          }, null, 8, ["component-model", "surface", "components", "component-events", "component-prop-allowlist"]))), 128))
+        ]),
+        _: 1
+      }, 16)) : vue.createCommentVNode("", !0);
+    };
+  }
+}), Rr = /* @__PURE__ */ vue.defineComponent({
+  __name: "A2UISurface",
+  props: {
+    messages: {},
+    surfaceId: {},
+    components: { default: () => ({}) },
+    catalog: { default: () => ({
+      catalogId: "touchvue-a2ui-default",
+      components: {}
+    }) }
+  },
+  emits: ["action"],
+  setup(n, { emit: e }) {
+    const t = n;
+    function r(m, O) {
+      var ee, _e, X, Me, be, dt, lt, ft, ht, pt;
+      const N = (Me = (X = (ee = m == null ? void 0 : m.name) != null ? ee : m == null ? void 0 : m.action) != null ? X : (_e = m == null ? void 0 : m.event) == null ? void 0 : _e.name) != null ? Me : "unknown", U = (lt = (dt = (be = m == null ? void 0 : m.sourceComponentId) != null ? be : m == null ? void 0 : m.componentId) != null ? dt : m == null ? void 0 : m.targetComponentId) != null ? lt : "", ve = (pt = (ht = m == null ? void 0 : m.context) != null ? ht : (ft = m == null ? void 0 : m.event) == null ? void 0 : ft.context) != null ? pt : {};
+      return {
+        name: N,
+        surfaceId: O,
+        sourceComponentId: U,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        context: ve
+      };
+    }
+    const s = e, a = vue.computed(() => Mr(t.catalog)), i = vue.computed(() => {
+      const m = {};
+      for (const [O, N] of Object.entries(t.catalog.components))
+        m[O] = c(N.events);
+      return console.log(m), m;
+    }), o = vue.computed(() => {
+      var O;
+      const m = {};
+      for (const [N, U] of Object.entries(t.catalog.components))
+        m[N] = Object.keys((O = U.properties) != null ? O : {});
+      return m;
+    });
+    function c(m) {
+      return m ? Array.isArray(m) ? m : Object.keys(m) : [];
+    }
+    const { surfaces: u, processMessages: y } = Pr({
+      catalogs: [a.value],
+      onAction: (m) => {
+        s("action", r(m, t.surfaceId));
+      }
+    }), T = vue.ref(0);
+    vue.watch(
+      () => t.messages.length,
+      () => {
+        y(t.messages), T.value++;
+      },
+      { immediate: !0 }
+    );
+    const v = vue.computed(() => u.value.get(t.surfaceId)), w = vue.computed(() => {
+      var ve;
+      T.value;
+      const m = v.value;
+      if (!m)
+        return [];
+      const O = /* @__PURE__ */ new Set(), N = /* @__PURE__ */ new Set();
+      for (const [ee, _e] of m.componentsModel.entries) {
+        O.add(ee);
+        const X = (ve = _e.properties) == null ? void 0 : ve.children;
+        X && (Array.isArray(X) ? X : [X]).forEach((be) => N.add(be));
+      }
+      return Array.from(O).filter((ee) => !N.has(ee));
+    });
+    function I(m) {
+      var O;
+      return (O = v.value) == null ? void 0 : O.componentsModel.get(m);
+    }
+    return (m, O) => (vue.openBlock(!0), vue.createElementBlock(vue.Fragment, null, vue.renderList(w.value, (N) => (vue.openBlock(), vue.createBlock(Er, {
+      key: N,
+      "component-model": I(N),
+      surface: v.value,
+      components: t.components,
+      "component-events": i.value,
+      "component-prop-allowlist": o.value
+    }, null, 8, ["component-model", "surface", "components", "component-events", "component-prop-allowlist"]))), 128));
+  }
+});
+
+exports.TouchA2ui = Rr;
+exports.useA2UI = Pr;
+//# sourceMappingURL=index.js.map