@xyo-network/hash 5.2.24 → 5.2.25

package/dist/browser/worker/wasmHash-bundle.mjs

@@ -182,6 +182,7 @@
     objectClone: () => objectClone,
     omit: () => omit,
     optionalKeys: () => optionalKeys,
+    parsedType: () => parsedType,
     partial: () => partial,
     pick: () => pick,
     prefixIssues: () => prefixIssues,
@@ -514,6 +515,11 @@
   };
   function pick(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+      throw new Error(".pick() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
       get shape() {
         const newShape = {};
@@ -534,6 +540,11 @@
   }
   function omit(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+      throw new Error(".omit() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
       get shape() {
         const newShape = { ...schema._zod.def.shape };
@@ -559,15 +570,19 @@
     const checks = schema._zod.def.checks;
     const hasChecks = checks && checks.length > 0;
     if (hasChecks) {
-      throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+      const existingShape = schema._zod.def.shape;
+      for (const key in shape) {
+        if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
+          throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+        }
+      }
     }
     const def = mergeDefs(schema._zod.def, {
       get shape() {
         const _shape = { ...schema._zod.def.shape, ...shape };
         assignProp(this, "shape", _shape);
         return _shape;
-      },
-      checks: []
+      }
     });
     return clone(schema, def);
   }
@@ -575,15 +590,13 @@
     if (!isPlainObject(shape)) {
       throw new Error("Invalid input to safeExtend: expected a plain object");
     }
-    const def = {
-      ...schema._zod.def,
+    const def = mergeDefs(schema._zod.def, {
       get shape() {
         const _shape = { ...schema._zod.def.shape, ...shape };
         assignProp(this, "shape", _shape);
         return _shape;
-      },
-      checks: schema._zod.def.checks
-    };
+      }
+    });
     return clone(schema, def);
   }
   function merge(a, b) {
@@ -602,6 +615,12 @@
     return clone(a, def);
   }
   function partial(Class2, schema, mask) {
+    const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+      throw new Error(".partial() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
       get shape() {
         const oldShape = schema._zod.def.shape;
@@ -660,8 +679,7 @@
         }
         assignProp(this, "shape", shape);
         return shape;
-      },
-      checks: []
+      }
     });
     return clone(schema, def);
   }
@@ -715,6 +733,27 @@
       return "string";
     return "unknown";
   }
+  function parsedType(data) {
+    const t = typeof data;
+    switch (t) {
+      case "number": {
+        return Number.isNaN(data) ? "nan" : "number";
+      }
+      case "object": {
+        if (data === null) {
+          return "null";
+        }
+        if (Array.isArray(data)) {
+          return "array";
+        }
+        const obj = data;
+        if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+          return obj.constructor.name;
+        }
+      }
+    }
+    return t;
+  }
   function issue(...args) {
     const [iss, input, inst] = args;
     if (typeof iss === "string") {
@@ -793,10 +832,10 @@
   };
   var $ZodError = $constructor("$ZodError", initializer);
   var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
-  function flattenError(error46, mapper = (issue2) => issue2.message) {
+  function flattenError(error48, mapper = (issue2) => issue2.message) {
     const fieldErrors = {};
     const formErrors = [];
-    for (const sub of error46.issues) {
+    for (const sub of error48.issues) {
       if (sub.path.length > 0) {
         fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
         fieldErrors[sub.path[0]].push(mapper(sub));
@@ -806,10 +845,10 @@
     }
     return { formErrors, fieldErrors };
   }
-  function formatError(error46, mapper = (issue2) => issue2.message) {
+  function formatError(error48, mapper = (issue2) => issue2.message) {
     const fieldErrors = { _errors: [] };
-    const processError = (error47) => {
-      for (const issue2 of error47.issues) {
+    const processError = (error49) => {
+      for (const issue2 of error49.issues) {
         if (issue2.code === "invalid_union" && issue2.errors.length) {
           issue2.errors.map((issues) => processError({ issues }));
         } else if (issue2.code === "invalid_key") {
@@ -836,7 +875,7 @@
         }
       }
     };
-    processError(error46);
+    processError(error48);
     return fieldErrors;
   }
 
@@ -1019,7 +1058,7 @@
   var base64url = /^[A-Za-z0-9_-]*$/;
   var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
   var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
-  var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+  var e164 = /^\+[1-9]\d{6,14}$/;
   var dateSource = `(?:(?:\\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])))`;
   var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
   function timeSource(args) {
@@ -1046,7 +1085,7 @@
   };
   var bigint = /^-?\d+n?$/;
   var integer = /^-?\d+$/;
-  var number = /^-?\d+(?:\.\d+)?/;
+  var number = /^-?\d+(?:\.\d+)?$/;
   var boolean = /^(?:true|false)$/i;
   var _null = /^null$/i;
   var _undefined = /^undefined$/i;
@@ -1107,7 +1146,7 @@
       payload.issues.push({
         origin,
         code: "too_big",
-        maximum: def.value,
+        maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
         input: payload.value,
         inclusive: def.inclusive,
         inst,
@@ -1135,7 +1174,7 @@
       payload.issues.push({
         origin,
         code: "too_small",
-        minimum: def.value,
+        minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
         input: payload.value,
         inclusive: def.inclusive,
         inst,
@@ -1202,6 +1241,7 @@
               note: "Integers must be within the safe integer range.",
               inst,
               origin,
+              inclusive: true,
               continue: !def.abort
             });
           } else {
@@ -1212,6 +1252,7 @@
               note: "Integers must be within the safe integer range.",
               inst,
               origin,
+              inclusive: true,
               continue: !def.abort
             });
           }
@@ -1235,7 +1276,9 @@
           input,
           code: "too_big",
           maximum,
-          inst
+          inclusive: true,
+          inst,
+          continue: !def.abort
         });
       }
     };
@@ -1464,8 +1507,8 @@
   // ../../../../../../node_modules/zod/v4/core/versions.js
   var version = {
     major: 4,
-    minor: 2,
-    patch: 1
+    minor: 3,
+    patch: 5
   };
 
   // ../../../../../../node_modules/zod/v4/core/schemas.js
@@ -1565,7 +1608,7 @@
         return runChecks(result, checks, ctx);
       };
     }
-    inst["~standard"] = {
+    defineLazy(inst, "~standard", () => ({
       validate: (value) => {
         try {
           const r = safeParse(inst, value);
@@ -1576,7 +1619,7 @@
       },
       vendor: "zod",
       version: 1
-    };
+    }));
   });
   var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
     $ZodType.init(inst, def);
@@ -2082,11 +2125,34 @@
     return { valid: false, mergeErrorPath: [] };
   }
   function handleIntersectionResults(result, left, right) {
-    if (left.issues.length) {
-      result.issues.push(...left.issues);
+    const unrecKeys = /* @__PURE__ */ new Map();
+    let unrecIssue;
+    for (const iss of left.issues) {
+      if (iss.code === "unrecognized_keys") {
+        unrecIssue ?? (unrecIssue = iss);
+        for (const k of iss.keys) {
+          if (!unrecKeys.has(k))
+            unrecKeys.set(k, {});
+          unrecKeys.get(k).l = true;
+        }
+      } else {
+        result.issues.push(iss);
+      }
+    }
+    for (const iss of right.issues) {
+      if (iss.code === "unrecognized_keys") {
+        for (const k of iss.keys) {
+          if (!unrecKeys.has(k))
+            unrecKeys.set(k, {});
+          unrecKeys.get(k).r = true;
+        }
+      } else {
+        result.issues.push(iss);
+      }
     }
-    if (right.issues.length) {
-      result.issues.push(...right.issues);
+    const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+    if (bothKeys.length && unrecIssue) {
+      result.issues.push({ ...unrecIssue, keys: bothKeys });
     }
     if (aborted(result))
       return result;
@@ -2148,6 +2214,14 @@
       return def.innerType._zod.run(payload, ctx);
     };
   });
+  var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
+    $ZodOptional.init(inst, def);
+    defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+    defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
+    inst._zod.parse = (payload, ctx) => {
+      return def.innerType._zod.run(payload, ctx);
+    };
+  });
   var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
     $ZodType.init(inst, def);
     defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
@@ -2372,6 +2446,7 @@
     frCA: () => fr_CA_default,
     he: () => he_default,
     hu: () => hu_default,
+    hy: () => hy_default,
     id: () => id_default,
     is: () => is_default,
     it: () => it_default,
@@ -2398,6 +2473,7 @@
     ua: () => ua_default,
     uk: () => uk_default,
     ur: () => ur_default,
+    uz: () => uz_default,
     vi: () => vi_default,
     yo: () => yo_default,
     zhCN: () => zh_CN_default,
@@ -2415,27 +2491,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0645\u062F\u062E\u0644",
       email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A",
       url: "\u0631\u0627\u0628\u0637",
