@reforma/components 0.1.5 → 0.2.0

package/dist/node_modules/zod/v4/core/checks.js

@@ -0,0 +1,262 @@
+import { $constructor as r } from "./core.js";
+import { uppercase as k, lowercase as b } from "./regexes.js";
+import { codePointLength as m, getLengthableOrigin as l, nullish as $, escapeRegex as g, floatSafeRemainder as C, NUMBER_FORMAT_RANGES as x } from "./util.js";
+const s = /* @__PURE__ */ r("$ZodCheck", (e, t) => {
+  var n;
+  e._zod ?? (e._zod = {}), e._zod.def = t, (n = e._zod).onattach ?? (n.onattach = []);
+}), v = (e) => {
+  const t = e.value;
+  return !$(t) && t.length !== void 0;
+}, a = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+}, E = /* @__PURE__ */ r("$ZodCheckLessThan", (e, t) => {
+  s.init(e, t);
+  const n = a[typeof t.value];
+  e._zod.check = (i) => {
+    (t.inclusive ? i.value <= t.value : i.value < t.value) || i.issues.push({
+      origin: a[typeof i.value] ?? n,
+      code: "too_big",
+      maximum: typeof t.value == "object" ? t.value.getTime() : t.value,
+      input: i.value,
+      inclusive: t.inclusive,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), I = /* @__PURE__ */ r("$ZodCheckGreaterThan", (e, t) => {
+  s.init(e, t);
+  const n = a[typeof t.value];
+  e._zod.check = (i) => {
+    (t.inclusive ? i.value >= t.value : i.value > t.value) || i.issues.push({
+      origin: a[typeof i.value] ?? n,
+      code: "too_small",
+      minimum: typeof t.value == "object" ? t.value.getTime() : t.value,
+      input: i.value,
+      inclusive: t.inclusive,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), L = /* @__PURE__ */ r("$ZodCheckMultipleOf", (e, t) => {
+  s.init(e, t), e._zod.check = (n) => {
+    if (typeof n.value != typeof t.value)
+      throw new Error("Cannot mix number and bigint in multiple_of check.");
+    (typeof n.value == "bigint" ? (
+      // `value % 0n` throws, and nothing is a multiple of zero — the number branch already fails this way via NaN
+      t.value !== BigInt(0) && n.value % t.value === BigInt(0)
+    ) : C(n.value, t.value) === 0) || n.issues.push({
+      origin: typeof n.value,
+      code: "not_multiple_of",
+      divisor: t.value,
+      input: n.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), M = /* @__PURE__ */ r("$ZodCheckNumberFormat", (e, t) => {
+  s.init(e, t), t.format = t.format || "float64";
+  const n = t.format?.includes("int"), i = n ? "int" : "number", [o, c] = x[t.format];
+  e._zod.check = (h) => {
+    const u = h.value;
+    if (n) {
+      if (!Number.isInteger(u)) {
+        h.issues.push({
+          expected: i,
+          format: t.format,
+          code: "invalid_type",
+          continue: !1,
+          input: u,
+          inst: e
+        });
+        return;
+      }
+      if (!Number.isSafeInteger(u)) {
+        u > 0 ? h.issues.push({
+          input: u,
+          code: "too_big",
+          maximum: Number.MAX_SAFE_INTEGER,
+          note: "Integers must be within the safe integer range.",
+          inst: e,
+          origin: i,
+          inclusive: !0,
+          continue: !t.abort
+        }) : h.issues.push({
+          input: u,
+          code: "too_small",
+          minimum: Number.MIN_SAFE_INTEGER,
+          note: "Integers must be within the safe integer range.",
+          inst: e,
+          origin: i,
+          inclusive: !0,
+          continue: !t.abort
+        });
+        return;
+      }
+    }
+    u < o && h.issues.push({
+      origin: "number",
+      input: u,
+      code: "too_small",
+      minimum: o,
+      inclusive: !0,
+      inst: e,
+      continue: !t.abort
+    }), u > c && h.issues.push({
+      origin: "number",
+      input: u,
+      code: "too_big",
+      maximum: c,
+      inclusive: !0,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), R = /* @__PURE__ */ r("$ZodCheckMaxLength", (e, t) => {
+  var n;
+  s.init(e, t), (n = e._zod.def).when ?? (n.when = v), e._zod.check = (i) => {
+    const o = i.value, c = o.length;
+    if ((typeof o == "string" && c > t.maximum ? m(o) : c) <= t.maximum)
+      return;
+    const u = l(o);
+    i.issues.push({
+      origin: u,
+      code: "too_big",
+      maximum: t.maximum,
+      inclusive: !0,
+      input: o,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), N = /* @__PURE__ */ r("$ZodCheckMinLength", (e, t) => {
+  var n;
+  s.init(e, t), (n = e._zod.def).when ?? (n.when = v), e._zod.check = (i) => {
+    const o = i.value, c = o.length;
+    if ((typeof o == "string" && c >= t.minimum && c < t.minimum * 2 ? m(o) : c) >= t.minimum)
+      return;
+    const u = l(o);
+    i.issues.push({
+      origin: u,
+      code: "too_small",
+      minimum: t.minimum,
+      inclusive: !0,
+      input: o,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), S = /* @__PURE__ */ r("$ZodCheckLengthEquals", (e, t) => {
+  var n;
+  s.init(e, t), (n = e._zod.def).when ?? (n.when = v), e._zod.check = (i) => {
+    const o = i.value, c = o.length, h = typeof o == "string" && c >= t.length && c <= t.length * 2 ? m(o) : c;
+    if (h === t.length)
+      return;
+    const u = l(o), _ = h > t.length;
+    i.issues.push({
+      origin: u,
+      ..._ ? { code: "too_big", maximum: t.length } : { code: "too_small", minimum: t.length },
+      inclusive: !0,
+      exact: !0,
+      input: i.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), p = /* @__PURE__ */ r("$ZodCheckStringFormat", (e, t) => {
+  var n, i;
+  s.init(e, t), t.pattern ? (n = e._zod).check ?? (n.check = (o) => {
+    t.pattern.lastIndex = 0, !t.pattern.test(o.value) && o.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: t.format,
+      input: o.value,
+      ...t.pattern ? { pattern: t.pattern.toString() } : {},
+      inst: e,
+      continue: !t.abort
+    });
+  }) : (i = e._zod).check ?? (i.check = () => {
+  });
+}), T = /* @__PURE__ */ r("$ZodCheckRegex", (e, t) => {
+  p.init(e, t), e._zod.check = (n) => {
+    t.pattern.lastIndex = 0, !t.pattern.test(n.value) && n.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "regex",
+      input: n.value,
+      pattern: t.pattern.toString(),
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), F = /* @__PURE__ */ r("$ZodCheckLowerCase", (e, t) => {
+  t.pattern ?? (t.pattern = b), p.init(e, t);
+}), O = /* @__PURE__ */ r("$ZodCheckUpperCase", (e, t) => {
+  t.pattern ?? (t.pattern = k), p.init(e, t);
+}), W = /* @__PURE__ */ r("$ZodCheckIncludes", (e, t) => {
+  s.init(e, t);
+  const n = g(t.includes), i = new RegExp(typeof t.position == "number" ? `^.{${t.position},}${n}` : n);
+  t.pattern = i, e._zod.check = (o) => {
+    o.value.includes(t.includes, t.position) || o.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "includes",
+      includes: t.includes,
+      input: o.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), A = /* @__PURE__ */ r("$ZodCheckStartsWith", (e, t) => {
+  s.init(e, t);
+  const n = new RegExp(`^${g(t.prefix)}.*`);
+  t.pattern ?? (t.pattern = n), e._zod.check = (i) => {
+    i.value.startsWith(t.prefix) || i.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "starts_with",
+      prefix: t.prefix,
+      input: i.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), G = /* @__PURE__ */ r("$ZodCheckEndsWith", (e, t) => {
+  s.init(e, t);
+  const n = new RegExp(`.*${g(t.suffix)}$`);
+  t.pattern ?? (t.pattern = n), e._zod.check = (i) => {
+    i.value.endsWith(t.suffix) || i.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "ends_with",
+      suffix: t.suffix,
+      input: i.value,
+      inst: e,
+      continue: !t.abort
+    });
+  };
+}), B = /* @__PURE__ */ r("$ZodCheckOverwrite", (e, t) => {
+  s.init(e, t), e._zod.check = (n) => {
+    n.value = t.tx(n.value);
+  };
+});
+export {
+  s as $ZodCheck,
+  G as $ZodCheckEndsWith,
+  I as $ZodCheckGreaterThan,
+  W as $ZodCheckIncludes,
+  S as $ZodCheckLengthEquals,
+  E as $ZodCheckLessThan,
+  F as $ZodCheckLowerCase,
+  R as $ZodCheckMaxLength,
+  N as $ZodCheckMinLength,
+  L as $ZodCheckMultipleOf,
+  M as $ZodCheckNumberFormat,
+  B as $ZodCheckOverwrite,
+  T as $ZodCheckRegex,
+  A as $ZodCheckStartsWith,
+  p as $ZodCheckStringFormat,
+  O as $ZodCheckUpperCase
+};
+//# sourceMappingURL=checks.js.map

package/dist/node_modules/zod/v4/core/checks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.js","sources":["../../../../../../../node_modules/zod/v4/core/checks.js"],"sourcesContent":["// import { $ZodType } from \"./schemas.js\";\nimport * as core from \"./core.js\";\nimport * as regexes from \"./regexes.js\";\nimport * as util from \"./util.js\";\nexport const $ZodCheck = /*@__PURE__*/ core.$constructor(\"$ZodCheck\", (inst, def) => {\n    var _a;\n    inst._zod ?? (inst._zod = {});\n    inst._zod.def = def;\n    (_a = inst._zod).onattach ?? (_a.onattach = []);\n});\n/** Default `when` for size-based checks: run only on non-nullish values with a `size`. */\nconst _whenHasSize = (payload) => {\n    const val = payload.value;\n    return !util.nullish(val) && val.size !== undefined;\n};\n/** Default `when` for length-based checks: run only on non-nullish values with a `length`. */\nconst _whenHasLength = (payload) => {\n    const val = payload.value;\n    return !util.nullish(val) && val.length !== undefined;\n};\nconst numericOriginMap = {\n    number: \"number\",\n    bigint: \"bigint\",\n    object: \"date\",\n};\nexport const $ZodCheckLessThan = /*@__PURE__*/ core.$constructor(\"$ZodCheckLessThan\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    const origin = numericOriginMap[typeof def.value];\n    inst._zod.check = (payload) => {\n        if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {\n            return;\n        }\n        payload.issues.push({\n            origin: numericOriginMap[typeof payload.value] ?? origin,\n            code: \"too_big\",\n            maximum: typeof def.value === \"object\" ? def.value.getTime() : def.value,\n            input: payload.value,\n            inclusive: def.inclusive,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckGreaterThan = /*@__PURE__*/ core.$constructor(\"$ZodCheckGreaterThan\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    const origin = numericOriginMap[typeof def.value];\n    inst._zod.check = (payload) => {\n        if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {\n            return;\n        }\n        payload.issues.push({\n            origin: numericOriginMap[typeof payload.value] ?? origin,\n            code: \"too_small\",\n            minimum: typeof def.value === \"object\" ? def.value.getTime() : def.value,\n            input: payload.value,\n            inclusive: def.inclusive,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckMultipleOf = \n/*@__PURE__*/ core.$constructor(\"$ZodCheckMultipleOf\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    inst._zod.check = (payload) => {\n        if (typeof payload.value !== typeof def.value)\n            throw new Error(\"Cannot mix number and bigint in multiple_of check.\");\n        const isMultiple = typeof payload.value === \"bigint\"\n            ? // `value % 0n` throws, and nothing is a multiple of zero — the number branch already fails this way via NaN\n                def.value !== BigInt(0) && payload.value % def.value === BigInt(0)\n            : util.floatSafeRemainder(payload.value, def.value) === 0;\n        if (isMultiple)\n            return;\n        payload.issues.push({\n            origin: typeof payload.value,\n            code: \"not_multiple_of\",\n            divisor: def.value,\n            input: payload.value,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckNumberFormat = /*@__PURE__*/ core.$constructor(\"$ZodCheckNumberFormat\", (inst, def) => {\n    $ZodCheck.init(inst, def); // no format checks\n    def.format = def.format || \"float64\";\n    const isInt = def.format?.includes(\"int\");\n    const origin = isInt ? \"int\" : \"number\";\n    const [minimum, maximum] = util.NUMBER_FORMAT_RANGES[def.format];\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        if (isInt) {\n            if (!Number.isInteger(input)) {\n                // invalid_format issue\n                // payload.issues.push({\n                //   expected: def.format,\n                //   format: def.format,\n                //   code: \"invalid_format\",\n                //   input,\n                //   inst,\n                // });\n                // invalid_type issue\n                payload.issues.push({\n                    expected: origin,\n                    format: def.format,\n                    code: \"invalid_type\",\n                    continue: false,\n                    input,\n                    inst,\n                });\n                return;\n                // not_multiple_of issue\n                // payload.issues.push({\n                //   code: \"not_multiple_of\",\n                //   origin: \"number\",\n                //   input,\n                //   inst,\n                //   divisor: 1,\n                // });\n            }\n            if (!Number.isSafeInteger(input)) {\n                if (input > 0) {\n                    // too_big\n                    payload.issues.push({\n                        input,\n                        code: \"too_big\",\n                        maximum: Number.MAX_SAFE_INTEGER,\n                        note: \"Integers must be within the safe integer range.\",\n                        inst,\n                        origin,\n                        inclusive: true,\n                        continue: !def.abort,\n                    });\n                }\n                else {\n                    // too_small\n                    payload.issues.push({\n                        input,\n                        code: \"too_small\",\n                        minimum: Number.MIN_SAFE_INTEGER,\n                        note: \"Integers must be within the safe integer range.\",\n                        inst,\n                        origin,\n                        inclusive: true,\n                        continue: !def.abort,\n                    });\n                }\n                return;\n            }\n        }\n        if (input < minimum) {\n            payload.issues.push({\n                origin: \"number\",\n                input,\n                code: \"too_small\",\n                minimum,\n                inclusive: true,\n                inst,\n                continue: !def.abort,\n            });\n        }\n        if (input > maximum) {\n            payload.issues.push({\n                origin: \"number\",\n                input,\n                code: \"too_big\",\n                maximum,\n                inclusive: true,\n                inst,\n                continue: !def.abort,\n            });\n        }\n    };\n});\nexport const $ZodCheckBigIntFormat = /*@__PURE__*/ core.$constructor(\"$ZodCheckBigIntFormat\", (inst, def) => {\n    $ZodCheck.init(inst, def); // no format checks\n    const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format];\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        if (input < minimum) {\n            payload.issues.push({\n                origin: \"bigint\",\n                input,\n                code: \"too_small\",\n                minimum: minimum,\n                inclusive: true,\n                inst,\n                continue: !def.abort,\n            });\n        }\n        if (input > maximum) {\n            payload.issues.push({\n                origin: \"bigint\",\n                input,\n                code: \"too_big\",\n                maximum,\n                inclusive: true,\n                inst,\n                continue: !def.abort,\n            });\n        }\n    };\n});\nexport const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor(\"$ZodCheckMaxSize\", (inst, def) => {\n    var _a;\n    $ZodCheck.init(inst, def);\n    (_a = inst._zod.def).when ?? (_a.when = _whenHasSize);\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        const size = input.size;\n        if (size <= def.maximum)\n            return;\n        payload.issues.push({\n            origin: util.getSizableOrigin(input),\n            code: \"too_big\",\n            maximum: def.maximum,\n            inclusive: true,\n            input,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor(\"$ZodCheckMinSize\", (inst, def) => {\n    var _a;\n    $ZodCheck.init(inst, def);\n    (_a = inst._zod.def).when ?? (_a.when = _whenHasSize);\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        const size = input.size;\n        if (size >= def.minimum)\n            return;\n        payload.issues.push({\n            origin: util.getSizableOrigin(input),\n            code: \"too_small\",\n            minimum: def.minimum,\n            inclusive: true,\n            input,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor(\"$ZodCheckSizeEquals\", (inst, def) => {\n    var _a;\n    $ZodCheck.init(inst, def);\n    (_a = inst._zod.def).when ?? (_a.when = _whenHasSize);\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        const size = input.size;\n        if (size === def.size)\n            return;\n        const tooBig = size > def.size;\n        payload.issues.push({\n            origin: util.getSizableOrigin(input),\n            ...(tooBig ? { code: \"too_big\", maximum: def.size } : { code: \"too_small\", minimum: def.size }),\n            inclusive: true,\n            exact: true,\n            input: payload.value,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor(\"$ZodCheckMaxLength\", (inst, def) => {\n    var _a;\n    $ZodCheck.init(inst, def);\n    (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        const units = input.length;\n        // Strings are measured in Unicode code points, not UTF-16 units. A code point is at most two units, so a string that already fits in units fits in code points; only an overflow has to be counted.\n        const length = typeof input === \"string\" && units > def.maximum ? util.codePointLength(input) : units;\n        if (length <= def.maximum)\n            return;\n        const origin = util.getLengthableOrigin(input);\n        payload.issues.push({\n            origin,\n            code: \"too_big\",\n            maximum: def.maximum,\n            inclusive: true,\n            input,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor(\"$ZodCheckMinLength\", (inst, def) => {\n    var _a;\n    $ZodCheck.init(inst, def);\n    (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        const units = input.length;\n        // A code point is one or two UTF-16 units, so fewer units than the floor can never reach it and twice the floor always clears it. Only in between is the exact count in doubt.\n        const length = typeof input === \"string\" && units >= def.minimum && units < def.minimum * 2\n            ? util.codePointLength(input)\n            : units;\n        if (length >= def.minimum)\n            return;\n        const origin = util.getLengthableOrigin(input);\n        payload.issues.push({\n            origin,\n            code: \"too_small\",\n            minimum: def.minimum,\n            inclusive: true,\n            input,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckLengthEquals = /*@__PURE__*/ core.$constructor(\"$ZodCheckLengthEquals\", (inst, def) => {\n    var _a;\n    $ZodCheck.init(inst, def);\n    (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n    inst._zod.check = (payload) => {\n        const input = payload.value;\n        const units = input.length;\n        // A code point is one or two UTF-16 units, so outside `[length, length * 2]` units the target is missed either way — and missed in the same direction in both measures.\n        const length = typeof input === \"string\" && units >= def.length && units <= def.length * 2\n            ? util.codePointLength(input)\n            : units;\n        if (length === def.length)\n            return;\n        const origin = util.getLengthableOrigin(input);\n        const tooBig = length > def.length;\n        payload.issues.push({\n            origin,\n            ...(tooBig ? { code: \"too_big\", maximum: def.length } : { code: \"too_small\", minimum: def.length }),\n            inclusive: true,\n            exact: true,\n            input: payload.value,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckStringFormat = /*@__PURE__*/ core.$constructor(\"$ZodCheckStringFormat\", (inst, def) => {\n    var _a, _b;\n    $ZodCheck.init(inst, def);\n    if (def.pattern)\n        (_a = inst._zod).check ?? (_a.check = (payload) => {\n            def.pattern.lastIndex = 0;\n            if (def.pattern.test(payload.value))\n                return;\n            payload.issues.push({\n                origin: \"string\",\n                code: \"invalid_format\",\n                format: def.format,\n                input: payload.value,\n                ...(def.pattern ? { pattern: def.pattern.toString() } : {}),\n                inst,\n                continue: !def.abort,\n            });\n        });\n    else\n        (_b = inst._zod).check ?? (_b.check = () => { });\n});\nexport const $ZodCheckRegex = /*@__PURE__*/ core.$constructor(\"$ZodCheckRegex\", (inst, def) => {\n    $ZodCheckStringFormat.init(inst, def);\n    inst._zod.check = (payload) => {\n        def.pattern.lastIndex = 0;\n        if (def.pattern.test(payload.value))\n            return;\n        payload.issues.push({\n            origin: \"string\",\n            code: \"invalid_format\",\n            format: \"regex\",\n            input: payload.value,\n            pattern: def.pattern.toString(),\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckLowerCase = /*@__PURE__*/ core.$constructor(\"$ZodCheckLowerCase\", (inst, def) => {\n    def.pattern ?? (def.pattern = regexes.lowercase);\n    $ZodCheckStringFormat.init(inst, def);\n});\nexport const $ZodCheckUpperCase = /*@__PURE__*/ core.$constructor(\"$ZodCheckUpperCase\", (inst, def) => {\n    def.pattern ?? (def.pattern = regexes.uppercase);\n    $ZodCheckStringFormat.init(inst, def);\n});\nexport const $ZodCheckIncludes = /*@__PURE__*/ core.$constructor(\"$ZodCheckIncludes\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    const escapedRegex = util.escapeRegex(def.includes);\n    // `String.prototype.includes(sub, position)` matches `sub` at `position`\n    // OR LATER, so the pattern must allow at least `position` leading chars\n    // (`{N,}`), not exactly `position` chars (`{N}`).\n    const pattern = new RegExp(typeof def.position === \"number\" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);\n    def.pattern = pattern;\n    inst._zod.check = (payload) => {\n        if (payload.value.includes(def.includes, def.position))\n            return;\n        payload.issues.push({\n            origin: \"string\",\n            code: \"invalid_format\",\n            format: \"includes\",\n            includes: def.includes,\n            input: payload.value,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckStartsWith = /*@__PURE__*/ core.$constructor(\"$ZodCheckStartsWith\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`);\n    def.pattern ?? (def.pattern = pattern);\n    inst._zod.check = (payload) => {\n        if (payload.value.startsWith(def.prefix))\n            return;\n        payload.issues.push({\n            origin: \"string\",\n            code: \"invalid_format\",\n            format: \"starts_with\",\n            prefix: def.prefix,\n            input: payload.value,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckEndsWith = /*@__PURE__*/ core.$constructor(\"$ZodCheckEndsWith\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`);\n    def.pattern ?? (def.pattern = pattern);\n    inst._zod.check = (payload) => {\n        if (payload.value.endsWith(def.suffix))\n            return;\n        payload.issues.push({\n            origin: \"string\",\n            code: \"invalid_format\",\n            format: \"ends_with\",\n            suffix: def.suffix,\n            input: payload.value,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\n///////////////////////////////////\n/////    $ZodCheckProperty    /////\n///////////////////////////////////\nfunction handleCheckPropertyResult(result, payload, property) {\n    if (result.issues.length) {\n        payload.issues.push(...util.prefixIssues(property, result.issues));\n    }\n}\nexport const $ZodCheckProperty = /*@__PURE__*/ core.$constructor(\"$ZodCheckProperty\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    inst._zod.check = (payload) => {\n        const result = def.schema._zod.run({\n            value: payload.value[def.property],\n            issues: [],\n        }, {});\n        if (result instanceof Promise) {\n            return result.then((result) => handleCheckPropertyResult(result, payload, def.property));\n        }\n        handleCheckPropertyResult(result, payload, def.property);\n        return;\n    };\n});\nexport const $ZodCheckProperties = /*@__PURE__*/ core.$constructor(\"$ZodCheckProperties\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    util.hide(inst, Symbol.iterator, function* () {\n        yield inst;\n    });\n    // key and schema snapshotted together: reading one live and the other cached lets a later mutation of the caller's shape object pair a stale key with a missing schema\n    let entries;\n    inst._zod.check = (payload) => {\n        // the base schema already typed the value, so only a nullish one is rejected here: the properties read on a primitive too, matching z.property() on a string's length\n        if (payload.value == null) {\n            payload.issues.push({ expected: \"object\", code: \"invalid_type\", input: payload.value, inst });\n            return undefined;\n        }\n        entries ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));\n        const input = payload.value;\n        let proms;\n        for (const [key, schema] of entries) {\n            const result = schema._zod.run({ value: input[key], issues: [] }, {});\n            if (result instanceof Promise) {\n                proms ?? (proms = []);\n                proms.push(result.then((result) => handleCheckPropertyResult(result, payload, key)));\n            }\n            else {\n                handleCheckPropertyResult(result, payload, key);\n            }\n        }\n        if (proms)\n            return Promise.all(proms).then(() => undefined);\n        return undefined;\n    };\n});\nexport const $ZodCheckMimeType = /*@__PURE__*/ core.$constructor(\"$ZodCheckMimeType\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    const mimeSet = new Set(def.mime);\n    inst._zod.check = (payload) => {\n        if (mimeSet.has(payload.value.type))\n            return;\n        payload.issues.push({\n            code: \"invalid_value\",\n            values: def.mime,\n            input: payload.value.type,\n            inst,\n            continue: !def.abort,\n        });\n    };\n});\nexport const $ZodCheckOverwrite = /*@__PURE__*/ core.$constructor(\"$ZodCheckOverwrite\", (inst, def) => {\n    $ZodCheck.init(inst, def);\n    inst._zod.check = (payload) => {\n        payload.value = def.tx(payload.value);\n    };\n});\n"],"names":["$ZodCheck","core.$constructor","inst","def","_a","_whenHasLength","payload","val","util.nullish","numericOriginMap","$ZodCheckLessThan","origin","$ZodCheckGreaterThan","$ZodCheckMultipleOf","util.floatSafeRemainder","$ZodCheckNumberFormat","isInt","minimum","maximum","util.NUMBER_FORMAT_RANGES","input","$ZodCheckMaxLength","units","util.codePointLength","util.getLengthableOrigin","$ZodCheckMinLength","$ZodCheckLengthEquals","length","tooBig","$ZodCheckStringFormat","_b","$ZodCheckRegex","$ZodCheckLowerCase","regexes.lowercase","$ZodCheckUpperCase","regexes.uppercase","$ZodCheckIncludes","escapedRegex","util.escapeRegex","pattern","$ZodCheckStartsWith","$ZodCheckEndsWith","$ZodCheckOverwrite"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/zod/v4/core/core.js

@@ -0,0 +1,97 @@
+import { members as j } from "./util.js";
+var P;
+const p = { value: void 0, enumerable: !1 };
+let h = "captureStackTrace" in Error ? Error : null;
+function m(r) {
+  const o = h;
+  if (o) {
+    const a = o.stackTraceLimit;
+    if (typeof a == "number") {
+      try {
+        o.stackTraceLimit = 0;
+      } catch {
+        return h = null, new r();
+      }
+      try {
+        return new r();
+      } finally {
+        o.stackTraceLimit = a;
+      }
+    }
+  }
+  return new r();
+}
+function w(r, o, a, d) {
+  const E = {};
+  function b(e) {
+    this.def = e, this.constr = c, this.traits = /* @__PURE__ */ new Set();
+  }
+  b.prototype = E;
+  const _ = a, f = _ && /* @__PURE__ */ new WeakSet();
+  function y(e, n) {
+    if (e._zod) {
+      if (e._zod.traits.has(r))
+        return;
+    } else {
+      p.value = new b(n);
+      try {
+        Object.defineProperty(e, "_zod", p);
+      } finally {
+        p.value = void 0;
+      }
+    }
+    if (e._zod.traits.add(r), o(e, n), f) {
+      const t = Object.getPrototypeOf(e), l = e._zod.constr.prototype;
+      let i = t;
+      for (; i && i !== l; )
+        i = Object.getPrototypeOf(i);
+      const u = i ?? t;
+      f.has(u) || (f.add(u), j(u, _));
+    }
+    const s = c.prototype;
+    for (const t in s)
+      Object.prototype.hasOwnProperty.call(s, t) && (t in e || (e[t] = s[t].bind(e)));
+  }
+  const O = d?.Parent ?? Object;
+  class g extends O {
+  }
+  Object.defineProperty(g, "name", { value: r });
+  function c(e) {
+    const n = d?.Parent ? m(g) : this;
+    y(n, e);
+    const s = n._zod.deferred;
+    if (s) {
+      for (const l of s)
+        l();
+      n._zod.deferred = void 0;
+    }
+    const t = globalThis.__zod_globalConfig?.postProcessor;
+    return t && t(n), n;
+  }
+  return Object.defineProperty(c, "init", { value: y }), Object.defineProperty(c, Symbol.hasInstance, {
+    value: (e) => d?.Parent && e instanceof d.Parent ? !0 : e?._zod?.traits?.has(r)
+  }), Object.defineProperty(c, "name", { value: r }), c;
+}
+class T extends Error {
+  constructor() {
+    super("Encountered Promise during synchronous parse. Use .parseAsync() instead.");
+  }
+}
+class k extends Error {
+  constructor(o) {
+    super(`Encountered unidirectional transform during encode: ${o}`), this.name = "ZodEncodeError";
+  }
+}
+(P = globalThis).__zod_globalConfig ?? (P.__zod_globalConfig = {});
+const z = globalThis.__zod_globalConfig;
+function x(r) {
+  return r && Object.assign(z, r), z;
+}
+export {
+  T as $ZodAsyncError,
+  k as $ZodEncodeError,
+  w as $constructor,
+  x as config,
+  z as globalConfig
+};
+//# sourceMappingURL=core.js.map

package/dist/node_modules/zod/v4/core/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sources":["../../../../../../../node_modules/zod/v4/core/core.js"],"sourcesContent":["var _a;\nimport { members as installMembers } from \"./util.js\";\n/** A special constant with type `never` */\nexport const NEVER = /*@__PURE__*/ Object.freeze({\n    status: \"aborted\",\n});\n/* Shared descriptor for installing `_zod`; defineProperty reads it\n * synchronously, so reusing one object avoids a per-instance allocation. */\nconst _zodDesc = { value: undefined, enumerable: false };\n// null where suppressing the capture would be unrecoverable: `parse()` puts the frames back with `captureStackTrace`, so without it the throw would lose its stack. also latched to null once `stackTraceLimit` proves unassignable, which a realm can do at any point by hardening Error\nlet _E = \"captureStackTrace\" in Error ? Error : null;\n// v8 captures a stack trace inside the Error constructor, which dominates a failed parse; costs only the frames, and parse() restores those. the constructor must RUN: Object.create is cheaper and passes instanceof, but Error.isError and util.types.isNativeError check an internal slot\nfunction newError(Definition) {\n    const E = _E;\n    if (E) {\n        const saved = E.stackTraceLimit;\n        if (typeof saved === \"number\") {\n            try {\n                E.stackTraceLimit = 0;\n            }\n            catch {\n                _E = null;\n                return new Definition();\n            }\n            try {\n                return new Definition();\n            }\n            finally {\n                E.stackTraceLimit = saved;\n            }\n        }\n    }\n    return new Definition();\n}\nexport /*@__NO_SIDE_EFFECTS__*/ function $constructor(name, initializer, \n/** This trait's members, installed once on every prototype that composes it. They cannot be declared in the initializer above: that runs per instance, and the prototype is shared. */\nproto, params) {\n    // Prototype for this constructor's `_zod` internals. Lazily-derived fields (`values`, `pattern`, `optin`, …) install here once rather than as an accessor on every instance.\n    const zodProto = {};\n    // Assigning the fields in the constructor body is what gives instances in-object slots; building the object literally and reparenting it costs a second allocation and a generic property copy.\n    function Internals(def) {\n        this.def = def;\n        this.constr = _;\n        this.traits = new Set();\n    }\n    Internals.prototype = zodProto;\n    const protoMembers = proto;\n    // One trait's members land on every prototype whose chain composes it, so the answer is per prototype rather than per trait.\n    const initialized = protoMembers && new WeakSet();\n    function init(inst, def) {\n        if (!inst._zod) {\n            _zodDesc.value = new Internals(def);\n            try {\n                Object.defineProperty(inst, \"_zod\", _zodDesc);\n            }\n            finally {\n                // Cleared even on throw, so the shared descriptor never leaks one instance's internals into the next.\n                _zodDesc.value = undefined;\n            }\n        }\n        else if (inst._zod.traits.has(name)) {\n            return;\n        }\n        inst._zod.traits.add(name);\n        initializer(inst, def);\n        if (initialized) {\n            // `super(def)` from a user subclass gives `this` a prototype the subclass owns, and installing there would overwrite whatever the subclass declared. `constr` built the instance, so its prototype is the one below the subclass's that should carry the members. A receiver whose chain never reaches that prototype installs on its own, which for a plain object handed straight to `init` means `Object.prototype` — unchanged from before.\n            const own = Object.getPrototypeOf(inst);\n            const ctorProto = inst._zod.constr.prototype;\n            let up = own;\n            while (up && up !== ctorProto)\n                up = Object.getPrototypeOf(up);\n            const target = up ?? own;\n            if (!initialized.has(target)) {\n                initialized.add(target);\n                installMembers(target, protoMembers);\n            }\n        }\n        // support prototype modifications; for-in avoids the array allocation of Object.keys on the (usually empty) prototype\n        const proto = _.prototype;\n        for (const k in proto) {\n            if (!Object.prototype.hasOwnProperty.call(proto, k))\n                continue;\n            if (!(k in inst)) {\n                inst[k] = proto[k].bind(inst);\n            }\n        }\n    }\n    // doesn't work if Parent has a constructor with arguments\n    const Parent = params?.Parent ?? Object;\n    class Definition extends Parent {\n    }\n    Object.defineProperty(Definition, \"name\", { value: name });\n    function _(def) {\n        const inst = params?.Parent ? newError(Definition) : this;\n        init(inst, def);\n        const deferred = inst._zod.deferred;\n        if (deferred) {\n            for (const fn of deferred) {\n                fn();\n            }\n            // Released: initializers run once, and the list would otherwise be retained for the schema's lifetime.\n            inst._zod.deferred = undefined;\n        }\n        // Global post-processor hook. Internal: installed by `import \"zod/compile\"` to enable AOT compilation for every constructed schema. Runs last, once the instance is fully built, because it hands the instance to compile(). The post-processor is expected to be reentrancy-guarded by its own implementation.\n        const pp = globalThis.__zod_globalConfig?.postProcessor;\n        if (pp)\n            pp(inst);\n        return inst;\n    }\n    Object.defineProperty(_, \"init\", { value: init });\n    Object.defineProperty(_, Symbol.hasInstance, {\n        value: (inst) => {\n            if (params?.Parent && inst instanceof params.Parent)\n                return true;\n            return inst?._zod?.traits?.has(name);\n        },\n    });\n    Object.defineProperty(_, \"name\", { value: name });\n    return _;\n}\n//////////////////////////////   UTILITIES   ///////////////////////////////////////\nexport const $brand = /*@__PURE__*/ Symbol(\"zod_brand\");\nexport class $ZodAsyncError extends Error {\n    constructor() {\n        super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);\n    }\n}\nexport class $ZodEncodeError extends Error {\n    constructor(name) {\n        super(`Encountered unidirectional transform during encode: ${name}`);\n        this.name = \"ZodEncodeError\";\n    }\n}\n(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});\nexport const globalConfig = globalThis.__zod_globalConfig;\nexport function config(newConfig) {\n    if (newConfig)\n        Object.assign(globalConfig, newConfig);\n    return globalConfig;\n}\n"],"names":["_a","_zodDesc","_E","newError","Definition","E","saved","$constructor","name","initializer","proto","params","zodProto","Internals","def","_","protoMembers","initialized","init","inst","own","ctorProto","up","target","installMembers","k","Parent","deferred","fn","pp","$ZodAsyncError","$ZodEncodeError","globalConfig","config","newConfig"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/zod/v4/core/doc.js

@@ -0,0 +1,35 @@
+class h {
+  constructor(t = [], e = {}) {
+    this.content = [], this.indent = 0, this.args = t, this.closed = e;
+  }
+  // the compiler catches a child's throw and keeps writing into this doc, so the indent has to unwind with it
+  indented(t) {
+    this.indent += 1;
+    try {
+      t(this);
+    } finally {
+      this.indent -= 1;
+    }
+  }
+  write(t) {
+    if (typeof t == "function") {
+      t(this, { execution: "sync" }), t(this, { execution: "async" });
+      return;
+    }
+    const i = t.split(`
+`).filter((n) => n), s = Math.min(...i.map((n) => n.length - n.trimStart().length)), c = i.map((n) => n.slice(s)).map((n) => " ".repeat(this.indent * 2) + n);
+    for (const n of c)
+      this.content.push(n);
+  }
+  compile() {
+    const t = Function, e = this?.content ?? [""];
+    return new t(...Object.keys(this.closed), `return function (${this.args.join(", ")}) {
+${e.join(`
+`)}
+};`)(...Object.values(this.closed));
+  }
+}
+export {
+  h as Doc
+};
+//# sourceMappingURL=doc.js.map

package/dist/node_modules/zod/v4/core/doc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc.js","sources":["../../../../../../../node_modules/zod/v4/core/doc.js"],"sourcesContent":["export class Doc {\n    constructor(args = [], closed = {}) {\n        this.content = [];\n        this.indent = 0;\n        this.args = args;\n        this.closed = closed;\n    }\n    // the compiler catches a child's throw and keeps writing into this doc, so the indent has to unwind with it\n    indented(fn) {\n        this.indent += 1;\n        try {\n            fn(this);\n        }\n        finally {\n            this.indent -= 1;\n        }\n    }\n    write(arg) {\n        if (typeof arg === \"function\") {\n            arg(this, { execution: \"sync\" });\n            arg(this, { execution: \"async\" });\n            return;\n        }\n        const content = arg;\n        const lines = content.split(\"\\n\").filter((x) => x);\n        const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));\n        const dedented = lines.map((x) => x.slice(minIndent)).map((x) => \" \".repeat(this.indent * 2) + x);\n        for (const line of dedented) {\n            this.content.push(line);\n        }\n    }\n    compile() {\n        const F = Function;\n        const content = this?.content ?? [``];\n        const factory = new F(...Object.keys(this.closed), `return function (${this.args.join(\", \")}) {\\n${content.join(\"\\n\")}\\n};`);\n        return factory(...Object.values(this.closed));\n    }\n}\n"],"names":["Doc","args","closed","fn","arg","lines","x","minIndent","dedented","line","F","content"],"mappings":"AAAO,MAAMA,EAAI;AAAA,EACb,YAAYC,IAAO,IAAIC,IAAS,CAAA,GAAI;AAChC,SAAK,UAAU,CAAA,GACf,KAAK,SAAS,GACd,KAAK,OAAOD,GACZ,KAAK,SAASC;AAAA,EAClB;AAAA;AAAA,EAEA,SAASC,GAAI;AACT,SAAK,UAAU;AACf,QAAI;AACA,MAAAA,EAAG,IAAI;AAAA,IACX,UACR;AACY,WAAK,UAAU;AAAA,IACnB;AAAA,EACJ;AAAA,EACA,MAAMC,GAAK;AACP,QAAI,OAAOA,KAAQ,YAAY;AAC3B,MAAAA,EAAI,MAAM,EAAE,WAAW,OAAM,CAAE,GAC/BA,EAAI,MAAM,EAAE,WAAW,QAAO,CAAE;AAChC;AAAA,IACJ;AAEA,UAAMC,IADUD,EACM,MAAM;AAAA,CAAI,EAAE,OAAO,CAACE,MAAMA,CAAC,GAC3CC,IAAY,KAAK,IAAI,GAAGF,EAAM,IAAI,CAACC,MAAMA,EAAE,SAASA,EAAE,UAAS,EAAG,MAAM,CAAC,GACzEE,IAAWH,EAAM,IAAI,CAACC,MAAMA,EAAE,MAAMC,CAAS,CAAC,EAAE,IAAI,CAACD,MAAM,IAAI,OAAO,KAAK,SAAS,CAAC,IAAIA,CAAC;AAChG,eAAWG,KAAQD;AACf,WAAK,QAAQ,KAAKC,CAAI;AAAA,EAE9B;AAAA,EACA,UAAU;AACN,UAAMC,IAAI,UACJC,IAAU,MAAM,WAAW,CAAC,EAAE;AAEpC,WADgB,IAAID,EAAE,GAAG,OAAO,KAAK,KAAK,MAAM,GAAG,oBAAoB,KAAK,KAAK,KAAK,IAAI,CAAC;AAAA,EAAQC,EAAQ,KAAK;AAAA,CAAI,CAAC;AAAA,GAAM,EAC5G,GAAG,OAAO,OAAO,KAAK,MAAM,CAAC;AAAA,EAChD;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/zod/v4/core/errors.js

@@ -0,0 +1,79 @@
+import { $constructor as b } from "./core.js";
+import { jsonStringifyReplacer as h } from "./util.js";
+function m() {
+  const e = this._zod;
+  return e.message ?? (e.message = JSON.stringify(e.def, h, 2)), e.message;
+}
+function _(e) {
+  this._zod.message = e;
+}
+const O = {
+  get: m,
+  set: _,
+  enumerable: !0,
+  configurable: !0
+}, f = { value: void 0, enumerable: !1 }, p = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]), y = (e, t) => {
+  e.name = "$ZodError", f.value = t, Object.defineProperty(e, "issues", f), f.value = void 0, Object.defineProperty(e, "message", O);
+  const r = Object.getPrototypeOf(e);
+  p.has(r) || (p.add(r), Object.defineProperty(r, "toString", {
+    configurable: !0,
+    enumerable: !1,
+    get() {
+      const o = () => this.message;
+      return Object.defineProperty(this, "toString", { value: o, configurable: !0, writable: !0 }), o;
+    },
+    set(o) {
+      Object.defineProperty(this, "toString", { value: o, configurable: !0, writable: !0 });
+    }
+  }));
+}, v = b("$ZodError", y);
+function E(e, t, r) {
+  return Object.prototype.hasOwnProperty.call(e, t) || (t === "__proto__" ? Object.defineProperty(e, t, { value: r(), writable: !0, enumerable: !0, configurable: !0 }) : e[t] = r()), e[t];
+}
+function w(e, t = (r) => r.message) {
+  const r = {}, o = [];
+  for (const n of e.issues)
+    n.path.length > 0 ? E(r, n.path[0], () => []).push(t(n)) : o.push(t(n));
+  return { formErrors: o, fieldErrors: r };
+}
+function S(e, t = (r) => r.message) {
+  const r = { _errors: [] }, o = (n, a = []) => {
+    for (const s of n.issues)
+      if (s.code === "invalid_union" && s.errors.length)
+        s.errors.map((i) => o({ issues: i }, [...a, ...s.path]));
+      else if (s.code === "invalid_key")
+        o({ issues: s.issues }, [...a, ...s.path]);
+      else if (s.code === "invalid_element")
+        o({ issues: s.issues }, [...a, ...s.path]);
+      else {
+        const i = [...a, ...s.path];
+        if (i.length === 0)
+          r._errors.push(t(s));
+        else {
+          let u = r, l = 0;
+          for (; l < i.length; ) {
+            const c = i[l], g = l === i.length - 1;
+            if (c === "_errors") {
+              g && u._errors.push(t(s)), l++;
+              continue;
+            }
+            Object.prototype.hasOwnProperty.call(u, c) || Object.defineProperty(u, c, {
+              value: { _errors: [] },
+              enumerable: !0,
+              writable: !0,
+              configurable: !0
+            });
+            const d = u[c];
+            g && d._errors.push(t(s)), u = d, l++;
+          }
+        }
+      }
+  };
+  return o(e), r;
+}
+export {
+  v as $ZodError,
+  w as flattenError,
+  S as formatError
+};
+//# sourceMappingURL=errors.js.map

package/dist/node_modules/zod/v4/core/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../../../../../../../node_modules/zod/v4/core/errors.js"],"sourcesContent":["import { $constructor } from \"./core.js\";\nimport * as util from \"./util.js\";\n/* Computing the message eagerly is expensive (pretty-printed JSON of all\n * issues), so defer it until first read. The accessor functions and\n * descriptors are shared across instances to keep error construction\n * cheap; the computed message is cached on the internals object. The\n * setter preserves plain assignment semantics for consumers that\n * overwrite `message`. */\nfunction _getMessage() {\n    const internals = this._zod;\n    internals.message ?? (internals.message = JSON.stringify(internals.def, util.jsonStringifyReplacer, 2));\n    return internals.message;\n}\nfunction _setMessage(value) {\n    this._zod.message = value;\n}\nconst _messageDesc = {\n    get: _getMessage,\n    set: _setMessage,\n    enumerable: true,\n    configurable: true,\n};\nconst _issuesDesc = { value: undefined, enumerable: false };\n/* Prototypes that already carry the lazy `toString`. Seeded with the\n * intrinsics so that `init` on a foreign object — it accepts any object —\n * can never install an accessor onto a prototype we do not own. */\nconst _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);\nconst initializer = (inst, def) => {\n    inst.name = \"$ZodError\";\n    // `_zod` is already non-enumerable: $constructor's init defined it with this same descriptor\n    _issuesDesc.value = def;\n    Object.defineProperty(inst, \"issues\", _issuesDesc);\n    // Clear the shared slot; a retained `value` pins the last error's issues.\n    _issuesDesc.value = undefined;\n    Object.defineProperty(inst, \"message\", _messageDesc);\n    /* `toString` lives as a non-enumerable lazy getter on the shared\n     * prototype; on first access it caches a per-instance closure so\n     * detached usage still works. */\n    const proto = Object.getPrototypeOf(inst);\n    if (!_installedToString.has(proto)) {\n        _installedToString.add(proto);\n        Object.defineProperty(proto, \"toString\", {\n            configurable: true,\n            enumerable: false,\n            get() {\n                const value = () => this.message;\n                Object.defineProperty(this, \"toString\", { value, configurable: true, writable: true });\n                return value;\n            },\n            set(value) {\n                Object.defineProperty(this, \"toString\", { value, configurable: true, writable: true });\n            },\n        });\n    }\n};\nexport const $ZodError = $constructor(\"$ZodError\", initializer);\nexport const $ZodRealError = $constructor(\"$ZodError\", initializer, undefined, {\n    Parent: Error,\n});\n/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member\n * (\"toString\", \"constructor\") would otherwise read through to the prototype, and assigning\n * \"__proto__\" would hit the setter instead of creating a key. */\nfunction node(obj, key, make) {\n    if (!Object.prototype.hasOwnProperty.call(obj, key)) {\n        if (key === \"__proto__\") {\n            Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });\n        }\n        else {\n            obj[key] = make();\n        }\n    }\n    return obj[key];\n}\nexport function flattenError(error, mapper = (issue) => issue.message) {\n    const fieldErrors = {};\n    const formErrors = [];\n    for (const sub of error.issues) {\n        if (sub.path.length > 0) {\n            node(fieldErrors, sub.path[0], () => []).push(mapper(sub));\n        }\n        else {\n            formErrors.push(mapper(sub));\n        }\n    }\n    return { formErrors, fieldErrors };\n}\nexport function formatError(error, mapper = (issue) => issue.message) {\n    const fieldErrors = { _errors: [] };\n    const processError = (error, path = []) => {\n        for (const issue of error.issues) {\n            if (issue.code === \"invalid_union\" && issue.errors.length) {\n                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));\n            }\n            else if (issue.code === \"invalid_key\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else if (issue.code === \"invalid_element\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else {\n                const fullpath = [...path, ...issue.path];\n                if (fullpath.length === 0) {\n                    fieldErrors._errors.push(mapper(issue));\n                }\n                else {\n                    let curr = fieldErrors;\n                    let i = 0;\n                    while (i < fullpath.length) {\n                        const el = fullpath[i];\n                        const terminal = i === fullpath.length - 1;\n                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.\n                        if (el === \"_errors\") {\n                            if (terminal)\n                                curr._errors.push(mapper(issue));\n                            i++;\n                            continue;\n                        }\n                        // A path element may collide with an inherited property name such as\n                        // \"__proto__\" or \"constructor\". Truthiness checks read the prototype\n                        // (so no node is created, then ._errors.push throws), and bracket\n                        // assignment of \"__proto__\" hits the setter instead of creating an\n                        // own key. Guard the read with hasOwnProperty and create the node\n                        // with defineProperty so any path element becomes a real own key.\n                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {\n                            Object.defineProperty(curr, el, {\n                                value: { _errors: [] },\n                                enumerable: true,\n                                writable: true,\n                                configurable: true,\n                            });\n                        }\n                        const node = curr[el];\n                        if (terminal) {\n                            node._errors.push(mapper(issue));\n                        }\n                        curr = node;\n                        i++;\n                    }\n                }\n            }\n        }\n    };\n    processError(error);\n    return fieldErrors;\n}\nexport function treeifyError(error, mapper = (issue) => issue.message) {\n    const result = { errors: [] };\n    const processError = (error, path = []) => {\n        var _a;\n        for (const issue of error.issues) {\n            if (issue.code === \"invalid_union\" && issue.errors.length) {\n                // regular union error\n                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));\n            }\n            else if (issue.code === \"invalid_key\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else if (issue.code === \"invalid_element\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else {\n                const fullpath = [...path, ...issue.path];\n                if (fullpath.length === 0) {\n                    result.errors.push(mapper(issue));\n                    continue;\n                }\n                let curr = result;\n                let i = 0;\n                while (i < fullpath.length) {\n                    const el = fullpath[i];\n                    const terminal = i === fullpath.length - 1;\n                    if (typeof el === \"string\") {\n                        curr.properties ?? (curr.properties = {});\n                        // el may collide with an inherited property name (\"__proto__\",\n                        // \"constructor\", ...); ??= reads the prototype so the node is never\n                        // created and curr.errors.push throws. Guard with hasOwnProperty and\n                        // create the node with defineProperty so \"__proto__\" becomes a real\n                        // own key rather than invoking the prototype setter.\n                        if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {\n                            Object.defineProperty(curr.properties, el, {\n                                value: { errors: [] },\n                                enumerable: true,\n                                writable: true,\n                                configurable: true,\n                            });\n                        }\n                        curr = curr.properties[el];\n                    }\n                    else {\n                        curr.items ?? (curr.items = []);\n                        (_a = curr.items)[el] ?? (_a[el] = { errors: [] });\n                        curr = curr.items[el];\n                    }\n                    if (terminal) {\n                        curr.errors.push(mapper(issue));\n                    }\n                    i++;\n                }\n            }\n        }\n    };\n    processError(error);\n    return result;\n}\n/** Format a ZodError as a human-readable string in the following form.\n *\n * From\n *\n * ```ts\n * ZodError {\n *   issues: [\n *     {\n *       expected: 'string',\n *       code: 'invalid_type',\n *       path: [ 'username' ],\n *       message: 'Invalid input: expected string'\n *     },\n *     {\n *       expected: 'number',\n *       code: 'invalid_type',\n *       path: [ 'favoriteNumbers', 1 ],\n *       message: 'Invalid input: expected number'\n *     }\n *   ];\n * }\n * ```\n *\n * to\n *\n * ```\n * username\n *   ✖ Expected number, received string at \"username\n * favoriteNumbers[0]\n *   ✖ Invalid input: expected number\n * ```\n */\nexport function toDotPath(_path) {\n    const segs = [];\n    const path = _path.map((seg) => (typeof seg === \"object\" ? seg.key : seg));\n    for (const seg of path) {\n        if (typeof seg === \"number\")\n            segs.push(`[${seg}]`);\n        else if (typeof seg === \"symbol\")\n            segs.push(`[${JSON.stringify(String(seg))}]`);\n        else if (/[^\\w$]/.test(seg))\n            segs.push(`[${JSON.stringify(seg)}]`);\n        else {\n            if (segs.length)\n                segs.push(\".\");\n            segs.push(seg);\n        }\n    }\n    return segs.join(\"\");\n}\nexport function prettifyError(error) {\n    const lines = [];\n    // sort by path length\n    const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);\n    // Process each issue\n    for (const issue of issues) {\n        lines.push(`✖ ${issue.message}`);\n        if (issue.path?.length)\n            lines.push(`  → at ${toDotPath(issue.path)}`);\n    }\n    // Convert Map to formatted string\n    return lines.join(\"\\n\");\n}\n"],"names":["_getMessage","internals","util.jsonStringifyReplacer","_setMessage","value","_messageDesc","_issuesDesc","_installedToString","initializer","inst","def","proto","$ZodError","$constructor","node","obj","key","make","flattenError","error","mapper","issue","fieldErrors","formErrors","sub","formatError","processError","path","issues","fullpath","curr","i","el","terminal"],"mappings":";;AAQA,SAASA,IAAc;AACnB,QAAMC,IAAY,KAAK;AACvB,SAAAA,EAAU,YAAYA,EAAU,UAAU,KAAK,UAAUA,EAAU,KAAKC,GAA4B,CAAC,IAC9FD,EAAU;AACrB;AACA,SAASE,EAAYC,GAAO;AACxB,OAAK,KAAK,UAAUA;AACxB;AACA,MAAMC,IAAe;AAAA,EACjB,KAAKL;AAAA,EACL,KAAKG;AAAA,EACL,YAAY;AAAA,EACZ,cAAc;AAClB,GACMG,IAAc,EAAE,OAAO,QAAW,YAAY,GAAK,GAInDC,IAAqC,oBAAI,QAAQ,CAAC,OAAO,WAAW,MAAM,SAAS,CAAC,GACpFC,IAAc,CAACC,GAAMC,MAAQ;AAC/B,EAAAD,EAAK,OAAO,aAEZH,EAAY,QAAQI,GACpB,OAAO,eAAeD,GAAM,UAAUH,CAAW,GAEjDA,EAAY,QAAQ,QACpB,OAAO,eAAeG,GAAM,WAAWJ,CAAY;AAInD,QAAMM,IAAQ,OAAO,eAAeF,CAAI;AACxC,EAAKF,EAAmB,IAAII,CAAK,MAC7BJ,EAAmB,IAAII,CAAK,GAC5B,OAAO,eAAeA,GAAO,YAAY;AAAA,IACrC,cAAc;AAAA,IACd,YAAY;AAAA,IACZ,MAAM;AACF,YAAMP,IAAQ,MAAM,KAAK;AACzB,oBAAO,eAAe,MAAM,YAAY,EAAE,OAAAA,GAAO,cAAc,IAAM,UAAU,IAAM,GAC9EA;AAAA,IACX;AAAA,IACA,IAAIA,GAAO;AACP,aAAO,eAAe,MAAM,YAAY,EAAE,OAAAA,GAAO,cAAc,IAAM,UAAU,IAAM;AAAA,IACzF;AAAA,EACZ,CAAS;AAET,GACaQ,IAAYC,EAAa,aAAaL,CAAW;AAO9D,SAASM,EAAKC,GAAKC,GAAKC,GAAM;AAC1B,SAAK,OAAO,UAAU,eAAe,KAAKF,GAAKC,CAAG,MAC1CA,MAAQ,cACR,OAAO,eAAeD,GAAKC,GAAK,EAAE,OAAOC,EAAI,GAAI,UAAU,IAAM,YAAY,IAAM,cAAc,GAAI,CAAE,IAGvGF,EAAIC,CAAG,IAAIC,EAAI,IAGhBF,EAAIC,CAAG;AAClB;AACO,SAASE,EAAaC,GAAOC,IAAS,CAACC,MAAUA,EAAM,SAAS;AACnE,QAAMC,IAAc,CAAA,GACdC,IAAa,CAAA;AACnB,aAAWC,KAAOL,EAAM;AACpB,IAAIK,EAAI,KAAK,SAAS,IAClBV,EAAKQ,GAAaE,EAAI,KAAK,CAAC,GAAG,MAAM,CAAA,CAAE,EAAE,KAAKJ,EAAOI,CAAG,CAAC,IAGzDD,EAAW,KAAKH,EAAOI,CAAG,CAAC;AAGnC,SAAO,EAAE,YAAAD,GAAY,aAAAD,EAAW;AACpC;AACO,SAASG,EAAYN,GAAOC,IAAS,CAACC,MAAUA,EAAM,SAAS;AAClE,QAAMC,IAAc,EAAE,SAAS,GAAE,GAC3BI,IAAe,CAACP,GAAOQ,IAAO,CAAA,MAAO;AACvC,eAAWN,KAASF,EAAM;AACtB,UAAIE,EAAM,SAAS,mBAAmBA,EAAM,OAAO;AAC/C,QAAAA,EAAM,OAAO,IAAI,CAACO,MAAWF,EAAa,EAAE,QAAAE,EAAM,GAAI,CAAC,GAAGD,GAAM,GAAGN,EAAM,IAAI,CAAC,CAAC;AAAA,eAE1EA,EAAM,SAAS;AACpB,QAAAK,EAAa,EAAE,QAAQL,EAAM,OAAM,GAAI,CAAC,GAAGM,GAAM,GAAGN,EAAM,IAAI,CAAC;AAAA,eAE1DA,EAAM,SAAS;AACpB,QAAAK,EAAa,EAAE,QAAQL,EAAM,OAAM,GAAI,CAAC,GAAGM,GAAM,GAAGN,EAAM,IAAI,CAAC;AAAA,WAE9D;AACD,cAAMQ,IAAW,CAAC,GAAGF,GAAM,GAAGN,EAAM,IAAI;AACxC,YAAIQ,EAAS,WAAW;AACpB,UAAAP,EAAY,QAAQ,KAAKF,EAAOC,CAAK,CAAC;AAAA,aAErC;AACD,cAAIS,IAAOR,GACPS,IAAI;AACR,iBAAOA,IAAIF,EAAS,UAAQ;AACxB,kBAAMG,IAAKH,EAASE,CAAC,GACfE,IAAWF,MAAMF,EAAS,SAAS;AAEzC,gBAAIG,MAAO,WAAW;AAClB,cAAIC,KACAH,EAAK,QAAQ,KAAKV,EAAOC,CAAK,CAAC,GACnCU;AACA;AAAA,YACJ;AAOA,YAAK,OAAO,UAAU,eAAe,KAAKD,GAAME,CAAE,KAC9C,OAAO,eAAeF,GAAME,GAAI;AAAA,cAC5B,OAAO,EAAE,SAAS,GAAE;AAAA,cACpB,YAAY;AAAA,cACZ,UAAU;AAAA,cACV,cAAc;AAAA,YAC9C,CAA6B;AAEL,kBAAMlB,IAAOgB,EAAKE,CAAE;AACpB,YAAIC,KACAnB,EAAK,QAAQ,KAAKM,EAAOC,CAAK,CAAC,GAEnCS,IAAOhB,GACPiB;AAAA,UACJ;AAAA,QACJ;AAAA,MACJ;AAAA,EAER;AACA,SAAAL,EAAaP,CAAK,GACXG;AACX;","x_google_ignoreList":[0]}