@opentabs-dev/opentabs-plugin-notebooklm 0.0.107 → 0.0.109

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/adapter.iife.js +1144 -423
  2. package/dist/adapter.iife.js.map +4 -4
  3. package/dist/tools.json +1 -1
  4. package/package.json +3 -3
package/dist/adapter.iife.js CHANGED
@@ -123,14 +123,14 @@
123
123
  ...rest,
124
124
  signal: combinedSignal
125
125
  });
126
- } catch (error48) {
127
- if (error48 instanceof DOMException && error48.name === "TimeoutError") {
126
+ } catch (error51) {
127
+ if (error51 instanceof DOMException && error51.name === "TimeoutError") {
128
128
  throw ToolError.timeout(`fetchFromPage: request timed out after ${timeout}ms for ${url2}`);
129
129
  }
130
130
  if (combinedSignal.aborted) {
131
131
  throw new ToolError(`fetchFromPage: request aborted for ${url2}`, "aborted");
132
132
  }
133
- throw new ToolError(`fetchFromPage: network error for ${url2}: ${toErrorMessage(error48)}`, "network_error", {
133
+ throw new ToolError(`fetchFromPage: network error for ${url2}: ${toErrorMessage(error51)}`, "network_error", {
134
134
  category: "internal",
135
135
  retryable: true
136
136
  });
@@ -641,6 +641,7 @@
641
641
  int32: () => int32,
642
642
  int64: () => int64,
643
643
  intersection: () => intersection,
644
+ invertCodec: () => invertCodec,
644
645
  ipv4: () => ipv42,
645
646
  ipv6: () => ipv62,
646
647
  iso: () => iso_exports,
@@ -1021,7 +1022,8 @@
1021
1022
  });
1022
1023
 
1023
1024
  // node_modules/zod/v4/core/core.js
1024
- var NEVER = Object.freeze({
1025
+ var _a;
1026
+ var NEVER = /* @__PURE__ */ Object.freeze({
1025
1027
  status: "aborted"
1026
1028
  });
1027
1029
  // @__NO_SIDE_EFFECTS__
@@ -1056,10 +1058,10 @@
1056
1058
  }
1057
1059
  Object.defineProperty(Definition, "name", { value: name });
1058
1060
  function _(def) {
1059
- var _a2;
1061
+ var _a3;
1060
1062
  const inst = params?.Parent ? new Definition() : this;
1061
1063
  init(inst, def);
1062
- (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
1064
+ (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
1063
1065
  for (const fn of inst._zod.deferred) {
1064
1066
  fn();
1065
1067
  }
@@ -1088,7 +1090,8 @@
1088
1090
  this.name = "ZodEncodeError";
1089
1091
  }
1090
1092
  };
1091
- var globalConfig = {};
1093
+ (_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
1094
+ var globalConfig = globalThis.__zod_globalConfig;
1092
1095
  function config(newConfig) {
1093
1096
  if (newConfig)
1094
1097
  Object.assign(globalConfig, newConfig);
@@ -1121,6 +1124,7 @@
1121
1124
  defineLazy: () => defineLazy,
1122
1125
  esc: () => esc,
1123
1126
  escapeRegex: () => escapeRegex,
1127
+ explicitlyAborted: () => explicitlyAborted,
1124
1128
  extend: () => extend,
1125
1129
  finalizeIssue: () => finalizeIssue,
1126
1130
  floatSafeRemainder: () => floatSafeRemainder,
@@ -1209,19 +1213,12 @@
1209
1213
  return source.slice(start, end);
1210
1214
  }
1211
1215
  function floatSafeRemainder(val, step) {
1212
- const valDecCount = (val.toString().split(".")[1] || "").length;
1213
- const stepString = step.toString();
1214
- let stepDecCount = (stepString.split(".")[1] || "").length;
1215
- if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
1216
- const match = stepString.match(/\d?e-(\d?)/);
1217
- if (match?.[1]) {
1218
- stepDecCount = Number.parseInt(match[1]);
1219
- }
1220
- }
1221
- const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
1222
- const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
1223
- const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
1224
- return valInt % stepInt / 10 ** decCount;
1216
+ const ratio = val / step;
1217
+ const roundedRatio = Math.round(ratio);
1218
+ const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
1219
+ if (Math.abs(ratio - roundedRatio) < tolerance)
1220
+ return 0;
1221
+ return ratio - roundedRatio;
1225
1222
  }
1226
1223
  var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
1227
1224
  function defineLazy(object2, key, getter) {
@@ -1303,7 +1300,10 @@
1303
1300
  function isObject(data) {
1304
1301
  return typeof data === "object" && data !== null && !Array.isArray(data);
1305
1302
  }
1306
- var allowsEval = cached(() => {
1303
+ var allowsEval = /* @__PURE__ */ cached(() => {
1304
+ if (globalConfig.jitless) {
1305
+ return false;
1306
+ }
1307
1307
  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
1308
1308
  return false;
1309
1309
  }
@@ -1336,6 +1336,10 @@
1336
1336
  return { ...o };
1337
1337
  if (Array.isArray(o))
1338
1338
  return [...o];
1339
+ if (o instanceof Map)
1340
+ return new Map(o);
1341
+ if (o instanceof Set)
1342
+ return new Set(o);
1339
1343
  return o;
1340
1344
  }
1341
1345
  function numKeys(data) {
@@ -1392,7 +1396,14 @@
1392
1396
  }
1393
1397
  };
1394
1398
  var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
1395
- var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
1399
+ var primitiveTypes = /* @__PURE__ */ new Set([
1400
+ "string",
1401
+ "number",
1402
+ "bigint",
1403
+ "boolean",
1404
+ "symbol",
1405
+ "undefined"
1406
+ ]);
1396
1407
  function escapeRegex(str) {
1397
1408
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
1398
1409
  }
@@ -1561,6 +1572,9 @@
1561
1572
  return clone(schema, def);
1562
1573
  }
1563
1574
  function merge(a, b) {
1575
+ if (a._zod.def.checks?.length) {
1576
+ throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
1577
+ }
1564
1578
  const def = mergeDefs(a._zod.def, {
1565
1579
  get shape() {
1566
1580
  const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
@@ -1570,8 +1584,7 @@
1570
1584
  get catchall() {
1571
1585
  return b._zod.def.catchall;
1572
1586
  },
1573
- checks: []
1574
- // delete existing checks
1587
+ checks: b._zod.def.checks ?? []
1575
1588
  });
1576
1589
  return clone(a, def);
1577
1590
  }
@@ -1654,10 +1667,20 @@
1654
1667
  }
1655
1668
  return false;
1656
1669
  }
1670
+ function explicitlyAborted(x, startIndex = 0) {
1671
+ if (x.aborted === true)
1672
+ return true;
1673
+ for (let i = startIndex; i < x.issues.length; i++) {
1674
+ if (x.issues[i]?.continue === false) {
1675
+ return true;
1676
+ }
1677
+ }
1678
+ return false;
1679
+ }
1657
1680
  function prefixIssues(path, issues) {
1658
1681
  return issues.map((iss) => {
1659
- var _a2;
1660
- (_a2 = iss).path ?? (_a2.path = []);
1682
+ var _a3;
1683
+ (_a3 = iss).path ?? (_a3.path = []);
1661
1684
  iss.path.unshift(path);
1662
1685
  return iss;
1663
1686
  });
@@ -1666,17 +1689,14 @@
1666
1689
  return typeof message === "string" ? message : message?.message;
1667
1690
  }
1668
1691
  function finalizeIssue(iss, ctx, config2) {
1669
- const full = { ...iss, path: iss.path ?? [] };
1670
- if (!iss.message) {
1671
- const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
1672
- full.message = message;
1692
+ const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
1693
+ const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
1694
+ rest.path ?? (rest.path = []);
1695
+ rest.message = message;
1696
+ if (ctx?.reportInput) {
1697
+ rest.input = _input;
1673
1698
  }
1674
- delete full.inst;
1675
- delete full.continue;
1676
- if (!ctx?.reportInput) {
1677
- delete full.input;
1678
- }
1679
- return full;
1699
+ return rest;
1680
1700
  }
1681
1701
  function getSizableOrigin(input) {
1682
1702
  if (input instanceof Set)
@@ -1793,10 +1813,10 @@
1793
1813
  };
1794
1814
  var $ZodError = $constructor("$ZodError", initializer);
1795
1815
  var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
1796
- function flattenError(error48, mapper = (issue2) => issue2.message) {
1816
+ function flattenError(error51, mapper = (issue2) => issue2.message) {
1797
1817
  const fieldErrors = {};
1798
1818
  const formErrors = [];
1799
- for (const sub of error48.issues) {
1819
+ for (const sub of error51.issues) {
1800
1820
  if (sub.path.length > 0) {
1801
1821
  fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
1802
1822
  fieldErrors[sub.path[0]].push(mapper(sub));
@@ -1806,50 +1826,53 @@
1806
1826
  }
1807
1827
  return { formErrors, fieldErrors };
1808
1828
  }
1809
- function formatError(error48, mapper = (issue2) => issue2.message) {
1829
+ function formatError(error51, mapper = (issue2) => issue2.message) {
1810
1830
  const fieldErrors = { _errors: [] };
1811
- const processError = (error49) => {
1812
- for (const issue2 of error49.issues) {
1831
+ const processError = (error52, path = []) => {
1832
+ for (const issue2 of error52.issues) {
1813
1833
  if (issue2.code === "invalid_union" && issue2.errors.length) {
1814
- issue2.errors.map((issues) => processError({ issues }));
1834
+ issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
1815
1835
  } else if (issue2.code === "invalid_key") {
1816
- processError({ issues: issue2.issues });
1836
+ processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1817
1837
  } else if (issue2.code === "invalid_element") {
1818
- processError({ issues: issue2.issues });
1819
- } else if (issue2.path.length === 0) {
1820
- fieldErrors._errors.push(mapper(issue2));
1838
+ processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1821
1839
  } else {
1822
- let curr = fieldErrors;
1823
- let i = 0;
1824
- while (i < issue2.path.length) {
1825
- const el = issue2.path[i];
1826
- const terminal = i === issue2.path.length - 1;
1827
- if (!terminal) {
1828
- curr[el] = curr[el] || { _errors: [] };
1829
- } else {
1830
- curr[el] = curr[el] || { _errors: [] };
1831
- curr[el]._errors.push(mapper(issue2));
1840
+ const fullpath = [...path, ...issue2.path];
1841
+ if (fullpath.length === 0) {
1842
+ fieldErrors._errors.push(mapper(issue2));
1843
+ } else {
1844
+ let curr = fieldErrors;
1845
+ let i = 0;
1846
+ while (i < fullpath.length) {
1847
+ const el = fullpath[i];
1848
+ const terminal = i === fullpath.length - 1;
1849
+ if (!terminal) {
1850
+ curr[el] = curr[el] || { _errors: [] };
1851
+ } else {
1852
+ curr[el] = curr[el] || { _errors: [] };
1853
+ curr[el]._errors.push(mapper(issue2));
1854
+ }
1855
+ curr = curr[el];
1856
+ i++;
1832
1857
  }
1833
- curr = curr[el];
1834
- i++;
1835
1858
  }
1836
1859
  }
1837
1860
  }
1838
1861
  };
1839
- processError(error48);
1862
+ processError(error51);
1840
1863
  return fieldErrors;
1841
1864
  }
1842
- function treeifyError(error48, mapper = (issue2) => issue2.message) {
1865
+ function treeifyError(error51, mapper = (issue2) => issue2.message) {
1843
1866
  const result = { errors: [] };
1844
- const processError = (error49, path = []) => {
1845
- var _a2, _b;
1846
- for (const issue2 of error49.issues) {
1867
+ const processError = (error52, path = []) => {
1868
+ var _a3, _b;
1869
+ for (const issue2 of error52.issues) {
1847
1870
  if (issue2.code === "invalid_union" && issue2.errors.length) {
1848
- issue2.errors.map((issues) => processError({ issues }, issue2.path));
1871
+ issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
1849
1872
  } else if (issue2.code === "invalid_key") {
1850
- processError({ issues: issue2.issues }, issue2.path);
1873
+ processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1851
1874
  } else if (issue2.code === "invalid_element") {
1852
- processError({ issues: issue2.issues }, issue2.path);
1875
+ processError({ issues: issue2.issues }, [...path, ...issue2.path]);
1853
1876
  } else {
1854
1877
  const fullpath = [...path, ...issue2.path];
1855
1878
  if (fullpath.length === 0) {
@@ -1863,7 +1886,7 @@
1863
1886
  const terminal = i === fullpath.length - 1;
1864
1887
  if (typeof el === "string") {
1865
1888
  curr.properties ?? (curr.properties = {});
1866
- (_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
1889
+ (_a3 = curr.properties)[el] ?? (_a3[el] = { errors: [] });
1867
1890
  curr = curr.properties[el];
1868
1891
  } else {
1869
1892
  curr.items ?? (curr.items = []);
@@ -1878,7 +1901,7 @@
1878
1901
  }
1879
1902
  }
1880
1903
  };
1881
- processError(error48);
1904
+ processError(error51);
1882
1905
  return result;
1883
1906
  }
1884
1907
  function toDotPath(_path) {
@@ -1899,9 +1922,9 @@
1899
1922
  }
1900
1923
  return segs.join("");
1901
1924
  }
1902
- function prettifyError(error48) {
1925
+ function prettifyError(error51) {
1903
1926
  const lines = [];
1904
- const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
1927
+ const issues = [...error51.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
1905
1928
  for (const issue2 of issues) {
1906
1929
  lines.push(`\u2716 ${issue2.message}`);
1907
1930
  if (issue2.path?.length)
@@ -1912,7 +1935,7 @@
1912
1935
 
1913
1936
  // node_modules/zod/v4/core/parse.js
1914
1937
  var _parse = (_Err) => (schema, value, _ctx, _params) => {
1915
- const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
1938
+ const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
1916
1939
  const result = schema._zod.run({ value, issues: [] }, ctx);
1917
1940
  if (result instanceof Promise) {
1918
1941
  throw new $ZodAsyncError();
@@ -1926,7 +1949,7 @@
1926
1949
  };
1927
1950
  var parse = /* @__PURE__ */ _parse($ZodRealError);
1928
1951
  var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
1929
- const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
1952
+ const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
1930
1953
  let result = schema._zod.run({ value, issues: [] }, ctx);
1931
1954
  if (result instanceof Promise)
1932
1955
  result = await result;
@@ -1951,7 +1974,7 @@
1951
1974
  };
1952
1975
  var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
1953
1976
  var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
1954
- const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
1977
+ const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
1955
1978
  let result = schema._zod.run({ value, issues: [] }, ctx);
1956
1979
  if (result instanceof Promise)
1957
1980
  result = await result;
@@ -1962,7 +1985,7 @@
1962
1985
  };
1963
1986
  var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
1964
1987
  var _encode = (_Err) => (schema, value, _ctx) => {
1965
- const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
1988
+ const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
1966
1989
  return _parse(_Err)(schema, value, ctx);
1967
1990
  };
1968
1991
  var encode = /* @__PURE__ */ _encode($ZodRealError);
@@ -1971,7 +1994,7 @@
1971
1994
  };
1972
1995
  var decode = /* @__PURE__ */ _decode($ZodRealError);
1973
1996
  var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
1974
- const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
1997
+ const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
1975
1998
  return _parseAsync(_Err)(schema, value, ctx);
1976
1999
  };
1977
2000
  var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
@@ -1980,7 +2003,7 @@
1980
2003
  };
1981
2004
  var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
1982
2005
  var _safeEncode = (_Err) => (schema, value, _ctx) => {
1983
- const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
2006
+ const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
1984
2007
  return _safeParse(_Err)(schema, value, ctx);
1985
2008
  };
1986
2009
  var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
@@ -1989,7 +2012,7 @@
1989
2012
  };
1990
2013
  var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
1991
2014
  var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
1992
- const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
2015
+ const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
1993
2016
  return _safeParseAsync(_Err)(schema, value, ctx);
1994
2017
  };
1995
2018
  var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
@@ -2022,6 +2045,7 @@
2022
2045
  hex: () => hex,
2023
2046
  hostname: () => hostname,
2024
2047
  html5Email: () => html5Email,
2048
+ httpProtocol: () => httpProtocol,
2025
2049
  idnEmail: () => idnEmail,
2026
2050
  integer: () => integer,
2027
2051
  ipv4: () => ipv4,
@@ -2060,7 +2084,7 @@
2060
2084
  uuid7: () => uuid7,
2061
2085
  xid: () => xid
2062
2086
  });
2063
- var cuid = /^[cC][^\s-]{8,}$/;
2087
+ var cuid = /^[cC][0-9a-z]{6,}$/;
2064
2088
  var cuid2 = /^[0-9a-z]+$/;
2065
2089
  var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
2066
2090
  var xid = /^[0-9a-vA-V]{20}$/;
@@ -2099,6 +2123,7 @@
2099
2123
  var base64url = /^[A-Za-z0-9_-]*$/;
2100
2124
  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])?)*\.?$/;
2101
2125
  var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
2126
+ var httpProtocol = /^https?$/;
2102
2127
  var e164 = /^\+[1-9]\d{6,14}$/;
2103
2128
  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])))`;
2104
2129
  var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
@@ -2157,10 +2182,10 @@
2157
2182
 
2158
2183
  // node_modules/zod/v4/core/checks.js
2159
2184
  var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
2160
- var _a2;
2185
+ var _a3;
2161
2186
  inst._zod ?? (inst._zod = {});
2162
2187
  inst._zod.def = def;
2163
- (_a2 = inst._zod).onattach ?? (_a2.onattach = []);
2188
+ (_a3 = inst._zod).onattach ?? (_a3.onattach = []);
2164
2189
  });
2165
2190
  var numericOriginMap = {
2166
2191
  number: "number",
@@ -2226,8 +2251,8 @@
2226
2251
  var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
2227
2252
  $ZodCheck.init(inst, def);
2228
2253
  inst._zod.onattach.push((inst2) => {
2229
- var _a2;
2230
- (_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);
2254
+ var _a3;
2255
+ (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value);
2231
2256
  });
2232
2257
  inst._zod.check = (payload) => {
2233
2258
  if (typeof payload.value !== typeof def.value)
@@ -2360,9 +2385,9 @@
2360
2385
  };
2361
2386
  });
2362
2387
  var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
2363
- var _a2;
2388
+ var _a3;
2364
2389
  $ZodCheck.init(inst, def);
2365
- (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2390
+ (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2366
2391
  const val = payload.value;
2367
2392
  return !nullish(val) && val.size !== void 0;
2368
2393
  });
@@ -2388,9 +2413,9 @@
2388
2413
  };
2389
2414
  });
2390
2415
  var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
2391
- var _a2;
2416
+ var _a3;
2392
2417
  $ZodCheck.init(inst, def);
2393
- (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2418
+ (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2394
2419
  const val = payload.value;
2395
2420
  return !nullish(val) && val.size !== void 0;
2396
2421
  });
@@ -2416,9 +2441,9 @@
2416
2441
  };
2417
2442
  });
2418
2443
  var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
2419
- var _a2;
2444
+ var _a3;
2420
2445
  $ZodCheck.init(inst, def);
2421
- (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2446
+ (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2422
2447
  const val = payload.value;
2423
2448
  return !nullish(val) && val.size !== void 0;
2424
2449
  });
@@ -2446,9 +2471,9 @@
2446
2471
  };
2447
2472
  });
2448
2473
  var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
2449
- var _a2;
2474
+ var _a3;
2450
2475
  $ZodCheck.init(inst, def);
2451
- (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2476
+ (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2452
2477
  const val = payload.value;
2453
2478
  return !nullish(val) && val.length !== void 0;
2454
2479
  });
@@ -2475,9 +2500,9 @@
2475
2500
  };
2476
2501
  });
2477
2502
  var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
2478
- var _a2;
2503
+ var _a3;
2479
2504
  $ZodCheck.init(inst, def);
2480
- (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2505
+ (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2481
2506
  const val = payload.value;
2482
2507
  return !nullish(val) && val.length !== void 0;
2483
2508
  });
@@ -2504,9 +2529,9 @@
2504
2529
  };
2505
2530
  });
2506
2531
  var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
2507
- var _a2;
2532
+ var _a3;
2508
2533
  $ZodCheck.init(inst, def);
2509
- (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
2534
+ (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
2510
2535
  const val = payload.value;
2511
2536
  return !nullish(val) && val.length !== void 0;
2512
2537
  });
@@ -2535,7 +2560,7 @@
2535
2560
  };
2536
2561
  });
2537
2562
  var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
2538
- var _a2, _b;
2563
+ var _a3, _b;
2539
2564
  $ZodCheck.init(inst, def);
2540
2565
  inst._zod.onattach.push((inst2) => {
2541
2566
  const bag = inst2._zod.bag;
@@ -2546,7 +2571,7 @@
2546
2571
  }
2547
2572
  });
2548
2573
  if (def.pattern)
2549
- (_a2 = inst._zod).check ?? (_a2.check = (payload) => {
2574
+ (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
2550
2575
  def.pattern.lastIndex = 0;
2551
2576
  if (def.pattern.test(payload.value))
2552
2577
  return;
@@ -2742,13 +2767,13 @@
2742
2767
  // node_modules/zod/v4/core/versions.js
2743
2768
  var version = {
2744
2769
  major: 4,
2745
- minor: 3,
2746
- patch: 6
2770
+ minor: 4,
2771
+ patch: 1
2747
2772
  };
2748
2773
 
2749
2774
  // node_modules/zod/v4/core/schemas.js
2750
2775
  var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
2751
- var _a2;
2776
+ var _a3;
2752
2777
  inst ?? (inst = {});
2753
2778
  inst._zod.def = def;
2754
2779
  inst._zod.bag = inst._zod.bag || {};
@@ -2763,7 +2788,7 @@
2763
2788
  }
2764
2789
  }
2765
2790
  if (checks.length === 0) {
2766
- (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
2791
+ (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
2767
2792
  inst._zod.deferred?.push(() => {
2768
2793
  inst._zod.run = inst._zod.parse;
2769
2794
  });
@@ -2773,6 +2798,8 @@
2773
2798
  let asyncResult;
2774
2799
  for (const ch of checks2) {
2775
2800
  if (ch._zod.def.when) {
2801
+ if (explicitlyAborted(payload))
2802
+ continue;
2776
2803
  const shouldRun = ch._zod.def.when(payload);
2777
2804
  if (!shouldRun)
2778
2805
  continue;
@@ -2913,6 +2940,19 @@
2913
2940
  inst._zod.check = (payload) => {
2914
2941
  try {
2915
2942
  const trimmed = payload.value.trim();
2943
+ if (!def.normalize && def.protocol?.source === httpProtocol.source) {
2944
+ if (!/^https?:\/\//i.test(trimmed)) {
2945
+ payload.issues.push({
2946
+ code: "invalid_format",
2947
+ format: "url",
2948
+ note: "Invalid URL format",
2949
+ input: payload.value,
2950
+ inst,
2951
+ continue: !def.abort
2952
+ });
2953
+ return;
2954
+ }
2955
+ }
2916
2956
  const url2 = new URL(trimmed);
2917
2957
  if (def.hostname) {
2918
2958
  def.hostname.lastIndex = 0;
@@ -3066,6 +3106,8 @@
3066
3106
  function isValidBase64(data) {
3067
3107
  if (data === "")
3068
3108
  return true;
3109
+ if (/\s/.test(data))
3110
+ return false;
3069
3111
  if (data.length % 4 !== 0)
3070
3112
  return false;
3071
3113
  try {
@@ -3258,8 +3300,6 @@
3258
3300
  $ZodType.init(inst, def);
3259
3301
  inst._zod.pattern = _undefined;
3260
3302
  inst._zod.values = /* @__PURE__ */ new Set([void 0]);
3261
- inst._zod.optin = "optional";
3262
- inst._zod.optout = "optional";
3263
3303
  inst._zod.parse = (payload, _ctx) => {
3264
3304
  const input = payload.value;
3265
3305
  if (typeof input === "undefined")
@@ -3388,15 +3428,27 @@
3388
3428
  return payload;
3389
3429
  };
3390
3430
  });
3391
- function handlePropertyResult(result, final, key, input, isOptionalOut) {
3431
+ function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
3432
+ const isPresent = key in input;
3392
3433
  if (result.issues.length) {
3393
- if (isOptionalOut && !(key in input)) {
3434
+ if (isOptionalIn && isOptionalOut && !isPresent) {
3394
3435
  return;
3395
3436
  }
3396
3437
  final.issues.push(...prefixIssues(key, result.issues));
3397
3438
  }
3439
+ if (!isPresent && !isOptionalIn) {
3440
+ if (!result.issues.length) {
3441
+ final.issues.push({
3442
+ code: "invalid_type",
3443
+ expected: "nonoptional",
3444
+ input: void 0,
3445
+ path: [key]
3446
+ });
3447
+ }
3448
+ return;
3449
+ }
3398
3450
  if (result.value === void 0) {
3399
- if (key in input) {
3451
+ if (isPresent) {
3400
3452
  final.value[key] = void 0;
3401
3453
  }
3402
3454
  } else {
@@ -3424,8 +3476,11 @@
3424
3476
  const keySet = def.keySet;
3425
3477
  const _catchall = def.catchall._zod;
3426
3478
  const t = _catchall.def.type;
3479
+ const isOptionalIn = _catchall.optin === "optional";
3427
3480
  const isOptionalOut = _catchall.optout === "optional";
3428
3481
  for (const key in input) {
3482
+ if (key === "__proto__")
3483
+ continue;
3429
3484
  if (keySet.has(key))
3430
3485
  continue;
3431
3486
  if (t === "never") {
@@ -3434,9 +3489,9 @@
3434
3489
  }
3435
3490
  const r = _catchall.run({ value: input[key], issues: [] }, ctx);
3436
3491
  if (r instanceof Promise) {
3437
- proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
3492
+ proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
3438
3493
  } else {
3439
- handlePropertyResult(r, payload, key, input, isOptionalOut);
3494
+ handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
3440
3495
  }
3441
3496
  }
3442
3497
  if (unrecognized.length) {
@@ -3502,12 +3557,13 @@
3502
3557
  const shape = value.shape;
3503
3558
  for (const key of value.keys) {
3504
3559
  const el = shape[key];
3560
+ const isOptionalIn = el._zod.optin === "optional";
3505
3561
  const isOptionalOut = el._zod.optout === "optional";
3506
3562
  const r = el._zod.run({ value: input[key], issues: [] }, ctx);
3507
3563
  if (r instanceof Promise) {
3508
- proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
3564
+ proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
3509
3565
  } else {
3510
- handlePropertyResult(r, payload, key, input, isOptionalOut);
3566
+ handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
3511
3567
  }
3512
3568
  }
3513
3569
  if (!catchall) {
@@ -3538,9 +3594,10 @@
3538
3594
  const id = ids[key];
3539
3595
  const k = esc(key);
3540
3596
  const schema = shape[key];
3597
+ const isOptionalIn = schema?._zod?.optin === "optional";
3541
3598
  const isOptionalOut = schema?._zod?.optout === "optional";
3542
3599
  doc.write(`const ${id} = ${parseStr(key)};`);
3543
- if (isOptionalOut) {
3600
+ if (isOptionalIn && isOptionalOut) {
3544
3601
  doc.write(`
3545
3602
  if (${id}.issues.length) {
3546
3603
  if (${k} in input) {
@@ -3559,6 +3616,33 @@
3559
3616
  newResult[${k}] = ${id}.value;
3560
3617
  }
3561
3618
 
3619
+ `);
3620
+ } else if (!isOptionalIn) {
3621
+ doc.write(`
3622
+ const ${id}_present = ${k} in input;
3623
+ if (${id}.issues.length) {
3624
+ payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
3625
+ ...iss,
3626
+ path: iss.path ? [${k}, ...iss.path] : [${k}]
3627
+ })));
3628
+ }
3629
+ if (!${id}_present && !${id}.issues.length) {
3630
+ payload.issues.push({
3631
+ code: "invalid_type",
3632
+ expected: "nonoptional",
3633
+ input: undefined,
3634
+ path: [${k}]
3635
+ });
3636
+ }
3637
+
3638
+ if (${id}_present) {
3639
+ if (${id}.value === undefined) {
3640
+ newResult[${k}] = undefined;
3641
+ } else {
3642
+ newResult[${k}] = ${id}.value;
3643
+ }
3644
+ }
3645
+
3562
3646
  `);
3563
3647
  } else {
3564
3648
  doc.write(`
@@ -3652,10 +3736,9 @@
3652
3736
  }
3653
3737
  return void 0;
3654
3738
  });
3655
- const single = def.options.length === 1;
3656
- const first = def.options[0]._zod.run;
3739
+ const first = def.options.length === 1 ? def.options[0]._zod.run : null;
3657
3740
  inst._zod.parse = (payload, ctx) => {
3658
- if (single) {
3741
+ if (first) {
3659
3742
  return first(payload, ctx);
3660
3743
  }
3661
3744
  let async = false;
@@ -3708,10 +3791,9 @@
3708
3791
  var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
3709
3792
  $ZodUnion.init(inst, def);
3710
3793
  def.inclusive = false;
3711
- const single = def.options.length === 1;
3712
- const first = def.options[0]._zod.run;
3794
+ const first = def.options.length === 1 ? def.options[0]._zod.run : null;
3713
3795
  inst._zod.parse = (payload, ctx) => {
3714
- if (single) {
3796
+ if (first) {
3715
3797
  return first(payload, ctx);
3716
3798
  }
3717
3799
  let async = false;
@@ -3786,7 +3868,7 @@
3786
3868
  if (opt) {
3787
3869
  return opt._zod.run(payload, ctx);
3788
3870
  }
3789
- if (def.unionFallback) {
3871
+ if (def.unionFallback || ctx.direction === "backward") {
3790
3872
  return _super(payload, ctx);
3791
3873
  }
3792
3874
  payload.issues.push({
@@ -3794,6 +3876,7 @@
3794
3876
  errors: [],
3795
3877
  note: "No matching discriminator",
3796
3878
  discriminator: def.discriminator,
3879
+ options: Array.from(disc.value.keys()),
3797
3880
  input,
3798
3881
  path: [def.discriminator],
3799
3882
  inst
@@ -3915,64 +3998,96 @@
3915
3998
  }
3916
3999
  payload.value = [];
3917
4000
  const proms = [];
3918
- const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
3919
- const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
4001
+ const optinStart = getTupleOptStart(items, "optin");
4002
+ const optoutStart = getTupleOptStart(items, "optout");
3920
4003
  if (!def.rest) {
3921
- const tooBig = input.length > items.length;
3922
- const tooSmall = input.length < optStart - 1;
3923
- if (tooBig || tooSmall) {
4004
+ if (input.length < optinStart) {
3924
4005
  payload.issues.push({
3925
- ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
4006
+ code: "too_small",
4007
+ minimum: optinStart,
4008
+ inclusive: true,
3926
4009
  input,
3927
4010
  inst,
3928
4011
  origin: "array"
3929
4012
  });
3930
4013
  return payload;
3931
4014
  }
3932
- }
3933
- let i = -1;
3934
- for (const item of items) {
3935
- i++;
3936
- if (i >= input.length) {
3937
- if (i >= optStart)
3938
- continue;
4015
+ if (input.length > items.length) {
4016
+ payload.issues.push({
4017
+ code: "too_big",
4018
+ maximum: items.length,
4019
+ inclusive: true,
4020
+ input,
4021
+ inst,
4022
+ origin: "array"
4023
+ });
3939
4024
  }
3940
- const result = item._zod.run({
3941
- value: input[i],
3942
- issues: []
3943
- }, ctx);
3944
- if (result instanceof Promise) {
3945
- proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
4025
+ }
4026
+ const itemResults = new Array(items.length);
4027
+ for (let i = 0; i < items.length; i++) {
4028
+ const r = items[i]._zod.run({ value: input[i], issues: [] }, ctx);
4029
+ if (r instanceof Promise) {
4030
+ proms.push(r.then((rr) => {
4031
+ itemResults[i] = rr;
4032
+ }));
3946
4033
  } else {
3947
- handleTupleResult(result, payload, i);
4034
+ itemResults[i] = r;
3948
4035
  }
3949
4036
  }
3950
4037
  if (def.rest) {
4038
+ let i = items.length - 1;
3951
4039
  const rest = input.slice(items.length);
3952
4040
  for (const el of rest) {
3953
4041
  i++;
3954
- const result = def.rest._zod.run({
3955
- value: el,
3956
- issues: []
3957
- }, ctx);
4042
+ const result = def.rest._zod.run({ value: el, issues: [] }, ctx);
3958
4043
  if (result instanceof Promise) {
3959
- proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
4044
+ proms.push(result.then((r) => handleTupleResult(r, payload, i)));
3960
4045
  } else {
3961
4046
  handleTupleResult(result, payload, i);
3962
4047
  }
3963
4048
  }
3964
4049
  }
3965
- if (proms.length)
3966
- return Promise.all(proms).then(() => payload);
3967
- return payload;
4050
+ if (proms.length) {
4051
+ return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input, optoutStart));
4052
+ }
4053
+ return handleTupleResults(itemResults, payload, items, input, optoutStart);
3968
4054
  };
3969
4055
  });
4056
+ function getTupleOptStart(items, key) {
4057
+ for (let i = items.length - 1; i >= 0; i--) {
4058
+ if (items[i]._zod[key] !== "optional")
4059
+ return i + 1;
4060
+ }
4061
+ return 0;
4062
+ }
3970
4063
  function handleTupleResult(result, final, index) {
3971
4064
  if (result.issues.length) {
3972
4065
  final.issues.push(...prefixIssues(index, result.issues));
3973
4066
  }
3974
4067
  final.value[index] = result.value;
3975
4068
  }
4069
+ function handleTupleResults(itemResults, final, items, input, optoutStart) {
4070
+ for (let i = 0; i < items.length; i++) {
4071
+ const r = itemResults[i];
4072
+ const isPresent = i < input.length;
4073
+ if (r.issues.length) {
4074
+ if (!isPresent && i >= optoutStart) {
4075
+ final.value.length = i;
4076
+ break;
4077
+ }
4078
+ final.issues.push(...prefixIssues(i, r.issues));
4079
+ }
4080
+ final.value[i] = r.value;
4081
+ }
4082
+ for (let i = final.value.length - 1; i >= input.length; i--) {
4083
+ if (items[i]._zod.optout === "optional" && final.value[i] === void 0) {
4084
+ final.value.length = i;
4085
+ } else {
4086
+ break;
4087
+ }
4088
+ }
4089
+ return final;
4090
+ }
3976
4091
  var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
3977
4092
  $ZodType.init(inst, def);
3978
4093
  inst._zod.parse = (payload, ctx) => {
@@ -3994,19 +4109,35 @@
3994
4109
  for (const key of values) {
3995
4110
  if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
3996
4111
  recordKeys.add(typeof key === "number" ? key.toString() : key);
4112
+ const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
4113
+ if (keyResult instanceof Promise) {
4114
+ throw new Error("Async schemas not supported in object keys currently");
4115
+ }
4116
+ if (keyResult.issues.length) {
4117
+ payload.issues.push({
4118
+ code: "invalid_key",
4119
+ origin: "record",
4120
+ issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
4121
+ input: key,
4122
+ path: [key],
4123
+ inst
4124
+ });
4125
+ continue;
4126
+ }
4127
+ const outKey = keyResult.value;
3997
4128
  const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
3998
4129
  if (result instanceof Promise) {
3999
4130
  proms.push(result.then((result2) => {
4000
4131
  if (result2.issues.length) {
4001
4132
  payload.issues.push(...prefixIssues(key, result2.issues));
4002
4133
  }
4003
- payload.value[key] = result2.value;
4134
+ payload.value[outKey] = result2.value;
4004
4135
  }));
4005
4136
  } else {
4006
4137
  if (result.issues.length) {
4007
4138
  payload.issues.push(...prefixIssues(key, result.issues));
4008
4139
  }
4009
- payload.value[key] = result.value;
4140
+ payload.value[outKey] = result.value;
4010
4141
  }
4011
4142
  }
4012
4143
  }
@@ -4030,6 +4161,8 @@
4030
4161
  for (const key of Reflect.ownKeys(input)) {
4031
4162
  if (key === "__proto__")
4032
4163
  continue;
4164
+ if (!Object.prototype.propertyIsEnumerable.call(input, key))
4165
+ continue;
4033
4166
  let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
4034
4167
  if (keyResult instanceof Promise) {
4035
4168
  throw new Error("Async schemas not supported in object keys currently");
@@ -4673,7 +4806,12 @@
4673
4806
  });
4674
4807
  var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
4675
4808
  $ZodType.init(inst, def);
4676
- defineLazy(inst._zod, "innerType", () => def.getter());
4809
+ defineLazy(inst._zod, "innerType", () => {
4810
+ const d = def;
4811
+ if (!d._cachedInner)
4812
+ d._cachedInner = def.getter();
4813
+ return d._cachedInner;
4814
+ });
4677
4815
  defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
4678
4816
  defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
4679
4817
  defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
@@ -4728,6 +4866,7 @@
4728
4866
  cs: () => cs_default,
4729
4867
  da: () => da_default,
4730
4868
  de: () => de_default,
4869
+ el: () => el_default,
4731
4870
  en: () => en_default,
4732
4871
  eo: () => eo_default,
4733
4872
  es: () => es_default,
@@ -4736,6 +4875,7 @@
4736
4875
  fr: () => fr_default,
4737
4876
  frCA: () => fr_CA_default,
4738
4877
  he: () => he_default,
4878
+ hr: () => hr_default,
4739
4879
  hu: () => hu_default,
4740
4880
  hy: () => hy_default,
4741
4881
  id: () => id_default,
@@ -4755,6 +4895,7 @@
4755
4895
  pl: () => pl_default,
4756
4896
  ps: () => ps_default,
4757
4897
  pt: () => pt_default,
4898
+ ro: () => ro_default,
4758
4899
  ru: () => ru_default,
4759
4900
  sl: () => sl_default,
4760
4901
  sv: () => sv_default,
@@ -5708,8 +5849,118 @@
5708
5849
  };
5709
5850
  }
5710
5851
 
5711
- // node_modules/zod/v4/locales/en.js
5852
+ // node_modules/zod/v4/locales/el.js
5712
5853
  var error9 = () => {
5854
+ const Sizable = {
5855
+ string: { unit: "\u03C7\u03B1\u03C1\u03B1\u03BA\u03C4\u03AE\u03C1\u03B5\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
5856
+ file: { unit: "bytes", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
5857
+ array: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
5858
+ set: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
5859
+ map: { unit: "\u03BA\u03B1\u03C4\u03B1\u03C7\u03C9\u03C1\u03AE\u03C3\u03B5\u03B9\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" }
5860
+ };
5861
+ function getSizing(origin) {
5862
+ return Sizable[origin] ?? null;
5863
+ }
5864
+ const FormatDictionary = {
5865
+ regex: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2",
5866
+ email: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 email",
5867
+ url: "URL",
5868
+ emoji: "emoji",
5869
+ uuid: "UUID",
5870
+ uuidv4: "UUIDv4",
5871
+ uuidv6: "UUIDv6",
5872
+ nanoid: "nanoid",
5873
+ guid: "GUID",
5874
+ cuid: "cuid",
5875
+ cuid2: "cuid2",
5876
+ ulid: "ULID",
5877
+ xid: "XID",
5878
+ ksuid: "KSUID",
5879
+ datetime: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1 \u03BA\u03B1\u03B9 \u03CE\u03C1\u03B1",
5880
+ date: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1",
5881
+ time: "ISO \u03CE\u03C1\u03B1",
5882
+ duration: "ISO \u03B4\u03B9\u03AC\u03C1\u03BA\u03B5\u03B9\u03B1",
5883
+ ipv4: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv4",
5884
+ ipv6: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv6",
5885
+ mac: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 MAC",
5886
+ cidrv4: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv4",
5887
+ cidrv6: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv6",
5888
+ base64: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64",
5889
+ base64url: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64url",
5890
+ json_string: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC JSON",
5891
+ e164: "\u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2 E.164",
5892
+ jwt: "JWT",
5893
+ template_literal: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2"
5894
+ };
5895
+ const TypeDictionary = {
5896
+ nan: "NaN"
5897
+ };
5898
+ return (issue2) => {
5899
+ switch (issue2.code) {
5900
+ case "invalid_type": {
5901
+ const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
5902
+ const receivedType = parsedType(issue2.input);
5903
+ const received = TypeDictionary[receivedType] ?? receivedType;
5904
+ if (typeof issue2.expected === "string" && /^[A-Z]/.test(issue2.expected)) {
5905
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD instanceof ${issue2.expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
5906
+ }
5907
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
5908
+ }
5909
+ case "invalid_value":
5910
+ if (issue2.values.length === 1)
5911
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${stringifyPrimitive(issue2.values[0])}`;
5912
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03C0\u03B9\u03BB\u03BF\u03B3\u03AE: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD \u03AD\u03BD\u03B1 \u03B1\u03C0\u03CC ${joinValues(issue2.values, "|")}`;
5913
+ case "too_big": {
5914
+ const adj = issue2.inclusive ? "<=" : "<";
5915
+ const sizing = getSizing(issue2.origin);
5916
+ if (sizing)
5917
+ return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1"}`;
5918
+ return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.maximum.toString()}`;
5919
+ }
5920
+ case "too_small": {
5921
+ const adj = issue2.inclusive ? ">=" : ">";
5922
+ const sizing = getSizing(issue2.origin);
5923
+ if (sizing) {
5924
+ return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
5925
+ }
5926
+ return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.minimum.toString()}`;
5927
+ }
5928
+ case "invalid_format": {
5929
+ const _issue = issue2;
5930
+ if (_issue.format === "starts_with") {
5931
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03BE\u03B5\u03BA\u03B9\u03BD\u03AC \u03BC\u03B5 "${_issue.prefix}"`;
5932
+ }
5933
+ if (_issue.format === "ends_with")
5934
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B5\u03BB\u03B5\u03B9\u03CE\u03BD\u03B5\u03B9 \u03BC\u03B5 "${_issue.suffix}"`;
5935
+ if (_issue.format === "includes")
5936
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C0\u03B5\u03C1\u03B9\u03AD\u03C7\u03B5\u03B9 "${_issue.includes}"`;
5937
+ if (_issue.format === "regex")
5938
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B1\u03B9\u03C1\u03B9\u03AC\u03B6\u03B5\u03B9 \u03BC\u03B5 \u03C4\u03BF \u03BC\u03BF\u03C4\u03AF\u03B2\u03BF ${_issue.pattern}`;
5939
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF: ${FormatDictionary[_issue.format] ?? issue2.format}`;
5940
+ }
5941
+ case "not_multiple_of":
5942
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF\u03C2 \u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 \u03C0\u03BF\u03BB\u03BB\u03B1\u03C0\u03BB\u03AC\u03C3\u03B9\u03BF \u03C4\u03BF\u03C5 ${issue2.divisor}`;
5943
+ case "unrecognized_keys":
5944
+ return `\u0386\u03B3\u03BD\u03C9\u03C3\u03C4${issue2.keys.length > 1 ? "\u03B1" : "\u03BF"} \u03BA\u03BB\u03B5\u03B9\u03B4${issue2.keys.length > 1 ? "\u03B9\u03AC" : "\u03AF"}: ${joinValues(issue2.keys, ", ")}`;
5945
+ case "invalid_key":
5946
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF \u03BA\u03BB\u03B5\u03B9\u03B4\u03AF \u03C3\u03C4\u03BF ${issue2.origin}`;
5947
+ case "invalid_union":
5948
+ return "\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2";
5949
+ case "invalid_element":
5950
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C4\u03B9\u03BC\u03AE \u03C3\u03C4\u03BF ${issue2.origin}`;
5951
+ default:
5952
+ return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2`;
5953
+ }
5954
+ };
5955
+ };
5956
+ function el_default() {
5957
+ return {
5958
+ localeError: error9()
5959
+ };
5960
+ }
5961
+
5962
+ // node_modules/zod/v4/locales/en.js
5963
+ var error10 = () => {
5713
5964
  const Sizable = {
5714
5965
  string: { unit: "characters", verb: "to have" },
5715
5966
  file: { unit: "bytes", verb: "to have" },
@@ -5803,6 +6054,10 @@
5803
6054
  case "invalid_key":
5804
6055
  return `Invalid key in ${issue2.origin}`;
5805
6056
  case "invalid_union":
6057
+ if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
6058
+ const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
6059
+ return `Invalid discriminator value. Expected ${opts}`;
6060
+ }
5806
6061
  return "Invalid input";
5807
6062
  case "invalid_element":
5808
6063
  return `Invalid value in ${issue2.origin}`;
@@ -5813,12 +6068,12 @@
5813
6068
  };
5814
6069
  function en_default() {
5815
6070
  return {
5816
- localeError: error9()
6071
+ localeError: error10()
5817
6072
  };
5818
6073
  }
5819
6074
 
5820
6075
  // node_modules/zod/v4/locales/eo.js
5821
- var error10 = () => {
6076
+ var error11 = () => {
5822
6077
  const Sizable = {
5823
6078
  string: { unit: "karaktrojn", verb: "havi" },
5824
6079
  file: { unit: "bajtojn", verb: "havi" },
@@ -5923,12 +6178,12 @@
5923
6178
  };
5924
6179
  function eo_default() {
5925
6180
  return {
5926
- localeError: error10()
6181
+ localeError: error11()
5927
6182
  };
5928
6183
  }
5929
6184
 
5930
6185
  // node_modules/zod/v4/locales/es.js
5931
- var error11 = () => {
6186
+ var error12 = () => {
5932
6187
  const Sizable = {
5933
6188
  string: { unit: "caracteres", verb: "tener" },
5934
6189
  file: { unit: "bytes", verb: "tener" },
@@ -6056,12 +6311,12 @@
6056
6311
  };
6057
6312
  function es_default() {
6058
6313
  return {
6059
- localeError: error11()
6314
+ localeError: error12()
6060
6315
  };
6061
6316
  }
6062
6317
 
6063
6318
  // node_modules/zod/v4/locales/fa.js
6064
- var error12 = () => {
6319
+ var error13 = () => {
6065
6320
  const Sizable = {
6066
6321
  string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
6067
6322
  file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
@@ -6171,12 +6426,12 @@
6171
6426
  };
6172
6427
  function fa_default() {
6173
6428
  return {
6174
- localeError: error12()
6429
+ localeError: error13()
6175
6430
  };
6176
6431
  }
6177
6432
 
6178
6433
  // node_modules/zod/v4/locales/fi.js
6179
- var error13 = () => {
6434
+ var error14 = () => {
6180
6435
  const Sizable = {
6181
6436
  string: { unit: "merkki\xE4", subject: "merkkijonon" },
6182
6437
  file: { unit: "tavua", subject: "tiedoston" },
@@ -6284,12 +6539,12 @@
6284
6539
  };
6285
6540
  function fi_default() {
6286
6541
  return {
6287
- localeError: error13()
6542
+ localeError: error14()
6288
6543
  };
6289
6544
  }
6290
6545
 
6291
6546
  // node_modules/zod/v4/locales/fr.js
6292
- var error14 = () => {
6547
+ var error15 = () => {
6293
6548
  const Sizable = {
6294
6549
  string: { unit: "caract\xE8res", verb: "avoir" },
6295
6550
  file: { unit: "octets", verb: "avoir" },
@@ -6330,9 +6585,27 @@
6330
6585
  template_literal: "entr\xE9e"
6331
6586
  };
6332
6587
  const TypeDictionary = {
6333
- nan: "NaN",
6588
+ string: "cha\xEEne",
6334
6589
  number: "nombre",
6335
- array: "tableau"
6590
+ int: "entier",
6591
+ boolean: "bool\xE9en",
6592
+ bigint: "grand entier",
6593
+ symbol: "symbole",
6594
+ undefined: "ind\xE9fini",
6595
+ null: "null",
6596
+ never: "jamais",
6597
+ void: "vide",
6598
+ date: "date",
6599
+ array: "tableau",
6600
+ object: "objet",
6601
+ tuple: "tuple",
6602
+ record: "enregistrement",
6603
+ map: "carte",
6604
+ set: "ensemble",
6605
+ file: "fichier",
6606
+ nonoptional: "non-optionnel",
6607
+ nan: "NaN",
6608
+ function: "fonction"
6336
6609
  };
6337
6610
  return (issue2) => {
6338
6611
  switch (issue2.code) {
@@ -6353,16 +6626,15 @@
6353
6626
  const adj = issue2.inclusive ? "<=" : "<";
6354
6627
  const sizing = getSizing(issue2.origin);
6355
6628
  if (sizing)
6356
- return `Trop grand : ${issue2.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
6357
- return `Trop grand : ${issue2.origin ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
6629
+ return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
6630
+ return `Trop grand : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
6358
6631
  }
6359
6632
  case "too_small": {
6360
6633
  const adj = issue2.inclusive ? ">=" : ">";
6361
6634
  const sizing = getSizing(issue2.origin);
6362
- if (sizing) {
6363
- return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
6364
- }
6365
- return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
6635
+ if (sizing)
6636
+ return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
6637
+ return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
6366
6638
  }
6367
6639
  case "invalid_format": {
6368
6640
  const _issue = issue2;
@@ -6393,12 +6665,12 @@
6393
6665
  };
6394
6666
  function fr_default() {
6395
6667
  return {
6396
- localeError: error14()
6668
+ localeError: error15()
6397
6669
  };
6398
6670
  }
6399
6671
 
6400
6672
  // node_modules/zod/v4/locales/fr-CA.js
6401
- var error15 = () => {
6673
+ var error16 = () => {
6402
6674
  const Sizable = {
6403
6675
  string: { unit: "caract\xE8res", verb: "avoir" },
6404
6676
  file: { unit: "octets", verb: "avoir" },
@@ -6501,12 +6773,12 @@
6501
6773
  };
6502
6774
  function fr_CA_default() {
6503
6775
  return {
6504
- localeError: error15()
6776
+ localeError: error16()
6505
6777
  };
6506
6778
  }
6507
6779
 
6508
6780
  // node_modules/zod/v4/locales/he.js
6509
- var error16 = () => {
6781
+ var error17 = () => {
6510
6782
  const TypeNames = {
6511
6783
  string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
6512
6784
  number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
@@ -6696,24 +6968,24 @@
6696
6968
  };
6697
6969
  function he_default() {
6698
6970
  return {
6699
- localeError: error16()
6971
+ localeError: error17()
6700
6972
  };
6701
6973
  }
6702
6974
 
6703
- // node_modules/zod/v4/locales/hu.js
6704
- var error17 = () => {
6975
+ // node_modules/zod/v4/locales/hr.js
6976
+ var error18 = () => {
6705
6977
  const Sizable = {
6706
- string: { unit: "karakter", verb: "legyen" },
6707
- file: { unit: "byte", verb: "legyen" },
6708
- array: { unit: "elem", verb: "legyen" },
6709
- set: { unit: "elem", verb: "legyen" }
6978
+ string: { unit: "znakova", verb: "imati" },
6979
+ file: { unit: "bajtova", verb: "imati" },
6980
+ array: { unit: "stavki", verb: "imati" },
6981
+ set: { unit: "stavki", verb: "imati" }
6710
6982
  };
6711
6983
  function getSizing(origin) {
6712
6984
  return Sizable[origin] ?? null;
6713
6985
  }
6714
6986
  const FormatDictionary = {
6715
- regex: "bemenet",
6716
- email: "email c\xEDm",
6987
+ regex: "unos",
6988
+ email: "email adresa",
6717
6989
  url: "URL",
6718
6990
  emoji: "emoji",
6719
6991
  uuid: "UUID",
@@ -6726,25 +6998,37 @@
6726
6998
  ulid: "ULID",
6727
6999
  xid: "XID",
6728
7000
  ksuid: "KSUID",
6729
- datetime: "ISO id\u0151b\xE9lyeg",
6730
- date: "ISO d\xE1tum",
6731
- time: "ISO id\u0151",
6732
- duration: "ISO id\u0151intervallum",
6733
- ipv4: "IPv4 c\xEDm",
6734
- ipv6: "IPv6 c\xEDm",
6735
- cidrv4: "IPv4 tartom\xE1ny",
6736
- cidrv6: "IPv6 tartom\xE1ny",
6737
- base64: "base64-k\xF3dolt string",
6738
- base64url: "base64url-k\xF3dolt string",
6739
- json_string: "JSON string",
6740
- e164: "E.164 sz\xE1m",
7001
+ datetime: "ISO datum i vrijeme",
7002
+ date: "ISO datum",
7003
+ time: "ISO vrijeme",
7004
+ duration: "ISO trajanje",
7005
+ ipv4: "IPv4 adresa",
7006
+ ipv6: "IPv6 adresa",
7007
+ cidrv4: "IPv4 raspon",
7008
+ cidrv6: "IPv6 raspon",
7009
+ base64: "base64 kodirani tekst",
7010
+ base64url: "base64url kodirani tekst",
7011
+ json_string: "JSON tekst",
7012
+ e164: "E.164 broj",
6741
7013
  jwt: "JWT",
6742
- template_literal: "bemenet"
7014
+ template_literal: "unos"
6743
7015
  };
6744
7016
  const TypeDictionary = {
6745
7017
  nan: "NaN",
6746
- number: "sz\xE1m",
6747
- array: "t\xF6mb"
7018
+ string: "tekst",
7019
+ number: "broj",
7020
+ boolean: "boolean",
7021
+ array: "niz",
7022
+ object: "objekt",
7023
+ set: "skup",
7024
+ file: "datoteka",
7025
+ date: "datum",
7026
+ bigint: "bigint",
7027
+ symbol: "simbol",
7028
+ undefined: "undefined",
7029
+ null: "null",
7030
+ function: "funkcija",
7031
+ map: "mapa"
6748
7032
  };
6749
7033
  return (issue2) => {
6750
7034
  switch (issue2.code) {
@@ -6753,35 +7037,146 @@
6753
7037
  const receivedType = parsedType(issue2.input);
6754
7038
  const received = TypeDictionary[receivedType] ?? receivedType;
6755
7039
  if (/^[A-Z]/.test(issue2.expected)) {
6756
- return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
7040
+ return `Neispravan unos: o\u010Dekuje se instanceof ${issue2.expected}, a primljeno je ${received}`;
6757
7041
  }
6758
- return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
7042
+ return `Neispravan unos: o\u010Dekuje se ${expected}, a primljeno je ${received}`;
6759
7043
  }
6760
7044
  case "invalid_value":
6761
7045
  if (issue2.values.length === 1)
6762
- return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
6763
- return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
7046
+ return `Neispravna vrijednost: o\u010Dekivano ${stringifyPrimitive(issue2.values[0])}`;
7047
+ return `Neispravna opcija: o\u010Dekivano jedno od ${joinValues(issue2.values, "|")}`;
6764
7048
  case "too_big": {
6765
7049
  const adj = issue2.inclusive ? "<=" : "<";
6766
7050
  const sizing = getSizing(issue2.origin);
7051
+ const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
6767
7052
  if (sizing)
6768
- return `T\xFAl nagy: ${issue2.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elem"}`;
6769
- return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue2.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue2.maximum.toString()}`;
7053
+ return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} ima ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemenata"}`;
7054
+ return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} bude ${adj}${issue2.maximum.toString()}`;
6770
7055
  }
6771
7056
  case "too_small": {
6772
7057
  const adj = issue2.inclusive ? ">=" : ">";
6773
7058
  const sizing = getSizing(issue2.origin);
7059
+ const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
6774
7060
  if (sizing) {
6775
- return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} m\xE9rete t\xFAl kicsi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
7061
+ return `Premalo: o\u010Dekivano da ${origin} ima ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
6776
7062
  }
6777
- return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} t\xFAl kicsi ${adj}${issue2.minimum.toString()}`;
7063
+ return `Premalo: o\u010Dekivano da ${origin} bude ${adj}${issue2.minimum.toString()}`;
6778
7064
  }
6779
7065
  case "invalid_format": {
6780
7066
  const _issue = issue2;
6781
7067
  if (_issue.format === "starts_with")
6782
- return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
7068
+ return `Neispravan tekst: mora zapo\u010Dinjati s "${_issue.prefix}"`;
6783
7069
  if (_issue.format === "ends_with")
6784
- return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
7070
+ return `Neispravan tekst: mora zavr\u0161avati s "${_issue.suffix}"`;
7071
+ if (_issue.format === "includes")
7072
+ return `Neispravan tekst: mora sadr\u017Eavati "${_issue.includes}"`;
7073
+ if (_issue.format === "regex")
7074
+ return `Neispravan tekst: mora odgovarati uzorku ${_issue.pattern}`;
7075
+ return `Neispravna ${FormatDictionary[_issue.format] ?? issue2.format}`;
7076
+ }
7077
+ case "not_multiple_of":
7078
+ return `Neispravan broj: mora biti vi\u0161ekratnik od ${issue2.divisor}`;
7079
+ case "unrecognized_keys":
7080
+ return `Neprepoznat${issue2.keys.length > 1 ? "i klju\u010Devi" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
7081
+ case "invalid_key":
7082
+ return `Neispravan klju\u010D u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
7083
+ case "invalid_union":
7084
+ return "Neispravan unos";
7085
+ case "invalid_element":
7086
+ return `Neispravna vrijednost u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
7087
+ default:
7088
+ return `Neispravan unos`;
7089
+ }
7090
+ };
7091
+ };
7092
+ function hr_default() {
7093
+ return {
7094
+ localeError: error18()
7095
+ };
7096
+ }
7097
+
7098
+ // node_modules/zod/v4/locales/hu.js
7099
+ var error19 = () => {
7100
+ const Sizable = {
7101
+ string: { unit: "karakter", verb: "legyen" },
7102
+ file: { unit: "byte", verb: "legyen" },
7103
+ array: { unit: "elem", verb: "legyen" },
7104
+ set: { unit: "elem", verb: "legyen" }
7105
+ };
7106
+ function getSizing(origin) {
7107
+ return Sizable[origin] ?? null;
7108
+ }
7109
+ const FormatDictionary = {
7110
+ regex: "bemenet",
7111
+ email: "email c\xEDm",
7112
+ url: "URL",
7113
+ emoji: "emoji",
7114
+ uuid: "UUID",
7115
+ uuidv4: "UUIDv4",
7116
+ uuidv6: "UUIDv6",
7117
+ nanoid: "nanoid",
7118
+ guid: "GUID",
7119
+ cuid: "cuid",
7120
+ cuid2: "cuid2",
7121
+ ulid: "ULID",
7122
+ xid: "XID",
7123
+ ksuid: "KSUID",
7124
+ datetime: "ISO id\u0151b\xE9lyeg",
7125
+ date: "ISO d\xE1tum",
7126
+ time: "ISO id\u0151",
7127
+ duration: "ISO id\u0151intervallum",
7128
+ ipv4: "IPv4 c\xEDm",
7129
+ ipv6: "IPv6 c\xEDm",
7130
+ cidrv4: "IPv4 tartom\xE1ny",
7131
+ cidrv6: "IPv6 tartom\xE1ny",
7132
+ base64: "base64-k\xF3dolt string",
7133
+ base64url: "base64url-k\xF3dolt string",
7134
+ json_string: "JSON string",
7135
+ e164: "E.164 sz\xE1m",
7136
+ jwt: "JWT",
7137
+ template_literal: "bemenet"
7138
+ };
7139
+ const TypeDictionary = {
7140
+ nan: "NaN",
7141
+ number: "sz\xE1m",
7142
+ array: "t\xF6mb"
7143
+ };
7144
+ return (issue2) => {
7145
+ switch (issue2.code) {
7146
+ case "invalid_type": {
7147
+ const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
7148
+ const receivedType = parsedType(issue2.input);
7149
+ const received = TypeDictionary[receivedType] ?? receivedType;
7150
+ if (/^[A-Z]/.test(issue2.expected)) {
7151
+ return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
7152
+ }
7153
+ return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
7154
+ }
7155
+ case "invalid_value":
7156
+ if (issue2.values.length === 1)
7157
+ return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
7158
+ return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
7159
+ case "too_big": {
7160
+ const adj = issue2.inclusive ? "<=" : "<";
7161
+ const sizing = getSizing(issue2.origin);
7162
+ if (sizing)
7163
+ return `T\xFAl nagy: ${issue2.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elem"}`;
7164
+ return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue2.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue2.maximum.toString()}`;
7165
+ }
7166
+ case "too_small": {
7167
+ const adj = issue2.inclusive ? ">=" : ">";
7168
+ const sizing = getSizing(issue2.origin);
7169
+ if (sizing) {
7170
+ return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} m\xE9rete t\xFAl kicsi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
7171
+ }
7172
+ return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} t\xFAl kicsi ${adj}${issue2.minimum.toString()}`;
7173
+ }
7174
+ case "invalid_format": {
7175
+ const _issue = issue2;
7176
+ if (_issue.format === "starts_with")
7177
+ return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
7178
+ if (_issue.format === "ends_with")
7179
+ return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
6785
7180
  if (_issue.format === "includes")
6786
7181
  return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
6787
7182
  if (_issue.format === "regex")
@@ -6805,7 +7200,7 @@
6805
7200
  };
6806
7201
  function hu_default() {
6807
7202
  return {
6808
- localeError: error17()
7203
+ localeError: error19()
6809
7204
  };
6810
7205
  }
6811
7206
 
@@ -6820,7 +7215,7 @@
6820
7215
  const lastChar = word[word.length - 1];
6821
7216
  return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
6822
7217
  }
6823
- var error18 = () => {
7218
+ var error20 = () => {
6824
7219
  const Sizable = {
6825
7220
  string: {
6826
7221
  unit: {
@@ -6953,12 +7348,12 @@
6953
7348
  };
6954
7349
  function hy_default() {
6955
7350
  return {
6956
- localeError: error18()
7351
+ localeError: error20()
6957
7352
  };
6958
7353
  }
6959
7354
 
6960
7355
  // node_modules/zod/v4/locales/id.js
6961
- var error19 = () => {
7356
+ var error21 = () => {
6962
7357
  const Sizable = {
6963
7358
  string: { unit: "karakter", verb: "memiliki" },
6964
7359
  file: { unit: "byte", verb: "memiliki" },
@@ -7060,12 +7455,12 @@
7060
7455
  };
7061
7456
  function id_default() {
7062
7457
  return {
7063
- localeError: error19()
7458
+ localeError: error21()
7064
7459
  };
7065
7460
  }
7066
7461
 
7067
7462
  // node_modules/zod/v4/locales/is.js
7068
- var error20 = () => {
7463
+ var error22 = () => {
7069
7464
  const Sizable = {
7070
7465
  string: { unit: "stafi", verb: "a\xF0 hafa" },
7071
7466
  file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
@@ -7170,12 +7565,12 @@
7170
7565
  };
7171
7566
  function is_default() {
7172
7567
  return {
7173
- localeError: error20()
7568
+ localeError: error22()
7174
7569
  };
7175
7570
  }
7176
7571
 
7177
7572
  // node_modules/zod/v4/locales/it.js
7178
- var error21 = () => {
7573
+ var error23 = () => {
7179
7574
  const Sizable = {
7180
7575
  string: { unit: "caratteri", verb: "avere" },
7181
7576
  file: { unit: "byte", verb: "avere" },
@@ -7260,7 +7655,7 @@
7260
7655
  return `Stringa non valida: deve includere "${_issue.includes}"`;
7261
7656
  if (_issue.format === "regex")
7262
7657
  return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
7263
- return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
7658
+ return `Input non valido: ${FormatDictionary[_issue.format] ?? issue2.format}`;
7264
7659
  }
7265
7660
  case "not_multiple_of":
7266
7661
  return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
@@ -7279,12 +7674,12 @@
7279
7674
  };
7280
7675
  function it_default() {
7281
7676
  return {
7282
- localeError: error21()
7677
+ localeError: error23()
7283
7678
  };
7284
7679
  }
7285
7680
 
7286
7681
  // node_modules/zod/v4/locales/ja.js
7287
- var error22 = () => {
7682
+ var error24 = () => {
7288
7683
  const Sizable = {
7289
7684
  string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
7290
7685
  file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
@@ -7387,12 +7782,12 @@
7387
7782
  };
7388
7783
  function ja_default() {
7389
7784
  return {
7390
- localeError: error22()
7785
+ localeError: error24()
7391
7786
  };
7392
7787
  }
7393
7788
 
7394
7789
  // node_modules/zod/v4/locales/ka.js
7395
- var error23 = () => {
7790
+ var error25 = () => {
7396
7791
  const Sizable = {
7397
7792
  string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
7398
7793
  file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
@@ -7425,9 +7820,9 @@
7425
7820
  ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
7426
7821
  cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
7427
7822
  cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
7428
- base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7429
- base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7430
- json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7823
+ base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
7824
+ base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
7825
+ json_string: "JSON \u10D5\u10D4\u10DA\u10D8",
7431
7826
  e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
7432
7827
  jwt: "JWT",
7433
7828
  template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
@@ -7435,7 +7830,7 @@
7435
7830
  const TypeDictionary = {
7436
7831
  nan: "NaN",
7437
7832
  number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
7438
- string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
7833
+ string: "\u10D5\u10D4\u10DA\u10D8",
7439
7834
  boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
7440
7835
  function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
7441
7836
  array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
@@ -7473,14 +7868,14 @@
7473
7868
  case "invalid_format": {
7474
7869
  const _issue = issue2;
7475
7870
  if (_issue.format === "starts_with") {
7476
- return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
7871
+ return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
7477
7872
  }
7478
7873
  if (_issue.format === "ends_with")
7479
- return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
7874
+ return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
7480
7875
  if (_issue.format === "includes")
7481
- 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`;
7876
+ return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
7482
7877
  if (_issue.format === "regex")
7483
- 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}`;
7878
+ return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D4\u10DA\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}`;
7484
7879
  return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;
7485
7880
  }
7486
7881
  case "not_multiple_of":
@@ -7500,12 +7895,12 @@
7500
7895
  };
7501
7896
  function ka_default() {
7502
7897
  return {
7503
- localeError: error23()
7898
+ localeError: error25()
7504
7899
  };
7505
7900
  }
7506
7901
 
7507
7902
  // node_modules/zod/v4/locales/km.js
7508
- var error24 = () => {
7903
+ var error26 = () => {
7509
7904
  const Sizable = {
7510
7905
  string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
7511
7906
  file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
@@ -7611,7 +8006,7 @@
7611
8006
  };
7612
8007
  function km_default() {
7613
8008
  return {
7614
- localeError: error24()
8009
+ localeError: error26()
7615
8010
  };
7616
8011
  }
7617
8012
 
@@ -7621,7 +8016,7 @@
7621
8016
  }
7622
8017
 
7623
8018
  // node_modules/zod/v4/locales/ko.js
7624
- var error25 = () => {
8019
+ var error27 = () => {
7625
8020
  const Sizable = {
7626
8021
  string: { unit: "\uBB38\uC790", verb: "to have" },
7627
8022
  file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
@@ -7728,7 +8123,7 @@
7728
8123
  };
7729
8124
  function ko_default() {
7730
8125
  return {
7731
- localeError: error25()
8126
+ localeError: error27()
7732
8127
  };
7733
8128
  }
7734
8129
 
@@ -7746,7 +8141,7 @@
7746
8141
  return "one";
7747
8142
  return "few";
7748
8143
  }
7749
- var error26 = () => {
8144
+ var error28 = () => {
7750
8145
  const Sizable = {
7751
8146
  string: {
7752
8147
  unit: {
@@ -7932,12 +8327,12 @@
7932
8327
  };
7933
8328
  function lt_default() {
7934
8329
  return {
7935
- localeError: error26()
8330
+ localeError: error28()
7936
8331
  };
7937
8332
  }
7938
8333
 
7939
8334
  // node_modules/zod/v4/locales/mk.js
7940
- var error27 = () => {
8335
+ var error29 = () => {
7941
8336
  const Sizable = {
7942
8337
  string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
7943
8338
  file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
@@ -8042,12 +8437,12 @@
8042
8437
  };
8043
8438
  function mk_default() {
8044
8439
  return {
8045
- localeError: error27()
8440
+ localeError: error29()
8046
8441
  };
8047
8442
  }
8048
8443
 
8049
8444
  // node_modules/zod/v4/locales/ms.js
8050
- var error28 = () => {
8445
+ var error30 = () => {
8051
8446
  const Sizable = {
8052
8447
  string: { unit: "aksara", verb: "mempunyai" },
8053
8448
  file: { unit: "bait", verb: "mempunyai" },
@@ -8150,12 +8545,12 @@
8150
8545
  };
8151
8546
  function ms_default() {
8152
8547
  return {
8153
- localeError: error28()
8548
+ localeError: error30()
8154
8549
  };
8155
8550
  }
8156
8551
 
8157
8552
  // node_modules/zod/v4/locales/nl.js
8158
- var error29 = () => {
8553
+ var error31 = () => {
8159
8554
  const Sizable = {
8160
8555
  string: { unit: "tekens", verb: "heeft" },
8161
8556
  file: { unit: "bytes", verb: "heeft" },
@@ -8261,12 +8656,12 @@
8261
8656
  };
8262
8657
  function nl_default() {
8263
8658
  return {
8264
- localeError: error29()
8659
+ localeError: error31()
8265
8660
  };
8266
8661
  }
8267
8662
 
8268
8663
  // node_modules/zod/v4/locales/no.js
8269
- var error30 = () => {
8664
+ var error32 = () => {
8270
8665
  const Sizable = {
8271
8666
  string: { unit: "tegn", verb: "\xE5 ha" },
8272
8667
  file: { unit: "bytes", verb: "\xE5 ha" },
@@ -8370,12 +8765,12 @@
8370
8765
  };
8371
8766
  function no_default() {
8372
8767
  return {
8373
- localeError: error30()
8768
+ localeError: error32()
8374
8769
  };
8375
8770
  }
8376
8771
 
8377
8772
  // node_modules/zod/v4/locales/ota.js
8378
- var error31 = () => {
8773
+ var error33 = () => {
8379
8774
  const Sizable = {
8380
8775
  string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
8381
8776
  file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
@@ -8480,12 +8875,12 @@
8480
8875
  };
8481
8876
  function ota_default() {
8482
8877
  return {
8483
- localeError: error31()
8878
+ localeError: error33()
8484
8879
  };
8485
8880
  }
8486
8881
 
8487
8882
  // node_modules/zod/v4/locales/ps.js
8488
- var error32 = () => {
8883
+ var error34 = () => {
8489
8884
  const Sizable = {
8490
8885
  string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
8491
8886
  file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
@@ -8595,12 +8990,12 @@
8595
8990
  };
8596
8991
  function ps_default() {
8597
8992
  return {
8598
- localeError: error32()
8993
+ localeError: error34()
8599
8994
  };
8600
8995
  }
8601
8996
 
8602
8997
  // node_modules/zod/v4/locales/pl.js
8603
- var error33 = () => {
8998
+ var error35 = () => {
8604
8999
  const Sizable = {
8605
9000
  string: { unit: "znak\xF3w", verb: "mie\u0107" },
8606
9001
  file: { unit: "bajt\xF3w", verb: "mie\u0107" },
@@ -8705,12 +9100,12 @@
8705
9100
  };
8706
9101
  function pl_default() {
8707
9102
  return {
8708
- localeError: error33()
9103
+ localeError: error35()
8709
9104
  };
8710
9105
  }
8711
9106
 
8712
9107
  // node_modules/zod/v4/locales/pt.js
8713
- var error34 = () => {
9108
+ var error36 = () => {
8714
9109
  const Sizable = {
8715
9110
  string: { unit: "caracteres", verb: "ter" },
8716
9111
  file: { unit: "bytes", verb: "ter" },
@@ -8814,7 +9209,127 @@
8814
9209
  };
8815
9210
  function pt_default() {
8816
9211
  return {
8817
- localeError: error34()
9212
+ localeError: error36()
9213
+ };
9214
+ }
9215
+
9216
+ // node_modules/zod/v4/locales/ro.js
9217
+ var error37 = () => {
9218
+ const Sizable = {
9219
+ string: { unit: "caractere", verb: "s\u0103 aib\u0103" },
9220
+ file: { unit: "octe\u021Bi", verb: "s\u0103 aib\u0103" },
9221
+ array: { unit: "elemente", verb: "s\u0103 aib\u0103" },
9222
+ set: { unit: "elemente", verb: "s\u0103 aib\u0103" },
9223
+ map: { unit: "intr\u0103ri", verb: "s\u0103 aib\u0103" }
9224
+ };
9225
+ function getSizing(origin) {
9226
+ return Sizable[origin] ?? null;
9227
+ }
9228
+ const FormatDictionary = {
9229
+ regex: "intrare",
9230
+ email: "adres\u0103 de email",
9231
+ url: "URL",
9232
+ emoji: "emoji",
9233
+ uuid: "UUID",
9234
+ uuidv4: "UUIDv4",
9235
+ uuidv6: "UUIDv6",
9236
+ nanoid: "nanoid",
9237
+ guid: "GUID",
9238
+ cuid: "cuid",
9239
+ cuid2: "cuid2",
9240
+ ulid: "ULID",
9241
+ xid: "XID",
9242
+ ksuid: "KSUID",
9243
+ datetime: "dat\u0103 \u0219i or\u0103 ISO",
9244
+ date: "dat\u0103 ISO",
9245
+ time: "or\u0103 ISO",
9246
+ duration: "durat\u0103 ISO",
9247
+ ipv4: "adres\u0103 IPv4",
9248
+ ipv6: "adres\u0103 IPv6",
9249
+ mac: "adres\u0103 MAC",
9250
+ cidrv4: "interval IPv4",
9251
+ cidrv6: "interval IPv6",
9252
+ base64: "\u0219ir codat base64",
9253
+ base64url: "\u0219ir codat base64url",
9254
+ json_string: "\u0219ir JSON",
9255
+ e164: "num\u0103r E.164",
9256
+ jwt: "JWT",
9257
+ template_literal: "intrare"
9258
+ };
9259
+ const TypeDictionary = {
9260
+ nan: "NaN",
9261
+ string: "\u0219ir",
9262
+ number: "num\u0103r",
9263
+ boolean: "boolean",
9264
+ function: "func\u021Bie",
9265
+ array: "matrice",
9266
+ object: "obiect",
9267
+ undefined: "nedefinit",
9268
+ symbol: "simbol",
9269
+ bigint: "num\u0103r mare",
9270
+ void: "void",
9271
+ never: "never",
9272
+ map: "hart\u0103",
9273
+ set: "set"
9274
+ };
9275
+ return (issue2) => {
9276
+ switch (issue2.code) {
9277
+ case "invalid_type": {
9278
+ const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
9279
+ const receivedType = parsedType(issue2.input);
9280
+ const received = TypeDictionary[receivedType] ?? receivedType;
9281
+ return `Intrare invalid\u0103: a\u0219teptat ${expected}, primit ${received}`;
9282
+ }
9283
+ case "invalid_value":
9284
+ if (issue2.values.length === 1)
9285
+ return `Intrare invalid\u0103: a\u0219teptat ${stringifyPrimitive(issue2.values[0])}`;
9286
+ return `Op\u021Biune invalid\u0103: a\u0219teptat una dintre ${joinValues(issue2.values, "|")}`;
9287
+ case "too_big": {
9288
+ const adj = issue2.inclusive ? "<=" : "<";
9289
+ const sizing = getSizing(issue2.origin);
9290
+ if (sizing)
9291
+ return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemente"}`;
9292
+ return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} s\u0103 fie ${adj}${issue2.maximum.toString()}`;
9293
+ }
9294
+ case "too_small": {
9295
+ const adj = issue2.inclusive ? ">=" : ">";
9296
+ const sizing = getSizing(issue2.origin);
9297
+ if (sizing) {
9298
+ return `Prea mic: a\u0219teptat ca ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
9299
+ }
9300
+ return `Prea mic: a\u0219teptat ca ${issue2.origin} s\u0103 fie ${adj}${issue2.minimum.toString()}`;
9301
+ }
9302
+ case "invalid_format": {
9303
+ const _issue = issue2;
9304
+ if (_issue.format === "starts_with") {
9305
+ return `\u0218ir invalid: trebuie s\u0103 \xEEnceap\u0103 cu "${_issue.prefix}"`;
9306
+ }
9307
+ if (_issue.format === "ends_with")
9308
+ return `\u0218ir invalid: trebuie s\u0103 se termine cu "${_issue.suffix}"`;
9309
+ if (_issue.format === "includes")
9310
+ return `\u0218ir invalid: trebuie s\u0103 includ\u0103 "${_issue.includes}"`;
9311
+ if (_issue.format === "regex")
9312
+ return `\u0218ir invalid: trebuie s\u0103 se potriveasc\u0103 cu modelul ${_issue.pattern}`;
9313
+ return `Format invalid: ${FormatDictionary[_issue.format] ?? issue2.format}`;
9314
+ }
9315
+ case "not_multiple_of":
9316
+ return `Num\u0103r invalid: trebuie s\u0103 fie multiplu de ${issue2.divisor}`;
9317
+ case "unrecognized_keys":
9318
+ return `Chei nerecunoscute: ${joinValues(issue2.keys, ", ")}`;
9319
+ case "invalid_key":
9320
+ return `Cheie invalid\u0103 \xEEn ${issue2.origin}`;
9321
+ case "invalid_union":
9322
+ return "Intrare invalid\u0103";
9323
+ case "invalid_element":
9324
+ return `Valoare invalid\u0103 \xEEn ${issue2.origin}`;
9325
+ default:
9326
+ return `Intrare invalid\u0103`;
9327
+ }
9328
+ };
9329
+ };
9330
+ function ro_default() {
9331
+ return {
9332
+ localeError: error37()
8818
9333
  };
8819
9334
  }
8820
9335
 
@@ -8834,7 +9349,7 @@
8834
9349
  }
8835
9350
  return many;
8836
9351
  }
8837
- var error35 = () => {
9352
+ var error38 = () => {
8838
9353
  const Sizable = {
8839
9354
  string: {
8840
9355
  unit: {
@@ -8971,12 +9486,12 @@
8971
9486
  };
8972
9487
  function ru_default() {
8973
9488
  return {
8974
- localeError: error35()
9489
+ localeError: error38()
8975
9490
  };
8976
9491
  }
8977
9492
 
8978
9493
  // node_modules/zod/v4/locales/sl.js
8979
- var error36 = () => {
9494
+ var error39 = () => {
8980
9495
  const Sizable = {
8981
9496
  string: { unit: "znakov", verb: "imeti" },
8982
9497
  file: { unit: "bajtov", verb: "imeti" },
@@ -9081,12 +9596,12 @@
9081
9596
  };
9082
9597
  function sl_default() {
9083
9598
  return {
9084
- localeError: error36()
9599
+ localeError: error39()
9085
9600
  };
9086
9601
  }
9087
9602
 
9088
9603
  // node_modules/zod/v4/locales/sv.js
9089
- var error37 = () => {
9604
+ var error40 = () => {
9090
9605
  const Sizable = {
9091
9606
  string: { unit: "tecken", verb: "att ha" },
9092
9607
  file: { unit: "bytes", verb: "att ha" },
@@ -9192,12 +9707,12 @@
9192
9707
  };
9193
9708
  function sv_default() {
9194
9709
  return {
9195
- localeError: error37()
9710
+ localeError: error40()
9196
9711
  };
9197
9712
  }
9198
9713
 
9199
9714
  // node_modules/zod/v4/locales/ta.js
9200
- var error38 = () => {
9715
+ var error41 = () => {
9201
9716
  const Sizable = {
9202
9717
  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" },
9203
9718
  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" },
@@ -9303,12 +9818,12 @@
9303
9818
  };
9304
9819
  function ta_default() {
9305
9820
  return {
9306
- localeError: error38()
9821
+ localeError: error41()
9307
9822
  };
9308
9823
  }
9309
9824
 
9310
9825
  // node_modules/zod/v4/locales/th.js
9311
- var error39 = () => {
9826
+ var error42 = () => {
9312
9827
  const Sizable = {
9313
9828
  string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
9314
9829
  file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
@@ -9414,12 +9929,12 @@
9414
9929
  };
9415
9930
  function th_default() {
9416
9931
  return {
9417
- localeError: error39()
9932
+ localeError: error42()
9418
9933
  };
9419
9934
  }
9420
9935
 
9421
9936
  // node_modules/zod/v4/locales/tr.js
9422
- var error40 = () => {
9937
+ var error43 = () => {
9423
9938
  const Sizable = {
9424
9939
  string: { unit: "karakter", verb: "olmal\u0131" },
9425
9940
  file: { unit: "bayt", verb: "olmal\u0131" },
@@ -9520,12 +10035,12 @@
9520
10035
  };
9521
10036
  function tr_default() {
9522
10037
  return {
9523
- localeError: error40()
10038
+ localeError: error43()
9524
10039
  };
9525
10040
  }
9526
10041
 
9527
10042
  // node_modules/zod/v4/locales/uk.js
9528
- var error41 = () => {
10043
+ var error44 = () => {
9529
10044
  const Sizable = {
9530
10045
  string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
9531
10046
  file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
@@ -9629,7 +10144,7 @@
9629
10144
  };
9630
10145
  function uk_default() {
9631
10146
  return {
9632
- localeError: error41()
10147
+ localeError: error44()
9633
10148
  };
9634
10149
  }
9635
10150
 
@@ -9639,7 +10154,7 @@
9639
10154
  }
9640
10155
 
9641
10156
  // node_modules/zod/v4/locales/ur.js
9642
- var error42 = () => {
10157
+ var error45 = () => {
9643
10158
  const Sizable = {
9644
10159
  string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
9645
10160
  file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
@@ -9745,17 +10260,18 @@
9745
10260
  };
9746
10261
  function ur_default() {
9747
10262
  return {
9748
- localeError: error42()
10263
+ localeError: error45()
9749
10264
  };
9750
10265
  }
9751
10266
 
9752
10267
  // node_modules/zod/v4/locales/uz.js
9753
- var error43 = () => {
10268
+ var error46 = () => {
9754
10269
  const Sizable = {
9755
10270
  string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
9756
10271
  file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
9757
10272
  array: { unit: "element", verb: "bo\u2018lishi kerak" },
9758
- set: { unit: "element", verb: "bo\u2018lishi kerak" }
10273
+ set: { unit: "element", verb: "bo\u2018lishi kerak" },
10274
+ map: { unit: "yozuv", verb: "bo\u2018lishi kerak" }
9759
10275
  };
9760
10276
  function getSizing(origin) {
9761
10277
  return Sizable[origin] ?? null;
@@ -9855,12 +10371,12 @@
9855
10371
  };
9856
10372
  function uz_default() {
9857
10373
  return {
9858
- localeError: error43()
10374
+ localeError: error46()
9859
10375
  };
9860
10376
  }
9861
10377
 
9862
10378
  // node_modules/zod/v4/locales/vi.js
9863
- var error44 = () => {
10379
+ var error47 = () => {
9864
10380
  const Sizable = {
9865
10381
  string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
9866
10382
  file: { unit: "byte", verb: "c\xF3" },
@@ -9964,12 +10480,12 @@
9964
10480
  };
9965
10481
  function vi_default() {
9966
10482
  return {
9967
- localeError: error44()
10483
+ localeError: error47()
9968
10484
  };
9969
10485
  }
9970
10486
 
9971
10487
  // node_modules/zod/v4/locales/zh-CN.js
9972
- var error45 = () => {
10488
+ var error48 = () => {
9973
10489
  const Sizable = {
9974
10490
  string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
9975
10491
  file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
@@ -10074,12 +10590,12 @@
10074
10590
  };
10075
10591
  function zh_CN_default() {
10076
10592
  return {
10077
- localeError: error45()
10593
+ localeError: error48()
10078
10594
  };
10079
10595
  }
10080
10596
 
10081
10597
  // node_modules/zod/v4/locales/zh-TW.js
10082
- var error46 = () => {
10598
+ var error49 = () => {
10083
10599
  const Sizable = {
10084
10600
  string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
10085
10601
  file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
@@ -10182,12 +10698,12 @@
10182
10698
  };
10183
10699
  function zh_TW_default() {
10184
10700
  return {
10185
- localeError: error46()
10701
+ localeError: error49()
10186
10702
  };
10187
10703
  }
10188
10704
 
10189
10705
  // node_modules/zod/v4/locales/yo.js
10190
- var error47 = () => {
10706
+ var error50 = () => {
10191
10707
  const Sizable = {
10192
10708
  string: { unit: "\xE0mi", verb: "n\xED" },
10193
10709
  file: { unit: "bytes", verb: "n\xED" },
@@ -10290,12 +10806,12 @@
10290
10806
  };
10291
10807
  function yo_default() {
10292
10808
  return {
10293
- localeError: error47()
10809
+ localeError: error50()
10294
10810
  };
10295
10811
  }
10296
10812
 
10297
10813
  // node_modules/zod/v4/core/registries.js
10298
- var _a;
10814
+ var _a2;
10299
10815
  var $output = /* @__PURE__ */ Symbol("ZodOutput");
10300
10816
  var $input = /* @__PURE__ */ Symbol("ZodInput");
10301
10817
  var $ZodRegistry = class {
@@ -10341,7 +10857,7 @@
10341
10857
  function registry() {
10342
10858
  return new $ZodRegistry();
10343
10859
  }
10344
- (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
10860
+ (_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
10345
10861
  var globalRegistry = globalThis.__zod_globalRegistry;
10346
10862
 
10347
10863
  // node_modules/zod/v4/core/api.js
@@ -11259,7 +11775,7 @@
11259
11775
  return schema;
11260
11776
  }
11261
11777
  // @__NO_SIDE_EFFECTS__
11262
- function _superRefine(fn) {
11778
+ function _superRefine(fn, params) {
11263
11779
  const ch = /* @__PURE__ */ _check((payload) => {
11264
11780
  payload.addIssue = (issue2) => {
11265
11781
  if (typeof issue2 === "string") {
@@ -11276,7 +11792,7 @@
11276
11792
  }
11277
11793
  };
11278
11794
  return fn(payload.value, payload);
11279
- });
11795
+ }, params);
11280
11796
  return ch;
11281
11797
  }
11282
11798
  // @__NO_SIDE_EFFECTS__
@@ -11406,7 +11922,7 @@
11406
11922
  };
11407
11923
  }
11408
11924
  function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
11409
- var _a2;
11925
+ var _a3;
11410
11926
  const def = schema._zod.def;
11411
11927
  const seen = ctx.seen.get(schema);
11412
11928
  if (seen) {
@@ -11453,8 +11969,8 @@
11453
11969
  delete result.schema.examples;
11454
11970
  delete result.schema.default;
11455
11971
  }
11456
- if (ctx.io === "input" && result.schema._prefault)
11457
- (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
11972
+ if (ctx.io === "input" && "_prefault" in result.schema)
11973
+ (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
11458
11974
  delete result.schema._prefault;
11459
11975
  const _result = ctx.seen.get(schema);
11460
11976
  return _result.schema;
@@ -11635,10 +12151,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
11635
12151
  result.$id = ctx.external.uri(id);
11636
12152
  }
11637
12153
  Object.assign(result, root.def ?? root.schema);
12154
+ const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
12155
+ if (rootMetaId !== void 0 && result.id === rootMetaId)
12156
+ delete result.id;
11638
12157
  const defs = ctx.external?.defs ?? {};
11639
12158
  for (const entry of ctx.seen.entries()) {
11640
12159
  const seen = entry[1];
11641
12160
  if (seen.def && seen.defId) {
12161
+ if (seen.def.id === seen.defId)
12162
+ delete seen.def.id;
11642
12163
  defs[seen.defId] = seen.def;
11643
12164
  }
11644
12165
  }
@@ -11783,39 +12304,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
11783
12304
  json2.type = "integer";
11784
12305
  else
11785
12306
  json2.type = "number";
11786
- if (typeof exclusiveMinimum === "number") {
11787
- if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
12307
+ const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
12308
+ const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
12309
+ const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
12310
+ if (exMin) {
12311
+ if (legacy) {
11788
12312
  json2.minimum = exclusiveMinimum;
11789
12313
  json2.exclusiveMinimum = true;
11790
12314
  } else {
11791
12315
  json2.exclusiveMinimum = exclusiveMinimum;
11792
12316
  }
11793
- }
11794
- if (typeof minimum === "number") {
12317
+ } else if (typeof minimum === "number") {
11795
12318
  json2.minimum = minimum;
11796
- if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
11797
- if (exclusiveMinimum >= minimum)
11798
- delete json2.minimum;
11799
- else
11800
- delete json2.exclusiveMinimum;
11801
- }
11802
12319
  }
11803
- if (typeof exclusiveMaximum === "number") {
11804
- if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
12320
+ if (exMax) {
12321
+ if (legacy) {
11805
12322
  json2.maximum = exclusiveMaximum;
11806
12323
  json2.exclusiveMaximum = true;
11807
12324
  } else {
11808
12325
  json2.exclusiveMaximum = exclusiveMaximum;
11809
12326
  }
11810
- }
11811
- if (typeof maximum === "number") {
12327
+ } else if (typeof maximum === "number") {
11812
12328
  json2.maximum = maximum;
11813
- if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
11814
- if (exclusiveMaximum <= maximum)
11815
- delete json2.maximum;
11816
- else
11817
- delete json2.exclusiveMaximum;
11818
- }
11819
12329
  }
11820
12330
  if (typeof multipleOf === "number")
11821
12331
  json2.multipleOf = multipleOf;
@@ -11987,7 +12497,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
11987
12497
  if (typeof maximum === "number")
11988
12498
  json2.maxItems = maximum;
11989
12499
  json2.type = "array";
11990
- json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
12500
+ json2.items = process2(def.element, ctx, {
12501
+ ...params,
12502
+ path: [...params.path, "items"]
12503
+ });
11991
12504
  };
11992
12505
  var objectProcessor = (schema, ctx, _json, params) => {
11993
12506
  const json2 = _json;
@@ -12474,6 +12987,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12474
12987
  int32: () => int32,
12475
12988
  int64: () => int64,
12476
12989
  intersection: () => intersection,
12990
+ invertCodec: () => invertCodec,
12477
12991
  ipv4: () => ipv42,
12478
12992
  ipv6: () => ipv62,
12479
12993
  json: () => json,
@@ -12643,8 +13157,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12643
13157
  }
12644
13158
  });
12645
13159
  };
12646
- var ZodError = $constructor("ZodError", initializer2);
12647
- var ZodRealError = $constructor("ZodError", initializer2, {
13160
+ var ZodError = /* @__PURE__ */ $constructor("ZodError", initializer2);
13161
+ var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
12648
13162
  Parent: Error
12649
13163
  });
12650
13164
 
@@ -12663,6 +13177,43 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12663
13177
  var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
12664
13178
 
12665
13179
  // node_modules/zod/v4/classic/schemas.js
13180
+ var _installedGroups = /* @__PURE__ */ new WeakMap();
13181
+ function _installLazyMethods(inst, group, methods) {
13182
+ const proto = Object.getPrototypeOf(inst);
13183
+ let installed = _installedGroups.get(proto);
13184
+ if (!installed) {
13185
+ installed = /* @__PURE__ */ new Set();
13186
+ _installedGroups.set(proto, installed);
13187
+ }
13188
+ if (installed.has(group))
13189
+ return;
13190
+ installed.add(group);
13191
+ for (const key in methods) {
13192
+ const fn = methods[key];
13193
+ Object.defineProperty(proto, key, {
13194
+ configurable: true,
13195
+ enumerable: false,
13196
+ get() {
13197
+ const bound = fn.bind(this);
13198
+ Object.defineProperty(this, key, {
13199
+ configurable: true,
13200
+ writable: true,
13201
+ enumerable: true,
13202
+ value: bound
13203
+ });
13204
+ return bound;
13205
+ },
13206
+ set(v) {
13207
+ Object.defineProperty(this, key, {
13208
+ configurable: true,
13209
+ writable: true,
13210
+ enumerable: true,
13211
+ value: v
13212
+ });
13213
+ }
13214
+ });
13215
+ }
13216
+ }
12666
13217
  var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
12667
13218
  $ZodType.init(inst, def);
12668
13219
  Object.assign(inst["~standard"], {
@@ -12675,23 +13226,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12675
13226
  inst.def = def;
12676
13227
  inst.type = def.type;
12677
13228
  Object.defineProperty(inst, "_def", { value: def });
12678
- inst.check = (...checks) => {
12679
- return inst.clone(util_exports.mergeDefs(def, {
12680
- checks: [
12681
- ...def.checks ?? [],
12682
- ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
12683
- ]
12684
- }), {
12685
- parent: true
12686
- });
12687
- };
12688
- inst.with = inst.check;
12689
- inst.clone = (def2, params) => clone(inst, def2, params);
12690
- inst.brand = () => inst;
12691
- inst.register = ((reg, meta3) => {
12692
- reg.add(inst, meta3);
12693
- return inst;
12694
- });
12695
13229
  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
12696
13230
  inst.safeParse = (data, params) => safeParse2(inst, data, params);
12697
13231
  inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
@@ -12705,45 +13239,108 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12705
13239
  inst.safeDecode = (data, params) => safeDecode2(inst, data, params);
12706
13240
  inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);
12707
13241
  inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);
12708
- inst.refine = (check2, params) => inst.check(refine(check2, params));
12709
- inst.superRefine = (refinement) => inst.check(superRefine(refinement));
12710
- inst.overwrite = (fn) => inst.check(_overwrite(fn));
12711
- inst.optional = () => optional(inst);
12712
- inst.exactOptional = () => exactOptional(inst);
12713
- inst.nullable = () => nullable(inst);
12714
- inst.nullish = () => optional(nullable(inst));
12715
- inst.nonoptional = (params) => nonoptional(inst, params);
12716
- inst.array = () => array(inst);
12717
- inst.or = (arg) => union([inst, arg]);
12718
- inst.and = (arg) => intersection(inst, arg);
12719
- inst.transform = (tx) => pipe(inst, transform(tx));
12720
- inst.default = (def2) => _default2(inst, def2);
12721
- inst.prefault = (def2) => prefault(inst, def2);
12722
- inst.catch = (params) => _catch2(inst, params);
12723
- inst.pipe = (target) => pipe(inst, target);
12724
- inst.readonly = () => readonly(inst);
12725
- inst.describe = (description) => {
12726
- const cl = inst.clone();
12727
- globalRegistry.add(cl, { description });
12728
- return cl;
12729
- };
13242
+ _installLazyMethods(inst, "ZodType", {
13243
+ check(...chks) {
13244
+ const def2 = this.def;
13245
+ return this.clone(util_exports.mergeDefs(def2, {
13246
+ checks: [
13247
+ ...def2.checks ?? [],
13248
+ ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
13249
+ ]
13250
+ }), { parent: true });
13251
+ },
13252
+ with(...chks) {
13253
+ return this.check(...chks);
13254
+ },
13255
+ clone(def2, params) {
13256
+ return clone(this, def2, params);
13257
+ },
13258
+ brand() {
13259
+ return this;
13260
+ },
13261
+ register(reg, meta3) {
13262
+ reg.add(this, meta3);
13263
+ return this;
13264
+ },
13265
+ refine(check2, params) {
13266
+ return this.check(refine(check2, params));
13267
+ },
13268
+ superRefine(refinement, params) {
13269
+ return this.check(superRefine(refinement, params));
13270
+ },
13271
+ overwrite(fn) {
13272
+ return this.check(_overwrite(fn));
13273
+ },
13274
+ optional() {
13275
+ return optional(this);
13276
+ },
13277
+ exactOptional() {
13278
+ return exactOptional(this);
13279
+ },
13280
+ nullable() {
13281
+ return nullable(this);
13282
+ },
13283
+ nullish() {
13284
+ return optional(nullable(this));
13285
+ },
13286
+ nonoptional(params) {
13287
+ return nonoptional(this, params);
13288
+ },
13289
+ array() {
13290
+ return array(this);
13291
+ },
13292
+ or(arg) {
13293
+ return union([this, arg]);
13294
+ },
13295
+ and(arg) {
13296
+ return intersection(this, arg);
13297
+ },
13298
+ transform(tx) {
13299
+ return pipe(this, transform(tx));
13300
+ },
13301
+ default(d) {
13302
+ return _default2(this, d);
13303
+ },
13304
+ prefault(d) {
13305
+ return prefault(this, d);
13306
+ },
13307
+ catch(params) {
13308
+ return _catch2(this, params);
13309
+ },
13310
+ pipe(target) {
13311
+ return pipe(this, target);
13312
+ },
13313
+ readonly() {
13314
+ return readonly(this);
13315
+ },
13316
+ describe(description) {
13317
+ const cl = this.clone();
13318
+ globalRegistry.add(cl, { description });
13319
+ return cl;
13320
+ },
13321
+ meta(...args) {
13322
+ if (args.length === 0)
13323
+ return globalRegistry.get(this);
13324
+ const cl = this.clone();
13325
+ globalRegistry.add(cl, args[0]);
13326
+ return cl;
13327
+ },
13328
+ isOptional() {
13329
+ return this.safeParse(void 0).success;
13330
+ },
13331
+ isNullable() {
13332
+ return this.safeParse(null).success;
13333
+ },
13334
+ apply(fn) {
13335
+ return fn(this);
13336
+ }
13337
+ });
12730
13338
  Object.defineProperty(inst, "description", {
12731
13339
  get() {
12732
13340
  return globalRegistry.get(inst)?.description;
12733
13341
  },
12734
13342
  configurable: true
12735
13343
  });
12736
- inst.meta = (...args) => {
12737
- if (args.length === 0) {
12738
- return globalRegistry.get(inst);
12739
- }
12740
- const cl = inst.clone();
12741
- globalRegistry.add(cl, args[0]);
12742
- return cl;
12743
- };
12744
- inst.isOptional = () => inst.safeParse(void 0).success;
12745
- inst.isNullable = () => inst.safeParse(null).success;
12746
- inst.apply = (fn) => fn(inst);
12747
13344
  return inst;
12748
13345
  });
12749
13346
  var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
@@ -12754,21 +13351,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12754
13351
  inst.format = bag.format ?? null;
12755
13352
  inst.minLength = bag.minimum ?? null;
12756
13353
  inst.maxLength = bag.maximum ?? null;
12757
- inst.regex = (...args) => inst.check(_regex(...args));
12758
- inst.includes = (...args) => inst.check(_includes(...args));
12759
- inst.startsWith = (...args) => inst.check(_startsWith(...args));
12760
- inst.endsWith = (...args) => inst.check(_endsWith(...args));
12761
- inst.min = (...args) => inst.check(_minLength(...args));
12762
- inst.max = (...args) => inst.check(_maxLength(...args));
12763
- inst.length = (...args) => inst.check(_length(...args));
12764
- inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
12765
- inst.lowercase = (params) => inst.check(_lowercase(params));
12766
- inst.uppercase = (params) => inst.check(_uppercase(params));
12767
- inst.trim = () => inst.check(_trim());
12768
- inst.normalize = (...args) => inst.check(_normalize(...args));
12769
- inst.toLowerCase = () => inst.check(_toLowerCase());
12770
- inst.toUpperCase = () => inst.check(_toUpperCase());
12771
- inst.slugify = () => inst.check(_slugify());
13354
+ _installLazyMethods(inst, "_ZodString", {
13355
+ regex(...args) {
13356
+ return this.check(_regex(...args));
13357
+ },
13358
+ includes(...args) {
13359
+ return this.check(_includes(...args));
13360
+ },
13361
+ startsWith(...args) {
13362
+ return this.check(_startsWith(...args));
13363
+ },
13364
+ endsWith(...args) {
13365
+ return this.check(_endsWith(...args));
13366
+ },
13367
+ min(...args) {
13368
+ return this.check(_minLength(...args));
13369
+ },
13370
+ max(...args) {
13371
+ return this.check(_maxLength(...args));
13372
+ },
13373
+ length(...args) {
13374
+ return this.check(_length(...args));
13375
+ },
13376
+ nonempty(...args) {
13377
+ return this.check(_minLength(1, ...args));
13378
+ },
13379
+ lowercase(params) {
13380
+ return this.check(_lowercase(params));
13381
+ },
13382
+ uppercase(params) {
13383
+ return this.check(_uppercase(params));
13384
+ },
13385
+ trim() {
13386
+ return this.check(_trim());
13387
+ },
13388
+ normalize(...args) {
13389
+ return this.check(_normalize(...args));
13390
+ },
13391
+ toLowerCase() {
13392
+ return this.check(_toLowerCase());
13393
+ },
13394
+ toUpperCase() {
13395
+ return this.check(_toUpperCase());
13396
+ },
13397
+ slugify() {
13398
+ return this.check(_slugify());
13399
+ }
13400
+ });
12772
13401
  });
12773
13402
  var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
12774
13403
  $ZodString.init(inst, def);
@@ -12847,7 +13476,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12847
13476
  }
12848
13477
  function httpUrl(params) {
12849
13478
  return _url(ZodURL, {
12850
- protocol: /^https?$/,
13479
+ protocol: regexes_exports.httpProtocol,
12851
13480
  hostname: regexes_exports.domain,
12852
13481
  ...util_exports.normalizeParams(params)
12853
13482
  });
@@ -12989,21 +13618,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
12989
13618
  $ZodNumber.init(inst, def);
12990
13619
  ZodType.init(inst, def);
12991
13620
  inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
12992
- inst.gt = (value, params) => inst.check(_gt(value, params));
12993
- inst.gte = (value, params) => inst.check(_gte(value, params));
12994
- inst.min = (value, params) => inst.check(_gte(value, params));
12995
- inst.lt = (value, params) => inst.check(_lt(value, params));
12996
- inst.lte = (value, params) => inst.check(_lte(value, params));
12997
- inst.max = (value, params) => inst.check(_lte(value, params));
12998
- inst.int = (params) => inst.check(int(params));
12999
- inst.safe = (params) => inst.check(int(params));
13000
- inst.positive = (params) => inst.check(_gt(0, params));
13001
- inst.nonnegative = (params) => inst.check(_gte(0, params));
13002
- inst.negative = (params) => inst.check(_lt(0, params));
13003
- inst.nonpositive = (params) => inst.check(_lte(0, params));
13004
- inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
13005
- inst.step = (value, params) => inst.check(_multipleOf(value, params));
13006
- inst.finite = () => inst;
13621
+ _installLazyMethods(inst, "ZodNumber", {
13622
+ gt(value, params) {
13623
+ return this.check(_gt(value, params));
13624
+ },
13625
+ gte(value, params) {
13626
+ return this.check(_gte(value, params));
13627
+ },
13628
+ min(value, params) {
13629
+ return this.check(_gte(value, params));
13630
+ },
13631
+ lt(value, params) {
13632
+ return this.check(_lt(value, params));
13633
+ },
13634
+ lte(value, params) {
13635
+ return this.check(_lte(value, params));
13636
+ },
13637
+ max(value, params) {
13638
+ return this.check(_lte(value, params));
13639
+ },
13640
+ int(params) {
13641
+ return this.check(int(params));
13642
+ },
13643
+ safe(params) {
13644
+ return this.check(int(params));
13645
+ },
13646
+ positive(params) {
13647
+ return this.check(_gt(0, params));
13648
+ },
13649
+ nonnegative(params) {
13650
+ return this.check(_gte(0, params));
13651
+ },
13652
+ negative(params) {
13653
+ return this.check(_lt(0, params));
13654
+ },
13655
+ nonpositive(params) {
13656
+ return this.check(_lte(0, params));
13657
+ },
13658
+ multipleOf(value, params) {
13659
+ return this.check(_multipleOf(value, params));
13660
+ },
13661
+ step(value, params) {
13662
+ return this.check(_multipleOf(value, params));
13663
+ },
13664
+ finite() {
13665
+ return this;
13666
+ }
13667
+ });
13007
13668
  const bag = inst._zod.bag;
13008
13669
  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
13009
13670
  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
@@ -13150,11 +13811,23 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
13150
13811
  ZodType.init(inst, def);
13151
13812
  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
13152
13813
  inst.element = def.element;
13153
- inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
13154
- inst.nonempty = (params) => inst.check(_minLength(1, params));
13155
- inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
13156
- inst.length = (len, params) => inst.check(_length(len, params));
13157
- inst.unwrap = () => inst.element;
13814
+ _installLazyMethods(inst, "ZodArray", {
13815
+ min(n, params) {
13816
+ return this.check(_minLength(n, params));
13817
+ },
13818
+ nonempty(params) {
13819
+ return this.check(_minLength(1, params));
13820
+ },
13821
+ max(n, params) {
13822
+ return this.check(_maxLength(n, params));
13823
+ },
13824
+ length(n, params) {
13825
+ return this.check(_length(n, params));
13826
+ },
13827
+ unwrap() {
13828
+ return this.element;
13829
+ }
13830
+ });
13158
13831
  });
13159
13832
  function array(element, params) {
13160
13833
  return _array(ZodArray, element, params);
@@ -13170,23 +13843,47 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
13170
13843
  util_exports.defineLazy(inst, "shape", () => {
13171
13844
  return def.shape;
13172
13845
  });
13173
- inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
13174
- inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
13175
- inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
13176
- inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
13177
- inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
13178
- inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
13179
- inst.extend = (incoming) => {
13180
- return util_exports.extend(inst, incoming);
13181
- };
13182
- inst.safeExtend = (incoming) => {
13183
- return util_exports.safeExtend(inst, incoming);
13184
- };
13185
- inst.merge = (other) => util_exports.merge(inst, other);
13186
- inst.pick = (mask) => util_exports.pick(inst, mask);
13187
- inst.omit = (mask) => util_exports.omit(inst, mask);
13188
- inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
13189
- inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
13846
+ _installLazyMethods(inst, "ZodObject", {
13847
+ keyof() {
13848
+ return _enum2(Object.keys(this._zod.def.shape));
13849
+ },
13850
+ catchall(catchall) {
13851
+ return this.clone({ ...this._zod.def, catchall });
13852
+ },
13853
+ passthrough() {
13854
+ return this.clone({ ...this._zod.def, catchall: unknown() });
13855
+ },
13856
+ loose() {
13857
+ return this.clone({ ...this._zod.def, catchall: unknown() });
13858
+ },
13859
+ strict() {
13860
+ return this.clone({ ...this._zod.def, catchall: never() });
13861
+ },
13862
+ strip() {
13863
+ return this.clone({ ...this._zod.def, catchall: void 0 });
13864
+ },
13865
+ extend(incoming) {
13866
+ return util_exports.extend(this, incoming);
13867
+ },
13868
+ safeExtend(incoming) {
13869
+ return util_exports.safeExtend(this, incoming);
13870
+ },
13871
+ merge(other) {
13872
+ return util_exports.merge(this, other);
13873
+ },
13874
+ pick(mask) {
13875
+ return util_exports.pick(this, mask);
13876
+ },
13877
+ omit(mask) {
13878
+ return util_exports.omit(this, mask);
13879
+ },
13880
+ partial(...args) {
13881
+ return util_exports.partial(ZodOptional, this, args[0]);
13882
+ },
13883
+ required(...args) {
13884
+ return util_exports.required(ZodNonOptional, this, args[0]);
13885
+ }
13886
+ });
13190
13887
  });
13191
13888
  function object(shape, params) {
13192
13889
  const def = {
@@ -13291,6 +13988,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
13291
13988
  inst.valueType = def.valueType;
13292
13989
  });
13293
13990
  function record(keyType, valueType, params) {
13991
+ if (!valueType || !valueType._zod) {
13992
+ return new ZodRecord({
13993
+ type: "record",
13994
+ keyType: string2(),
13995
+ valueType: keyType,
13996
+ ...util_exports.normalizeParams(valueType)
13997
+ });
13998
+ }
13294
13999
  return new ZodRecord({
13295
14000
  type: "record",
13296
14001
  keyType,
@@ -13620,6 +14325,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
13620
14325
  reverseTransform: params.encode
13621
14326
  });
13622
14327
  }
14328
+ function invertCodec(codec2) {
14329
+ const def = codec2._zod.def;
14330
+ return new ZodCodec({
14331
+ type: "pipe",
14332
+ in: def.out,
14333
+ out: def.in,
14334
+ transform: def.reverseTransform,
14335
+ reverseTransform: def.transform
14336
+ });
14337
+ }
13623
14338
  var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
13624
14339
  $ZodReadonly.init(inst, def);
13625
14340
  ZodType.init(inst, def);
@@ -13699,8 +14414,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
13699
14414
  function refine(fn, _params = {}) {
13700
14415
  return _refine(ZodCustom, fn, _params);
13701
14416
  }
13702
- function superRefine(fn) {
13703
- return _superRefine(fn);
14417
+ function superRefine(fn, params) {
14418
+ return _superRefine(fn, params);
13704
14419
  }
13705
14420
  var describe2 = describe;
13706
14421
  var meta2 = meta;
@@ -14159,12 +14874,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
14159
14874
  default:
14160
14875
  throw new Error(`Unsupported type: ${type}`);
14161
14876
  }
14162
- if (schema.description) {
14163
- zodSchema = zodSchema.describe(schema.description);
14164
- }
14165
- if (schema.default !== void 0) {
14166
- zodSchema = zodSchema.default(schema.default);
14167
- }
14168
14877
  return zodSchema;
14169
14878
  }
14170
14879
  function convertSchema(schema, ctx) {
@@ -14201,6 +14910,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
14201
14910
  if (schema.readOnly === true) {
14202
14911
  baseSchema = z.readonly(baseSchema);
14203
14912
  }
14913
+ if (schema.default !== void 0) {
14914
+ baseSchema = baseSchema.default(schema.default);
14915
+ }
14204
14916
  const extraMeta = {};
14205
14917
  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
14206
14918
  for (const key of coreMetadataKeys) {
@@ -14222,23 +14934,32 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
14222
14934
  if (Object.keys(extraMeta).length > 0) {
14223
14935
  ctx.registry.add(baseSchema, extraMeta);
14224
14936
  }
14937
+ if (schema.description) {
14938
+ baseSchema = baseSchema.describe(schema.description);
14939
+ }
14225
14940
  return baseSchema;
14226
14941
  }
14227
14942
  function fromJSONSchema(schema, params) {
14228
14943
  if (typeof schema === "boolean") {
14229
14944
  return schema ? z.any() : z.never();
14230
14945
  }
14231
- const version2 = detectVersion(schema, params?.defaultTarget);
14232
- const defs = schema.$defs || schema.definitions || {};
14946
+ let normalized;
14947
+ try {
14948
+ normalized = JSON.parse(JSON.stringify(schema));
14949
+ } catch {
14950
+ throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
14951
+ }
14952
+ const version2 = detectVersion(normalized, params?.defaultTarget);
14953
+ const defs = normalized.$defs || normalized.definitions || {};
14233
14954
  const ctx = {
14234
14955
  version: version2,
14235
14956
  defs,
14236
14957
  refs: /* @__PURE__ */ new Map(),
14237
14958
  processing: /* @__PURE__ */ new Set(),
14238
- rootSchema: schema,
14959
+ rootSchema: normalized,
14239
14960
  registry: params?.registry ?? globalRegistry
14240
14961
  };
14241
- return convertSchema(schema, ctx);
14962
+ return convertSchema(normalized, ctx);
14242
14963
  }
14243
14964
 
14244
14965
  // node_modules/zod/v4/classic/coerce.js
@@ -14863,7 +15584,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
14863
15584
  };
14864
15585
  var src_default = new NotebookLMPlugin();
14865
15586
 
14866
- // dist/_adapter_entry_c41cc3f2-8165-4931-8bbe-5324ffc73e43.ts
15587
+ // dist/_adapter_entry_d011dd65-0016-4b4e-afd1-6332e4d2c743.ts
14867
15588
  if (!globalThis.__openTabs) {
14868
15589
  globalThis.__openTabs = {};
14869
15590
  } else {
@@ -15081,5 +15802,5 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
15081
15802
  };
15082
15803
  delete src_default.onDeactivate;
15083
15804
  }
15084
- })();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["notebooklm"]){var a=o.adapters["notebooklm"];a.__adapterHash="d2ed6b7c53beb010f422a76f56021d520e0f4ddc5d8427104d1896a8a945d738";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"notebooklm",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
15805
+ })();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["notebooklm"]){var a=o.adapters["notebooklm"];a.__adapterHash="68a241517a5412f8c434f837b44476b41508e855b89515a3b7837110cdb58bb1";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"notebooklm",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
15085
15806
  //# sourceMappingURL=adapter.iife.js.map