@@ -2465,10 +2521,20 @@
       jwt: "JWT",
       template_literal: "\u0645\u062F\u062E\u0644"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${issue2.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 instanceof ${issue2.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
+          }
+          return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${stringifyPrimitive(issue2.values[0])}`;
@@ -2498,7 +2564,7 @@
             return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`;
-          return `${Nouns[_issue.format] ?? issue2.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
         }
         case "not_multiple_of":
           return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue2.divisor}`;
@@ -2532,27 +2598,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "input",
       email: "email address",
       url: "URL",
@@ -2582,10 +2628,20 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${issue2.expected}, daxil olan ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n instanceof ${issue2.expected}, daxil olan ${received}`;
+          }
+          return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${expected}, daxil olan ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${stringifyPrimitive(issue2.values[0])}`;
@@ -2614,7 +2670,7 @@
             return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`;
           if (_issue.format === "regex")
             return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`;
-          return `Yanl\u0131\u015F ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Yanl\u0131\u015F ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Yanl\u0131\u015F \u0259d\u0259d: ${issue2.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`;
@@ -2691,27 +2747,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u043B\u0456\u043A";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u043C\u0430\u0441\u0456\u045E";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0443\u0432\u043E\u0434",
       email: "email \u0430\u0434\u0440\u0430\u0441",
       url: "URL",
@@ -2741,10 +2777,22 @@
       jwt: "JWT",
       template_literal: "\u0443\u0432\u043E\u0434"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u043B\u0456\u043A",
+      array: "\u043C\u0430\u0441\u0456\u045E"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${issue2.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F instanceof ${issue2.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
+          }
+          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`;
@@ -2779,7 +2827,7 @@
             return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
-          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`;
@@ -2803,26 +2851,6 @@
   }
 
   // ../../../../../../node_modules/zod/v4/locales/bg.js
-  var parsedType = (data) => {
-    const t = typeof data;
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "\u0447\u0438\u0441\u043B\u043E";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "\u043C\u0430\u0441\u0438\u0432";
-        }
-        if (data === null) {
-          return "null";
-        }
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
   var error4 = () => {
     const Sizable = {
       string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
@@ -2833,7 +2861,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0432\u0445\u043E\u0434",
       email: "\u0438\u043C\u0435\u0439\u043B \u0430\u0434\u0440\u0435\u0441",
       url: "URL",
@@ -2863,10 +2891,22 @@
       jwt: "JWT",
       template_literal: "\u0432\u0445\u043E\u0434"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0447\u0438\u0441\u043B\u043E",
+      array: "\u043C\u0430\u0441\u0438\u0432"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${parsedType(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
+          }
+          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${stringifyPrimitive(issue2.values[0])}`;
@@ -2908,7 +2948,7 @@
             invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
           if (_issue.format === "duration")
             invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
-          return `${invalid_adj} ${Nouns[_issue.format] ?? issue2.format}`;
+          return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E \u0447\u0438\u0441\u043B\u043E: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0431\u044A\u0434\u0435 \u043A\u0440\u0430\u0442\u043D\u043E \u043D\u0430 ${issue2.divisor}`;
@@ -2942,27 +2982,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "entrada",
       email: "adre\xE7a electr\xF2nica",
       url: "URL",
@@ -2992,11 +3012,20 @@
       jwt: "JWT",
       template_literal: "entrada"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Tipus inv\xE0lid: s'esperava ${issue2.expected}, s'ha rebut ${parsedType8(issue2.input)}`;
-        // return `Tipus invàlid: s'esperava ${issue.expected}, s'ha rebut ${util.getParsedType(issue.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Tipus inv\xE0lid: s'esperava instanceof ${issue2.expected}, s'ha rebut ${received}`;
+          }
+          return `Tipus inv\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Valor inv\xE0lid: s'esperava ${stringifyPrimitive(issue2.values[0])}`;
@@ -3027,7 +3056,7 @@
             return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`;
-          return `Format inv\xE0lid per a ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Format inv\xE0lid per a ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue2.divisor}`;
@@ -3062,45 +3091,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u010D\xEDslo";
-        }
-        case "string": {
-          return "\u0159et\u011Bzec";
-        }
-        case "boolean": {
-          return "boolean";
-        }
-        case "bigint": {
-          return "bigint";
-        }
-        case "function": {
-          return "funkce";
-        }
-        case "symbol": {
-          return "symbol";
-        }
-        case "undefined": {
-          return "undefined";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "pole";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "regul\xE1rn\xED v\xFDraz",
       email: "e-mailov\xE1 adresa",
       url: "URL",
@@ -3130,10 +3121,24 @@
       jwt: "JWT",
       template_literal: "vstup"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u010D\xEDslo",
+      string: "\u0159et\u011Bzec",
+      function: "funkce",
+      array: "pole"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${issue2.expected}, obdr\u017Eeno ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no instanceof ${issue2.expected}, obdr\u017Eeno ${received}`;
+          }
+          return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${expected}, obdr\u017Eeno ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${stringifyPrimitive(issue2.values[0])}`;
@@ -3164,7 +3169,7 @@
             return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`;
-          return `Neplatn\xFD form\xE1t ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Neplatn\xFD form\xE1t ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue2.divisor}`;
@@ -3195,43 +3200,10 @@
       array: { unit: "elementer", verb: "indeholdt" },
       set: { unit: "elementer", verb: "indeholdt" }
     };
-    const TypeNames = {
-      string: "streng",
-      number: "tal",
-      boolean: "boolean",
-      array: "liste",
-      object: "objekt",
-      set: "s\xE6t",
-      file: "fil"
-    };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    function getTypeName(type) {
-      return TypeNames[type] ?? type;
-    }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "tal";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "liste";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-          return "objekt";
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "input",
       email: "e-mailadresse",
       url: "URL",
@@ -3261,10 +3233,27 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      string: "streng",
+      number: "tal",
+      boolean: "boolean",
+      array: "liste",
+      object: "objekt",
+      set: "s\xE6t",
+      file: "fil"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Ugyldigt input: forventede ${getTypeName(issue2.expected)}, fik ${getTypeName(parsedType8(issue2.input))}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Ugyldigt input: forventede instanceof ${issue2.expected}, fik ${received}`;
+          }
+          return `Ugyldigt input: forventede ${expected}, fik ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Ugyldig v\xE6rdi: forventede ${stringifyPrimitive(issue2.values[0])}`;
@@ -3272,7 +3261,7 @@
         case "too_big": {
           const adj = issue2.inclusive ? "<=" : "<";
           const sizing = getSizing(issue2.origin);
-          const origin = getTypeName(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           if (sizing)
             return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "elementer"}`;
           return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue2.maximum.toString()}`;
@@ -3280,7 +3269,7 @@
         case "too_small": {
           const adj = issue2.inclusive ? ">=" : ">";
           const sizing = getSizing(issue2.origin);
-          const origin = getTypeName(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           if (sizing) {
             return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
           }
@@ -3296,7 +3285,7 @@
             return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Ugyldig streng: skal matche m\xF8nsteret ${_issue.pattern}`;
-          return `Ugyldig ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Ugyldigt tal: skal v\xE6re deleligt med ${issue2.divisor}`;
@@ -3330,27 +3319,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "Zahl";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "Array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "Eingabe",
       email: "E-Mail-Adresse",
       url: "URL",
@@ -3380,10 +3349,22 @@
       jwt: "JWT",
       template_literal: "Eingabe"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "Zahl",
+      array: "Array"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Ung\xFCltige Eingabe: erwartet ${issue2.expected}, erhalten ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Ung\xFCltige Eingabe: erwartet instanceof ${issue2.expected}, erhalten ${received}`;
+          }
+          return `Ung\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Ung\xFCltige Eingabe: erwartet ${stringifyPrimitive(issue2.values[0])}`;
@@ -3413,7 +3394,7 @@
             return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`;
           if (_issue.format === "regex")
             return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;
-          return `Ung\xFCltig: ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Ung\xFCltig: ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue2.divisor} sein`;
@@ -3437,37 +3418,18 @@
   }
 
   // ../../../../../../node_modules/zod/v4/locales/en.js
-  var parsedType2 = (data) => {
-    const t = typeof data;
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "number";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "array";
-        }
-        if (data === null) {
-          return "null";
-        }
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
   var error9 = () => {
     const Sizable = {
       string: { unit: "characters", verb: "to have" },
       file: { unit: "bytes", verb: "to have" },
       array: { unit: "items", verb: "to have" },
-      set: { unit: "items", verb: "to have" }
+      set: { unit: "items", verb: "to have" },
+      map: { unit: "entries", verb: "to have" }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
       regex: "input",
       email: "email address",
       url: "URL",
@@ -3498,10 +3460,19 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      // Compatibility: "nan" -> "NaN" for display
+      nan: "NaN"
+      // All other type names omitted - they fall back to raw values via ?? operator
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Invalid input: expected ${issue2.expected}, received ${parsedType2(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          return `Invalid input: expected ${expected}, received ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
@@ -3532,7 +3503,7 @@
             return `Invalid string: must include "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Invalid string: must match pattern ${_issue.pattern}`;
-          return `Invalid ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Invalid number: must be a multiple of ${issue2.divisor}`;
@@ -3556,26 +3527,6 @@
   }
 
   // ../../../../../../node_modules/zod/v4/locales/eo.js
-  var parsedType3 = (data) => {
-    const t = typeof data;
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "nombro";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "tabelo";
-        }
-        if (data === null) {
-          return "senvalora";
-        }
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
   var error10 = () => {
     const Sizable = {
       string: { unit: "karaktrojn", verb: "havi" },
@@ -3586,7 +3537,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
       regex: "enigo",
       email: "retadreso",
       url: "URL",
@@ -3616,10 +3567,23 @@
       jwt: "JWT",
       template_literal: "enigo"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "nombro",
+      array: "tabelo",
+      null: "senvalora"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Nevalida enigo: atendi\u011Dis ${issue2.expected}, ricevi\u011Dis ${parsedType3(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Nevalida enigo: atendi\u011Dis instanceof ${issue2.expected}, ricevi\u011Dis ${received}`;
+          }
+          return `Nevalida enigo: atendi\u011Dis ${expected}, ricevi\u011Dis ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive(issue2.values[0])}`;
@@ -3649,7 +3613,7 @@
             return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;
-          return `Nevalida ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Nevalida ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Nevalida nombro: devas esti oblo de ${issue2.divisor}`;
@@ -3680,60 +3644,10 @@
       array: { unit: "elementos", verb: "tener" },
       set: { unit: "elementos", verb: "tener" }
     };
-    const TypeNames = {
-      string: "texto",
-      number: "n\xFAmero",
-      boolean: "booleano",
-      array: "arreglo",
-      object: "objeto",
-      set: "conjunto",
-      file: "archivo",
-      date: "fecha",
-      bigint: "n\xFAmero grande",
-      symbol: "s\xEDmbolo",
-      undefined: "indefinido",
-      null: "nulo",
-      function: "funci\xF3n",
-      map: "mapa",
-      record: "registro",
-      tuple: "tupla",
-      enum: "enumeraci\xF3n",
-      union: "uni\xF3n",
-      literal: "literal",
-      promise: "promesa",
-      void: "vac\xEDo",
-      never: "nunca",
-      unknown: "desconocido",
-      any: "cualquiera"
-    };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    function getTypeName(type) {
-      return TypeNames[type] ?? type;
-    }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype) {
-            return data.constructor.name;
-          }
-          return "object";
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "entrada",
       email: "direcci\xF3n de correo electr\xF3nico",
       url: "URL",
@@ -3763,19 +3677,52 @@
       jwt: "JWT",
       template_literal: "entrada"
     };
-    return (issue2) => {
-      switch (issue2.code) {
-        case "invalid_type":
-          return `Entrada inv\xE1lida: se esperaba ${getTypeName(issue2.expected)}, recibido ${getTypeName(parsedType8(issue2.input))}`;
-        // return `Entrada inválida: se esperaba ${issue.expected}, recibido ${util.getParsedType(issue.input)}`;
-        case "invalid_value":
-          if (issue2.values.length === 1)
-            return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive(issue2.values[0])}`;
-          return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues(issue2.values, "|")}`;
+    const TypeDictionary = {
+      nan: "NaN",
+      string: "texto",
+      number: "n\xFAmero",
+      boolean: "booleano",
+      array: "arreglo",
+      object: "objeto",
+      set: "conjunto",
+      file: "archivo",
+      date: "fecha",
+      bigint: "n\xFAmero grande",
+      symbol: "s\xEDmbolo",
+      undefined: "indefinido",
+      null: "nulo",
+      function: "funci\xF3n",
+      map: "mapa",
+      record: "registro",
+      tuple: "tupla",
+      enum: "enumeraci\xF3n",
+      union: "uni\xF3n",
+      literal: "literal",
+      promise: "promesa",
+      void: "vac\xEDo",
+      never: "nunca",
+      unknown: "desconocido",
+      any: "cualquiera"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Entrada inv\xE1lida: se esperaba instanceof ${issue2.expected}, recibido ${received}`;
+          }
+          return `Entrada inv\xE1lida: se esperaba ${expected}, recibido ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive(issue2.values[0])}`;
+          return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues(issue2.values, "|")}`;
         case "too_big": {
           const adj = issue2.inclusive ? "<=" : "<";
           const sizing = getSizing(issue2.origin);
-          const origin = getTypeName(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           if (sizing)
             return `Demasiado grande: se esperaba que ${origin ?? "valor"} tuviera ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementos"}`;
           return `Demasiado grande: se esperaba que ${origin ?? "valor"} fuera ${adj}${issue2.maximum.toString()}`;
@@ -3783,7 +3730,7 @@
         case "too_small": {
           const adj = issue2.inclusive ? ">=" : ">";
           const sizing = getSizing(issue2.origin);
-          const origin = getTypeName(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           if (sizing) {
             return `Demasiado peque\xF1o: se esperaba que ${origin} tuviera ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
           }
@@ -3799,18 +3746,18 @@
             return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`;
-          return `Inv\xE1lido ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Inv\xE1lido ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue2.divisor}`;
         case "unrecognized_keys":
           return `Llave${issue2.keys.length > 1 ? "s" : ""} desconocida${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
         case "invalid_key":
-          return `Llave inv\xE1lida en ${getTypeName(issue2.origin)}`;
+          return `Llave inv\xE1lida en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
         case "invalid_union":
           return "Entrada inv\xE1lida";
         case "invalid_element":
-          return `Valor inv\xE1lido en ${getTypeName(issue2.origin)}`;
+          return `Valor inv\xE1lido en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
         default:
           return `Entrada inv\xE1lida`;
       }
@@ -3833,27 +3780,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u0639\u062F\u062F";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u0622\u0631\u0627\u06CC\u0647";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0648\u0631\u0648\u062F\u06CC",
       email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644",
       url: "URL",
@@ -3883,10 +3810,22 @@
       jwt: "JWT",
       template_literal: "\u0648\u0631\u0648\u062F\u06CC"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0639\u062F\u062F",
+      array: "\u0622\u0631\u0627\u06CC\u0647"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${issue2.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${parsedType8(issue2.input)} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A instanceof ${issue2.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
+          }
+          return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1) {
             return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${stringifyPrimitive(issue2.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`;
@@ -3922,7 +3861,7 @@
           if (_issue.format === "regex") {
             return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`;
           }
-          return `${Nouns[_issue.format] ?? issue2.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
         }
         case "not_multiple_of":
           return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue2.divisor} \u0628\u0627\u0634\u062F`;
@@ -3960,27 +3899,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "s\xE4\xE4nn\xF6llinen lauseke",
       email: "s\xE4hk\xF6postiosoite",
       url: "URL-osoite",
@@ -4010,10 +3929,20 @@
       jwt: "JWT",
       template_literal: "templaattimerkkijono"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Virheellinen tyyppi: odotettiin ${issue2.expected}, oli ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Virheellinen tyyppi: odotettiin instanceof ${issue2.expected}, oli ${received}`;
+          }
+          return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Virheellinen sy\xF6te: t\xE4ytyy olla ${stringifyPrimitive(issue2.values[0])}`;
@@ -4045,7 +3974,7 @@
           if (_issue.format === "regex") {
             return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`;
           }
-          return `Virheellinen ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Virheellinen ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Virheellinen luku: t\xE4ytyy olla luvun ${issue2.divisor} monikerta`;
@@ -4079,27 +4008,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "nombre";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "tableau";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "entr\xE9e",
       email: "adresse e-mail",
       url: "URL",
@@ -4129,10 +4038,22 @@
       jwt: "JWT",
       template_literal: "entr\xE9e"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "nombre",
+      array: "tableau"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Entr\xE9e invalide : ${issue2.expected} attendu, ${parsedType8(issue2.input)} re\xE7u`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Entr\xE9e invalide : instanceof ${issue2.expected} attendu, ${received} re\xE7u`;
+          }
+          return `Entr\xE9e invalide : ${expected} attendu, ${received} re\xE7u`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Entr\xE9e invalide : ${stringifyPrimitive(issue2.values[0])} attendu`;
@@ -4162,7 +4083,7 @@
             return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`;
-          return `${Nouns[_issue.format] ?? issue2.format} invalide`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;
         }
         case "not_multiple_of":
           return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`;
@@ -4196,27 +4117,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "entr\xE9e",
       email: "adresse courriel",
       url: "URL",
@@ -4246,10 +4147,20 @@
       jwt: "JWT",
       template_literal: "entr\xE9e"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Entr\xE9e invalide : attendu ${issue2.expected}, re\xE7u ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Entr\xE9e invalide : attendu instanceof ${issue2.expected}, re\xE7u ${received}`;
+          }
+          return `Entr\xE9e invalide : attendu ${expected}, re\xE7u ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Entr\xE9e invalide : attendu ${stringifyPrimitive(issue2.values[0])}`;
@@ -4280,7 +4191,7 @@
             return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;
-          return `${Nouns[_issue.format] ?? issue2.format} invalide`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;
         }
         case "not_multiple_of":
           return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`;
@@ -4351,26 +4262,7 @@
         return null;
       return Sizable[origin] ?? null;
     };
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number":
-          return Number.isNaN(data) ? "NaN" : "number";
-        case "object": {
-          if (Array.isArray(data))
-            return "array";
-          if (data === null)
-            return "null";
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-          return "object";
-        }
-        default:
-          return t;
-      }
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: { label: "\u05E7\u05DC\u05D8", gender: "m" },
       email: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", gender: "f" },
       url: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", gender: "f" },
@@ -4402,13 +4294,19 @@
       starts_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
       uppercase: { label: "\u05E7\u05DC\u05D8", gender: "m" }
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
         case "invalid_type": {
           const expectedKey = issue2.expected;
-          const expected = typeLabel(expectedKey);
-          const receivedKey = parsedType8(issue2.input);
-          const received = TypeNames[receivedKey]?.label ?? receivedKey;
+          const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel(expectedKey);
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue2.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
+          }
           return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
         }
         case "invalid_value": {
@@ -4481,7 +4379,7 @@
             return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
-          const nounEntry = Nouns[_issue.format];
+          const nounEntry = FormatDictionary[_issue.format];
           const noun = nounEntry?.label ?? _issue.format;
           const gender = nounEntry?.gender ?? "m";
           const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF";
@@ -4522,27 +4420,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "sz\xE1m";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "t\xF6mb";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "bemenet",
       email: "email c\xEDm",
       url: "URL",
@@ -4572,11 +4450,22 @@
       jwt: "JWT",
       template_literal: "bemenet"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "sz\xE1m",
+      array: "t\xF6mb"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${issue2.expected}, a kapott \xE9rt\xE9k ${parsedType8(issue2.input)}`;
-        // return `Invalid input: expected ${issue.expected}, received ${util.getParsedType(issue.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
+          }
+          return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
@@ -4606,7 +4495,7 @@
             return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
           if (_issue.format === "regex")
             return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`;
-          return `\xC9rv\xE9nytelen ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\xC9rv\xE9nytelen ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\xC9rv\xE9nytelen sz\xE1m: ${issue2.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`;
@@ -4629,38 +4518,166 @@
     };
   }
 
-  // ../../../../../../node_modules/zod/v4/locales/id.js
+  // ../../../../../../node_modules/zod/v4/locales/hy.js
+  function getArmenianPlural(count, one, many) {
+    return Math.abs(count) === 1 ? one : many;
+  }
+  function withDefiniteArticle(word) {
+    if (!word)
+      return "";
+    const vowels = ["\u0561", "\u0565", "\u0568", "\u056B", "\u0578", "\u0578\u0582", "\u0585"];
+    const lastChar = word[word.length - 1];
+    return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
+  }
   var error18 = () => {
     const Sizable = {
-      string: { unit: "karakter", verb: "memiliki" },
-      file: { unit: "byte", verb: "memiliki" },
-      array: { unit: "item", verb: "memiliki" },
-      set: { unit: "item", verb: "memiliki" }
+      string: {
+        unit: {
+          one: "\u0576\u0577\u0561\u0576",
+          many: "\u0576\u0577\u0561\u0576\u0576\u0565\u0580"
+        },
+        verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
+      },
+      file: {
+        unit: {
+          one: "\u0562\u0561\u0575\u0569",
+          many: "\u0562\u0561\u0575\u0569\u0565\u0580"
+        },
+        verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
+      },
+      array: {
+        unit: {
+          one: "\u057F\u0561\u0580\u0580",
+          many: "\u057F\u0561\u0580\u0580\u0565\u0580"
+        },
+        verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
+      },
+      set: {
+        unit: {
+          one: "\u057F\u0561\u0580\u0580",
+          many: "\u057F\u0561\u0580\u0580\u0565\u0580"
+        },
+        verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
+      }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
+    const FormatDictionary = {
+      regex: "\u0574\u0578\u0582\u057F\u0584",
+      email: "\u0567\u056C. \u0570\u0561\u057D\u0581\u0565",
+      url: "URL",
+      emoji: "\u0567\u0574\u0578\u057B\u056B",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E \u0587 \u056A\u0561\u0574",
+      date: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E",
+      time: "ISO \u056A\u0561\u0574",
+      duration: "ISO \u057F\u0587\u0578\u0572\u0578\u0582\u0569\u0575\u0578\u0582\u0576",
+      ipv4: "IPv4 \u0570\u0561\u057D\u0581\u0565",
+      ipv6: "IPv6 \u0570\u0561\u057D\u0581\u0565",
+      cidrv4: "IPv4 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
+      cidrv6: "IPv6 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
+      base64: "base64 \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
+      base64url: "base64url \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
+      json_string: "JSON \u057F\u0578\u0572",
+      e164: "E.164 \u0570\u0561\u0574\u0561\u0580",
+      jwt: "JWT",
+      template_literal: "\u0574\u0578\u0582\u057F\u0584"
+    };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0569\u056B\u057E",
+      array: "\u0566\u0561\u0576\u0563\u057E\u0561\u056E"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 instanceof ${issue2.expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
           }
-          if (data === null) {
-            return "null";
+          return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${stringifyPrimitive(issue2.values[1])}`;
+          return `\u054D\u056D\u0561\u056C \u057F\u0561\u0580\u0562\u0565\u0580\u0561\u056F\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 \u0570\u0565\u057F\u0587\u0575\u0561\u056C\u0576\u0565\u0580\u056B\u0581 \u0574\u0565\u056F\u0568\u055D ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          if (sizing) {
+            const maxValue = Number(issue2.maximum);
+            const unit = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many);
+            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.maximum.toString()} ${unit}`;
           }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
+          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          if (sizing) {
+            const minValue = Number(issue2.minimum);
+            const unit = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many);
+            return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.minimum.toString()} ${unit}`;
           }
+          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056C\u056B\u0576\u056B ${adj}${issue2.minimum.toString()}`;
+        }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with")
+            return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057D\u056F\u057D\u057E\u056B "${_issue.prefix}"-\u0578\u057E`;
+          if (_issue.format === "ends_with")
+            return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0561\u057E\u0561\u0580\u057F\u057E\u056B "${_issue.suffix}"-\u0578\u057E`;
+          if (_issue.format === "includes")
+            return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057A\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u056B "${_issue.includes}"`;
+          if (_issue.format === "regex")
+            return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0570\u0561\u0574\u0561\u057A\u0561\u057F\u0561\u057D\u056D\u0561\u0576\u056B ${_issue.pattern} \u0571\u0587\u0561\u0579\u0561\u0583\u056B\u0576`;
+          return `\u054D\u056D\u0561\u056C ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
+        case "not_multiple_of":
+          return `\u054D\u056D\u0561\u056C \u0569\u056B\u057E\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0562\u0561\u0566\u0574\u0561\u057A\u0561\u057F\u056B\u056F \u056C\u056B\u0576\u056B ${issue2.divisor}-\u056B`;
+        case "unrecognized_keys":
+          return `\u0549\u0573\u0561\u0576\u0561\u0579\u057E\u0561\u056E \u0562\u0561\u0576\u0561\u056C\u056B${issue2.keys.length > 1 ? "\u0576\u0565\u0580" : ""}. ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `\u054D\u056D\u0561\u056C \u0562\u0561\u0576\u0561\u056C\u056B ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`;
+        case "invalid_union":
+          return "\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574";
+        case "invalid_element":
+          return `\u054D\u056D\u0561\u056C \u0561\u0580\u056A\u0565\u0584 ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`;
+        default:
+          return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574`;
       }
-      return t;
     };
-    const Nouns = {
+  };
+  function hy_default() {
+    return {
+      localeError: error18()
+    };
+  }
+
+  // ../../../../../../node_modules/zod/v4/locales/id.js
+  var error19 = () => {
+    const Sizable = {
+      string: { unit: "karakter", verb: "memiliki" },
+      file: { unit: "byte", verb: "memiliki" },
+      array: { unit: "item", verb: "memiliki" },
+      set: { unit: "item", verb: "memiliki" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
       regex: "input",
       email: "alamat email",
       url: "URL",
@@ -4690,10 +4707,20 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Input tidak valid: diharapkan ${issue2.expected}, diterima ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Input tidak valid: diharapkan instanceof ${issue2.expected}, diterima ${received}`;
+          }
+          return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Input tidak valid: diharapkan ${stringifyPrimitive(issue2.values[0])}`;
@@ -4723,7 +4750,7 @@
             return `String tidak valid: harus menyertakan "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `String tidak valid: harus sesuai pola ${_issue.pattern}`;
-          return `${Nouns[_issue.format] ?? issue2.format} tidak valid`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} tidak valid`;
         }
         case "not_multiple_of":
           return `Angka tidak valid: harus kelipatan dari ${issue2.divisor}`;
@@ -4742,32 +4769,12 @@
   };
   function id_default() {
     return {
-      localeError: error18()
+      localeError: error19()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/is.js
-  var parsedType4 = (data) => {
-    const t = typeof data;
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "n\xFAmer";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "fylki";
-        }
-        if (data === null) {
-          return "null";
-        }
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
-  var error19 = () => {
+  var error20 = () => {
     const Sizable = {
       string: { unit: "stafi", verb: "a\xF0 hafa" },
       file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
@@ -4777,7 +4784,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
       regex: "gildi",
       email: "netfang",
       url: "vefsl\xF3\xF0",
@@ -4807,10 +4814,22 @@
       jwt: "JWT",
       template_literal: "gildi"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "n\xFAmer",
+      array: "fylki"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Rangt gildi: \xDE\xFA sl\xF3st inn ${parsedType4(issue2.input)} \xFEar sem \xE1 a\xF0 vera ${issue2.expected}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera instanceof ${issue2.expected}`;
+          }
+          return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera ${expected}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive(issue2.values[0])}`;
@@ -4841,7 +4860,7 @@
             return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`;
-          return `Rangt ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Rangt ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue2.divisor}`;
@@ -4860,12 +4879,12 @@
   };
   function is_default() {
     return {
-      localeError: error19()
+      localeError: error20()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/it.js
-  var error20 = () => {
+  var error21 = () => {
     const Sizable = {
       string: { unit: "caratteri", verb: "avere" },
       file: { unit: "byte", verb: "avere" },
@@ -4875,27 +4894,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "numero";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "vettore";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "input",
       email: "indirizzo email",
       url: "URL",
@@ -4925,11 +4924,22 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "numero",
+      array: "vettore"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Input non valido: atteso ${issue2.expected}, ricevuto ${parsedType8(issue2.input)}`;
-        // return `Input non valido: atteso ${issue.expected}, ricevuto ${util.getParsedType(issue.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Input non valido: atteso instanceof ${issue2.expected}, ricevuto ${received}`;
+          }
+          return `Input non valido: atteso ${expected}, ricevuto ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Input non valido: atteso ${stringifyPrimitive(issue2.values[0])}`;
@@ -4959,7 +4969,7 @@
             return `Stringa non valida: deve includere "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
-          return `Invalid ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
@@ -4978,12 +4988,12 @@
   };
   function it_default() {
     return {
-      localeError: error20()
+      localeError: error21()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ja.js
-  var error21 = () => {
+  var error22 = () => {
     const Sizable = {
       string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
       file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
@@ -4993,27 +5003,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u6570\u5024";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u914D\u5217";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u5165\u529B\u5024",
       email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9",
       url: "URL",
@@ -5043,10 +5033,22 @@
       jwt: "JWT",
       template_literal: "\u5165\u529B\u5024"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u6570\u5024",
+      array: "\u914D\u5217"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u7121\u52B9\u306A\u5165\u529B: ${issue2.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${parsedType8(issue2.input)}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u7121\u52B9\u306A\u5165\u529B: instanceof ${issue2.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
+          }
+          return `\u7121\u52B9\u306A\u5165\u529B: ${expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u7121\u52B9\u306A\u5165\u529B: ${stringifyPrimitive(issue2.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`;
@@ -5075,7 +5077,7 @@
             return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
           if (_issue.format === "regex")
             return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
-          return `\u7121\u52B9\u306A${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u7121\u52B9\u306A${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u7121\u52B9\u306A\u6570\u5024: ${issue2.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
@@ -5094,40 +5096,12 @@
   };
   function ja_default() {
     return {
-      localeError: error21()
+      localeError: error22()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ka.js
-  var parsedType5 = (data) => {
-    const t = typeof data;
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8";
-        }
-        if (data === null) {
-          return "null";
-        }
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    const typeMap = {
-      string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
-      boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
-      undefined: "undefined",
-      bigint: "bigint",
-      symbol: "symbol",
-      function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0"
-    };
-    return typeMap[t] ?? t;
-  };
-  var error22 = () => {
+  var error23 = () => {
     const Sizable = {
       string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
       file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
@@ -5137,7 +5111,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
       email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
       url: "URL",
@@ -5167,10 +5141,25 @@
       jwt: "JWT",
       template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
+      string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
+      boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
+      function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
+      array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${parsedType5(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 instanceof ${issue2.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
+          }
+          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive(issue2.values[0])}`;
@@ -5201,7 +5190,7 @@
             return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
           if (_issue.format === "regex")
             return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
-          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue2.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
@@ -5220,12 +5209,12 @@
   };
   function ka_default() {
     return {
-      localeError: error22()
+      localeError: error23()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/km.js
-  var error23 = () => {
+  var error24 = () => {
     const Sizable = {
       string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
       file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
@@ -5235,27 +5224,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "\u1798\u17B7\u1793\u1798\u17C2\u1793\u1787\u17B6\u179B\u17C1\u1781 (NaN)" : "\u179B\u17C1\u1781";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u17A2\u17B6\u179A\u17C1 (Array)";
-          }
-          if (data === null) {
-            return "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
       email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
       url: "URL",
@@ -5285,10 +5254,23 @@
       jwt: "JWT",
       template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u179B\u17C1\u1781",
+      array: "\u17A2\u17B6\u179A\u17C1 (Array)",
+      null: "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A instanceof ${issue2.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
+          }
+          return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive(issue2.values[0])}`;
@@ -5319,7 +5301,7 @@
             return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
-          return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue2.divisor}`;
@@ -5338,7 +5320,7 @@
   };
   function km_default() {
     return {
-      localeError: error23()
+      localeError: error24()
     };
   }
 
@@ -5348,37 +5330,17 @@
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ko.js
-  var error24 = () => {
+  var error25 = () => {
     const Sizable = {
       string: { unit: "\uBB38\uC790", verb: "to have" },
       file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
       array: { unit: "\uAC1C", verb: "to have" },
-      set: { unit: "\uAC1C", verb: "to have" }
-    };
-    function getSizing(origin) {
-      return Sizable[origin] ?? null;
-    }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
+      set: { unit: "\uAC1C", verb: "to have" }
     };
-    const Nouns = {
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
       regex: "\uC785\uB825",
       email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
       url: "URL",
@@ -5408,10 +5370,20 @@
       jwt: "JWT",
       template_literal: "\uC785\uB825"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${issue2.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${parsedType8(issue2.input)}\uC785\uB2C8\uB2E4`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 instanceof ${issue2.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
+          }
+          return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive(issue2.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
@@ -5446,7 +5418,7 @@
             return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
           if (_issue.format === "regex")
             return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
-          return `\uC798\uBABB\uB41C ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\uC798\uBABB\uB41C ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue2.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
@@ -5465,58 +5437,11 @@
   };
   function ko_default() {
     return {
-      localeError: error24()
+      localeError: error25()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/lt.js
-  var parsedType6 = (data) => {
-    const t = typeof data;
-    return parsedTypeFromType(t, data);
-  };
-  var parsedTypeFromType = (t, data = void 0) => {
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "skai\u010Dius";
-      }
-      case "bigint": {
-        return "sveikasis skai\u010Dius";
-      }
-      case "string": {
-        return "eilut\u0117";
-      }
-      case "boolean": {
-        return "login\u0117 reik\u0161m\u0117";
-      }
-      case "undefined":
-      case "void": {
-        return "neapibr\u0117\u017Eta reik\u0161m\u0117";
-      }
-      case "function": {
-        return "funkcija";
-      }
-      case "symbol": {
-        return "simbolis";
-      }
-      case "object": {
-        if (data === void 0)
-          return "ne\u017Einomas objektas";
-        if (data === null)
-          return "nulin\u0117 reik\u0161m\u0117";
-        if (Array.isArray(data))
-          return "masyvas";
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-        return "objektas";
-      }
-      //Zod types below
-      case "null": {
-        return "nulin\u0117 reik\u0161m\u0117";
-      }
-    }
-    return t;
-  };
   var capitalizeFirstCharacter = (text) => {
     return text.charAt(0).toUpperCase() + text.slice(1);
   };
@@ -5530,7 +5455,7 @@
       return "one";
     return "few";
   }
-  var error25 = () => {
+  var error26 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -5610,7 +5535,7 @@
         verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
       };
     }
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u012Fvestis",
       email: "el. pa\u0161to adresas",
       url: "URL",
@@ -5640,16 +5565,36 @@
       jwt: "JWT",
       template_literal: "\u012Fvestis"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "skai\u010Dius",
+      bigint: "sveikasis skai\u010Dius",
+      string: "eilut\u0117",
+      boolean: "login\u0117 reik\u0161m\u0117",
+      undefined: "neapibr\u0117\u017Eta reik\u0161m\u0117",
+      function: "funkcija",
+      symbol: "simbolis",
+      array: "masyvas",
+      object: "objektas",
+      null: "nulin\u0117 reik\u0161m\u0117"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Gautas tipas ${parsedType6(issue2.input)}, o tik\u0117tasi - ${parsedTypeFromType(issue2.expected)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Gautas tipas ${received}, o tik\u0117tasi - instanceof ${issue2.expected}`;
+          }
+          return `Gautas tipas ${received}, o tik\u0117tasi - ${expected}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Privalo b\u016Bti ${stringifyPrimitive(issue2.values[0])}`;
           return `Privalo b\u016Bti vienas i\u0161 ${joinValues(issue2.values, "|")} pasirinkim\u0173`;
         case "too_big": {
-          const origin = parsedTypeFromType(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.maximum)), issue2.inclusive ?? false, "smaller");
           if (sizing?.verb)
             return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue2.maximum.toString()} ${sizing.unit ?? "element\u0173"}`;
@@ -5657,7 +5602,7 @@
           return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue2.maximum.toString()} ${sizing?.unit}`;
         }
         case "too_small": {
-          const origin = parsedTypeFromType(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.minimum)), issue2.inclusive ?? false, "bigger");
           if (sizing?.verb)
             return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue2.minimum.toString()} ${sizing.unit ?? "element\u0173"}`;
@@ -5675,7 +5620,7 @@
             return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
-          return `Neteisingas ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Neteisingas ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Skai\u010Dius privalo b\u016Bti ${issue2.divisor} kartotinis.`;
@@ -5686,7 +5631,7 @@
         case "invalid_union":
           return "Klaidinga \u012Fvestis";
         case "invalid_element": {
-          const origin = parsedTypeFromType(issue2.origin);
+          const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
           return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
         }
         default:
@@ -5696,12 +5641,12 @@
   };
   function lt_default() {
     return {
-      localeError: error25()
+      localeError: error26()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/mk.js
-  var error26 = () => {
+  var error27 = () => {
     const Sizable = {
       string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
       file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
@@ -5711,27 +5656,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u0431\u0440\u043E\u0458";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u043D\u0438\u0437\u0430";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0432\u043D\u0435\u0441",
       email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
       url: "URL",
@@ -5761,11 +5686,22 @@
       jwt: "JWT",
       template_literal: "\u0432\u043D\u0435\u0441"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0431\u0440\u043E\u0458",
+      array: "\u043D\u0438\u0437\u0430"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${parsedType8(issue2.input)}`;
-        // return `Invalid input: expected ${issue.expected}, received ${util.getParsedType(issue.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 instanceof ${issue2.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
+          }
+          return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
@@ -5796,7 +5732,7 @@
             return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
-          return `Invalid ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue2.divisor}`;
@@ -5815,12 +5751,12 @@
   };
   function mk_default() {
     return {
-      localeError: error26()
+      localeError: error27()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ms.js
-  var error27 = () => {
+  var error28 = () => {
     const Sizable = {
       string: { unit: "aksara", verb: "mempunyai" },
       file: { unit: "bait", verb: "mempunyai" },
@@ -5830,27 +5766,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "nombor";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "input",
       email: "alamat e-mel",
       url: "URL",
@@ -5880,10 +5796,21 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "nombor"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Input tidak sah: dijangka ${issue2.expected}, diterima ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Input tidak sah: dijangka instanceof ${issue2.expected}, diterima ${received}`;
+          }
+          return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Input tidak sah: dijangka ${stringifyPrimitive(issue2.values[0])}`;
@@ -5913,7 +5840,7 @@
             return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
-          return `${Nouns[_issue.format] ?? issue2.format} tidak sah`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} tidak sah`;
         }
         case "not_multiple_of":
           return `Nombor tidak sah: perlu gandaan ${issue2.divisor}`;
@@ -5932,42 +5859,22 @@
   };
   function ms_default() {
     return {
-      localeError: error27()
+      localeError: error28()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/nl.js
-  var error28 = () => {
+  var error29 = () => {
     const Sizable = {
-      string: { unit: "tekens", verb: "te hebben" },
-      file: { unit: "bytes", verb: "te hebben" },
-      array: { unit: "elementen", verb: "te hebben" },
-      set: { unit: "elementen", verb: "te hebben" }
+      string: { unit: "tekens", verb: "heeft" },
+      file: { unit: "bytes", verb: "heeft" },
+      array: { unit: "elementen", verb: "heeft" },
+      set: { unit: "elementen", verb: "heeft" }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "getal";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "invoer",
       email: "emailadres",
       url: "URL",
@@ -5997,10 +5904,21 @@
       jwt: "JWT",
       template_literal: "invoer"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "getal"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Ongeldige invoer: verwacht ${issue2.expected}, ontving ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Ongeldige invoer: verwacht instanceof ${issue2.expected}, ontving ${received}`;
+          }
+          return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue2.values[0])}`;
@@ -6008,17 +5926,19 @@
         case "too_big": {
           const adj = issue2.inclusive ? "<=" : "<";
           const sizing = getSizing(issue2.origin);
+          const longName = issue2.origin === "date" ? "laat" : issue2.origin === "string" ? "lang" : "groot";
           if (sizing)
-            return `Te groot: verwacht dat ${issue2.origin ?? "waarde"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementen"}`;
-          return `Te groot: verwacht dat ${issue2.origin ?? "waarde"} ${adj}${issue2.maximum.toString()} is`;
+            return `Te ${longName}: verwacht dat ${issue2.origin ?? "waarde"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementen"} ${sizing.verb}`;
+          return `Te ${longName}: verwacht dat ${issue2.origin ?? "waarde"} ${adj}${issue2.maximum.toString()} is`;
         }
         case "too_small": {
           const adj = issue2.inclusive ? ">=" : ">";
           const sizing = getSizing(issue2.origin);
+          const shortName = issue2.origin === "date" ? "vroeg" : issue2.origin === "string" ? "kort" : "klein";
           if (sizing) {
-            return `Te klein: verwacht dat ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+            return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
           }
-          return `Te klein: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;
+          return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;
         }
         case "invalid_format": {
           const _issue = issue2;
@@ -6031,7 +5951,7 @@
             return `Ongeldige tekst: moet "${_issue.includes}" bevatten`;
           if (_issue.format === "regex")
             return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;
-          return `Ongeldig: ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Ongeldig: ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Ongeldig getal: moet een veelvoud van ${issue2.divisor} zijn`;
@@ -6050,12 +5970,12 @@
   };
   function nl_default() {
     return {
-      localeError: error28()
+      localeError: error29()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/no.js
-  var error29 = () => {
+  var error30 = () => {
     const Sizable = {
       string: { unit: "tegn", verb: "\xE5 ha" },
       file: { unit: "bytes", verb: "\xE5 ha" },
@@ -6065,27 +5985,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "tall";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "liste";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "input",
       email: "e-postadresse",
       url: "URL",
@@ -6115,10 +6015,22 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "tall",
+      array: "liste"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Ugyldig input: forventet ${issue2.expected}, fikk ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Ugyldig input: forventet instanceof ${issue2.expected}, fikk ${received}`;
+          }
+          return `Ugyldig input: forventet ${expected}, fikk ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Ugyldig verdi: forventet ${stringifyPrimitive(issue2.values[0])}`;
@@ -6148,7 +6060,7 @@
             return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
-          return `Ugyldig ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue2.divisor}`;
@@ -6167,12 +6079,12 @@
   };
   function no_default() {
     return {
-      localeError: error29()
+      localeError: error30()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ota.js
-  var error30 = () => {
+  var error31 = () => {
     const Sizable = {
       string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
       file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
@@ -6182,27 +6094,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "numara";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "saf";
-          }
-          if (data === null) {
-            return "gayb";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "giren",
       email: "epostag\xE2h",
       url: "URL",
@@ -6232,11 +6124,23 @@
       jwt: "JWT",
       template_literal: "giren"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "numara",
+      array: "saf",
+      null: "gayb"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `F\xE2sit giren: umulan ${issue2.expected}, al\u0131nan ${parsedType8(issue2.input)}`;
-        // return `Fâsit giren: umulan ${issue.expected}, alınan ${util.getParsedType(issue.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `F\xE2sit giren: umulan instanceof ${issue2.expected}, al\u0131nan ${received}`;
+          }
+          return `F\xE2sit giren: umulan ${expected}, al\u0131nan ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `F\xE2sit giren: umulan ${stringifyPrimitive(issue2.values[0])}`;
@@ -6266,7 +6170,7 @@
             return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
           if (_issue.format === "regex")
             return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
-          return `F\xE2sit ${Nouns[_issue.format] ?? issue2.format}`;
+          return `F\xE2sit ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `F\xE2sit say\u0131: ${issue2.divisor} kat\u0131 olmal\u0131yd\u0131.`;
@@ -6285,12 +6189,12 @@
   };
   function ota_default() {
     return {
-      localeError: error30()
+      localeError: error31()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ps.js
-  var error31 = () => {
+  var error32 = () => {
     const Sizable = {
       string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
       file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
@@ -6300,27 +6204,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u0639\u062F\u062F";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u0627\u0631\u06D0";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0648\u0631\u0648\u062F\u064A",
       email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9",
       url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644",
@@ -6350,10 +6234,22 @@
       jwt: "JWT",
       template_literal: "\u0648\u0631\u0648\u062F\u064A"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0639\u062F\u062F",
+      array: "\u0627\u0631\u06D0"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${issue2.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${parsedType8(issue2.input)} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F instanceof ${issue2.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
+          }
+          return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1) {
             return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${stringifyPrimitive(issue2.values[0])} \u0648\u0627\u06CC`;
@@ -6389,7 +6285,7 @@
           if (_issue.format === "regex") {
             return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`;
           }
-          return `${Nouns[_issue.format] ?? issue2.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
         }
         case "not_multiple_of":
           return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue2.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`;
@@ -6408,12 +6304,12 @@
   };
   function ps_default() {
     return {
-      localeError: error31()
+      localeError: error32()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/pl.js
-  var error32 = () => {
+  var error33 = () => {
     const Sizable = {
       string: { unit: "znak\xF3w", verb: "mie\u0107" },
       file: { unit: "bajt\xF3w", verb: "mie\u0107" },
@@ -6423,27 +6319,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "liczba";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "tablica";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "wyra\u017Cenie",
       email: "adres email",
       url: "URL",
@@ -6473,10 +6349,22 @@
       jwt: "JWT",
       template_literal: "wej\u015Bcie"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "liczba",
+      array: "tablica"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${issue2.expected}, otrzymano ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano instanceof ${issue2.expected}, otrzymano ${received}`;
+          }
+          return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive(issue2.values[0])}`;
@@ -6507,7 +6395,7 @@
             return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
-          return `Nieprawid\u0142ow(y/a/e) ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Nieprawid\u0142ow(y/a/e) ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue2.divisor}`;
@@ -6526,12 +6414,12 @@
   };
   function pl_default() {
     return {
-      localeError: error32()
+      localeError: error33()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/pt.js
-  var error33 = () => {
+  var error34 = () => {
     const Sizable = {
       string: { unit: "caracteres", verb: "ter" },
       file: { unit: "bytes", verb: "ter" },
@@ -6541,27 +6429,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "n\xFAmero";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "nulo";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "padr\xE3o",
       email: "endere\xE7o de e-mail",
       url: "URL",
@@ -6591,10 +6459,22 @@
       jwt: "JWT",
       template_literal: "entrada"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "n\xFAmero",
+      null: "nulo"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Tipo inv\xE1lido: esperado ${issue2.expected}, recebido ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Tipo inv\xE1lido: esperado instanceof ${issue2.expected}, recebido ${received}`;
+          }
+          return `Tipo inv\xE1lido: esperado ${expected}, recebido ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Entrada inv\xE1lida: esperado ${stringifyPrimitive(issue2.values[0])}`;
@@ -6624,7 +6504,7 @@
             return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
-          return `${Nouns[_issue.format] ?? issue2.format} inv\xE1lido`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} inv\xE1lido`;
         }
         case "not_multiple_of":
           return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
@@ -6643,7 +6523,7 @@
   };
   function pt_default() {
     return {
-      localeError: error33()
+      localeError: error34()
     };
   }
 
@@ -6663,7 +6543,7 @@
     }
     return many;
   }
-  var error34 = () => {
+  var error35 = () => {
     const Sizable = {
       string: {
         unit: {
@@ -6701,27 +6581,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u0447\u0438\u0441\u043B\u043E";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u043C\u0430\u0441\u0441\u0438\u0432";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0432\u0432\u043E\u0434",
       email: "email \u0430\u0434\u0440\u0435\u0441",
       url: "URL",
@@ -6751,10 +6611,22 @@
       jwt: "JWT",
       template_literal: "\u0432\u0432\u043E\u0434"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0447\u0438\u0441\u043B\u043E",
+      array: "\u043C\u0430\u0441\u0441\u0438\u0432"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
+          }
+          return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive(issue2.values[0])}`;
@@ -6789,7 +6661,7 @@
             return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
-          return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`;
@@ -6808,12 +6680,12 @@
   };
   function ru_default() {
     return {
-      localeError: error34()
+      localeError: error35()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/sl.js
-  var error35 = () => {
+  var error36 = () => {
     const Sizable = {
       string: { unit: "znakov", verb: "imeti" },
       file: { unit: "bajtov", verb: "imeti" },
@@ -6823,27 +6695,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u0161tevilo";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "tabela";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "vnos",
       email: "e-po\u0161tni naslov",
       url: "URL",
@@ -6873,10 +6725,22 @@
       jwt: "JWT",
       template_literal: "vnos"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0161tevilo",
+      array: "tabela"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Neveljaven vnos: pri\u010Dakovano ${issue2.expected}, prejeto ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Neveljaven vnos: pri\u010Dakovano instanceof ${issue2.expected}, prejeto ${received}`;
+          }
+          return `Neveljaven vnos: pri\u010Dakovano ${expected}, prejeto ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive(issue2.values[0])}`;
@@ -6907,7 +6771,7 @@
             return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
-          return `Neveljaven ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Neveljaven ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue2.divisor}`;
@@ -6926,12 +6790,12 @@
   };
   function sl_default() {
     return {
-      localeError: error35()
+      localeError: error36()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/sv.js
-  var error36 = () => {
+  var error37 = () => {
     const Sizable = {
       string: { unit: "tecken", verb: "att ha" },
       file: { unit: "bytes", verb: "att ha" },
@@ -6941,27 +6805,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "antal";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "lista";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "regulj\xE4rt uttryck",
       email: "e-postadress",
       url: "URL",
@@ -6991,10 +6835,22 @@
       jwt: "JWT",
       template_literal: "mall-literal"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "antal",
+      array: "lista"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Ogiltig inmatning: f\xF6rv\xE4ntat ${issue2.expected}, fick ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Ogiltig inmatning: f\xF6rv\xE4ntat instanceof ${issue2.expected}, fick ${received}`;
+          }
+          return `Ogiltig inmatning: f\xF6rv\xE4ntat ${expected}, fick ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive(issue2.values[0])}`;
@@ -7026,7 +6882,7 @@
             return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
-          return `Ogiltig(t) ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Ogiltig(t) ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue2.divisor}`;
@@ -7045,12 +6901,12 @@
   };
   function sv_default() {
     return {
-      localeError: error36()
+      localeError: error37()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ta.js
-  var error37 = () => {
+  var error38 = () => {
     const Sizable = {
       string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
       file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
@@ -7060,27 +6916,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "\u0B8E\u0BA3\u0BCD \u0B85\u0BB2\u0BCD\u0BB2\u0BBE\u0BA4\u0BA4\u0BC1" : "\u0B8E\u0BA3\u0BCD";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u0B85\u0BA3\u0BBF";
-          }
-          if (data === null) {
-            return "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
       email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
       url: "URL",
@@ -7110,10 +6946,23 @@
       jwt: "JWT",
       template_literal: "input"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0B8E\u0BA3\u0BCD",
+      array: "\u0B85\u0BA3\u0BBF",
+      null: "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 instanceof ${issue2.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
+          }
+          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive(issue2.values[0])}`;
@@ -7144,7 +6993,7 @@
             return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
           if (_issue.format === "regex")
             return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
-          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue2.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
@@ -7163,12 +7012,12 @@
   };
   function ta_default() {
     return {
-      localeError: error37()
+      localeError: error38()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/th.js
-  var error38 = () => {
+  var error39 = () => {
     const Sizable = {
       string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
       file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
@@ -7178,27 +7027,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "\u0E44\u0E21\u0E48\u0E43\u0E0A\u0E48\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02 (NaN)" : "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)";
-          }
-          if (data === null) {
-            return "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
       email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
       url: "URL",
@@ -7228,10 +7057,23 @@
       jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
       template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02",
+      array: "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)",
+      null: "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${issue2.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 instanceof ${issue2.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
+          }
+          return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive(issue2.values[0])}`;
@@ -7262,7 +7104,7 @@
             return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
           if (_issue.format === "regex")
             return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
-          return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue2.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
@@ -7281,32 +7123,12 @@
   };
   function th_default() {
     return {
-      localeError: error38()
-    };
-  }
-
-  // ../../../../../../node_modules/zod/v4/locales/tr.js
-  var parsedType7 = (data) => {
-    const t = typeof data;
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "number";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "array";
-        }
-        if (data === null) {
-          return "null";
-        }
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
-  var error39 = () => {
+      localeError: error39()
+    };
+  }
+
+  // ../../../../../../node_modules/zod/v4/locales/tr.js
+  var error40 = () => {
     const Sizable = {
       string: { unit: "karakter", verb: "olmal\u0131" },
       file: { unit: "bayt", verb: "olmal\u0131" },
@@ -7316,7 +7138,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
       regex: "girdi",
       email: "e-posta adresi",
       url: "URL",
@@ -7346,10 +7168,20 @@
       jwt: "JWT",
       template_literal: "\u015Eablon dizesi"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `Ge\xE7ersiz de\u011Fer: beklenen ${issue2.expected}, al\u0131nan ${parsedType7(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Ge\xE7ersiz de\u011Fer: beklenen instanceof ${issue2.expected}, al\u0131nan ${received}`;
+          }
+          return `Ge\xE7ersiz de\u011Fer: beklenen ${expected}, al\u0131nan ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive(issue2.values[0])}`;
@@ -7378,7 +7210,7 @@
             return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
           if (_issue.format === "regex")
             return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
-          return `Ge\xE7ersiz ${Nouns[_issue.format] ?? issue2.format}`;
+          return `Ge\xE7ersiz ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `Ge\xE7ersiz say\u0131: ${issue2.divisor} ile tam b\xF6l\xFCnebilmeli`;
@@ -7397,12 +7229,12 @@
   };
   function tr_default() {
     return {
-      localeError: error39()
+      localeError: error40()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/uk.js
-  var error40 = () => {
+  var error41 = () => {
     const Sizable = {
       string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
       file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
@@ -7412,27 +7244,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u0447\u0438\u0441\u043B\u043E";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u043C\u0430\u0441\u0438\u0432";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
       email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
       url: "URL",
@@ -7462,11 +7274,22 @@
       jwt: "JWT",
       template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0447\u0438\u0441\u043B\u043E",
+      array: "\u043C\u0430\u0441\u0438\u0432"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${issue2.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${parsedType8(issue2.input)}`;
-        // return `Неправильні вхідні дані: очікується ${issue.expected}, отримано ${util.getParsedType(issue.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F instanceof ${issue2.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
+          }
+          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`;
@@ -7496,7 +7319,7 @@
             return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
-          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue2.divisor}`;
@@ -7515,7 +7338,7 @@
   };
   function uk_default() {
     return {
-      localeError: error40()
+      localeError: error41()
     };
   }
 
@@ -7525,7 +7348,7 @@
   }
 
   // ../../../../../../node_modules/zod/v4/locales/ur.js
-  var error41 = () => {
+  var error42 = () => {
     const Sizable = {
       string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
       file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
@@ -7535,27 +7358,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "\u0646\u0645\u0628\u0631";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u0622\u0631\u06D2";
-          }
-          if (data === null) {
-            return "\u0646\u0644";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u0627\u0646 \u067E\u0679",
       email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
       url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
@@ -7585,10 +7388,23 @@
       jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
       template_literal: "\u0627\u0646 \u067E\u0679"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u0646\u0645\u0628\u0631",
+      array: "\u0622\u0631\u06D2",
+      null: "\u0646\u0644"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${issue2.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${parsedType8(issue2.input)} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: instanceof ${issue2.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
+          }
+          return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive(issue2.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
@@ -7619,7 +7435,7 @@
             return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
           if (_issue.format === "regex")
             return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
-          return `\u063A\u0644\u0637 ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u063A\u0644\u0637 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue2.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
@@ -7638,42 +7454,132 @@
   };
   function ur_default() {
     return {
-      localeError: error41()
+      localeError: error42()
     };
   }
 
-  // ../../../../../../node_modules/zod/v4/locales/vi.js
-  var error42 = () => {
+  // ../../../../../../node_modules/zod/v4/locales/uz.js
+  var error43 = () => {
     const Sizable = {
-      string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
-      file: { unit: "byte", verb: "c\xF3" },
-      array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
-      set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
+      string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
+      file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
+      array: { unit: "element", verb: "bo\u2018lishi kerak" },
+      set: { unit: "element", verb: "bo\u2018lishi kerak" }
     };
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "s\u1ED1";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "m\u1EA3ng";
-          }
-          if (data === null) {
-            return "null";
+    const FormatDictionary = {
+      regex: "kirish",
+      email: "elektron pochta manzili",
+      url: "URL",
+      emoji: "emoji",
+      uuid: "UUID",
+      uuidv4: "UUIDv4",
+      uuidv6: "UUIDv6",
+      nanoid: "nanoid",
+      guid: "GUID",
+      cuid: "cuid",
+      cuid2: "cuid2",
+      ulid: "ULID",
+      xid: "XID",
+      ksuid: "KSUID",
+      datetime: "ISO sana va vaqti",
+      date: "ISO sana",
+      time: "ISO vaqt",
+      duration: "ISO davomiylik",
+      ipv4: "IPv4 manzil",
+      ipv6: "IPv6 manzil",
+      mac: "MAC manzil",
+      cidrv4: "IPv4 diapazon",
+      cidrv6: "IPv6 diapazon",
+      base64: "base64 kodlangan satr",
+      base64url: "base64url kodlangan satr",
+      json_string: "JSON satr",
+      e164: "E.164 raqam",
+      jwt: "JWT",
+      template_literal: "kirish"
+    };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "raqam",
+      array: "massiv"
+    };
+    return (issue2) => {
+      switch (issue2.code) {
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `Noto\u2018g\u2018ri kirish: kutilgan instanceof ${issue2.expected}, qabul qilingan ${received}`;
           }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
+          return `Noto\u2018g\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;
+        }
+        case "invalid_value":
+          if (issue2.values.length === 1)
+            return `Noto\u2018g\u2018ri kirish: kutilgan ${stringifyPrimitive(issue2.values[0])}`;
+          return `Noto\u2018g\u2018ri variant: quyidagilardan biri kutilgan ${joinValues(issue2.values, "|")}`;
+        case "too_big": {
+          const adj = issue2.inclusive ? "<=" : "<";
+          const sizing = getSizing(issue2.origin);
+          if (sizing)
+            return `Juda katta: kutilgan ${issue2.origin ?? "qiymat"} ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
+          return `Juda katta: kutilgan ${issue2.origin ?? "qiymat"} ${adj}${issue2.maximum.toString()}`;
+        }
+        case "too_small": {
+          const adj = issue2.inclusive ? ">=" : ">";
+          const sizing = getSizing(issue2.origin);
+          if (sizing) {
+            return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
           }
+          return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
         }
+        case "invalid_format": {
+          const _issue = issue2;
+          if (_issue.format === "starts_with")
+            return `Noto\u2018g\u2018ri satr: "${_issue.prefix}" bilan boshlanishi kerak`;
+          if (_issue.format === "ends_with")
+            return `Noto\u2018g\u2018ri satr: "${_issue.suffix}" bilan tugashi kerak`;
+          if (_issue.format === "includes")
+            return `Noto\u2018g\u2018ri satr: "${_issue.includes}" ni o\u2018z ichiga olishi kerak`;
+          if (_issue.format === "regex")
+            return `Noto\u2018g\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;
+          return `Noto\u2018g\u2018ri ${FormatDictionary[_issue.format] ?? issue2.format}`;
+        }
+        case "not_multiple_of":
+          return `Noto\u2018g\u2018ri raqam: ${issue2.divisor} ning karralisi bo\u2018lishi kerak`;
+        case "unrecognized_keys":
+          return `Noma\u2019lum kalit${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
+        case "invalid_key":
+          return `${issue2.origin} dagi kalit noto\u2018g\u2018ri`;
+        case "invalid_union":
+          return "Noto\u2018g\u2018ri kirish";
+        case "invalid_element":
+          return `${issue2.origin} da noto\u2018g\u2018ri qiymat`;
+        default:
+          return `Noto\u2018g\u2018ri kirish`;
       }
-      return t;
     };
-    const Nouns = {
+  };
+  function uz_default() {
+    return {
+      localeError: error43()
+    };
+  }
+
+  // ../../../../../../node_modules/zod/v4/locales/vi.js
+  var error44 = () => {
+    const Sizable = {
+      string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
+      file: { unit: "byte", verb: "c\xF3" },
+      array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
+      set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
+    };
+    function getSizing(origin) {
+      return Sizable[origin] ?? null;
+    }
+    const FormatDictionary = {
       regex: "\u0111\u1EA7u v\xE0o",
       email: "\u0111\u1ECBa ch\u1EC9 email",
       url: "URL",
@@ -7703,10 +7609,22 @@
       jwt: "JWT",
       template_literal: "\u0111\u1EA7u v\xE0o"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "s\u1ED1",
+      array: "m\u1EA3ng"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${issue2.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i instanceof ${issue2.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
+          }
+          return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive(issue2.values[0])}`;
@@ -7736,7 +7654,7 @@
             return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
-          return `${Nouns[_issue.format] ?? issue2.format} kh\xF4ng h\u1EE3p l\u1EC7`;
+          return `${FormatDictionary[_issue.format] ?? issue2.format} kh\xF4ng h\u1EE3p l\u1EC7`;
         }
         case "not_multiple_of":
           return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue2.divisor}`;
@@ -7755,12 +7673,12 @@
   };
   function vi_default() {
     return {
-      localeError: error42()
+      localeError: error44()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/zh-CN.js
-  var error43 = () => {
+  var error45 = () => {
     const Sizable = {
       string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
       file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
@@ -7770,27 +7688,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "\u975E\u6570\u5B57(NaN)" : "\u6570\u5B57";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "\u6570\u7EC4";
-          }
-          if (data === null) {
-            return "\u7A7A\u503C(null)";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u8F93\u5165",
       email: "\u7535\u5B50\u90AE\u4EF6",
       url: "URL",
@@ -7820,10 +7718,23 @@
       jwt: "JWT",
       template_literal: "\u8F93\u5165"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "\u6570\u5B57",
+      array: "\u6570\u7EC4",
+      null: "\u7A7A\u503C(null)"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${issue2.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B instanceof ${issue2.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
+          }
+          return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive(issue2.values[0])}`;
@@ -7853,7 +7764,7 @@
             return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
-          return `\u65E0\u6548${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u65E0\u6548${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue2.divisor} \u7684\u500D\u6570`;
@@ -7872,12 +7783,12 @@
   };
   function zh_CN_default() {
     return {
-      localeError: error43()
+      localeError: error45()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/zh-TW.js
-  var error44 = () => {
+  var error46 = () => {
     const Sizable = {
       string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
       file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
@@ -7887,27 +7798,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "number";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "array";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u8F38\u5165",
       email: "\u90F5\u4EF6\u5730\u5740",
       url: "URL",
@@ -7937,10 +7828,20 @@
       jwt: "JWT",
       template_literal: "\u8F38\u5165"
     };
+    const TypeDictionary = {
+      nan: "NaN"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${issue2.expected}\uFF0C\u4F46\u6536\u5230 ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA instanceof ${issue2.expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
+          }
+          return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive(issue2.values[0])}`;
@@ -7971,7 +7872,7 @@
             return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
-          return `\u7121\u6548\u7684 ${Nouns[_issue.format] ?? issue2.format}`;
+          return `\u7121\u6548\u7684 ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue2.divisor} \u7684\u500D\u6578`;
@@ -7990,12 +7891,12 @@
   };
   function zh_TW_default() {
     return {
-      localeError: error44()
+      localeError: error46()
     };
   }
 
   // ../../../../../../node_modules/zod/v4/locales/yo.js
-  var error45 = () => {
+  var error47 = () => {
     const Sizable = {
       string: { unit: "\xE0mi", verb: "n\xED" },
       file: { unit: "bytes", verb: "n\xED" },
@@ -8005,27 +7906,7 @@
     function getSizing(origin) {
       return Sizable[origin] ?? null;
     }
-    const parsedType8 = (data) => {
-      const t = typeof data;
-      switch (t) {
-        case "number": {
-          return Number.isNaN(data) ? "NaN" : "n\u1ECD\u0301mb\xE0";
-        }
-        case "object": {
-          if (Array.isArray(data)) {
-            return "akop\u1ECD";
-          }
-          if (data === null) {
-            return "null";
-          }
-          if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-            return data.constructor.name;
-          }
-        }
-      }
-      return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
       regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9",
       email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC",
       url: "URL",
@@ -8055,10 +7936,22 @@
       jwt: "JWT",
       template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9"
     };
+    const TypeDictionary = {
+      nan: "NaN",
+      number: "n\u1ECD\u0301mb\xE0",
+      array: "akop\u1ECD"
+    };
     return (issue2) => {
       switch (issue2.code) {
-        case "invalid_type":
-          return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${issue2.expected}, \xE0m\u1ECD\u0300 a r\xED ${parsedType8(issue2.input)}`;
+        case "invalid_type": {
+          const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
+          const receivedType = parsedType(issue2.input);
+          const received = TypeDictionary[receivedType] ?? receivedType;
+          if (/^[A-Z]/.test(issue2.expected)) {
+            return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi instanceof ${issue2.expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
+          }
+          return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
+        }
         case "invalid_value":
           if (issue2.values.length === 1)
             return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${stringifyPrimitive(issue2.values[0])}`;
@@ -8087,7 +7980,7 @@
             return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`;
           if (_issue.format === "regex")
             return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`;
-          return `A\u1E63\xEC\u1E63e: ${Nouns[_issue.format] ?? issue2.format}`;
+          return `A\u1E63\xEC\u1E63e: ${FormatDictionary[_issue.format] ?? issue2.format}`;
         }
         case "not_multiple_of":
           return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue2.divisor}`;
@@ -8106,7 +7999,7 @@
   };
   function yo_default() {
     return {
-      localeError: error45()
+      localeError: error47()
     };
   }
 
@@ -8121,9 +8014,6 @@
       const meta2 = _meta[0];
       this._map.set(schema, meta2);
       if (meta2 && typeof meta2 === "object" && "id" in meta2) {
-        if (this._idmap.has(meta2.id)) {
-          throw new Error(`ID ${meta2.id} already exists in the registry`);
-        }
         this._idmap.set(meta2.id, schema);
       }
       return this;
@@ -8162,12 +8052,14 @@
   var globalRegistry = globalThis.__zod_globalRegistry;
 
   // ../../../../../../node_modules/zod/v4/core/api.js
+  // @__NO_SIDE_EFFECTS__
   function _string(Class2, params) {
     return new Class2({
       type: "string",
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _email(Class2, params) {
     return new Class2({
       type: "string",
@@ -8177,6 +8069,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _guid(Class2, params) {
     return new Class2({
       type: "string",
@@ -8186,6 +8079,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _uuid(Class2, params) {
     return new Class2({
       type: "string",
@@ -8195,6 +8089,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _uuidv4(Class2, params) {
     return new Class2({
       type: "string",
@@ -8205,6 +8100,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _uuidv6(Class2, params) {
     return new Class2({
       type: "string",
@@ -8215,6 +8111,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _uuidv7(Class2, params) {
     return new Class2({
       type: "string",
@@ -8225,6 +8122,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _url(Class2, params) {
     return new Class2({
       type: "string",
@@ -8234,6 +8132,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _emoji2(Class2, params) {
     return new Class2({
       type: "string",
@@ -8243,6 +8142,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _nanoid(Class2, params) {
     return new Class2({
       type: "string",
@@ -8252,6 +8152,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _cuid(Class2, params) {
     return new Class2({
       type: "string",
@@ -8261,6 +8162,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _cuid2(Class2, params) {
     return new Class2({
       type: "string",
@@ -8270,6 +8172,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _ulid(Class2, params) {
     return new Class2({
       type: "string",
@@ -8279,6 +8182,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _xid(Class2, params) {
     return new Class2({
       type: "string",
@@ -8288,6 +8192,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _ksuid(Class2, params) {
     return new Class2({
       type: "string",
@@ -8297,6 +8202,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _ipv4(Class2, params) {
     return new Class2({
       type: "string",
@@ -8306,6 +8212,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _ipv6(Class2, params) {
     return new Class2({
       type: "string",
@@ -8315,6 +8222,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _cidrv4(Class2, params) {
     return new Class2({
       type: "string",
@@ -8324,6 +8232,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _cidrv6(Class2, params) {
     return new Class2({
       type: "string",
@@ -8333,6 +8242,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _base64(Class2, params) {
     return new Class2({
       type: "string",
@@ -8342,6 +8252,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _base64url(Class2, params) {
     return new Class2({
       type: "string",
@@ -8351,6 +8262,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _e164(Class2, params) {
     return new Class2({
       type: "string",
@@ -8360,6 +8272,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _jwt(Class2, params) {
     return new Class2({
       type: "string",
@@ -8369,6 +8282,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _isoDateTime(Class2, params) {
     return new Class2({
       type: "string",
@@ -8380,6 +8294,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _isoDate(Class2, params) {
     return new Class2({
       type: "string",
@@ -8388,6 +8303,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _isoTime(Class2, params) {
     return new Class2({
       type: "string",
@@ -8397,6 +8313,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _isoDuration(Class2, params) {
     return new Class2({
       type: "string",
@@ -8405,6 +8322,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _number(Class2, params) {
     return new Class2({
       type: "number",
@@ -8412,6 +8330,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _int(Class2, params) {
     return new Class2({
       type: "number",
@@ -8421,12 +8340,14 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _bigint(Class2, params) {
     return new Class2({
       type: "bigint",
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _lt(value, params) {
     return new $ZodCheckLessThan({
       check: "less_than",
@@ -8435,6 +8356,7 @@
       inclusive: false
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _lte(value, params) {
     return new $ZodCheckLessThan({
       check: "less_than",
@@ -8443,6 +8365,7 @@
       inclusive: true
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _gt(value, params) {
     return new $ZodCheckGreaterThan({
       check: "greater_than",
@@ -8451,6 +8374,7 @@
       inclusive: false
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _gte(value, params) {
     return new $ZodCheckGreaterThan({
       check: "greater_than",
@@ -8459,6 +8383,7 @@
       inclusive: true
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _multipleOf(value, params) {
     return new $ZodCheckMultipleOf({
       check: "multiple_of",
@@ -8466,6 +8391,7 @@
       value
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _maxLength(maximum, params) {
     const ch = new $ZodCheckMaxLength({
       check: "max_length",
@@ -8474,6 +8400,7 @@
     });
     return ch;
   }
+  // @__NO_SIDE_EFFECTS__
   function _minLength(minimum, params) {
     return new $ZodCheckMinLength({
       check: "min_length",
@@ -8481,6 +8408,7 @@
       minimum
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _length(length, params) {
     return new $ZodCheckLengthEquals({
       check: "length_equals",
@@ -8488,6 +8416,7 @@
       length
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _regex(pattern, params) {
     return new $ZodCheckRegex({
       check: "string_format",
@@ -8496,6 +8425,7 @@
       pattern
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _lowercase(params) {
     return new $ZodCheckLowerCase({
       check: "string_format",
@@ -8503,6 +8433,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _uppercase(params) {
     return new $ZodCheckUpperCase({
       check: "string_format",
@@ -8510,6 +8441,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _includes(includes, params) {
     return new $ZodCheckIncludes({
       check: "string_format",
@@ -8518,6 +8450,7 @@
       includes
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _startsWith(prefix, params) {
     return new $ZodCheckStartsWith({
       check: "string_format",
@@ -8526,6 +8459,7 @@
       prefix
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _endsWith(suffix, params) {
     return new $ZodCheckEndsWith({
       check: "string_format",
@@ -8534,27 +8468,34 @@
       suffix
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _overwrite(tx) {
     return new $ZodCheckOverwrite({
       check: "overwrite",
       tx
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _normalize(form) {
-    return _overwrite((input) => input.normalize(form));
+    return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
   }
+  // @__NO_SIDE_EFFECTS__
   function _trim() {
-    return _overwrite((input) => input.trim());
+    return /* @__PURE__ */ _overwrite((input) => input.trim());
   }
+  // @__NO_SIDE_EFFECTS__
   function _toLowerCase() {
-    return _overwrite((input) => input.toLowerCase());
+    return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
   }
+  // @__NO_SIDE_EFFECTS__
   function _toUpperCase() {
-    return _overwrite((input) => input.toUpperCase());
+    return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
   }
+  // @__NO_SIDE_EFFECTS__
   function _slugify() {
-    return _overwrite((input) => slugify(input));
+    return /* @__PURE__ */ _overwrite((input) => slugify(input));
   }
+  // @__NO_SIDE_EFFECTS__
   function _array(Class2, element, params) {
     return new Class2({
       type: "array",
@@ -8565,6 +8506,7 @@
       ...normalizeParams(params)
     });
   }
+  // @__NO_SIDE_EFFECTS__
   function _refine(Class2, fn, _params) {
     const schema = new Class2({
       type: "custom",
@@ -8574,8 +8516,9 @@
     });
     return schema;
   }
+  // @__NO_SIDE_EFFECTS__
   function _superRefine(fn) {
-    const ch = _check((payload) => {
+    const ch = /* @__PURE__ */ _check((payload) => {
       payload.addIssue = (issue2) => {
         if (typeof issue2 === "string") {
           payload.issues.push(issue(issue2, payload.value, ch._zod.def));
@@ -8594,6 +8537,7 @@
     });
     return ch;
   }
+  // @__NO_SIDE_EFFECTS__
   function _check(fn, params) {
     const ch = new $ZodCheck({
       check: "custom",
@@ -8648,12 +8592,7 @@
         schemaPath: [..._params.schemaPath, schema],
         path: _params.path
       };
-      const parent = schema._zod.parent;
-      if (parent) {
-        result.ref = parent;
-        process2(parent, ctx, params);
-        ctx.seen.get(parent).isParent = true;
-      } else if (schema._zod.processJSONSchema) {
+      if (schema._zod.processJSONSchema) {
         schema._zod.processJSONSchema(ctx, result.schema, params);
       } else {
         const _json = result.schema;
@@ -8663,6 +8602,13 @@
         }
         processor(schema, ctx, _json, params);
       }
+      const parent = schema._zod.parent;
+      if (parent) {
+        if (!result.ref)
+          result.ref = parent;
+        process2(parent, ctx, params);
+        ctx.seen.get(parent).isParent = true;
+      }
     }
     const meta2 = ctx.metadataRegistry.get(schema);
     if (meta2)
@@ -8681,6 +8627,17 @@
     const root = ctx.seen.get(schema);
     if (!root)
       throw new Error("Unprocessed schema. This is a bug in Zod.");
+    const idToSchema = /* @__PURE__ */ new Map();
+    for (const entry of ctx.seen.entries()) {
+      const id = ctx.metadataRegistry.get(entry[0])?.id;
+      if (id) {
+        const existing = idToSchema.get(id);
+        if (existing && existing !== entry[0]) {
+          throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+        }
+        idToSchema.set(id, entry[0]);
+      }
+    }
     const makeURI = (entry) => {
       const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
       if (ctx.external) {
@@ -8762,30 +8719,65 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       throw new Error("Unprocessed schema. This is a bug in Zod.");
     const flattenRef = (zodSchema) => {
       const seen = ctx.seen.get(zodSchema);
+      if (seen.ref === null)
+        return;
       const schema2 = seen.def ?? seen.schema;
       const _cached = { ...schema2 };
-      if (seen.ref === null) {
-        return;
-      }
       const ref = seen.ref;
       seen.ref = null;
       if (ref) {
         flattenRef(ref);
-        const refSchema = ctx.seen.get(ref).schema;
+        const refSeen = ctx.seen.get(ref);
+        const refSchema = refSeen.schema;
         if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
           schema2.allOf = schema2.allOf ?? [];
           schema2.allOf.push(refSchema);
         } else {
           Object.assign(schema2, refSchema);
-          Object.assign(schema2, _cached);
+        }
+        Object.assign(schema2, _cached);
+        const isParentRef = zodSchema._zod.parent === ref;
+        if (isParentRef) {
+          for (const key in schema2) {
+            if (key === "$ref" || key === "allOf")
+              continue;
+            if (!(key in _cached)) {
+              delete schema2[key];
+            }
+          }
+        }
+        if (refSchema.$ref) {
+          for (const key in schema2) {
+            if (key === "$ref" || key === "allOf")
+              continue;
+            if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
+              delete schema2[key];
+            }
+          }
         }
       }
-      if (!seen.isParent)
-        ctx.override({
-          zodSchema,
-          jsonSchema: schema2,
-          path: seen.path ?? []
-        });
+      const parent = zodSchema._zod.parent;
+      if (parent && parent !== ref) {
+        flattenRef(parent);
+        const parentSeen = ctx.seen.get(parent);
+        if (parentSeen?.schema.$ref) {
+          schema2.$ref = parentSeen.schema.$ref;
+          if (parentSeen.def) {
+            for (const key in schema2) {
+              if (key === "$ref" || key === "allOf")
+                continue;
+              if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
+                delete schema2[key];
+              }
+            }
+          }
+        }
+      }
+      ctx.override({
+        zodSchema,
+        jsonSchema: schema2,
+        path: seen.path ?? []
+      });
     };
     for (const entry of [...ctx.seen.entries()].reverse()) {
       flattenRef(entry[0]);
@@ -8830,8 +8822,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         value: {
           ...schema["~standard"],
           jsonSchema: {
-            input: createStandardJSONSchemaMethod(schema, "input"),
-            output: createStandardJSONSchemaMethod(schema, "output")
+            input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+            output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
           }
         },
         enumerable: false,
@@ -8899,9 +8891,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     extractDefs(ctx, schema);
     return finalize(ctx, schema);
   };
-  var createStandardJSONSchemaMethod = (schema, io) => (params) => {
+  var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
     const { libraryOptions, target } = params ?? {};
-    const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors: {} });
+    const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
     process2(schema, ctx);
     extractDefs(ctx, schema);
     return finalize(ctx, schema);
@@ -8928,6 +8920,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       json.format = formatMap[format] ?? format;
       if (json.format === "")
         delete json.format;
+      if (format === "time") {
+        delete json.format;
+      }
     }
     if (contentEncoding)
       json.contentEncoding = contentEncoding;
@@ -9217,8 +9212,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           ...def.checks ?? [],
           ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
         ]
-      }));
+      }), {
+        parent: true
+      });
     };
+    inst.with = inst.check;
     inst.clone = (def2, params) => clone(inst, def2, params);
     inst.brand = () => inst;
     inst.register = ((reg, meta2) => {
@@ -9242,6 +9240,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.superRefine = (refinement) => inst.check(superRefine(refinement));
     inst.overwrite = (fn) => inst.check(_overwrite(fn));
     inst.optional = () => optional(inst);
+    inst.exactOptional = () => exactOptional(inst);
     inst.nullable = () => nullable(inst);
     inst.nullish = () => optional(nullable(inst));
     inst.nonoptional = (params) => nonoptional(inst, params);
@@ -9275,6 +9274,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     };
     inst.isOptional = () => inst.safeParse(void 0).success;
     inst.isNullable = () => inst.safeParse(null).success;
+    inst.apply = (fn) => fn(inst);
     return inst;
   });
   var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
@@ -9565,6 +9565,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       innerType
     });
   }
+  var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
+    $ZodExactOptional.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+  });
+  function exactOptional(innerType) {
+    return new ZodExactOptional({
+      type: "optional",
+      innerType
+    });
+  }
   var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
     $ZodNullable.init(inst, def);
     ZodType.init(inst, def);
@@ -9841,12 +9853,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         stack: message.stack
       });
     },
-    serialize(error46) {
+    serialize(error48) {
       return {
         __error_marker: "$$error",
-        message: error46.message,
-        name: error46.name,
-        stack: error46.stack
+        message: error48.message,
+        name: error48.name,
+        stack: error48.stack
       };
     }
   };
@@ -9903,9 +9915,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       implementation.postMessageToMaster(initMessage);
     }
     function postJobErrorMessage(uid, rawError) {
-      const { payload: error46, transferables } = deconstructTransfer(rawError);
+      const { payload: error48, transferables } = deconstructTransfer(rawError);
       const errorMessage = {
-        error: serialize(error46),
+        error: serialize(error48),
         type: "error",
         uid
       };
@@ -9929,10 +9941,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       };
       implementation.postMessageToMaster(startMessage);
     }
-    function postUncaughtErrorMessage(error46) {
+    function postUncaughtErrorMessage(error48) {
       try {
         const errorMessage = {
-          error: serialize(error46),
+          error: serialize(error48),
           type: "uncaughtError"
           /* uncaughtError */
         };
@@ -9942,7 +9954,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           "Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:",
           subError,
           "\nOriginal error:",
-          error46
+          error48
         );
       }
     }
@@ -9951,16 +9963,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       try {
         syncResult = fn(...args);
       } catch (ex) {
-        const error46 = ex;
-        return postJobErrorMessage(jobUID, error46);
+        const error48 = ex;
+        return postJobErrorMessage(jobUID, error48);
       }
       const resultType = isObservable(syncResult) ? "observable" : "promise";
       postJobStartMessage(jobUID, resultType);
       if (isObservable(syncResult)) {
         const subscription = syncResult.subscribe(
           (value) => postJobResultMessage(jobUID, false, serialize(value)),
-          (error46) => {
-            postJobErrorMessage(jobUID, serialize(error46));
+          (error48) => {
+            postJobErrorMessage(jobUID, serialize(error48));
             activeSubscriptions.delete(jobUID);
           },
           () => {
@@ -9973,8 +9985,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         try {
           const result = await syncResult;
           postJobResultMessage(jobUID, true, serialize(result));
-        } catch (error46) {
-          postJobErrorMessage(jobUID, serialize(error46));
+        } catch (error48) {
+          postJobErrorMessage(jobUID, serialize(error48));
         }
       }
     }
@@ -10020,19 +10032,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         setTimeout(() => postUncaughtErrorMessage(isErrorEvent(event) ? event.error : event), 250);
       });
       self2.addEventListener("unhandledrejection", (event) => {
-        const error46 = event.reason;
-        if (error46 && typeof error46.message === "string") {
-          setTimeout(() => postUncaughtErrorMessage(error46), 250);
+        const error48 = event.reason;
+        if (error48 && typeof error48.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error48), 250);
         }
       });
     }
     if (typeof process !== "undefined" && typeof process.on === "function" && implementation.isWorkerRuntime()) {
-      process.on("uncaughtException", (error46) => {
-        setTimeout(() => postUncaughtErrorMessage(error46), 250);
+      process.on("uncaughtException", (error48) => {
+        setTimeout(() => postUncaughtErrorMessage(error48), 250);
       });
-      process.on("unhandledRejection", (error46) => {
-        if (error46 && typeof error46.message === "string") {
-          setTimeout(() => postUncaughtErrorMessage(error46), 250);
+      process.on("unhandledRejection", (error48) => {
+        if (error48 && typeof error48.message === "string") {
+          setTimeout(() => postUncaughtErrorMessage(error48), 250);
         }
       });
     }