@turbofy-ai/app-runtime 0.0.12 → 0.0.14
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.
- package/dist/src/api/actions.d.ts +7 -0
- package/dist/src/api/index.d.ts +2 -1
- package/dist/src/api/types.d.ts +11 -1
- package/dist/src/dsl.d.ts +3 -2
- package/dist/src/dsl.js +397 -1139
- package/dist/src/lib/auth.d.ts +40 -3
- package/dist/src/lib/auth.test.d.ts +1 -0
- package/dist/src/lib/guest-page.d.ts +8 -0
- package/dist/src/lib/guest-page.test.d.ts +1 -0
- package/dist/src/lib/preview-auth.d.ts +7 -0
- package/dist/src/lib/social-callback.d.ts +11 -0
- package/dist/src/lib/social-callback.test.d.ts +1 -0
- package/dist/src/lib/social-popup.d.ts +23 -0
- package/dist/src/lib/social-popup.test.d.ts +1 -0
- package/dist/src/lib/social-sign-in.test.d.ts +1 -0
- package/package.json +2 -2
package/dist/src/dsl.js
CHANGED
|
@@ -699,7 +699,6 @@ __export(external_exports, {
|
|
|
699
699
|
ZodOptional: () => ZodOptional,
|
|
700
700
|
ZodPipe: () => ZodPipe,
|
|
701
701
|
ZodPrefault: () => ZodPrefault,
|
|
702
|
-
ZodPreprocess: () => ZodPreprocess,
|
|
703
702
|
ZodPromise: () => ZodPromise,
|
|
704
703
|
ZodReadonly: () => ZodReadonly,
|
|
705
704
|
ZodRealError: () => ZodRealError,
|
|
@@ -778,7 +777,6 @@ __export(external_exports, {
|
|
|
778
777
|
int32: () => int32,
|
|
779
778
|
int64: () => int64,
|
|
780
779
|
intersection: () => intersection,
|
|
781
|
-
invertCodec: () => invertCodec,
|
|
782
780
|
ipv4: () => ipv42,
|
|
783
781
|
ipv6: () => ipv62,
|
|
784
782
|
iso: () => iso_exports,
|
|
@@ -960,7 +958,6 @@ __export(core_exports2, {
|
|
|
960
958
|
$ZodOptional: () => $ZodOptional,
|
|
961
959
|
$ZodPipe: () => $ZodPipe,
|
|
962
960
|
$ZodPrefault: () => $ZodPrefault,
|
|
963
|
-
$ZodPreprocess: () => $ZodPreprocess,
|
|
964
961
|
$ZodPromise: () => $ZodPromise,
|
|
965
962
|
$ZodReadonly: () => $ZodReadonly,
|
|
966
963
|
$ZodRealError: () => $ZodRealError,
|
|
@@ -1160,8 +1157,7 @@ __export(core_exports2, {
|
|
|
1160
1157
|
});
|
|
1161
1158
|
|
|
1162
1159
|
// ../../node_modules/zod/v4/core/core.js
|
|
1163
|
-
var
|
|
1164
|
-
var NEVER = /* @__PURE__ */ Object.freeze({
|
|
1160
|
+
var NEVER = Object.freeze({
|
|
1165
1161
|
status: "aborted"
|
|
1166
1162
|
});
|
|
1167
1163
|
// @__NO_SIDE_EFFECTS__
|
|
@@ -1196,10 +1192,10 @@ function $constructor(name, initializer3, params) {
|
|
|
1196
1192
|
}
|
|
1197
1193
|
Object.defineProperty(Definition, "name", { value: name });
|
|
1198
1194
|
function _(def) {
|
|
1199
|
-
var
|
|
1195
|
+
var _a2;
|
|
1200
1196
|
const inst = params?.Parent ? new Definition() : this;
|
|
1201
1197
|
init(inst, def);
|
|
1202
|
-
(
|
|
1198
|
+
(_a2 = inst._zod).deferred ?? (_a2.deferred = []);
|
|
1203
1199
|
for (const fn of inst._zod.deferred) {
|
|
1204
1200
|
fn();
|
|
1205
1201
|
}
|
|
@@ -1228,8 +1224,7 @@ var $ZodEncodeError = class extends Error {
|
|
|
1228
1224
|
this.name = "ZodEncodeError";
|
|
1229
1225
|
}
|
|
1230
1226
|
};
|
|
1231
|
-
|
|
1232
|
-
var globalConfig = globalThis.__zod_globalConfig;
|
|
1227
|
+
var globalConfig = {};
|
|
1233
1228
|
function config(newConfig) {
|
|
1234
1229
|
if (newConfig)
|
|
1235
1230
|
Object.assign(globalConfig, newConfig);
|
|
@@ -1262,7 +1257,6 @@ __export(util_exports, {
|
|
|
1262
1257
|
defineLazy: () => defineLazy,
|
|
1263
1258
|
esc: () => esc,
|
|
1264
1259
|
escapeRegex: () => escapeRegex,
|
|
1265
|
-
explicitlyAborted: () => explicitlyAborted,
|
|
1266
1260
|
extend: () => extend,
|
|
1267
1261
|
finalizeIssue: () => finalizeIssue,
|
|
1268
1262
|
floatSafeRemainder: () => floatSafeRemainder,
|
|
@@ -1351,12 +1345,19 @@ function cleanRegex(source) {
|
|
|
1351
1345
|
return source.slice(start, end);
|
|
1352
1346
|
}
|
|
1353
1347
|
function floatSafeRemainder(val, step2) {
|
|
1354
|
-
const
|
|
1355
|
-
const
|
|
1356
|
-
|
|
1357
|
-
if (
|
|
1358
|
-
|
|
1359
|
-
|
|
1348
|
+
const valDecCount = (val.toString().split(".")[1] || "").length;
|
|
1349
|
+
const stepString = step2.toString();
|
|
1350
|
+
let stepDecCount = (stepString.split(".")[1] || "").length;
|
|
1351
|
+
if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
|
|
1352
|
+
const match = stepString.match(/\d?e-(\d?)/);
|
|
1353
|
+
if (match?.[1]) {
|
|
1354
|
+
stepDecCount = Number.parseInt(match[1]);
|
|
1355
|
+
}
|
|
1356
|
+
}
|
|
1357
|
+
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
|
|
1358
|
+
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
|
|
1359
|
+
const stepInt = Number.parseInt(step2.toFixed(decCount).replace(".", ""));
|
|
1360
|
+
return valInt % stepInt / 10 ** decCount;
|
|
1360
1361
|
}
|
|
1361
1362
|
var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
|
|
1362
1363
|
function defineLazy(object2, key, getter) {
|
|
@@ -1438,10 +1439,7 @@ var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace :
|
|
|
1438
1439
|
function isObject(data2) {
|
|
1439
1440
|
return typeof data2 === "object" && data2 !== null && !Array.isArray(data2);
|
|
1440
1441
|
}
|
|
1441
|
-
var allowsEval =
|
|
1442
|
-
if (globalConfig.jitless) {
|
|
1443
|
-
return false;
|
|
1444
|
-
}
|
|
1442
|
+
var allowsEval = cached(() => {
|
|
1445
1443
|
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
|
1446
1444
|
return false;
|
|
1447
1445
|
}
|
|
@@ -1474,10 +1472,6 @@ function shallowClone(o) {
|
|
|
1474
1472
|
return { ...o };
|
|
1475
1473
|
if (Array.isArray(o))
|
|
1476
1474
|
return [...o];
|
|
1477
|
-
if (o instanceof Map)
|
|
1478
|
-
return new Map(o);
|
|
1479
|
-
if (o instanceof Set)
|
|
1480
|
-
return new Set(o);
|
|
1481
1475
|
return o;
|
|
1482
1476
|
}
|
|
1483
1477
|
function numKeys(data2) {
|
|
@@ -1534,14 +1528,7 @@ var getParsedType = (data2) => {
|
|
|
1534
1528
|
}
|
|
1535
1529
|
};
|
|
1536
1530
|
var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
|
|
1537
|
-
var primitiveTypes = /* @__PURE__ */ new Set([
|
|
1538
|
-
"string",
|
|
1539
|
-
"number",
|
|
1540
|
-
"bigint",
|
|
1541
|
-
"boolean",
|
|
1542
|
-
"symbol",
|
|
1543
|
-
"undefined"
|
|
1544
|
-
]);
|
|
1531
|
+
var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
|
|
1545
1532
|
function escapeRegex(str) {
|
|
1546
1533
|
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
1547
1534
|
}
|
|
@@ -1710,9 +1697,6 @@ function safeExtend(schema, shape) {
|
|
|
1710
1697
|
return clone(schema, def);
|
|
1711
1698
|
}
|
|
1712
1699
|
function merge(a, b) {
|
|
1713
|
-
if (a._zod.def.checks?.length) {
|
|
1714
|
-
throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
|
|
1715
|
-
}
|
|
1716
1700
|
const def = mergeDefs(a._zod.def, {
|
|
1717
1701
|
get shape() {
|
|
1718
1702
|
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
|
@@ -1722,7 +1706,8 @@ function merge(a, b) {
|
|
|
1722
1706
|
get catchall() {
|
|
1723
1707
|
return b._zod.def.catchall;
|
|
1724
1708
|
},
|
|
1725
|
-
checks:
|
|
1709
|
+
checks: []
|
|
1710
|
+
// delete existing checks
|
|
1726
1711
|
});
|
|
1727
1712
|
return clone(a, def);
|
|
1728
1713
|
}
|
|
@@ -1805,20 +1790,10 @@ function aborted(x, startIndex = 0) {
|
|
|
1805
1790
|
}
|
|
1806
1791
|
return false;
|
|
1807
1792
|
}
|
|
1808
|
-
function explicitlyAborted(x, startIndex = 0) {
|
|
1809
|
-
if (x.aborted === true)
|
|
1810
|
-
return true;
|
|
1811
|
-
for (let i = startIndex; i < x.issues.length; i++) {
|
|
1812
|
-
if (x.issues[i]?.continue === false) {
|
|
1813
|
-
return true;
|
|
1814
|
-
}
|
|
1815
|
-
}
|
|
1816
|
-
return false;
|
|
1817
|
-
}
|
|
1818
1793
|
function prefixIssues(path, issues) {
|
|
1819
1794
|
return issues.map((iss) => {
|
|
1820
|
-
var
|
|
1821
|
-
(
|
|
1795
|
+
var _a2;
|
|
1796
|
+
(_a2 = iss).path ?? (_a2.path = []);
|
|
1822
1797
|
iss.path.unshift(path);
|
|
1823
1798
|
return iss;
|
|
1824
1799
|
});
|
|
@@ -1827,14 +1802,17 @@ function unwrapMessage(message) {
|
|
|
1827
1802
|
return typeof message === "string" ? message : message?.message;
|
|
1828
1803
|
}
|
|
1829
1804
|
function finalizeIssue(iss, ctx, config2) {
|
|
1830
|
-
const
|
|
1831
|
-
|
|
1832
|
-
|
|
1833
|
-
|
|
1834
|
-
|
|
1835
|
-
|
|
1805
|
+
const full = { ...iss, path: iss.path ?? [] };
|
|
1806
|
+
if (!iss.message) {
|
|
1807
|
+
const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
|
|
1808
|
+
full.message = message;
|
|
1809
|
+
}
|
|
1810
|
+
delete full.inst;
|
|
1811
|
+
delete full.continue;
|
|
1812
|
+
if (!ctx?.reportInput) {
|
|
1813
|
+
delete full.input;
|
|
1836
1814
|
}
|
|
1837
|
-
return
|
|
1815
|
+
return full;
|
|
1838
1816
|
}
|
|
1839
1817
|
function getSizableOrigin(input) {
|
|
1840
1818
|
if (input instanceof Set)
|
|
@@ -1951,10 +1929,10 @@ var initializer = (inst, def) => {
|
|
|
1951
1929
|
};
|
|
1952
1930
|
var $ZodError = $constructor("$ZodError", initializer);
|
|
1953
1931
|
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
|
|
1954
|
-
function flattenError(
|
|
1932
|
+
function flattenError(error48, mapper = (issue2) => issue2.message) {
|
|
1955
1933
|
const fieldErrors = {};
|
|
1956
1934
|
const formErrors = [];
|
|
1957
|
-
for (const sub of
|
|
1935
|
+
for (const sub of error48.issues) {
|
|
1958
1936
|
if (sub.path.length > 0) {
|
|
1959
1937
|
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
|
|
1960
1938
|
fieldErrors[sub.path[0]].push(mapper(sub));
|
|
@@ -1964,53 +1942,50 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
|
|
|
1964
1942
|
}
|
|
1965
1943
|
return { formErrors, fieldErrors };
|
|
1966
1944
|
}
|
|
1967
|
-
function formatError(
|
|
1945
|
+
function formatError(error48, mapper = (issue2) => issue2.message) {
|
|
1968
1946
|
const fieldErrors = { _errors: [] };
|
|
1969
|
-
const processError = (
|
|
1970
|
-
for (const issue2 of
|
|
1947
|
+
const processError = (error49) => {
|
|
1948
|
+
for (const issue2 of error49.issues) {
|
|
1971
1949
|
if (issue2.code === "invalid_union" && issue2.errors.length) {
|
|
1972
|
-
issue2.errors.map((issues) => processError({ issues }
|
|
1950
|
+
issue2.errors.map((issues) => processError({ issues }));
|
|
1973
1951
|
} else if (issue2.code === "invalid_key") {
|
|
1974
|
-
processError({ issues: issue2.issues }
|
|
1952
|
+
processError({ issues: issue2.issues });
|
|
1975
1953
|
} else if (issue2.code === "invalid_element") {
|
|
1976
|
-
processError({ issues: issue2.issues }
|
|
1954
|
+
processError({ issues: issue2.issues });
|
|
1955
|
+
} else if (issue2.path.length === 0) {
|
|
1956
|
+
fieldErrors._errors.push(mapper(issue2));
|
|
1977
1957
|
} else {
|
|
1978
|
-
|
|
1979
|
-
|
|
1980
|
-
|
|
1981
|
-
|
|
1982
|
-
|
|
1983
|
-
|
|
1984
|
-
|
|
1985
|
-
|
|
1986
|
-
|
|
1987
|
-
|
|
1988
|
-
curr[el] = curr[el] || { _errors: [] };
|
|
1989
|
-
} else {
|
|
1990
|
-
curr[el] = curr[el] || { _errors: [] };
|
|
1991
|
-
curr[el]._errors.push(mapper(issue2));
|
|
1992
|
-
}
|
|
1993
|
-
curr = curr[el];
|
|
1994
|
-
i++;
|
|
1958
|
+
let curr = fieldErrors;
|
|
1959
|
+
let i = 0;
|
|
1960
|
+
while (i < issue2.path.length) {
|
|
1961
|
+
const el = issue2.path[i];
|
|
1962
|
+
const terminal = i === issue2.path.length - 1;
|
|
1963
|
+
if (!terminal) {
|
|
1964
|
+
curr[el] = curr[el] || { _errors: [] };
|
|
1965
|
+
} else {
|
|
1966
|
+
curr[el] = curr[el] || { _errors: [] };
|
|
1967
|
+
curr[el]._errors.push(mapper(issue2));
|
|
1995
1968
|
}
|
|
1969
|
+
curr = curr[el];
|
|
1970
|
+
i++;
|
|
1996
1971
|
}
|
|
1997
1972
|
}
|
|
1998
1973
|
}
|
|
1999
1974
|
};
|
|
2000
|
-
processError(
|
|
1975
|
+
processError(error48);
|
|
2001
1976
|
return fieldErrors;
|
|
2002
1977
|
}
|
|
2003
|
-
function treeifyError(
|
|
1978
|
+
function treeifyError(error48, mapper = (issue2) => issue2.message) {
|
|
2004
1979
|
const result = { errors: [] };
|
|
2005
|
-
const processError = (
|
|
2006
|
-
var
|
|
2007
|
-
for (const issue2 of
|
|
1980
|
+
const processError = (error49, path = []) => {
|
|
1981
|
+
var _a2, _b;
|
|
1982
|
+
for (const issue2 of error49.issues) {
|
|
2008
1983
|
if (issue2.code === "invalid_union" && issue2.errors.length) {
|
|
2009
|
-
issue2.errors.map((issues) => processError({ issues },
|
|
1984
|
+
issue2.errors.map((issues) => processError({ issues }, issue2.path));
|
|
2010
1985
|
} else if (issue2.code === "invalid_key") {
|
|
2011
|
-
processError({ issues: issue2.issues },
|
|
1986
|
+
processError({ issues: issue2.issues }, issue2.path);
|
|
2012
1987
|
} else if (issue2.code === "invalid_element") {
|
|
2013
|
-
processError({ issues: issue2.issues },
|
|
1988
|
+
processError({ issues: issue2.issues }, issue2.path);
|
|
2014
1989
|
} else {
|
|
2015
1990
|
const fullpath = [...path, ...issue2.path];
|
|
2016
1991
|
if (fullpath.length === 0) {
|
|
@@ -2024,7 +1999,7 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
|
|
|
2024
1999
|
const terminal = i === fullpath.length - 1;
|
|
2025
2000
|
if (typeof el === "string") {
|
|
2026
2001
|
curr.properties ?? (curr.properties = {});
|
|
2027
|
-
(
|
|
2002
|
+
(_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
|
|
2028
2003
|
curr = curr.properties[el];
|
|
2029
2004
|
} else {
|
|
2030
2005
|
curr.items ?? (curr.items = []);
|
|
@@ -2039,7 +2014,7 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
|
|
|
2039
2014
|
}
|
|
2040
2015
|
}
|
|
2041
2016
|
};
|
|
2042
|
-
processError(
|
|
2017
|
+
processError(error48);
|
|
2043
2018
|
return result;
|
|
2044
2019
|
}
|
|
2045
2020
|
function toDotPath(_path) {
|
|
@@ -2060,9 +2035,9 @@ function toDotPath(_path) {
|
|
|
2060
2035
|
}
|
|
2061
2036
|
return segs.join("");
|
|
2062
2037
|
}
|
|
2063
|
-
function prettifyError(
|
|
2038
|
+
function prettifyError(error48) {
|
|
2064
2039
|
const lines = [];
|
|
2065
|
-
const issues = [...
|
|
2040
|
+
const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
|
|
2066
2041
|
for (const issue2 of issues) {
|
|
2067
2042
|
lines.push(`\u2716 ${issue2.message}`);
|
|
2068
2043
|
if (issue2.path?.length)
|
|
@@ -2073,7 +2048,7 @@ function prettifyError(error51) {
|
|
|
2073
2048
|
|
|
2074
2049
|
// ../../node_modules/zod/v4/core/parse.js
|
|
2075
2050
|
var _parse = (_Err) => (schema, value, _ctx, _params) => {
|
|
2076
|
-
const ctx = _ctx ?
|
|
2051
|
+
const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
|
|
2077
2052
|
const result = schema._zod.run({ value, issues: [] }, ctx);
|
|
2078
2053
|
if (result instanceof Promise) {
|
|
2079
2054
|
throw new $ZodAsyncError();
|
|
@@ -2087,7 +2062,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
|
|
|
2087
2062
|
};
|
|
2088
2063
|
var parse = /* @__PURE__ */ _parse($ZodRealError);
|
|
2089
2064
|
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
|
|
2090
|
-
const ctx = _ctx ?
|
|
2065
|
+
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
|
2091
2066
|
let result = schema._zod.run({ value, issues: [] }, ctx);
|
|
2092
2067
|
if (result instanceof Promise)
|
|
2093
2068
|
result = await result;
|
|
@@ -2112,7 +2087,7 @@ var _safeParse = (_Err) => (schema, value, _ctx) => {
|
|
|
2112
2087
|
};
|
|
2113
2088
|
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
|
|
2114
2089
|
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
|
|
2115
|
-
const ctx = _ctx ?
|
|
2090
|
+
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
|
2116
2091
|
let result = schema._zod.run({ value, issues: [] }, ctx);
|
|
2117
2092
|
if (result instanceof Promise)
|
|
2118
2093
|
result = await result;
|
|
@@ -2123,7 +2098,7 @@ var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
|
|
|
2123
2098
|
};
|
|
2124
2099
|
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
|
|
2125
2100
|
var _encode = (_Err) => (schema, value, _ctx) => {
|
|
2126
|
-
const ctx = _ctx ?
|
|
2101
|
+
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
2127
2102
|
return _parse(_Err)(schema, value, ctx);
|
|
2128
2103
|
};
|
|
2129
2104
|
var encode = /* @__PURE__ */ _encode($ZodRealError);
|
|
@@ -2132,7 +2107,7 @@ var _decode = (_Err) => (schema, value, _ctx) => {
|
|
|
2132
2107
|
};
|
|
2133
2108
|
var decode = /* @__PURE__ */ _decode($ZodRealError);
|
|
2134
2109
|
var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
2135
|
-
const ctx = _ctx ?
|
|
2110
|
+
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
2136
2111
|
return _parseAsync(_Err)(schema, value, ctx);
|
|
2137
2112
|
};
|
|
2138
2113
|
var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
|
|
@@ -2141,7 +2116,7 @@ var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
|
2141
2116
|
};
|
|
2142
2117
|
var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
|
|
2143
2118
|
var _safeEncode = (_Err) => (schema, value, _ctx) => {
|
|
2144
|
-
const ctx = _ctx ?
|
|
2119
|
+
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
2145
2120
|
return _safeParse(_Err)(schema, value, ctx);
|
|
2146
2121
|
};
|
|
2147
2122
|
var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
|
|
@@ -2150,7 +2125,7 @@ var _safeDecode = (_Err) => (schema, value, _ctx) => {
|
|
|
2150
2125
|
};
|
|
2151
2126
|
var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
|
|
2152
2127
|
var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
2153
|
-
const ctx = _ctx ?
|
|
2128
|
+
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
2154
2129
|
return _safeParseAsync(_Err)(schema, value, ctx);
|
|
2155
2130
|
};
|
|
2156
2131
|
var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
|
|
@@ -2183,7 +2158,6 @@ __export(regexes_exports, {
|
|
|
2183
2158
|
hex: () => hex,
|
|
2184
2159
|
hostname: () => hostname,
|
|
2185
2160
|
html5Email: () => html5Email,
|
|
2186
|
-
httpProtocol: () => httpProtocol,
|
|
2187
2161
|
idnEmail: () => idnEmail,
|
|
2188
2162
|
integer: () => integer,
|
|
2189
2163
|
ipv4: () => ipv4,
|
|
@@ -2222,7 +2196,7 @@ __export(regexes_exports, {
|
|
|
2222
2196
|
uuid7: () => uuid7,
|
|
2223
2197
|
xid: () => xid
|
|
2224
2198
|
});
|
|
2225
|
-
var cuid = /^[cC][
|
|
2199
|
+
var cuid = /^[cC][^\s-]{8,}$/;
|
|
2226
2200
|
var cuid2 = /^[0-9a-z]+$/;
|
|
2227
2201
|
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
|
|
2228
2202
|
var xid = /^[0-9a-vA-V]{20}$/;
|
|
@@ -2261,7 +2235,6 @@ var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/
|
|
|
2261
2235
|
var base64url = /^[A-Za-z0-9_-]*$/;
|
|
2262
2236
|
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])?)*\.?$/;
|
|
2263
2237
|
var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
|
|
2264
|
-
var httpProtocol = /^https?$/;
|
|
2265
2238
|
var e164 = /^\+[1-9]\d{6,14}$/;
|
|
2266
2239
|
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])))`;
|
|
2267
2240
|
var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
|
|
@@ -2320,10 +2293,10 @@ var sha512_base64url = /* @__PURE__ */ fixedBase64url(86);
|
|
|
2320
2293
|
|
|
2321
2294
|
// ../../node_modules/zod/v4/core/checks.js
|
|
2322
2295
|
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
|
|
2323
|
-
var
|
|
2296
|
+
var _a2;
|
|
2324
2297
|
inst._zod ?? (inst._zod = {});
|
|
2325
2298
|
inst._zod.def = def;
|
|
2326
|
-
(
|
|
2299
|
+
(_a2 = inst._zod).onattach ?? (_a2.onattach = []);
|
|
2327
2300
|
});
|
|
2328
2301
|
var numericOriginMap = {
|
|
2329
2302
|
number: "number",
|
|
@@ -2389,8 +2362,8 @@ var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan",
|
|
|
2389
2362
|
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
|
|
2390
2363
|
$ZodCheck.init(inst, def);
|
|
2391
2364
|
inst._zod.onattach.push((inst2) => {
|
|
2392
|
-
var
|
|
2393
|
-
(
|
|
2365
|
+
var _a2;
|
|
2366
|
+
(_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);
|
|
2394
2367
|
});
|
|
2395
2368
|
inst._zod.check = (payload) => {
|
|
2396
2369
|
if (typeof payload.value !== typeof def.value)
|
|
@@ -2523,9 +2496,9 @@ var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat"
|
|
|
2523
2496
|
};
|
|
2524
2497
|
});
|
|
2525
2498
|
var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
|
|
2526
|
-
var
|
|
2499
|
+
var _a2;
|
|
2527
2500
|
$ZodCheck.init(inst, def);
|
|
2528
|
-
(
|
|
2501
|
+
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
2529
2502
|
const val = payload.value;
|
|
2530
2503
|
return !nullish(val) && val.size !== void 0;
|
|
2531
2504
|
});
|
|
@@ -2551,9 +2524,9 @@ var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, d
|
|
|
2551
2524
|
};
|
|
2552
2525
|
});
|
|
2553
2526
|
var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
|
|
2554
|
-
var
|
|
2527
|
+
var _a2;
|
|
2555
2528
|
$ZodCheck.init(inst, def);
|
|
2556
|
-
(
|
|
2529
|
+
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
2557
2530
|
const val = payload.value;
|
|
2558
2531
|
return !nullish(val) && val.size !== void 0;
|
|
2559
2532
|
});
|
|
@@ -2579,9 +2552,9 @@ var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, d
|
|
|
2579
2552
|
};
|
|
2580
2553
|
});
|
|
2581
2554
|
var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
|
|
2582
|
-
var
|
|
2555
|
+
var _a2;
|
|
2583
2556
|
$ZodCheck.init(inst, def);
|
|
2584
|
-
(
|
|
2557
|
+
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
2585
2558
|
const val = payload.value;
|
|
2586
2559
|
return !nullish(val) && val.size !== void 0;
|
|
2587
2560
|
});
|
|
@@ -2609,9 +2582,9 @@ var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (i
|
|
|
2609
2582
|
};
|
|
2610
2583
|
});
|
|
2611
2584
|
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
|
|
2612
|
-
var
|
|
2585
|
+
var _a2;
|
|
2613
2586
|
$ZodCheck.init(inst, def);
|
|
2614
|
-
(
|
|
2587
|
+
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
2615
2588
|
const val = payload.value;
|
|
2616
2589
|
return !nullish(val) && val.length !== void 0;
|
|
2617
2590
|
});
|
|
@@ -2638,9 +2611,9 @@ var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (ins
|
|
|
2638
2611
|
};
|
|
2639
2612
|
});
|
|
2640
2613
|
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
|
|
2641
|
-
var
|
|
2614
|
+
var _a2;
|
|
2642
2615
|
$ZodCheck.init(inst, def);
|
|
2643
|
-
(
|
|
2616
|
+
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
2644
2617
|
const val = payload.value;
|
|
2645
2618
|
return !nullish(val) && val.length !== void 0;
|
|
2646
2619
|
});
|
|
@@ -2667,9 +2640,9 @@ var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (ins
|
|
|
2667
2640
|
};
|
|
2668
2641
|
});
|
|
2669
2642
|
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
|
|
2670
|
-
var
|
|
2643
|
+
var _a2;
|
|
2671
2644
|
$ZodCheck.init(inst, def);
|
|
2672
|
-
(
|
|
2645
|
+
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
2673
2646
|
const val = payload.value;
|
|
2674
2647
|
return !nullish(val) && val.length !== void 0;
|
|
2675
2648
|
});
|
|
@@ -2698,7 +2671,7 @@ var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals"
|
|
|
2698
2671
|
};
|
|
2699
2672
|
});
|
|
2700
2673
|
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
|
|
2701
|
-
var
|
|
2674
|
+
var _a2, _b;
|
|
2702
2675
|
$ZodCheck.init(inst, def);
|
|
2703
2676
|
inst._zod.onattach.push((inst2) => {
|
|
2704
2677
|
const bag = inst2._zod.bag;
|
|
@@ -2709,7 +2682,7 @@ var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat"
|
|
|
2709
2682
|
}
|
|
2710
2683
|
});
|
|
2711
2684
|
if (def.pattern)
|
|
2712
|
-
(
|
|
2685
|
+
(_a2 = inst._zod).check ?? (_a2.check = (payload) => {
|
|
2713
2686
|
def.pattern.lastIndex = 0;
|
|
2714
2687
|
if (def.pattern.test(payload.value))
|
|
2715
2688
|
return;
|
|
@@ -2905,13 +2878,13 @@ var Doc = class {
|
|
|
2905
2878
|
// ../../node_modules/zod/v4/core/versions.js
|
|
2906
2879
|
var version = {
|
|
2907
2880
|
major: 4,
|
|
2908
|
-
minor:
|
|
2909
|
-
patch:
|
|
2881
|
+
minor: 3,
|
|
2882
|
+
patch: 6
|
|
2910
2883
|
};
|
|
2911
2884
|
|
|
2912
2885
|
// ../../node_modules/zod/v4/core/schemas.js
|
|
2913
2886
|
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
|
|
2914
|
-
var
|
|
2887
|
+
var _a2;
|
|
2915
2888
|
inst ?? (inst = {});
|
|
2916
2889
|
inst._zod.def = def;
|
|
2917
2890
|
inst._zod.bag = inst._zod.bag || {};
|
|
@@ -2926,7 +2899,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
|
|
|
2926
2899
|
}
|
|
2927
2900
|
}
|
|
2928
2901
|
if (checks.length === 0) {
|
|
2929
|
-
(
|
|
2902
|
+
(_a2 = inst._zod).deferred ?? (_a2.deferred = []);
|
|
2930
2903
|
inst._zod.deferred?.push(() => {
|
|
2931
2904
|
inst._zod.run = inst._zod.parse;
|
|
2932
2905
|
});
|
|
@@ -2936,8 +2909,6 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
|
|
|
2936
2909
|
let asyncResult;
|
|
2937
2910
|
for (const ch of checks2) {
|
|
2938
2911
|
if (ch._zod.def.when) {
|
|
2939
|
-
if (explicitlyAborted(payload))
|
|
2940
|
-
continue;
|
|
2941
2912
|
const shouldRun = ch._zod.def.when(payload);
|
|
2942
2913
|
if (!shouldRun)
|
|
2943
2914
|
continue;
|
|
@@ -3078,19 +3049,6 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
|
|
|
3078
3049
|
inst._zod.check = (payload) => {
|
|
3079
3050
|
try {
|
|
3080
3051
|
const trimmed = payload.value.trim();
|
|
3081
|
-
if (!def.normalize && def.protocol?.source === httpProtocol.source) {
|
|
3082
|
-
if (!/^https?:\/\//i.test(trimmed)) {
|
|
3083
|
-
payload.issues.push({
|
|
3084
|
-
code: "invalid_format",
|
|
3085
|
-
format: "url",
|
|
3086
|
-
note: "Invalid URL format",
|
|
3087
|
-
input: payload.value,
|
|
3088
|
-
inst,
|
|
3089
|
-
continue: !def.abort
|
|
3090
|
-
});
|
|
3091
|
-
return;
|
|
3092
|
-
}
|
|
3093
|
-
}
|
|
3094
3052
|
const url2 = new URL(trimmed);
|
|
3095
3053
|
if (def.hostname) {
|
|
3096
3054
|
def.hostname.lastIndex = 0;
|
|
@@ -3244,8 +3202,6 @@ var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
|
|
|
3244
3202
|
function isValidBase64(data2) {
|
|
3245
3203
|
if (data2 === "")
|
|
3246
3204
|
return true;
|
|
3247
|
-
if (/\s/.test(data2))
|
|
3248
|
-
return false;
|
|
3249
3205
|
if (data2.length % 4 !== 0)
|
|
3250
3206
|
return false;
|
|
3251
3207
|
try {
|
|
@@ -3438,6 +3394,8 @@ var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) =>
|
|
|
3438
3394
|
$ZodType.init(inst, def);
|
|
3439
3395
|
inst._zod.pattern = _undefined;
|
|
3440
3396
|
inst._zod.values = /* @__PURE__ */ new Set([void 0]);
|
|
3397
|
+
inst._zod.optin = "optional";
|
|
3398
|
+
inst._zod.optout = "optional";
|
|
3441
3399
|
inst._zod.parse = (payload, _ctx) => {
|
|
3442
3400
|
const input = payload.value;
|
|
3443
3401
|
if (typeof input === "undefined")
|
|
@@ -3566,27 +3524,15 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
|
|
|
3566
3524
|
return payload;
|
|
3567
3525
|
};
|
|
3568
3526
|
});
|
|
3569
|
-
function handlePropertyResult(result, final, key, input,
|
|
3570
|
-
const isPresent = key in input;
|
|
3527
|
+
function handlePropertyResult(result, final, key, input, isOptionalOut) {
|
|
3571
3528
|
if (result.issues.length) {
|
|
3572
|
-
if (
|
|
3529
|
+
if (isOptionalOut && !(key in input)) {
|
|
3573
3530
|
return;
|
|
3574
3531
|
}
|
|
3575
3532
|
final.issues.push(...prefixIssues(key, result.issues));
|
|
3576
3533
|
}
|
|
3577
|
-
if (!isPresent && !isOptionalIn) {
|
|
3578
|
-
if (!result.issues.length) {
|
|
3579
|
-
final.issues.push({
|
|
3580
|
-
code: "invalid_type",
|
|
3581
|
-
expected: "nonoptional",
|
|
3582
|
-
input: void 0,
|
|
3583
|
-
path: [key]
|
|
3584
|
-
});
|
|
3585
|
-
}
|
|
3586
|
-
return;
|
|
3587
|
-
}
|
|
3588
3534
|
if (result.value === void 0) {
|
|
3589
|
-
if (
|
|
3535
|
+
if (key in input) {
|
|
3590
3536
|
final.value[key] = void 0;
|
|
3591
3537
|
}
|
|
3592
3538
|
} else {
|
|
@@ -3614,11 +3560,8 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
|
|
|
3614
3560
|
const keySet = def.keySet;
|
|
3615
3561
|
const _catchall = def.catchall._zod;
|
|
3616
3562
|
const t = _catchall.def.type;
|
|
3617
|
-
const isOptionalIn = _catchall.optin === "optional";
|
|
3618
3563
|
const isOptionalOut = _catchall.optout === "optional";
|
|
3619
3564
|
for (const key in input) {
|
|
3620
|
-
if (key === "__proto__")
|
|
3621
|
-
continue;
|
|
3622
3565
|
if (keySet.has(key))
|
|
3623
3566
|
continue;
|
|
3624
3567
|
if (t === "never") {
|
|
@@ -3627,9 +3570,9 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
|
|
|
3627
3570
|
}
|
|
3628
3571
|
const r = _catchall.run({ value: input[key], issues: [] }, ctx);
|
|
3629
3572
|
if (r instanceof Promise) {
|
|
3630
|
-
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input,
|
|
3573
|
+
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
|
|
3631
3574
|
} else {
|
|
3632
|
-
handlePropertyResult(r, payload, key, input,
|
|
3575
|
+
handlePropertyResult(r, payload, key, input, isOptionalOut);
|
|
3633
3576
|
}
|
|
3634
3577
|
}
|
|
3635
3578
|
if (unrecognized.length) {
|
|
@@ -3695,13 +3638,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
|
|
|
3695
3638
|
const shape = value.shape;
|
|
3696
3639
|
for (const key of value.keys) {
|
|
3697
3640
|
const el = shape[key];
|
|
3698
|
-
const isOptionalIn = el._zod.optin === "optional";
|
|
3699
3641
|
const isOptionalOut = el._zod.optout === "optional";
|
|
3700
3642
|
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
|
|
3701
3643
|
if (r instanceof Promise) {
|
|
3702
|
-
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input,
|
|
3644
|
+
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
|
|
3703
3645
|
} else {
|
|
3704
|
-
handlePropertyResult(r, payload, key, input,
|
|
3646
|
+
handlePropertyResult(r, payload, key, input, isOptionalOut);
|
|
3705
3647
|
}
|
|
3706
3648
|
}
|
|
3707
3649
|
if (!catchall) {
|
|
@@ -3732,10 +3674,9 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
|
|
|
3732
3674
|
const id = ids[key];
|
|
3733
3675
|
const k = esc(key);
|
|
3734
3676
|
const schema = shape[key];
|
|
3735
|
-
const isOptionalIn = schema?._zod?.optin === "optional";
|
|
3736
3677
|
const isOptionalOut = schema?._zod?.optout === "optional";
|
|
3737
3678
|
doc.write(`const ${id} = ${parseStr(key)};`);
|
|
3738
|
-
if (
|
|
3679
|
+
if (isOptionalOut) {
|
|
3739
3680
|
doc.write(`
|
|
3740
3681
|
if (${id}.issues.length) {
|
|
3741
3682
|
if (${k} in input) {
|
|
@@ -3754,33 +3695,6 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
|
|
|
3754
3695
|
newResult[${k}] = ${id}.value;
|
|
3755
3696
|
}
|
|
3756
3697
|
|
|
3757
|
-
`);
|
|
3758
|
-
} else if (!isOptionalIn) {
|
|
3759
|
-
doc.write(`
|
|
3760
|
-
const ${id}_present = ${k} in input;
|
|
3761
|
-
if (${id}.issues.length) {
|
|
3762
|
-
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
3763
|
-
...iss,
|
|
3764
|
-
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
3765
|
-
})));
|
|
3766
|
-
}
|
|
3767
|
-
if (!${id}_present && !${id}.issues.length) {
|
|
3768
|
-
payload.issues.push({
|
|
3769
|
-
code: "invalid_type",
|
|
3770
|
-
expected: "nonoptional",
|
|
3771
|
-
input: undefined,
|
|
3772
|
-
path: [${k}]
|
|
3773
|
-
});
|
|
3774
|
-
}
|
|
3775
|
-
|
|
3776
|
-
if (${id}_present) {
|
|
3777
|
-
if (${id}.value === undefined) {
|
|
3778
|
-
newResult[${k}] = undefined;
|
|
3779
|
-
} else {
|
|
3780
|
-
newResult[${k}] = ${id}.value;
|
|
3781
|
-
}
|
|
3782
|
-
}
|
|
3783
|
-
|
|
3784
3698
|
`);
|
|
3785
3699
|
} else {
|
|
3786
3700
|
doc.write(`
|
|
@@ -3874,9 +3788,10 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
|
|
|
3874
3788
|
}
|
|
3875
3789
|
return void 0;
|
|
3876
3790
|
});
|
|
3877
|
-
const
|
|
3791
|
+
const single = def.options.length === 1;
|
|
3792
|
+
const first = def.options[0]._zod.run;
|
|
3878
3793
|
inst._zod.parse = (payload, ctx) => {
|
|
3879
|
-
if (
|
|
3794
|
+
if (single) {
|
|
3880
3795
|
return first(payload, ctx);
|
|
3881
3796
|
}
|
|
3882
3797
|
let async = false;
|
|
@@ -3929,9 +3844,10 @@ function handleExclusiveUnionResults(results, final, inst, ctx) {
|
|
|
3929
3844
|
var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
|
|
3930
3845
|
$ZodUnion.init(inst, def);
|
|
3931
3846
|
def.inclusive = false;
|
|
3932
|
-
const
|
|
3847
|
+
const single = def.options.length === 1;
|
|
3848
|
+
const first = def.options[0]._zod.run;
|
|
3933
3849
|
inst._zod.parse = (payload, ctx) => {
|
|
3934
|
-
if (
|
|
3850
|
+
if (single) {
|
|
3935
3851
|
return first(payload, ctx);
|
|
3936
3852
|
}
|
|
3937
3853
|
let async = false;
|
|
@@ -4006,7 +3922,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
|
|
|
4006
3922
|
if (opt) {
|
|
4007
3923
|
return opt._zod.run(payload, ctx);
|
|
4008
3924
|
}
|
|
4009
|
-
if (def.unionFallback
|
|
3925
|
+
if (def.unionFallback) {
|
|
4010
3926
|
return _super(payload, ctx);
|
|
4011
3927
|
}
|
|
4012
3928
|
payload.issues.push({
|
|
@@ -4014,7 +3930,6 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
|
|
|
4014
3930
|
errors: [],
|
|
4015
3931
|
note: "No matching discriminator",
|
|
4016
3932
|
discriminator: def.discriminator,
|
|
4017
|
-
options: Array.from(disc.value.keys()),
|
|
4018
3933
|
input,
|
|
4019
3934
|
path: [def.discriminator],
|
|
4020
3935
|
inst
|
|
@@ -4136,96 +4051,64 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
|
|
|
4136
4051
|
}
|
|
4137
4052
|
payload.value = [];
|
|
4138
4053
|
const proms = [];
|
|
4139
|
-
const
|
|
4140
|
-
const
|
|
4054
|
+
const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
|
|
4055
|
+
const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
|
|
4141
4056
|
if (!def.rest) {
|
|
4142
|
-
|
|
4057
|
+
const tooBig = input.length > items.length;
|
|
4058
|
+
const tooSmall = input.length < optStart - 1;
|
|
4059
|
+
if (tooBig || tooSmall) {
|
|
4143
4060
|
payload.issues.push({
|
|
4144
|
-
code: "too_small",
|
|
4145
|
-
minimum: optinStart,
|
|
4146
|
-
inclusive: true,
|
|
4061
|
+
...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
|
|
4147
4062
|
input,
|
|
4148
4063
|
inst,
|
|
4149
4064
|
origin: "array"
|
|
4150
4065
|
});
|
|
4151
4066
|
return payload;
|
|
4152
4067
|
}
|
|
4153
|
-
if (input.length > items.length) {
|
|
4154
|
-
payload.issues.push({
|
|
4155
|
-
code: "too_big",
|
|
4156
|
-
maximum: items.length,
|
|
4157
|
-
inclusive: true,
|
|
4158
|
-
input,
|
|
4159
|
-
inst,
|
|
4160
|
-
origin: "array"
|
|
4161
|
-
});
|
|
4162
|
-
}
|
|
4163
4068
|
}
|
|
4164
|
-
|
|
4165
|
-
for (
|
|
4166
|
-
|
|
4167
|
-
if (
|
|
4168
|
-
|
|
4169
|
-
|
|
4170
|
-
|
|
4069
|
+
let i = -1;
|
|
4070
|
+
for (const item of items) {
|
|
4071
|
+
i++;
|
|
4072
|
+
if (i >= input.length) {
|
|
4073
|
+
if (i >= optStart)
|
|
4074
|
+
continue;
|
|
4075
|
+
}
|
|
4076
|
+
const result = item._zod.run({
|
|
4077
|
+
value: input[i],
|
|
4078
|
+
issues: []
|
|
4079
|
+
}, ctx);
|
|
4080
|
+
if (result instanceof Promise) {
|
|
4081
|
+
proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
|
|
4171
4082
|
} else {
|
|
4172
|
-
|
|
4083
|
+
handleTupleResult(result, payload, i);
|
|
4173
4084
|
}
|
|
4174
4085
|
}
|
|
4175
4086
|
if (def.rest) {
|
|
4176
|
-
let i = items.length - 1;
|
|
4177
4087
|
const rest = input.slice(items.length);
|
|
4178
4088
|
for (const el of rest) {
|
|
4179
4089
|
i++;
|
|
4180
|
-
const result = def.rest._zod.run({
|
|
4090
|
+
const result = def.rest._zod.run({
|
|
4091
|
+
value: el,
|
|
4092
|
+
issues: []
|
|
4093
|
+
}, ctx);
|
|
4181
4094
|
if (result instanceof Promise) {
|
|
4182
|
-
proms.push(result.then((
|
|
4095
|
+
proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
|
|
4183
4096
|
} else {
|
|
4184
4097
|
handleTupleResult(result, payload, i);
|
|
4185
4098
|
}
|
|
4186
4099
|
}
|
|
4187
4100
|
}
|
|
4188
|
-
if (proms.length)
|
|
4189
|
-
return Promise.all(proms).then(() =>
|
|
4190
|
-
|
|
4191
|
-
return handleTupleResults(itemResults, payload, items, input, optoutStart);
|
|
4101
|
+
if (proms.length)
|
|
4102
|
+
return Promise.all(proms).then(() => payload);
|
|
4103
|
+
return payload;
|
|
4192
4104
|
};
|
|
4193
4105
|
});
|
|
4194
|
-
function getTupleOptStart(items, key) {
|
|
4195
|
-
for (let i = items.length - 1; i >= 0; i--) {
|
|
4196
|
-
if (items[i]._zod[key] !== "optional")
|
|
4197
|
-
return i + 1;
|
|
4198
|
-
}
|
|
4199
|
-
return 0;
|
|
4200
|
-
}
|
|
4201
4106
|
function handleTupleResult(result, final, index) {
|
|
4202
4107
|
if (result.issues.length) {
|
|
4203
4108
|
final.issues.push(...prefixIssues(index, result.issues));
|
|
4204
4109
|
}
|
|
4205
4110
|
final.value[index] = result.value;
|
|
4206
4111
|
}
|
|
4207
|
-
function handleTupleResults(itemResults, final, items, input, optoutStart) {
|
|
4208
|
-
for (let i = 0; i < items.length; i++) {
|
|
4209
|
-
const r = itemResults[i];
|
|
4210
|
-
const isPresent = i < input.length;
|
|
4211
|
-
if (r.issues.length) {
|
|
4212
|
-
if (!isPresent && i >= optoutStart) {
|
|
4213
|
-
final.value.length = i;
|
|
4214
|
-
break;
|
|
4215
|
-
}
|
|
4216
|
-
final.issues.push(...prefixIssues(i, r.issues));
|
|
4217
|
-
}
|
|
4218
|
-
final.value[i] = r.value;
|
|
4219
|
-
}
|
|
4220
|
-
for (let i = final.value.length - 1; i >= input.length; i--) {
|
|
4221
|
-
if (items[i]._zod.optout === "optional" && final.value[i] === void 0) {
|
|
4222
|
-
final.value.length = i;
|
|
4223
|
-
} else {
|
|
4224
|
-
break;
|
|
4225
|
-
}
|
|
4226
|
-
}
|
|
4227
|
-
return final;
|
|
4228
|
-
}
|
|
4229
4112
|
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
|
|
4230
4113
|
$ZodType.init(inst, def);
|
|
4231
4114
|
inst._zod.parse = (payload, ctx) => {
|
|
@@ -4247,35 +4130,19 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
|
|
|
4247
4130
|
for (const key of values) {
|
|
4248
4131
|
if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
|
|
4249
4132
|
recordKeys.add(typeof key === "number" ? key.toString() : key);
|
|
4250
|
-
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
4251
|
-
if (keyResult instanceof Promise) {
|
|
4252
|
-
throw new Error("Async schemas not supported in object keys currently");
|
|
4253
|
-
}
|
|
4254
|
-
if (keyResult.issues.length) {
|
|
4255
|
-
payload.issues.push({
|
|
4256
|
-
code: "invalid_key",
|
|
4257
|
-
origin: "record",
|
|
4258
|
-
issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
|
|
4259
|
-
input: key,
|
|
4260
|
-
path: [key],
|
|
4261
|
-
inst
|
|
4262
|
-
});
|
|
4263
|
-
continue;
|
|
4264
|
-
}
|
|
4265
|
-
const outKey = keyResult.value;
|
|
4266
4133
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
4267
4134
|
if (result instanceof Promise) {
|
|
4268
4135
|
proms.push(result.then((result2) => {
|
|
4269
4136
|
if (result2.issues.length) {
|
|
4270
4137
|
payload.issues.push(...prefixIssues(key, result2.issues));
|
|
4271
4138
|
}
|
|
4272
|
-
payload.value[
|
|
4139
|
+
payload.value[key] = result2.value;
|
|
4273
4140
|
}));
|
|
4274
4141
|
} else {
|
|
4275
4142
|
if (result.issues.length) {
|
|
4276
4143
|
payload.issues.push(...prefixIssues(key, result.issues));
|
|
4277
4144
|
}
|
|
4278
|
-
payload.value[
|
|
4145
|
+
payload.value[key] = result.value;
|
|
4279
4146
|
}
|
|
4280
4147
|
}
|
|
4281
4148
|
}
|
|
@@ -4299,8 +4166,6 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
|
|
|
4299
4166
|
for (const key of Reflect.ownKeys(input)) {
|
|
4300
4167
|
if (key === "__proto__")
|
|
4301
4168
|
continue;
|
|
4302
|
-
if (!Object.prototype.propertyIsEnumerable.call(input, key))
|
|
4303
|
-
continue;
|
|
4304
4169
|
let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
4305
4170
|
if (keyResult instanceof Promise) {
|
|
4306
4171
|
throw new Error("Async schemas not supported in object keys currently");
|
|
@@ -4505,7 +4370,6 @@ var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
|
|
|
4505
4370
|
});
|
|
4506
4371
|
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
|
|
4507
4372
|
$ZodType.init(inst, def);
|
|
4508
|
-
inst._zod.optin = "optional";
|
|
4509
4373
|
inst._zod.parse = (payload, ctx) => {
|
|
4510
4374
|
if (ctx.direction === "backward") {
|
|
4511
4375
|
throw new $ZodEncodeError(inst.constructor.name);
|
|
@@ -4515,7 +4379,6 @@ var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) =>
|
|
|
4515
4379
|
const output = _out instanceof Promise ? _out : Promise.resolve(_out);
|
|
4516
4380
|
return output.then((output2) => {
|
|
4517
4381
|
payload.value = output2;
|
|
4518
|
-
payload.fallback = true;
|
|
4519
4382
|
return payload;
|
|
4520
4383
|
});
|
|
4521
4384
|
}
|
|
@@ -4523,12 +4386,11 @@ var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) =>
|
|
|
4523
4386
|
throw new $ZodAsyncError();
|
|
4524
4387
|
}
|
|
4525
4388
|
payload.value = _out;
|
|
4526
|
-
payload.fallback = true;
|
|
4527
4389
|
return payload;
|
|
4528
4390
|
};
|
|
4529
4391
|
});
|
|
4530
4392
|
function handleOptionalResult(result, input) {
|
|
4531
|
-
if (input === void 0
|
|
4393
|
+
if (result.issues.length && input === void 0) {
|
|
4532
4394
|
return { issues: [], value: void 0 };
|
|
4533
4395
|
}
|
|
4534
4396
|
return result;
|
|
@@ -4546,11 +4408,10 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
|
|
|
4546
4408
|
});
|
|
4547
4409
|
inst._zod.parse = (payload, ctx) => {
|
|
4548
4410
|
if (def.innerType._zod.optin === "optional") {
|
|
4549
|
-
const input = payload.value;
|
|
4550
4411
|
const result = def.innerType._zod.run(payload, ctx);
|
|
4551
4412
|
if (result instanceof Promise)
|
|
4552
|
-
return result.then((r) => handleOptionalResult(r,
|
|
4553
|
-
return handleOptionalResult(result,
|
|
4413
|
+
return result.then((r) => handleOptionalResult(r, payload.value));
|
|
4414
|
+
return handleOptionalResult(result, payload.value);
|
|
4554
4415
|
}
|
|
4555
4416
|
if (payload.value === void 0) {
|
|
4556
4417
|
return payload;
|
|
@@ -4666,7 +4527,7 @@ var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
|
|
|
4666
4527
|
});
|
|
4667
4528
|
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
|
|
4668
4529
|
$ZodType.init(inst, def);
|
|
4669
|
-
inst._zod
|
|
4530
|
+
defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
4670
4531
|
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
4671
4532
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
4672
4533
|
inst._zod.parse = (payload, ctx) => {
|
|
@@ -4686,7 +4547,6 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
|
|
|
4686
4547
|
input: payload.value
|
|
4687
4548
|
});
|
|
4688
4549
|
payload.issues = [];
|
|
4689
|
-
payload.fallback = true;
|
|
4690
4550
|
}
|
|
4691
4551
|
return payload;
|
|
4692
4552
|
});
|
|
@@ -4701,7 +4561,6 @@ var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
|
|
|
4701
4561
|
input: payload.value
|
|
4702
4562
|
});
|
|
4703
4563
|
payload.issues = [];
|
|
4704
|
-
payload.fallback = true;
|
|
4705
4564
|
}
|
|
4706
4565
|
return payload;
|
|
4707
4566
|
};
|
|
@@ -4747,7 +4606,7 @@ function handlePipeResult(left, next, ctx) {
|
|
|
4747
4606
|
left.aborted = true;
|
|
4748
4607
|
return left;
|
|
4749
4608
|
}
|
|
4750
|
-
return next._zod.run({ value: left.value, issues: left.issues
|
|
4609
|
+
return next._zod.run({ value: left.value, issues: left.issues }, ctx);
|
|
4751
4610
|
}
|
|
4752
4611
|
var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
|
|
4753
4612
|
$ZodType.init(inst, def);
|
|
@@ -4799,9 +4658,6 @@ function handleCodecTxResult(left, value, nextSchema, ctx) {
|
|
|
4799
4658
|
}
|
|
4800
4659
|
return nextSchema._zod.run({ value, issues: left.issues }, ctx);
|
|
4801
4660
|
}
|
|
4802
|
-
var $ZodPreprocess = /* @__PURE__ */ $constructor("$ZodPreprocess", (inst, def) => {
|
|
4803
|
-
$ZodPipe.init(inst, def);
|
|
4804
|
-
});
|
|
4805
4661
|
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
|
|
4806
4662
|
$ZodType.init(inst, def);
|
|
4807
4663
|
defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
|
|
@@ -4953,12 +4809,7 @@ var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
|
|
|
4953
4809
|
});
|
|
4954
4810
|
var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
|
|
4955
4811
|
$ZodType.init(inst, def);
|
|
4956
|
-
defineLazy(inst._zod, "innerType", () =>
|
|
4957
|
-
const d = def;
|
|
4958
|
-
if (!d._cachedInner)
|
|
4959
|
-
d._cachedInner = def.getter();
|
|
4960
|
-
return d._cachedInner;
|
|
4961
|
-
});
|
|
4812
|
+
defineLazy(inst._zod, "innerType", () => def.getter());
|
|
4962
4813
|
defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
|
|
4963
4814
|
defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
|
|
4964
4815
|
defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
|
|
@@ -5013,7 +4864,6 @@ __export(locales_exports, {
|
|
|
5013
4864
|
cs: () => cs_default,
|
|
5014
4865
|
da: () => da_default,
|
|
5015
4866
|
de: () => de_default,
|
|
5016
|
-
el: () => el_default,
|
|
5017
4867
|
en: () => en_default,
|
|
5018
4868
|
eo: () => eo_default,
|
|
5019
4869
|
es: () => es_default,
|
|
@@ -5022,7 +4872,6 @@ __export(locales_exports, {
|
|
|
5022
4872
|
fr: () => fr_default,
|
|
5023
4873
|
frCA: () => fr_CA_default,
|
|
5024
4874
|
he: () => he_default,
|
|
5025
|
-
hr: () => hr_default,
|
|
5026
4875
|
hu: () => hu_default,
|
|
5027
4876
|
hy: () => hy_default,
|
|
5028
4877
|
id: () => id_default,
|
|
@@ -5042,7 +4891,6 @@ __export(locales_exports, {
|
|
|
5042
4891
|
pl: () => pl_default,
|
|
5043
4892
|
ps: () => ps_default,
|
|
5044
4893
|
pt: () => pt_default,
|
|
5045
|
-
ro: () => ro_default,
|
|
5046
4894
|
ru: () => ru_default,
|
|
5047
4895
|
sl: () => sl_default,
|
|
5048
4896
|
sv: () => sv_default,
|
|
@@ -5996,118 +5844,8 @@ function de_default() {
|
|
|
5996
5844
|
};
|
|
5997
5845
|
}
|
|
5998
5846
|
|
|
5999
|
-
// ../../node_modules/zod/v4/locales/el.js
|
|
6000
|
-
var error9 = () => {
|
|
6001
|
-
const Sizable = {
|
|
6002
|
-
string: { unit: "\u03C7\u03B1\u03C1\u03B1\u03BA\u03C4\u03AE\u03C1\u03B5\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
|
|
6003
|
-
file: { unit: "bytes", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
|
|
6004
|
-
array: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
|
|
6005
|
-
set: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
|
|
6006
|
-
map: { unit: "\u03BA\u03B1\u03C4\u03B1\u03C7\u03C9\u03C1\u03AE\u03C3\u03B5\u03B9\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" }
|
|
6007
|
-
};
|
|
6008
|
-
function getSizing(origin) {
|
|
6009
|
-
return Sizable[origin] ?? null;
|
|
6010
|
-
}
|
|
6011
|
-
const FormatDictionary = {
|
|
6012
|
-
regex: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2",
|
|
6013
|
-
email: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 email",
|
|
6014
|
-
url: "URL",
|
|
6015
|
-
emoji: "emoji",
|
|
6016
|
-
uuid: "UUID",
|
|
6017
|
-
uuidv4: "UUIDv4",
|
|
6018
|
-
uuidv6: "UUIDv6",
|
|
6019
|
-
nanoid: "nanoid",
|
|
6020
|
-
guid: "GUID",
|
|
6021
|
-
cuid: "cuid",
|
|
6022
|
-
cuid2: "cuid2",
|
|
6023
|
-
ulid: "ULID",
|
|
6024
|
-
xid: "XID",
|
|
6025
|
-
ksuid: "KSUID",
|
|
6026
|
-
datetime: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1 \u03BA\u03B1\u03B9 \u03CE\u03C1\u03B1",
|
|
6027
|
-
date: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1",
|
|
6028
|
-
time: "ISO \u03CE\u03C1\u03B1",
|
|
6029
|
-
duration: "ISO \u03B4\u03B9\u03AC\u03C1\u03BA\u03B5\u03B9\u03B1",
|
|
6030
|
-
ipv4: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv4",
|
|
6031
|
-
ipv6: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv6",
|
|
6032
|
-
mac: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 MAC",
|
|
6033
|
-
cidrv4: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv4",
|
|
6034
|
-
cidrv6: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv6",
|
|
6035
|
-
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",
|
|
6036
|
-
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",
|
|
6037
|
-
json_string: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC JSON",
|
|
6038
|
-
e164: "\u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2 E.164",
|
|
6039
|
-
jwt: "JWT",
|
|
6040
|
-
template_literal: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2"
|
|
6041
|
-
};
|
|
6042
|
-
const TypeDictionary = {
|
|
6043
|
-
nan: "NaN"
|
|
6044
|
-
};
|
|
6045
|
-
return (issue2) => {
|
|
6046
|
-
switch (issue2.code) {
|
|
6047
|
-
case "invalid_type": {
|
|
6048
|
-
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
6049
|
-
const receivedType = parsedType(issue2.input);
|
|
6050
|
-
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
6051
|
-
if (typeof issue2.expected === "string" && /^[A-Z]/.test(issue2.expected)) {
|
|
6052
|
-
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}`;
|
|
6053
|
-
}
|
|
6054
|
-
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}`;
|
|
6055
|
-
}
|
|
6056
|
-
case "invalid_value":
|
|
6057
|
-
if (issue2.values.length === 1)
|
|
6058
|
-
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])}`;
|
|
6059
|
-
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, "|")}`;
|
|
6060
|
-
case "too_big": {
|
|
6061
|
-
const adj = issue2.inclusive ? "<=" : "<";
|
|
6062
|
-
const sizing = getSizing(issue2.origin);
|
|
6063
|
-
if (sizing)
|
|
6064
|
-
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"}`;
|
|
6065
|
-
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()}`;
|
|
6066
|
-
}
|
|
6067
|
-
case "too_small": {
|
|
6068
|
-
const adj = issue2.inclusive ? ">=" : ">";
|
|
6069
|
-
const sizing = getSizing(issue2.origin);
|
|
6070
|
-
if (sizing) {
|
|
6071
|
-
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}`;
|
|
6072
|
-
}
|
|
6073
|
-
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()}`;
|
|
6074
|
-
}
|
|
6075
|
-
case "invalid_format": {
|
|
6076
|
-
const _issue = issue2;
|
|
6077
|
-
if (_issue.format === "starts_with") {
|
|
6078
|
-
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}"`;
|
|
6079
|
-
}
|
|
6080
|
-
if (_issue.format === "ends_with")
|
|
6081
|
-
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}"`;
|
|
6082
|
-
if (_issue.format === "includes")
|
|
6083
|
-
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}"`;
|
|
6084
|
-
if (_issue.format === "regex")
|
|
6085
|
-
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}`;
|
|
6086
|
-
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF: ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
6087
|
-
}
|
|
6088
|
-
case "not_multiple_of":
|
|
6089
|
-
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}`;
|
|
6090
|
-
case "unrecognized_keys":
|
|
6091
|
-
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, ", ")}`;
|
|
6092
|
-
case "invalid_key":
|
|
6093
|
-
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF \u03BA\u03BB\u03B5\u03B9\u03B4\u03AF \u03C3\u03C4\u03BF ${issue2.origin}`;
|
|
6094
|
-
case "invalid_union":
|
|
6095
|
-
return "\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2";
|
|
6096
|
-
case "invalid_element":
|
|
6097
|
-
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C4\u03B9\u03BC\u03AE \u03C3\u03C4\u03BF ${issue2.origin}`;
|
|
6098
|
-
default:
|
|
6099
|
-
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2`;
|
|
6100
|
-
}
|
|
6101
|
-
};
|
|
6102
|
-
};
|
|
6103
|
-
function el_default() {
|
|
6104
|
-
return {
|
|
6105
|
-
localeError: error9()
|
|
6106
|
-
};
|
|
6107
|
-
}
|
|
6108
|
-
|
|
6109
5847
|
// ../../node_modules/zod/v4/locales/en.js
|
|
6110
|
-
var
|
|
5848
|
+
var error9 = () => {
|
|
6111
5849
|
const Sizable = {
|
|
6112
5850
|
string: { unit: "characters", verb: "to have" },
|
|
6113
5851
|
file: { unit: "bytes", verb: "to have" },
|
|
@@ -6201,10 +5939,6 @@ var error10 = () => {
|
|
|
6201
5939
|
case "invalid_key":
|
|
6202
5940
|
return `Invalid key in ${issue2.origin}`;
|
|
6203
5941
|
case "invalid_union":
|
|
6204
|
-
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
|
|
6205
|
-
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
|
|
6206
|
-
return `Invalid discriminator value. Expected ${opts}`;
|
|
6207
|
-
}
|
|
6208
5942
|
return "Invalid input";
|
|
6209
5943
|
case "invalid_element":
|
|
6210
5944
|
return `Invalid value in ${issue2.origin}`;
|
|
@@ -6215,12 +5949,12 @@ var error10 = () => {
|
|
|
6215
5949
|
};
|
|
6216
5950
|
function en_default() {
|
|
6217
5951
|
return {
|
|
6218
|
-
localeError:
|
|
5952
|
+
localeError: error9()
|
|
6219
5953
|
};
|
|
6220
5954
|
}
|
|
6221
5955
|
|
|
6222
5956
|
// ../../node_modules/zod/v4/locales/eo.js
|
|
6223
|
-
var
|
|
5957
|
+
var error10 = () => {
|
|
6224
5958
|
const Sizable = {
|
|
6225
5959
|
string: { unit: "karaktrojn", verb: "havi" },
|
|
6226
5960
|
file: { unit: "bajtojn", verb: "havi" },
|
|
@@ -6325,12 +6059,12 @@ var error11 = () => {
|
|
|
6325
6059
|
};
|
|
6326
6060
|
function eo_default() {
|
|
6327
6061
|
return {
|
|
6328
|
-
localeError:
|
|
6062
|
+
localeError: error10()
|
|
6329
6063
|
};
|
|
6330
6064
|
}
|
|
6331
6065
|
|
|
6332
6066
|
// ../../node_modules/zod/v4/locales/es.js
|
|
6333
|
-
var
|
|
6067
|
+
var error11 = () => {
|
|
6334
6068
|
const Sizable = {
|
|
6335
6069
|
string: { unit: "caracteres", verb: "tener" },
|
|
6336
6070
|
file: { unit: "bytes", verb: "tener" },
|
|
@@ -6458,12 +6192,12 @@ var error12 = () => {
|
|
|
6458
6192
|
};
|
|
6459
6193
|
function es_default() {
|
|
6460
6194
|
return {
|
|
6461
|
-
localeError:
|
|
6195
|
+
localeError: error11()
|
|
6462
6196
|
};
|
|
6463
6197
|
}
|
|
6464
6198
|
|
|
6465
6199
|
// ../../node_modules/zod/v4/locales/fa.js
|
|
6466
|
-
var
|
|
6200
|
+
var error12 = () => {
|
|
6467
6201
|
const Sizable = {
|
|
6468
6202
|
string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
6469
6203
|
file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
@@ -6573,12 +6307,12 @@ var error13 = () => {
|
|
|
6573
6307
|
};
|
|
6574
6308
|
function fa_default() {
|
|
6575
6309
|
return {
|
|
6576
|
-
localeError:
|
|
6310
|
+
localeError: error12()
|
|
6577
6311
|
};
|
|
6578
6312
|
}
|
|
6579
6313
|
|
|
6580
6314
|
// ../../node_modules/zod/v4/locales/fi.js
|
|
6581
|
-
var
|
|
6315
|
+
var error13 = () => {
|
|
6582
6316
|
const Sizable = {
|
|
6583
6317
|
string: { unit: "merkki\xE4", subject: "merkkijonon" },
|
|
6584
6318
|
file: { unit: "tavua", subject: "tiedoston" },
|
|
@@ -6686,12 +6420,12 @@ var error14 = () => {
|
|
|
6686
6420
|
};
|
|
6687
6421
|
function fi_default() {
|
|
6688
6422
|
return {
|
|
6689
|
-
localeError:
|
|
6423
|
+
localeError: error13()
|
|
6690
6424
|
};
|
|
6691
6425
|
}
|
|
6692
6426
|
|
|
6693
6427
|
// ../../node_modules/zod/v4/locales/fr.js
|
|
6694
|
-
var
|
|
6428
|
+
var error14 = () => {
|
|
6695
6429
|
const Sizable = {
|
|
6696
6430
|
string: { unit: "caract\xE8res", verb: "avoir" },
|
|
6697
6431
|
file: { unit: "octets", verb: "avoir" },
|
|
@@ -6732,27 +6466,9 @@ var error15 = () => {
|
|
|
6732
6466
|
template_literal: "entr\xE9e"
|
|
6733
6467
|
};
|
|
6734
6468
|
const TypeDictionary = {
|
|
6735
|
-
string: "cha\xEEne",
|
|
6736
|
-
number: "nombre",
|
|
6737
|
-
int: "entier",
|
|
6738
|
-
boolean: "bool\xE9en",
|
|
6739
|
-
bigint: "grand entier",
|
|
6740
|
-
symbol: "symbole",
|
|
6741
|
-
undefined: "ind\xE9fini",
|
|
6742
|
-
null: "null",
|
|
6743
|
-
never: "jamais",
|
|
6744
|
-
void: "vide",
|
|
6745
|
-
date: "date",
|
|
6746
|
-
array: "tableau",
|
|
6747
|
-
object: "objet",
|
|
6748
|
-
tuple: "tuple",
|
|
6749
|
-
record: "enregistrement",
|
|
6750
|
-
map: "carte",
|
|
6751
|
-
set: "ensemble",
|
|
6752
|
-
file: "fichier",
|
|
6753
|
-
nonoptional: "non-optionnel",
|
|
6754
6469
|
nan: "NaN",
|
|
6755
|
-
|
|
6470
|
+
number: "nombre",
|
|
6471
|
+
array: "tableau"
|
|
6756
6472
|
};
|
|
6757
6473
|
return (issue2) => {
|
|
6758
6474
|
switch (issue2.code) {
|
|
@@ -6773,15 +6489,16 @@ var error15 = () => {
|
|
|
6773
6489
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
6774
6490
|
const sizing = getSizing(issue2.origin);
|
|
6775
6491
|
if (sizing)
|
|
6776
|
-
return `Trop grand : ${
|
|
6777
|
-
return `Trop grand : ${
|
|
6492
|
+
return `Trop grand : ${issue2.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
|
|
6493
|
+
return `Trop grand : ${issue2.origin ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
|
|
6778
6494
|
}
|
|
6779
6495
|
case "too_small": {
|
|
6780
6496
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
6781
6497
|
const sizing = getSizing(issue2.origin);
|
|
6782
|
-
if (sizing)
|
|
6783
|
-
return `Trop petit : ${
|
|
6784
|
-
|
|
6498
|
+
if (sizing) {
|
|
6499
|
+
return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
6500
|
+
}
|
|
6501
|
+
return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
|
|
6785
6502
|
}
|
|
6786
6503
|
case "invalid_format": {
|
|
6787
6504
|
const _issue = issue2;
|
|
@@ -6812,12 +6529,12 @@ var error15 = () => {
|
|
|
6812
6529
|
};
|
|
6813
6530
|
function fr_default() {
|
|
6814
6531
|
return {
|
|
6815
|
-
localeError:
|
|
6532
|
+
localeError: error14()
|
|
6816
6533
|
};
|
|
6817
6534
|
}
|
|
6818
6535
|
|
|
6819
6536
|
// ../../node_modules/zod/v4/locales/fr-CA.js
|
|
6820
|
-
var
|
|
6537
|
+
var error15 = () => {
|
|
6821
6538
|
const Sizable = {
|
|
6822
6539
|
string: { unit: "caract\xE8res", verb: "avoir" },
|
|
6823
6540
|
file: { unit: "octets", verb: "avoir" },
|
|
@@ -6920,12 +6637,12 @@ var error16 = () => {
|
|
|
6920
6637
|
};
|
|
6921
6638
|
function fr_CA_default() {
|
|
6922
6639
|
return {
|
|
6923
|
-
localeError:
|
|
6640
|
+
localeError: error15()
|
|
6924
6641
|
};
|
|
6925
6642
|
}
|
|
6926
6643
|
|
|
6927
6644
|
// ../../node_modules/zod/v4/locales/he.js
|
|
6928
|
-
var
|
|
6645
|
+
var error16 = () => {
|
|
6929
6646
|
const TypeNames = {
|
|
6930
6647
|
string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
|
|
6931
6648
|
number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
|
|
@@ -7115,135 +6832,12 @@ var error17 = () => {
|
|
|
7115
6832
|
};
|
|
7116
6833
|
function he_default() {
|
|
7117
6834
|
return {
|
|
7118
|
-
localeError:
|
|
7119
|
-
};
|
|
7120
|
-
}
|
|
7121
|
-
|
|
7122
|
-
// ../../node_modules/zod/v4/locales/hr.js
|
|
7123
|
-
var error18 = () => {
|
|
7124
|
-
const Sizable = {
|
|
7125
|
-
string: { unit: "znakova", verb: "imati" },
|
|
7126
|
-
file: { unit: "bajtova", verb: "imati" },
|
|
7127
|
-
array: { unit: "stavki", verb: "imati" },
|
|
7128
|
-
set: { unit: "stavki", verb: "imati" }
|
|
7129
|
-
};
|
|
7130
|
-
function getSizing(origin) {
|
|
7131
|
-
return Sizable[origin] ?? null;
|
|
7132
|
-
}
|
|
7133
|
-
const FormatDictionary = {
|
|
7134
|
-
regex: "unos",
|
|
7135
|
-
email: "email adresa",
|
|
7136
|
-
url: "URL",
|
|
7137
|
-
emoji: "emoji",
|
|
7138
|
-
uuid: "UUID",
|
|
7139
|
-
uuidv4: "UUIDv4",
|
|
7140
|
-
uuidv6: "UUIDv6",
|
|
7141
|
-
nanoid: "nanoid",
|
|
7142
|
-
guid: "GUID",
|
|
7143
|
-
cuid: "cuid",
|
|
7144
|
-
cuid2: "cuid2",
|
|
7145
|
-
ulid: "ULID",
|
|
7146
|
-
xid: "XID",
|
|
7147
|
-
ksuid: "KSUID",
|
|
7148
|
-
datetime: "ISO datum i vrijeme",
|
|
7149
|
-
date: "ISO datum",
|
|
7150
|
-
time: "ISO vrijeme",
|
|
7151
|
-
duration: "ISO trajanje",
|
|
7152
|
-
ipv4: "IPv4 adresa",
|
|
7153
|
-
ipv6: "IPv6 adresa",
|
|
7154
|
-
cidrv4: "IPv4 raspon",
|
|
7155
|
-
cidrv6: "IPv6 raspon",
|
|
7156
|
-
base64: "base64 kodirani tekst",
|
|
7157
|
-
base64url: "base64url kodirani tekst",
|
|
7158
|
-
json_string: "JSON tekst",
|
|
7159
|
-
e164: "E.164 broj",
|
|
7160
|
-
jwt: "JWT",
|
|
7161
|
-
template_literal: "unos"
|
|
7162
|
-
};
|
|
7163
|
-
const TypeDictionary = {
|
|
7164
|
-
nan: "NaN",
|
|
7165
|
-
string: "tekst",
|
|
7166
|
-
number: "broj",
|
|
7167
|
-
boolean: "boolean",
|
|
7168
|
-
array: "niz",
|
|
7169
|
-
object: "objekt",
|
|
7170
|
-
set: "skup",
|
|
7171
|
-
file: "datoteka",
|
|
7172
|
-
date: "datum",
|
|
7173
|
-
bigint: "bigint",
|
|
7174
|
-
symbol: "simbol",
|
|
7175
|
-
undefined: "undefined",
|
|
7176
|
-
null: "null",
|
|
7177
|
-
function: "funkcija",
|
|
7178
|
-
map: "mapa"
|
|
7179
|
-
};
|
|
7180
|
-
return (issue2) => {
|
|
7181
|
-
switch (issue2.code) {
|
|
7182
|
-
case "invalid_type": {
|
|
7183
|
-
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
7184
|
-
const receivedType = parsedType(issue2.input);
|
|
7185
|
-
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
7186
|
-
if (/^[A-Z]/.test(issue2.expected)) {
|
|
7187
|
-
return `Neispravan unos: o\u010Dekuje se instanceof ${issue2.expected}, a primljeno je ${received}`;
|
|
7188
|
-
}
|
|
7189
|
-
return `Neispravan unos: o\u010Dekuje se ${expected}, a primljeno je ${received}`;
|
|
7190
|
-
}
|
|
7191
|
-
case "invalid_value":
|
|
7192
|
-
if (issue2.values.length === 1)
|
|
7193
|
-
return `Neispravna vrijednost: o\u010Dekivano ${stringifyPrimitive(issue2.values[0])}`;
|
|
7194
|
-
return `Neispravna opcija: o\u010Dekivano jedno od ${joinValues(issue2.values, "|")}`;
|
|
7195
|
-
case "too_big": {
|
|
7196
|
-
const adj = issue2.inclusive ? "<=" : "<";
|
|
7197
|
-
const sizing = getSizing(issue2.origin);
|
|
7198
|
-
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
7199
|
-
if (sizing)
|
|
7200
|
-
return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} ima ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemenata"}`;
|
|
7201
|
-
return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} bude ${adj}${issue2.maximum.toString()}`;
|
|
7202
|
-
}
|
|
7203
|
-
case "too_small": {
|
|
7204
|
-
const adj = issue2.inclusive ? ">=" : ">";
|
|
7205
|
-
const sizing = getSizing(issue2.origin);
|
|
7206
|
-
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
7207
|
-
if (sizing) {
|
|
7208
|
-
return `Premalo: o\u010Dekivano da ${origin} ima ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
7209
|
-
}
|
|
7210
|
-
return `Premalo: o\u010Dekivano da ${origin} bude ${adj}${issue2.minimum.toString()}`;
|
|
7211
|
-
}
|
|
7212
|
-
case "invalid_format": {
|
|
7213
|
-
const _issue = issue2;
|
|
7214
|
-
if (_issue.format === "starts_with")
|
|
7215
|
-
return `Neispravan tekst: mora zapo\u010Dinjati s "${_issue.prefix}"`;
|
|
7216
|
-
if (_issue.format === "ends_with")
|
|
7217
|
-
return `Neispravan tekst: mora zavr\u0161avati s "${_issue.suffix}"`;
|
|
7218
|
-
if (_issue.format === "includes")
|
|
7219
|
-
return `Neispravan tekst: mora sadr\u017Eavati "${_issue.includes}"`;
|
|
7220
|
-
if (_issue.format === "regex")
|
|
7221
|
-
return `Neispravan tekst: mora odgovarati uzorku ${_issue.pattern}`;
|
|
7222
|
-
return `Neispravna ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
7223
|
-
}
|
|
7224
|
-
case "not_multiple_of":
|
|
7225
|
-
return `Neispravan broj: mora biti vi\u0161ekratnik od ${issue2.divisor}`;
|
|
7226
|
-
case "unrecognized_keys":
|
|
7227
|
-
return `Neprepoznat${issue2.keys.length > 1 ? "i klju\u010Devi" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
|
|
7228
|
-
case "invalid_key":
|
|
7229
|
-
return `Neispravan klju\u010D u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
|
|
7230
|
-
case "invalid_union":
|
|
7231
|
-
return "Neispravan unos";
|
|
7232
|
-
case "invalid_element":
|
|
7233
|
-
return `Neispravna vrijednost u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
|
|
7234
|
-
default:
|
|
7235
|
-
return `Neispravan unos`;
|
|
7236
|
-
}
|
|
7237
|
-
};
|
|
7238
|
-
};
|
|
7239
|
-
function hr_default() {
|
|
7240
|
-
return {
|
|
7241
|
-
localeError: error18()
|
|
6835
|
+
localeError: error16()
|
|
7242
6836
|
};
|
|
7243
6837
|
}
|
|
7244
6838
|
|
|
7245
6839
|
// ../../node_modules/zod/v4/locales/hu.js
|
|
7246
|
-
var
|
|
6840
|
+
var error17 = () => {
|
|
7247
6841
|
const Sizable = {
|
|
7248
6842
|
string: { unit: "karakter", verb: "legyen" },
|
|
7249
6843
|
file: { unit: "byte", verb: "legyen" },
|
|
@@ -7347,7 +6941,7 @@ var error19 = () => {
|
|
|
7347
6941
|
};
|
|
7348
6942
|
function hu_default() {
|
|
7349
6943
|
return {
|
|
7350
|
-
localeError:
|
|
6944
|
+
localeError: error17()
|
|
7351
6945
|
};
|
|
7352
6946
|
}
|
|
7353
6947
|
|
|
@@ -7362,7 +6956,7 @@ function withDefiniteArticle(word) {
|
|
|
7362
6956
|
const lastChar = word[word.length - 1];
|
|
7363
6957
|
return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
|
|
7364
6958
|
}
|
|
7365
|
-
var
|
|
6959
|
+
var error18 = () => {
|
|
7366
6960
|
const Sizable = {
|
|
7367
6961
|
string: {
|
|
7368
6962
|
unit: {
|
|
@@ -7495,12 +7089,12 @@ var error20 = () => {
|
|
|
7495
7089
|
};
|
|
7496
7090
|
function hy_default() {
|
|
7497
7091
|
return {
|
|
7498
|
-
localeError:
|
|
7092
|
+
localeError: error18()
|
|
7499
7093
|
};
|
|
7500
7094
|
}
|
|
7501
7095
|
|
|
7502
7096
|
// ../../node_modules/zod/v4/locales/id.js
|
|
7503
|
-
var
|
|
7097
|
+
var error19 = () => {
|
|
7504
7098
|
const Sizable = {
|
|
7505
7099
|
string: { unit: "karakter", verb: "memiliki" },
|
|
7506
7100
|
file: { unit: "byte", verb: "memiliki" },
|
|
@@ -7602,12 +7196,12 @@ var error21 = () => {
|
|
|
7602
7196
|
};
|
|
7603
7197
|
function id_default() {
|
|
7604
7198
|
return {
|
|
7605
|
-
localeError:
|
|
7199
|
+
localeError: error19()
|
|
7606
7200
|
};
|
|
7607
7201
|
}
|
|
7608
7202
|
|
|
7609
7203
|
// ../../node_modules/zod/v4/locales/is.js
|
|
7610
|
-
var
|
|
7204
|
+
var error20 = () => {
|
|
7611
7205
|
const Sizable = {
|
|
7612
7206
|
string: { unit: "stafi", verb: "a\xF0 hafa" },
|
|
7613
7207
|
file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
|
|
@@ -7712,12 +7306,12 @@ var error22 = () => {
|
|
|
7712
7306
|
};
|
|
7713
7307
|
function is_default() {
|
|
7714
7308
|
return {
|
|
7715
|
-
localeError:
|
|
7309
|
+
localeError: error20()
|
|
7716
7310
|
};
|
|
7717
7311
|
}
|
|
7718
7312
|
|
|
7719
7313
|
// ../../node_modules/zod/v4/locales/it.js
|
|
7720
|
-
var
|
|
7314
|
+
var error21 = () => {
|
|
7721
7315
|
const Sizable = {
|
|
7722
7316
|
string: { unit: "caratteri", verb: "avere" },
|
|
7723
7317
|
file: { unit: "byte", verb: "avere" },
|
|
@@ -7802,7 +7396,7 @@ var error23 = () => {
|
|
|
7802
7396
|
return `Stringa non valida: deve includere "${_issue.includes}"`;
|
|
7803
7397
|
if (_issue.format === "regex")
|
|
7804
7398
|
return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
|
|
7805
|
-
return `
|
|
7399
|
+
return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
7806
7400
|
}
|
|
7807
7401
|
case "not_multiple_of":
|
|
7808
7402
|
return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
|
|
@@ -7821,12 +7415,12 @@ var error23 = () => {
|
|
|
7821
7415
|
};
|
|
7822
7416
|
function it_default() {
|
|
7823
7417
|
return {
|
|
7824
|
-
localeError:
|
|
7418
|
+
localeError: error21()
|
|
7825
7419
|
};
|
|
7826
7420
|
}
|
|
7827
7421
|
|
|
7828
7422
|
// ../../node_modules/zod/v4/locales/ja.js
|
|
7829
|
-
var
|
|
7423
|
+
var error22 = () => {
|
|
7830
7424
|
const Sizable = {
|
|
7831
7425
|
string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
|
|
7832
7426
|
file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
|
|
@@ -7929,12 +7523,12 @@ var error24 = () => {
|
|
|
7929
7523
|
};
|
|
7930
7524
|
function ja_default() {
|
|
7931
7525
|
return {
|
|
7932
|
-
localeError:
|
|
7526
|
+
localeError: error22()
|
|
7933
7527
|
};
|
|
7934
7528
|
}
|
|
7935
7529
|
|
|
7936
7530
|
// ../../node_modules/zod/v4/locales/ka.js
|
|
7937
|
-
var
|
|
7531
|
+
var error23 = () => {
|
|
7938
7532
|
const Sizable = {
|
|
7939
7533
|
string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
7940
7534
|
file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
@@ -7967,9 +7561,9 @@ var error25 = () => {
|
|
|
7967
7561
|
ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
|
|
7968
7562
|
cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
|
|
7969
7563
|
cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
|
|
7970
|
-
base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \
|
|
7971
|
-
base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \
|
|
7972
|
-
json_string: "JSON \
|
|
7564
|
+
base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
7565
|
+
base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
7566
|
+
json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
7973
7567
|
e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
|
|
7974
7568
|
jwt: "JWT",
|
|
7975
7569
|
template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
|
|
@@ -7977,7 +7571,7 @@ var error25 = () => {
|
|
|
7977
7571
|
const TypeDictionary = {
|
|
7978
7572
|
nan: "NaN",
|
|
7979
7573
|
number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
|
|
7980
|
-
string: "\
|
|
7574
|
+
string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
7981
7575
|
boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
|
|
7982
7576
|
function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
|
|
7983
7577
|
array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
|
|
@@ -8015,14 +7609,14 @@ var error25 = () => {
|
|
|
8015
7609
|
case "invalid_format": {
|
|
8016
7610
|
const _issue = issue2;
|
|
8017
7611
|
if (_issue.format === "starts_with") {
|
|
8018
|
-
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \
|
|
7612
|
+
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`;
|
|
8019
7613
|
}
|
|
8020
7614
|
if (_issue.format === "ends_with")
|
|
8021
|
-
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \
|
|
7615
|
+
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`;
|
|
8022
7616
|
if (_issue.format === "includes")
|
|
8023
|
-
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \
|
|
7617
|
+
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`;
|
|
8024
7618
|
if (_issue.format === "regex")
|
|
8025
|
-
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \
|
|
7619
|
+
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}`;
|
|
8026
7620
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
8027
7621
|
}
|
|
8028
7622
|
case "not_multiple_of":
|
|
@@ -8042,12 +7636,12 @@ var error25 = () => {
|
|
|
8042
7636
|
};
|
|
8043
7637
|
function ka_default() {
|
|
8044
7638
|
return {
|
|
8045
|
-
localeError:
|
|
7639
|
+
localeError: error23()
|
|
8046
7640
|
};
|
|
8047
7641
|
}
|
|
8048
7642
|
|
|
8049
7643
|
// ../../node_modules/zod/v4/locales/km.js
|
|
8050
|
-
var
|
|
7644
|
+
var error24 = () => {
|
|
8051
7645
|
const Sizable = {
|
|
8052
7646
|
string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
8053
7647
|
file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
@@ -8153,7 +7747,7 @@ var error26 = () => {
|
|
|
8153
7747
|
};
|
|
8154
7748
|
function km_default() {
|
|
8155
7749
|
return {
|
|
8156
|
-
localeError:
|
|
7750
|
+
localeError: error24()
|
|
8157
7751
|
};
|
|
8158
7752
|
}
|
|
8159
7753
|
|
|
@@ -8163,7 +7757,7 @@ function kh_default() {
|
|
|
8163
7757
|
}
|
|
8164
7758
|
|
|
8165
7759
|
// ../../node_modules/zod/v4/locales/ko.js
|
|
8166
|
-
var
|
|
7760
|
+
var error25 = () => {
|
|
8167
7761
|
const Sizable = {
|
|
8168
7762
|
string: { unit: "\uBB38\uC790", verb: "to have" },
|
|
8169
7763
|
file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
|
|
@@ -8270,7 +7864,7 @@ var error27 = () => {
|
|
|
8270
7864
|
};
|
|
8271
7865
|
function ko_default() {
|
|
8272
7866
|
return {
|
|
8273
|
-
localeError:
|
|
7867
|
+
localeError: error25()
|
|
8274
7868
|
};
|
|
8275
7869
|
}
|
|
8276
7870
|
|
|
@@ -8288,7 +7882,7 @@ function getUnitTypeFromNumber(number4) {
|
|
|
8288
7882
|
return "one";
|
|
8289
7883
|
return "few";
|
|
8290
7884
|
}
|
|
8291
|
-
var
|
|
7885
|
+
var error26 = () => {
|
|
8292
7886
|
const Sizable = {
|
|
8293
7887
|
string: {
|
|
8294
7888
|
unit: {
|
|
@@ -8474,12 +8068,12 @@ var error28 = () => {
|
|
|
8474
8068
|
};
|
|
8475
8069
|
function lt_default() {
|
|
8476
8070
|
return {
|
|
8477
|
-
localeError:
|
|
8071
|
+
localeError: error26()
|
|
8478
8072
|
};
|
|
8479
8073
|
}
|
|
8480
8074
|
|
|
8481
8075
|
// ../../node_modules/zod/v4/locales/mk.js
|
|
8482
|
-
var
|
|
8076
|
+
var error27 = () => {
|
|
8483
8077
|
const Sizable = {
|
|
8484
8078
|
string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
8485
8079
|
file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
@@ -8584,12 +8178,12 @@ var error29 = () => {
|
|
|
8584
8178
|
};
|
|
8585
8179
|
function mk_default() {
|
|
8586
8180
|
return {
|
|
8587
|
-
localeError:
|
|
8181
|
+
localeError: error27()
|
|
8588
8182
|
};
|
|
8589
8183
|
}
|
|
8590
8184
|
|
|
8591
8185
|
// ../../node_modules/zod/v4/locales/ms.js
|
|
8592
|
-
var
|
|
8186
|
+
var error28 = () => {
|
|
8593
8187
|
const Sizable = {
|
|
8594
8188
|
string: { unit: "aksara", verb: "mempunyai" },
|
|
8595
8189
|
file: { unit: "bait", verb: "mempunyai" },
|
|
@@ -8692,12 +8286,12 @@ var error30 = () => {
|
|
|
8692
8286
|
};
|
|
8693
8287
|
function ms_default() {
|
|
8694
8288
|
return {
|
|
8695
|
-
localeError:
|
|
8289
|
+
localeError: error28()
|
|
8696
8290
|
};
|
|
8697
8291
|
}
|
|
8698
8292
|
|
|
8699
8293
|
// ../../node_modules/zod/v4/locales/nl.js
|
|
8700
|
-
var
|
|
8294
|
+
var error29 = () => {
|
|
8701
8295
|
const Sizable = {
|
|
8702
8296
|
string: { unit: "tekens", verb: "heeft" },
|
|
8703
8297
|
file: { unit: "bytes", verb: "heeft" },
|
|
@@ -8803,12 +8397,12 @@ var error31 = () => {
|
|
|
8803
8397
|
};
|
|
8804
8398
|
function nl_default() {
|
|
8805
8399
|
return {
|
|
8806
|
-
localeError:
|
|
8400
|
+
localeError: error29()
|
|
8807
8401
|
};
|
|
8808
8402
|
}
|
|
8809
8403
|
|
|
8810
8404
|
// ../../node_modules/zod/v4/locales/no.js
|
|
8811
|
-
var
|
|
8405
|
+
var error30 = () => {
|
|
8812
8406
|
const Sizable = {
|
|
8813
8407
|
string: { unit: "tegn", verb: "\xE5 ha" },
|
|
8814
8408
|
file: { unit: "bytes", verb: "\xE5 ha" },
|
|
@@ -8912,12 +8506,12 @@ var error32 = () => {
|
|
|
8912
8506
|
};
|
|
8913
8507
|
function no_default() {
|
|
8914
8508
|
return {
|
|
8915
|
-
localeError:
|
|
8509
|
+
localeError: error30()
|
|
8916
8510
|
};
|
|
8917
8511
|
}
|
|
8918
8512
|
|
|
8919
8513
|
// ../../node_modules/zod/v4/locales/ota.js
|
|
8920
|
-
var
|
|
8514
|
+
var error31 = () => {
|
|
8921
8515
|
const Sizable = {
|
|
8922
8516
|
string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
|
|
8923
8517
|
file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
|
|
@@ -9022,12 +8616,12 @@ var error33 = () => {
|
|
|
9022
8616
|
};
|
|
9023
8617
|
function ota_default() {
|
|
9024
8618
|
return {
|
|
9025
|
-
localeError:
|
|
8619
|
+
localeError: error31()
|
|
9026
8620
|
};
|
|
9027
8621
|
}
|
|
9028
8622
|
|
|
9029
8623
|
// ../../node_modules/zod/v4/locales/ps.js
|
|
9030
|
-
var
|
|
8624
|
+
var error32 = () => {
|
|
9031
8625
|
const Sizable = {
|
|
9032
8626
|
string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
|
|
9033
8627
|
file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
|
|
@@ -9137,12 +8731,12 @@ var error34 = () => {
|
|
|
9137
8731
|
};
|
|
9138
8732
|
function ps_default() {
|
|
9139
8733
|
return {
|
|
9140
|
-
localeError:
|
|
8734
|
+
localeError: error32()
|
|
9141
8735
|
};
|
|
9142
8736
|
}
|
|
9143
8737
|
|
|
9144
8738
|
// ../../node_modules/zod/v4/locales/pl.js
|
|
9145
|
-
var
|
|
8739
|
+
var error33 = () => {
|
|
9146
8740
|
const Sizable = {
|
|
9147
8741
|
string: { unit: "znak\xF3w", verb: "mie\u0107" },
|
|
9148
8742
|
file: { unit: "bajt\xF3w", verb: "mie\u0107" },
|
|
@@ -9247,12 +8841,12 @@ var error35 = () => {
|
|
|
9247
8841
|
};
|
|
9248
8842
|
function pl_default() {
|
|
9249
8843
|
return {
|
|
9250
|
-
localeError:
|
|
8844
|
+
localeError: error33()
|
|
9251
8845
|
};
|
|
9252
8846
|
}
|
|
9253
8847
|
|
|
9254
8848
|
// ../../node_modules/zod/v4/locales/pt.js
|
|
9255
|
-
var
|
|
8849
|
+
var error34 = () => {
|
|
9256
8850
|
const Sizable = {
|
|
9257
8851
|
string: { unit: "caracteres", verb: "ter" },
|
|
9258
8852
|
file: { unit: "bytes", verb: "ter" },
|
|
@@ -9356,127 +8950,7 @@ var error36 = () => {
|
|
|
9356
8950
|
};
|
|
9357
8951
|
function pt_default() {
|
|
9358
8952
|
return {
|
|
9359
|
-
localeError:
|
|
9360
|
-
};
|
|
9361
|
-
}
|
|
9362
|
-
|
|
9363
|
-
// ../../node_modules/zod/v4/locales/ro.js
|
|
9364
|
-
var error37 = () => {
|
|
9365
|
-
const Sizable = {
|
|
9366
|
-
string: { unit: "caractere", verb: "s\u0103 aib\u0103" },
|
|
9367
|
-
file: { unit: "octe\u021Bi", verb: "s\u0103 aib\u0103" },
|
|
9368
|
-
array: { unit: "elemente", verb: "s\u0103 aib\u0103" },
|
|
9369
|
-
set: { unit: "elemente", verb: "s\u0103 aib\u0103" },
|
|
9370
|
-
map: { unit: "intr\u0103ri", verb: "s\u0103 aib\u0103" }
|
|
9371
|
-
};
|
|
9372
|
-
function getSizing(origin) {
|
|
9373
|
-
return Sizable[origin] ?? null;
|
|
9374
|
-
}
|
|
9375
|
-
const FormatDictionary = {
|
|
9376
|
-
regex: "intrare",
|
|
9377
|
-
email: "adres\u0103 de email",
|
|
9378
|
-
url: "URL",
|
|
9379
|
-
emoji: "emoji",
|
|
9380
|
-
uuid: "UUID",
|
|
9381
|
-
uuidv4: "UUIDv4",
|
|
9382
|
-
uuidv6: "UUIDv6",
|
|
9383
|
-
nanoid: "nanoid",
|
|
9384
|
-
guid: "GUID",
|
|
9385
|
-
cuid: "cuid",
|
|
9386
|
-
cuid2: "cuid2",
|
|
9387
|
-
ulid: "ULID",
|
|
9388
|
-
xid: "XID",
|
|
9389
|
-
ksuid: "KSUID",
|
|
9390
|
-
datetime: "dat\u0103 \u0219i or\u0103 ISO",
|
|
9391
|
-
date: "dat\u0103 ISO",
|
|
9392
|
-
time: "or\u0103 ISO",
|
|
9393
|
-
duration: "durat\u0103 ISO",
|
|
9394
|
-
ipv4: "adres\u0103 IPv4",
|
|
9395
|
-
ipv6: "adres\u0103 IPv6",
|
|
9396
|
-
mac: "adres\u0103 MAC",
|
|
9397
|
-
cidrv4: "interval IPv4",
|
|
9398
|
-
cidrv6: "interval IPv6",
|
|
9399
|
-
base64: "\u0219ir codat base64",
|
|
9400
|
-
base64url: "\u0219ir codat base64url",
|
|
9401
|
-
json_string: "\u0219ir JSON",
|
|
9402
|
-
e164: "num\u0103r E.164",
|
|
9403
|
-
jwt: "JWT",
|
|
9404
|
-
template_literal: "intrare"
|
|
9405
|
-
};
|
|
9406
|
-
const TypeDictionary = {
|
|
9407
|
-
nan: "NaN",
|
|
9408
|
-
string: "\u0219ir",
|
|
9409
|
-
number: "num\u0103r",
|
|
9410
|
-
boolean: "boolean",
|
|
9411
|
-
function: "func\u021Bie",
|
|
9412
|
-
array: "matrice",
|
|
9413
|
-
object: "obiect",
|
|
9414
|
-
undefined: "nedefinit",
|
|
9415
|
-
symbol: "simbol",
|
|
9416
|
-
bigint: "num\u0103r mare",
|
|
9417
|
-
void: "void",
|
|
9418
|
-
never: "never",
|
|
9419
|
-
map: "hart\u0103",
|
|
9420
|
-
set: "set"
|
|
9421
|
-
};
|
|
9422
|
-
return (issue2) => {
|
|
9423
|
-
switch (issue2.code) {
|
|
9424
|
-
case "invalid_type": {
|
|
9425
|
-
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
9426
|
-
const receivedType = parsedType(issue2.input);
|
|
9427
|
-
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
9428
|
-
return `Intrare invalid\u0103: a\u0219teptat ${expected}, primit ${received}`;
|
|
9429
|
-
}
|
|
9430
|
-
case "invalid_value":
|
|
9431
|
-
if (issue2.values.length === 1)
|
|
9432
|
-
return `Intrare invalid\u0103: a\u0219teptat ${stringifyPrimitive(issue2.values[0])}`;
|
|
9433
|
-
return `Op\u021Biune invalid\u0103: a\u0219teptat una dintre ${joinValues(issue2.values, "|")}`;
|
|
9434
|
-
case "too_big": {
|
|
9435
|
-
const adj = issue2.inclusive ? "<=" : "<";
|
|
9436
|
-
const sizing = getSizing(issue2.origin);
|
|
9437
|
-
if (sizing)
|
|
9438
|
-
return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemente"}`;
|
|
9439
|
-
return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} s\u0103 fie ${adj}${issue2.maximum.toString()}`;
|
|
9440
|
-
}
|
|
9441
|
-
case "too_small": {
|
|
9442
|
-
const adj = issue2.inclusive ? ">=" : ">";
|
|
9443
|
-
const sizing = getSizing(issue2.origin);
|
|
9444
|
-
if (sizing) {
|
|
9445
|
-
return `Prea mic: a\u0219teptat ca ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
9446
|
-
}
|
|
9447
|
-
return `Prea mic: a\u0219teptat ca ${issue2.origin} s\u0103 fie ${adj}${issue2.minimum.toString()}`;
|
|
9448
|
-
}
|
|
9449
|
-
case "invalid_format": {
|
|
9450
|
-
const _issue = issue2;
|
|
9451
|
-
if (_issue.format === "starts_with") {
|
|
9452
|
-
return `\u0218ir invalid: trebuie s\u0103 \xEEnceap\u0103 cu "${_issue.prefix}"`;
|
|
9453
|
-
}
|
|
9454
|
-
if (_issue.format === "ends_with")
|
|
9455
|
-
return `\u0218ir invalid: trebuie s\u0103 se termine cu "${_issue.suffix}"`;
|
|
9456
|
-
if (_issue.format === "includes")
|
|
9457
|
-
return `\u0218ir invalid: trebuie s\u0103 includ\u0103 "${_issue.includes}"`;
|
|
9458
|
-
if (_issue.format === "regex")
|
|
9459
|
-
return `\u0218ir invalid: trebuie s\u0103 se potriveasc\u0103 cu modelul ${_issue.pattern}`;
|
|
9460
|
-
return `Format invalid: ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
9461
|
-
}
|
|
9462
|
-
case "not_multiple_of":
|
|
9463
|
-
return `Num\u0103r invalid: trebuie s\u0103 fie multiplu de ${issue2.divisor}`;
|
|
9464
|
-
case "unrecognized_keys":
|
|
9465
|
-
return `Chei nerecunoscute: ${joinValues(issue2.keys, ", ")}`;
|
|
9466
|
-
case "invalid_key":
|
|
9467
|
-
return `Cheie invalid\u0103 \xEEn ${issue2.origin}`;
|
|
9468
|
-
case "invalid_union":
|
|
9469
|
-
return "Intrare invalid\u0103";
|
|
9470
|
-
case "invalid_element":
|
|
9471
|
-
return `Valoare invalid\u0103 \xEEn ${issue2.origin}`;
|
|
9472
|
-
default:
|
|
9473
|
-
return `Intrare invalid\u0103`;
|
|
9474
|
-
}
|
|
9475
|
-
};
|
|
9476
|
-
};
|
|
9477
|
-
function ro_default() {
|
|
9478
|
-
return {
|
|
9479
|
-
localeError: error37()
|
|
8953
|
+
localeError: error34()
|
|
9480
8954
|
};
|
|
9481
8955
|
}
|
|
9482
8956
|
|
|
@@ -9496,7 +8970,7 @@ function getRussianPlural(count, one, few, many) {
|
|
|
9496
8970
|
}
|
|
9497
8971
|
return many;
|
|
9498
8972
|
}
|
|
9499
|
-
var
|
|
8973
|
+
var error35 = () => {
|
|
9500
8974
|
const Sizable = {
|
|
9501
8975
|
string: {
|
|
9502
8976
|
unit: {
|
|
@@ -9633,12 +9107,12 @@ var error38 = () => {
|
|
|
9633
9107
|
};
|
|
9634
9108
|
function ru_default() {
|
|
9635
9109
|
return {
|
|
9636
|
-
localeError:
|
|
9110
|
+
localeError: error35()
|
|
9637
9111
|
};
|
|
9638
9112
|
}
|
|
9639
9113
|
|
|
9640
9114
|
// ../../node_modules/zod/v4/locales/sl.js
|
|
9641
|
-
var
|
|
9115
|
+
var error36 = () => {
|
|
9642
9116
|
const Sizable = {
|
|
9643
9117
|
string: { unit: "znakov", verb: "imeti" },
|
|
9644
9118
|
file: { unit: "bajtov", verb: "imeti" },
|
|
@@ -9743,12 +9217,12 @@ var error39 = () => {
|
|
|
9743
9217
|
};
|
|
9744
9218
|
function sl_default() {
|
|
9745
9219
|
return {
|
|
9746
|
-
localeError:
|
|
9220
|
+
localeError: error36()
|
|
9747
9221
|
};
|
|
9748
9222
|
}
|
|
9749
9223
|
|
|
9750
9224
|
// ../../node_modules/zod/v4/locales/sv.js
|
|
9751
|
-
var
|
|
9225
|
+
var error37 = () => {
|
|
9752
9226
|
const Sizable = {
|
|
9753
9227
|
string: { unit: "tecken", verb: "att ha" },
|
|
9754
9228
|
file: { unit: "bytes", verb: "att ha" },
|
|
@@ -9854,12 +9328,12 @@ var error40 = () => {
|
|
|
9854
9328
|
};
|
|
9855
9329
|
function sv_default() {
|
|
9856
9330
|
return {
|
|
9857
|
-
localeError:
|
|
9331
|
+
localeError: error37()
|
|
9858
9332
|
};
|
|
9859
9333
|
}
|
|
9860
9334
|
|
|
9861
9335
|
// ../../node_modules/zod/v4/locales/ta.js
|
|
9862
|
-
var
|
|
9336
|
+
var error38 = () => {
|
|
9863
9337
|
const Sizable = {
|
|
9864
9338
|
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" },
|
|
9865
9339
|
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" },
|
|
@@ -9965,12 +9439,12 @@ var error41 = () => {
|
|
|
9965
9439
|
};
|
|
9966
9440
|
function ta_default() {
|
|
9967
9441
|
return {
|
|
9968
|
-
localeError:
|
|
9442
|
+
localeError: error38()
|
|
9969
9443
|
};
|
|
9970
9444
|
}
|
|
9971
9445
|
|
|
9972
9446
|
// ../../node_modules/zod/v4/locales/th.js
|
|
9973
|
-
var
|
|
9447
|
+
var error39 = () => {
|
|
9974
9448
|
const Sizable = {
|
|
9975
9449
|
string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
9976
9450
|
file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
@@ -10076,12 +9550,12 @@ var error42 = () => {
|
|
|
10076
9550
|
};
|
|
10077
9551
|
function th_default() {
|
|
10078
9552
|
return {
|
|
10079
|
-
localeError:
|
|
9553
|
+
localeError: error39()
|
|
10080
9554
|
};
|
|
10081
9555
|
}
|
|
10082
9556
|
|
|
10083
9557
|
// ../../node_modules/zod/v4/locales/tr.js
|
|
10084
|
-
var
|
|
9558
|
+
var error40 = () => {
|
|
10085
9559
|
const Sizable = {
|
|
10086
9560
|
string: { unit: "karakter", verb: "olmal\u0131" },
|
|
10087
9561
|
file: { unit: "bayt", verb: "olmal\u0131" },
|
|
@@ -10182,12 +9656,12 @@ var error43 = () => {
|
|
|
10182
9656
|
};
|
|
10183
9657
|
function tr_default() {
|
|
10184
9658
|
return {
|
|
10185
|
-
localeError:
|
|
9659
|
+
localeError: error40()
|
|
10186
9660
|
};
|
|
10187
9661
|
}
|
|
10188
9662
|
|
|
10189
9663
|
// ../../node_modules/zod/v4/locales/uk.js
|
|
10190
|
-
var
|
|
9664
|
+
var error41 = () => {
|
|
10191
9665
|
const Sizable = {
|
|
10192
9666
|
string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
10193
9667
|
file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
@@ -10291,7 +9765,7 @@ var error44 = () => {
|
|
|
10291
9765
|
};
|
|
10292
9766
|
function uk_default() {
|
|
10293
9767
|
return {
|
|
10294
|
-
localeError:
|
|
9768
|
+
localeError: error41()
|
|
10295
9769
|
};
|
|
10296
9770
|
}
|
|
10297
9771
|
|
|
@@ -10301,7 +9775,7 @@ function ua_default() {
|
|
|
10301
9775
|
}
|
|
10302
9776
|
|
|
10303
9777
|
// ../../node_modules/zod/v4/locales/ur.js
|
|
10304
|
-
var
|
|
9778
|
+
var error42 = () => {
|
|
10305
9779
|
const Sizable = {
|
|
10306
9780
|
string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
|
|
10307
9781
|
file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
|
|
@@ -10407,18 +9881,17 @@ var error45 = () => {
|
|
|
10407
9881
|
};
|
|
10408
9882
|
function ur_default() {
|
|
10409
9883
|
return {
|
|
10410
|
-
localeError:
|
|
9884
|
+
localeError: error42()
|
|
10411
9885
|
};
|
|
10412
9886
|
}
|
|
10413
9887
|
|
|
10414
9888
|
// ../../node_modules/zod/v4/locales/uz.js
|
|
10415
|
-
var
|
|
9889
|
+
var error43 = () => {
|
|
10416
9890
|
const Sizable = {
|
|
10417
9891
|
string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
|
|
10418
9892
|
file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
|
|
10419
9893
|
array: { unit: "element", verb: "bo\u2018lishi kerak" },
|
|
10420
|
-
set: { unit: "element", verb: "bo\u2018lishi kerak" }
|
|
10421
|
-
map: { unit: "yozuv", verb: "bo\u2018lishi kerak" }
|
|
9894
|
+
set: { unit: "element", verb: "bo\u2018lishi kerak" }
|
|
10422
9895
|
};
|
|
10423
9896
|
function getSizing(origin) {
|
|
10424
9897
|
return Sizable[origin] ?? null;
|
|
@@ -10518,12 +9991,12 @@ var error46 = () => {
|
|
|
10518
9991
|
};
|
|
10519
9992
|
function uz_default() {
|
|
10520
9993
|
return {
|
|
10521
|
-
localeError:
|
|
9994
|
+
localeError: error43()
|
|
10522
9995
|
};
|
|
10523
9996
|
}
|
|
10524
9997
|
|
|
10525
9998
|
// ../../node_modules/zod/v4/locales/vi.js
|
|
10526
|
-
var
|
|
9999
|
+
var error44 = () => {
|
|
10527
10000
|
const Sizable = {
|
|
10528
10001
|
string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
|
|
10529
10002
|
file: { unit: "byte", verb: "c\xF3" },
|
|
@@ -10627,12 +10100,12 @@ var error47 = () => {
|
|
|
10627
10100
|
};
|
|
10628
10101
|
function vi_default() {
|
|
10629
10102
|
return {
|
|
10630
|
-
localeError:
|
|
10103
|
+
localeError: error44()
|
|
10631
10104
|
};
|
|
10632
10105
|
}
|
|
10633
10106
|
|
|
10634
10107
|
// ../../node_modules/zod/v4/locales/zh-CN.js
|
|
10635
|
-
var
|
|
10108
|
+
var error45 = () => {
|
|
10636
10109
|
const Sizable = {
|
|
10637
10110
|
string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
|
|
10638
10111
|
file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
|
|
@@ -10737,12 +10210,12 @@ var error48 = () => {
|
|
|
10737
10210
|
};
|
|
10738
10211
|
function zh_CN_default() {
|
|
10739
10212
|
return {
|
|
10740
|
-
localeError:
|
|
10213
|
+
localeError: error45()
|
|
10741
10214
|
};
|
|
10742
10215
|
}
|
|
10743
10216
|
|
|
10744
10217
|
// ../../node_modules/zod/v4/locales/zh-TW.js
|
|
10745
|
-
var
|
|
10218
|
+
var error46 = () => {
|
|
10746
10219
|
const Sizable = {
|
|
10747
10220
|
string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
|
|
10748
10221
|
file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
|
|
@@ -10845,12 +10318,12 @@ var error49 = () => {
|
|
|
10845
10318
|
};
|
|
10846
10319
|
function zh_TW_default() {
|
|
10847
10320
|
return {
|
|
10848
|
-
localeError:
|
|
10321
|
+
localeError: error46()
|
|
10849
10322
|
};
|
|
10850
10323
|
}
|
|
10851
10324
|
|
|
10852
10325
|
// ../../node_modules/zod/v4/locales/yo.js
|
|
10853
|
-
var
|
|
10326
|
+
var error47 = () => {
|
|
10854
10327
|
const Sizable = {
|
|
10855
10328
|
string: { unit: "\xE0mi", verb: "n\xED" },
|
|
10856
10329
|
file: { unit: "bytes", verb: "n\xED" },
|
|
@@ -10953,12 +10426,12 @@ var error50 = () => {
|
|
|
10953
10426
|
};
|
|
10954
10427
|
function yo_default() {
|
|
10955
10428
|
return {
|
|
10956
|
-
localeError:
|
|
10429
|
+
localeError: error47()
|
|
10957
10430
|
};
|
|
10958
10431
|
}
|
|
10959
10432
|
|
|
10960
10433
|
// ../../node_modules/zod/v4/core/registries.js
|
|
10961
|
-
var
|
|
10434
|
+
var _a;
|
|
10962
10435
|
var $output = /* @__PURE__ */ Symbol("ZodOutput");
|
|
10963
10436
|
var $input = /* @__PURE__ */ Symbol("ZodInput");
|
|
10964
10437
|
var $ZodRegistry = class {
|
|
@@ -11004,7 +10477,7 @@ var $ZodRegistry = class {
|
|
|
11004
10477
|
function registry() {
|
|
11005
10478
|
return new $ZodRegistry();
|
|
11006
10479
|
}
|
|
11007
|
-
(
|
|
10480
|
+
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
|
|
11008
10481
|
var globalRegistry = globalThis.__zod_globalRegistry;
|
|
11009
10482
|
|
|
11010
10483
|
// ../../node_modules/zod/v4/core/api.js
|
|
@@ -11922,7 +11395,7 @@ function _refine(Class2, fn, _params) {
|
|
|
11922
11395
|
return schema;
|
|
11923
11396
|
}
|
|
11924
11397
|
// @__NO_SIDE_EFFECTS__
|
|
11925
|
-
function _superRefine(fn
|
|
11398
|
+
function _superRefine(fn) {
|
|
11926
11399
|
const ch = /* @__PURE__ */ _check((payload) => {
|
|
11927
11400
|
payload.addIssue = (issue2) => {
|
|
11928
11401
|
if (typeof issue2 === "string") {
|
|
@@ -11939,7 +11412,7 @@ function _superRefine(fn, params) {
|
|
|
11939
11412
|
}
|
|
11940
11413
|
};
|
|
11941
11414
|
return fn(payload.value, payload);
|
|
11942
|
-
}
|
|
11415
|
+
});
|
|
11943
11416
|
return ch;
|
|
11944
11417
|
}
|
|
11945
11418
|
// @__NO_SIDE_EFFECTS__
|
|
@@ -12069,7 +11542,7 @@ function initializeContext(params) {
|
|
|
12069
11542
|
};
|
|
12070
11543
|
}
|
|
12071
11544
|
function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
|
12072
|
-
var
|
|
11545
|
+
var _a2;
|
|
12073
11546
|
const def = schema._zod.def;
|
|
12074
11547
|
const seen = ctx.seen.get(schema);
|
|
12075
11548
|
if (seen) {
|
|
@@ -12116,8 +11589,8 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
|
|
12116
11589
|
delete result.schema.examples;
|
|
12117
11590
|
delete result.schema.default;
|
|
12118
11591
|
}
|
|
12119
|
-
if (ctx.io === "input" &&
|
|
12120
|
-
(
|
|
11592
|
+
if (ctx.io === "input" && result.schema._prefault)
|
|
11593
|
+
(_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
|
|
12121
11594
|
delete result.schema._prefault;
|
|
12122
11595
|
const _result = ctx.seen.get(schema);
|
|
12123
11596
|
return _result.schema;
|
|
@@ -12298,15 +11771,10 @@ function finalize(ctx, schema) {
|
|
|
12298
11771
|
result.$id = ctx.external.uri(id);
|
|
12299
11772
|
}
|
|
12300
11773
|
Object.assign(result, root.def ?? root.schema);
|
|
12301
|
-
const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
|
|
12302
|
-
if (rootMetaId !== void 0 && result.id === rootMetaId)
|
|
12303
|
-
delete result.id;
|
|
12304
11774
|
const defs = ctx.external?.defs ?? {};
|
|
12305
11775
|
for (const entry of ctx.seen.entries()) {
|
|
12306
11776
|
const seen = entry[1];
|
|
12307
11777
|
if (seen.def && seen.defId) {
|
|
12308
|
-
if (seen.def.id === seen.defId)
|
|
12309
|
-
delete seen.def.id;
|
|
12310
11778
|
defs[seen.defId] = seen.def;
|
|
12311
11779
|
}
|
|
12312
11780
|
}
|
|
@@ -12362,8 +11830,6 @@ function isTransforming(_schema, _ctx) {
|
|
|
12362
11830
|
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
|
12363
11831
|
}
|
|
12364
11832
|
if (def.type === "pipe") {
|
|
12365
|
-
if (_schema._zod.traits.has("$ZodCodec"))
|
|
12366
|
-
return true;
|
|
12367
11833
|
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
|
12368
11834
|
}
|
|
12369
11835
|
if (def.type === "object") {
|
|
@@ -12453,28 +11919,39 @@ var numberProcessor = (schema, ctx, _json, _params) => {
|
|
|
12453
11919
|
json2.type = "integer";
|
|
12454
11920
|
else
|
|
12455
11921
|
json2.type = "number";
|
|
12456
|
-
|
|
12457
|
-
|
|
12458
|
-
const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
|
|
12459
|
-
if (exMin) {
|
|
12460
|
-
if (legacy) {
|
|
11922
|
+
if (typeof exclusiveMinimum === "number") {
|
|
11923
|
+
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
|
12461
11924
|
json2.minimum = exclusiveMinimum;
|
|
12462
11925
|
json2.exclusiveMinimum = true;
|
|
12463
11926
|
} else {
|
|
12464
11927
|
json2.exclusiveMinimum = exclusiveMinimum;
|
|
12465
11928
|
}
|
|
12466
|
-
}
|
|
11929
|
+
}
|
|
11930
|
+
if (typeof minimum === "number") {
|
|
12467
11931
|
json2.minimum = minimum;
|
|
11932
|
+
if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
|
|
11933
|
+
if (exclusiveMinimum >= minimum)
|
|
11934
|
+
delete json2.minimum;
|
|
11935
|
+
else
|
|
11936
|
+
delete json2.exclusiveMinimum;
|
|
11937
|
+
}
|
|
12468
11938
|
}
|
|
12469
|
-
if (
|
|
12470
|
-
if (
|
|
11939
|
+
if (typeof exclusiveMaximum === "number") {
|
|
11940
|
+
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
|
12471
11941
|
json2.maximum = exclusiveMaximum;
|
|
12472
11942
|
json2.exclusiveMaximum = true;
|
|
12473
11943
|
} else {
|
|
12474
11944
|
json2.exclusiveMaximum = exclusiveMaximum;
|
|
12475
11945
|
}
|
|
12476
|
-
}
|
|
11946
|
+
}
|
|
11947
|
+
if (typeof maximum === "number") {
|
|
12477
11948
|
json2.maximum = maximum;
|
|
11949
|
+
if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
|
|
11950
|
+
if (exclusiveMaximum <= maximum)
|
|
11951
|
+
delete json2.maximum;
|
|
11952
|
+
else
|
|
11953
|
+
delete json2.exclusiveMaximum;
|
|
11954
|
+
}
|
|
12478
11955
|
}
|
|
12479
11956
|
if (typeof multipleOf === "number")
|
|
12480
11957
|
json2.multipleOf = multipleOf;
|
|
@@ -12646,10 +12123,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
|
|
|
12646
12123
|
if (typeof maximum === "number")
|
|
12647
12124
|
json2.maxItems = maximum;
|
|
12648
12125
|
json2.type = "array";
|
|
12649
|
-
json2.items = process(def.element, ctx, {
|
|
12650
|
-
...params,
|
|
12651
|
-
path: [...params.path, "items"]
|
|
12652
|
-
});
|
|
12126
|
+
json2.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
|
|
12653
12127
|
};
|
|
12654
12128
|
var objectProcessor = (schema, ctx, _json, params) => {
|
|
12655
12129
|
const json2 = _json;
|
|
@@ -12842,8 +12316,7 @@ var catchProcessor = (schema, ctx, json2, params) => {
|
|
|
12842
12316
|
};
|
|
12843
12317
|
var pipeProcessor = (schema, ctx, _json, params) => {
|
|
12844
12318
|
const def = schema._zod.def;
|
|
12845
|
-
const
|
|
12846
|
-
const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
|
|
12319
|
+
const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
|
|
12847
12320
|
process(innerType, ctx, params);
|
|
12848
12321
|
const seen = ctx.seen.get(schema);
|
|
12849
12322
|
seen.ref = innerType;
|
|
@@ -13077,7 +12550,6 @@ __export(schemas_exports2, {
|
|
|
13077
12550
|
ZodOptional: () => ZodOptional,
|
|
13078
12551
|
ZodPipe: () => ZodPipe,
|
|
13079
12552
|
ZodPrefault: () => ZodPrefault,
|
|
13080
|
-
ZodPreprocess: () => ZodPreprocess,
|
|
13081
12553
|
ZodPromise: () => ZodPromise,
|
|
13082
12554
|
ZodReadonly: () => ZodReadonly,
|
|
13083
12555
|
ZodRecord: () => ZodRecord,
|
|
@@ -13138,7 +12610,6 @@ __export(schemas_exports2, {
|
|
|
13138
12610
|
int32: () => int32,
|
|
13139
12611
|
int64: () => int64,
|
|
13140
12612
|
intersection: () => intersection,
|
|
13141
|
-
invertCodec: () => invertCodec,
|
|
13142
12613
|
ipv4: () => ipv42,
|
|
13143
12614
|
ipv6: () => ipv62,
|
|
13144
12615
|
json: () => json,
|
|
@@ -13308,8 +12779,8 @@ var initializer2 = (inst, issues) => {
|
|
|
13308
12779
|
}
|
|
13309
12780
|
});
|
|
13310
12781
|
};
|
|
13311
|
-
var ZodError =
|
|
13312
|
-
var ZodRealError =
|
|
12782
|
+
var ZodError = $constructor("ZodError", initializer2);
|
|
12783
|
+
var ZodRealError = $constructor("ZodError", initializer2, {
|
|
13313
12784
|
Parent: Error
|
|
13314
12785
|
});
|
|
13315
12786
|
|
|
@@ -13328,43 +12799,6 @@ var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
|
|
|
13328
12799
|
var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
|
|
13329
12800
|
|
|
13330
12801
|
// ../../node_modules/zod/v4/classic/schemas.js
|
|
13331
|
-
var _installedGroups = /* @__PURE__ */ new WeakMap();
|
|
13332
|
-
function _installLazyMethods(inst, group, methods) {
|
|
13333
|
-
const proto = Object.getPrototypeOf(inst);
|
|
13334
|
-
let installed = _installedGroups.get(proto);
|
|
13335
|
-
if (!installed) {
|
|
13336
|
-
installed = /* @__PURE__ */ new Set();
|
|
13337
|
-
_installedGroups.set(proto, installed);
|
|
13338
|
-
}
|
|
13339
|
-
if (installed.has(group))
|
|
13340
|
-
return;
|
|
13341
|
-
installed.add(group);
|
|
13342
|
-
for (const key in methods) {
|
|
13343
|
-
const fn = methods[key];
|
|
13344
|
-
Object.defineProperty(proto, key, {
|
|
13345
|
-
configurable: true,
|
|
13346
|
-
enumerable: false,
|
|
13347
|
-
get() {
|
|
13348
|
-
const bound = fn.bind(this);
|
|
13349
|
-
Object.defineProperty(this, key, {
|
|
13350
|
-
configurable: true,
|
|
13351
|
-
writable: true,
|
|
13352
|
-
enumerable: true,
|
|
13353
|
-
value: bound
|
|
13354
|
-
});
|
|
13355
|
-
return bound;
|
|
13356
|
-
},
|
|
13357
|
-
set(v) {
|
|
13358
|
-
Object.defineProperty(this, key, {
|
|
13359
|
-
configurable: true,
|
|
13360
|
-
writable: true,
|
|
13361
|
-
enumerable: true,
|
|
13362
|
-
value: v
|
|
13363
|
-
});
|
|
13364
|
-
}
|
|
13365
|
-
});
|
|
13366
|
-
}
|
|
13367
|
-
}
|
|
13368
12802
|
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
|
|
13369
12803
|
$ZodType.init(inst, def);
|
|
13370
12804
|
Object.assign(inst["~standard"], {
|
|
@@ -13377,6 +12811,23 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
|
|
|
13377
12811
|
inst.def = def;
|
|
13378
12812
|
inst.type = def.type;
|
|
13379
12813
|
Object.defineProperty(inst, "_def", { value: def });
|
|
12814
|
+
inst.check = (...checks) => {
|
|
12815
|
+
return inst.clone(util_exports.mergeDefs(def, {
|
|
12816
|
+
checks: [
|
|
12817
|
+
...def.checks ?? [],
|
|
12818
|
+
...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
|
|
12819
|
+
]
|
|
12820
|
+
}), {
|
|
12821
|
+
parent: true
|
|
12822
|
+
});
|
|
12823
|
+
};
|
|
12824
|
+
inst.with = inst.check;
|
|
12825
|
+
inst.clone = (def2, params) => clone(inst, def2, params);
|
|
12826
|
+
inst.brand = () => inst;
|
|
12827
|
+
inst.register = ((reg, meta3) => {
|
|
12828
|
+
reg.add(inst, meta3);
|
|
12829
|
+
return inst;
|
|
12830
|
+
});
|
|
13380
12831
|
inst.parse = (data2, params) => parse2(inst, data2, params, { callee: inst.parse });
|
|
13381
12832
|
inst.safeParse = (data2, params) => safeParse2(inst, data2, params);
|
|
13382
12833
|
inst.parseAsync = async (data2, params) => parseAsync2(inst, data2, params, { callee: inst.parseAsync });
|
|
@@ -13390,108 +12841,45 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
|
|
|
13390
12841
|
inst.safeDecode = (data2, params) => safeDecode2(inst, data2, params);
|
|
13391
12842
|
inst.safeEncodeAsync = async (data2, params) => safeEncodeAsync2(inst, data2, params);
|
|
13392
12843
|
inst.safeDecodeAsync = async (data2, params) => safeDecodeAsync2(inst, data2, params);
|
|
13393
|
-
|
|
13394
|
-
|
|
13395
|
-
|
|
13396
|
-
|
|
13397
|
-
|
|
13398
|
-
|
|
13399
|
-
|
|
13400
|
-
|
|
13401
|
-
|
|
13402
|
-
|
|
13403
|
-
|
|
13404
|
-
|
|
13405
|
-
|
|
13406
|
-
|
|
13407
|
-
|
|
13408
|
-
|
|
13409
|
-
|
|
13410
|
-
|
|
13411
|
-
|
|
13412
|
-
|
|
13413
|
-
|
|
13414
|
-
|
|
13415
|
-
},
|
|
13416
|
-
refine(check2, params) {
|
|
13417
|
-
return this.check(refine(check2, params));
|
|
13418
|
-
},
|
|
13419
|
-
superRefine(refinement, params) {
|
|
13420
|
-
return this.check(superRefine(refinement, params));
|
|
13421
|
-
},
|
|
13422
|
-
overwrite(fn) {
|
|
13423
|
-
return this.check(_overwrite(fn));
|
|
13424
|
-
},
|
|
13425
|
-
optional() {
|
|
13426
|
-
return optional(this);
|
|
13427
|
-
},
|
|
13428
|
-
exactOptional() {
|
|
13429
|
-
return exactOptional(this);
|
|
13430
|
-
},
|
|
13431
|
-
nullable() {
|
|
13432
|
-
return nullable(this);
|
|
13433
|
-
},
|
|
13434
|
-
nullish() {
|
|
13435
|
-
return optional(nullable(this));
|
|
13436
|
-
},
|
|
13437
|
-
nonoptional(params) {
|
|
13438
|
-
return nonoptional(this, params);
|
|
13439
|
-
},
|
|
13440
|
-
array() {
|
|
13441
|
-
return array(this);
|
|
13442
|
-
},
|
|
13443
|
-
or(arg) {
|
|
13444
|
-
return union([this, arg]);
|
|
13445
|
-
},
|
|
13446
|
-
and(arg) {
|
|
13447
|
-
return intersection(this, arg);
|
|
13448
|
-
},
|
|
13449
|
-
transform(tx) {
|
|
13450
|
-
return pipe(this, transform(tx));
|
|
13451
|
-
},
|
|
13452
|
-
default(d) {
|
|
13453
|
-
return _default2(this, d);
|
|
13454
|
-
},
|
|
13455
|
-
prefault(d) {
|
|
13456
|
-
return prefault(this, d);
|
|
13457
|
-
},
|
|
13458
|
-
catch(params) {
|
|
13459
|
-
return _catch2(this, params);
|
|
13460
|
-
},
|
|
13461
|
-
pipe(target) {
|
|
13462
|
-
return pipe(this, target);
|
|
13463
|
-
},
|
|
13464
|
-
readonly() {
|
|
13465
|
-
return readonly(this);
|
|
13466
|
-
},
|
|
13467
|
-
describe(description) {
|
|
13468
|
-
const cl = this.clone();
|
|
13469
|
-
globalRegistry.add(cl, { description });
|
|
13470
|
-
return cl;
|
|
13471
|
-
},
|
|
13472
|
-
meta(...args) {
|
|
13473
|
-
if (args.length === 0)
|
|
13474
|
-
return globalRegistry.get(this);
|
|
13475
|
-
const cl = this.clone();
|
|
13476
|
-
globalRegistry.add(cl, args[0]);
|
|
13477
|
-
return cl;
|
|
13478
|
-
},
|
|
13479
|
-
isOptional() {
|
|
13480
|
-
return this.safeParse(void 0).success;
|
|
13481
|
-
},
|
|
13482
|
-
isNullable() {
|
|
13483
|
-
return this.safeParse(null).success;
|
|
13484
|
-
},
|
|
13485
|
-
apply(fn) {
|
|
13486
|
-
return fn(this);
|
|
13487
|
-
}
|
|
13488
|
-
});
|
|
12844
|
+
inst.refine = (check2, params) => inst.check(refine(check2, params));
|
|
12845
|
+
inst.superRefine = (refinement) => inst.check(superRefine(refinement));
|
|
12846
|
+
inst.overwrite = (fn) => inst.check(_overwrite(fn));
|
|
12847
|
+
inst.optional = () => optional(inst);
|
|
12848
|
+
inst.exactOptional = () => exactOptional(inst);
|
|
12849
|
+
inst.nullable = () => nullable(inst);
|
|
12850
|
+
inst.nullish = () => optional(nullable(inst));
|
|
12851
|
+
inst.nonoptional = (params) => nonoptional(inst, params);
|
|
12852
|
+
inst.array = () => array(inst);
|
|
12853
|
+
inst.or = (arg) => union([inst, arg]);
|
|
12854
|
+
inst.and = (arg) => intersection(inst, arg);
|
|
12855
|
+
inst.transform = (tx) => pipe(inst, transform(tx));
|
|
12856
|
+
inst.default = (def2) => _default2(inst, def2);
|
|
12857
|
+
inst.prefault = (def2) => prefault(inst, def2);
|
|
12858
|
+
inst.catch = (params) => _catch2(inst, params);
|
|
12859
|
+
inst.pipe = (target) => pipe(inst, target);
|
|
12860
|
+
inst.readonly = () => readonly(inst);
|
|
12861
|
+
inst.describe = (description) => {
|
|
12862
|
+
const cl = inst.clone();
|
|
12863
|
+
globalRegistry.add(cl, { description });
|
|
12864
|
+
return cl;
|
|
12865
|
+
};
|
|
13489
12866
|
Object.defineProperty(inst, "description", {
|
|
13490
12867
|
get() {
|
|
13491
12868
|
return globalRegistry.get(inst)?.description;
|
|
13492
12869
|
},
|
|
13493
12870
|
configurable: true
|
|
13494
12871
|
});
|
|
12872
|
+
inst.meta = (...args) => {
|
|
12873
|
+
if (args.length === 0) {
|
|
12874
|
+
return globalRegistry.get(inst);
|
|
12875
|
+
}
|
|
12876
|
+
const cl = inst.clone();
|
|
12877
|
+
globalRegistry.add(cl, args[0]);
|
|
12878
|
+
return cl;
|
|
12879
|
+
};
|
|
12880
|
+
inst.isOptional = () => inst.safeParse(void 0).success;
|
|
12881
|
+
inst.isNullable = () => inst.safeParse(null).success;
|
|
12882
|
+
inst.apply = (fn) => fn(inst);
|
|
13495
12883
|
return inst;
|
|
13496
12884
|
});
|
|
13497
12885
|
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
|
|
@@ -13502,53 +12890,21 @@ var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
|
|
|
13502
12890
|
inst.format = bag.format ?? null;
|
|
13503
12891
|
inst.minLength = bag.minimum ?? null;
|
|
13504
12892
|
inst.maxLength = bag.maximum ?? null;
|
|
13505
|
-
|
|
13506
|
-
|
|
13507
|
-
|
|
13508
|
-
|
|
13509
|
-
|
|
13510
|
-
|
|
13511
|
-
|
|
13512
|
-
|
|
13513
|
-
|
|
13514
|
-
|
|
13515
|
-
|
|
13516
|
-
|
|
13517
|
-
|
|
13518
|
-
|
|
13519
|
-
|
|
13520
|
-
},
|
|
13521
|
-
max(...args) {
|
|
13522
|
-
return this.check(_maxLength(...args));
|
|
13523
|
-
},
|
|
13524
|
-
length(...args) {
|
|
13525
|
-
return this.check(_length(...args));
|
|
13526
|
-
},
|
|
13527
|
-
nonempty(...args) {
|
|
13528
|
-
return this.check(_minLength(1, ...args));
|
|
13529
|
-
},
|
|
13530
|
-
lowercase(params) {
|
|
13531
|
-
return this.check(_lowercase(params));
|
|
13532
|
-
},
|
|
13533
|
-
uppercase(params) {
|
|
13534
|
-
return this.check(_uppercase(params));
|
|
13535
|
-
},
|
|
13536
|
-
trim() {
|
|
13537
|
-
return this.check(_trim());
|
|
13538
|
-
},
|
|
13539
|
-
normalize(...args) {
|
|
13540
|
-
return this.check(_normalize(...args));
|
|
13541
|
-
},
|
|
13542
|
-
toLowerCase() {
|
|
13543
|
-
return this.check(_toLowerCase());
|
|
13544
|
-
},
|
|
13545
|
-
toUpperCase() {
|
|
13546
|
-
return this.check(_toUpperCase());
|
|
13547
|
-
},
|
|
13548
|
-
slugify() {
|
|
13549
|
-
return this.check(_slugify());
|
|
13550
|
-
}
|
|
13551
|
-
});
|
|
12893
|
+
inst.regex = (...args) => inst.check(_regex(...args));
|
|
12894
|
+
inst.includes = (...args) => inst.check(_includes(...args));
|
|
12895
|
+
inst.startsWith = (...args) => inst.check(_startsWith(...args));
|
|
12896
|
+
inst.endsWith = (...args) => inst.check(_endsWith(...args));
|
|
12897
|
+
inst.min = (...args) => inst.check(_minLength(...args));
|
|
12898
|
+
inst.max = (...args) => inst.check(_maxLength(...args));
|
|
12899
|
+
inst.length = (...args) => inst.check(_length(...args));
|
|
12900
|
+
inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
|
|
12901
|
+
inst.lowercase = (params) => inst.check(_lowercase(params));
|
|
12902
|
+
inst.uppercase = (params) => inst.check(_uppercase(params));
|
|
12903
|
+
inst.trim = () => inst.check(_trim());
|
|
12904
|
+
inst.normalize = (...args) => inst.check(_normalize(...args));
|
|
12905
|
+
inst.toLowerCase = () => inst.check(_toLowerCase());
|
|
12906
|
+
inst.toUpperCase = () => inst.check(_toUpperCase());
|
|
12907
|
+
inst.slugify = () => inst.check(_slugify());
|
|
13552
12908
|
});
|
|
13553
12909
|
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
|
|
13554
12910
|
$ZodString.init(inst, def);
|
|
@@ -13627,7 +12983,7 @@ function url(params) {
|
|
|
13627
12983
|
}
|
|
13628
12984
|
function httpUrl(params) {
|
|
13629
12985
|
return _url(ZodURL, {
|
|
13630
|
-
protocol:
|
|
12986
|
+
protocol: /^https?$/,
|
|
13631
12987
|
hostname: regexes_exports.domain,
|
|
13632
12988
|
...util_exports.normalizeParams(params)
|
|
13633
12989
|
});
|
|
@@ -13769,53 +13125,21 @@ var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
|
|
|
13769
13125
|
$ZodNumber.init(inst, def);
|
|
13770
13126
|
ZodType.init(inst, def);
|
|
13771
13127
|
inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
|
|
13772
|
-
|
|
13773
|
-
|
|
13774
|
-
|
|
13775
|
-
|
|
13776
|
-
|
|
13777
|
-
|
|
13778
|
-
|
|
13779
|
-
|
|
13780
|
-
|
|
13781
|
-
|
|
13782
|
-
|
|
13783
|
-
|
|
13784
|
-
|
|
13785
|
-
|
|
13786
|
-
|
|
13787
|
-
},
|
|
13788
|
-
max(value, params) {
|
|
13789
|
-
return this.check(_lte(value, params));
|
|
13790
|
-
},
|
|
13791
|
-
int(params) {
|
|
13792
|
-
return this.check(int(params));
|
|
13793
|
-
},
|
|
13794
|
-
safe(params) {
|
|
13795
|
-
return this.check(int(params));
|
|
13796
|
-
},
|
|
13797
|
-
positive(params) {
|
|
13798
|
-
return this.check(_gt(0, params));
|
|
13799
|
-
},
|
|
13800
|
-
nonnegative(params) {
|
|
13801
|
-
return this.check(_gte(0, params));
|
|
13802
|
-
},
|
|
13803
|
-
negative(params) {
|
|
13804
|
-
return this.check(_lt(0, params));
|
|
13805
|
-
},
|
|
13806
|
-
nonpositive(params) {
|
|
13807
|
-
return this.check(_lte(0, params));
|
|
13808
|
-
},
|
|
13809
|
-
multipleOf(value, params) {
|
|
13810
|
-
return this.check(_multipleOf(value, params));
|
|
13811
|
-
},
|
|
13812
|
-
step(value, params) {
|
|
13813
|
-
return this.check(_multipleOf(value, params));
|
|
13814
|
-
},
|
|
13815
|
-
finite() {
|
|
13816
|
-
return this;
|
|
13817
|
-
}
|
|
13818
|
-
});
|
|
13128
|
+
inst.gt = (value, params) => inst.check(_gt(value, params));
|
|
13129
|
+
inst.gte = (value, params) => inst.check(_gte(value, params));
|
|
13130
|
+
inst.min = (value, params) => inst.check(_gte(value, params));
|
|
13131
|
+
inst.lt = (value, params) => inst.check(_lt(value, params));
|
|
13132
|
+
inst.lte = (value, params) => inst.check(_lte(value, params));
|
|
13133
|
+
inst.max = (value, params) => inst.check(_lte(value, params));
|
|
13134
|
+
inst.int = (params) => inst.check(int(params));
|
|
13135
|
+
inst.safe = (params) => inst.check(int(params));
|
|
13136
|
+
inst.positive = (params) => inst.check(_gt(0, params));
|
|
13137
|
+
inst.nonnegative = (params) => inst.check(_gte(0, params));
|
|
13138
|
+
inst.negative = (params) => inst.check(_lt(0, params));
|
|
13139
|
+
inst.nonpositive = (params) => inst.check(_lte(0, params));
|
|
13140
|
+
inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
|
|
13141
|
+
inst.step = (value, params) => inst.check(_multipleOf(value, params));
|
|
13142
|
+
inst.finite = () => inst;
|
|
13819
13143
|
const bag = inst._zod.bag;
|
|
13820
13144
|
inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
|
|
13821
13145
|
inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
|
|
@@ -13962,23 +13286,11 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
|
|
|
13962
13286
|
ZodType.init(inst, def);
|
|
13963
13287
|
inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
|
|
13964
13288
|
inst.element = def.element;
|
|
13965
|
-
|
|
13966
|
-
|
|
13967
|
-
|
|
13968
|
-
|
|
13969
|
-
|
|
13970
|
-
return this.check(_minLength(1, params));
|
|
13971
|
-
},
|
|
13972
|
-
max(n, params) {
|
|
13973
|
-
return this.check(_maxLength(n, params));
|
|
13974
|
-
},
|
|
13975
|
-
length(n, params) {
|
|
13976
|
-
return this.check(_length(n, params));
|
|
13977
|
-
},
|
|
13978
|
-
unwrap() {
|
|
13979
|
-
return this.element;
|
|
13980
|
-
}
|
|
13981
|
-
});
|
|
13289
|
+
inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
|
|
13290
|
+
inst.nonempty = (params) => inst.check(_minLength(1, params));
|
|
13291
|
+
inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
|
|
13292
|
+
inst.length = (len, params) => inst.check(_length(len, params));
|
|
13293
|
+
inst.unwrap = () => inst.element;
|
|
13982
13294
|
});
|
|
13983
13295
|
function array(element, params) {
|
|
13984
13296
|
return _array(ZodArray, element, params);
|
|
@@ -13994,47 +13306,23 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
|
|
|
13994
13306
|
util_exports.defineLazy(inst, "shape", () => {
|
|
13995
13307
|
return def.shape;
|
|
13996
13308
|
});
|
|
13997
|
-
|
|
13998
|
-
|
|
13999
|
-
|
|
14000
|
-
|
|
14001
|
-
|
|
14002
|
-
|
|
14003
|
-
|
|
14004
|
-
|
|
14005
|
-
|
|
14006
|
-
|
|
14007
|
-
|
|
14008
|
-
|
|
14009
|
-
|
|
14010
|
-
|
|
14011
|
-
|
|
14012
|
-
|
|
14013
|
-
|
|
14014
|
-
return this.clone({ ...this._zod.def, catchall: void 0 });
|
|
14015
|
-
},
|
|
14016
|
-
extend(incoming) {
|
|
14017
|
-
return util_exports.extend(this, incoming);
|
|
14018
|
-
},
|
|
14019
|
-
safeExtend(incoming) {
|
|
14020
|
-
return util_exports.safeExtend(this, incoming);
|
|
14021
|
-
},
|
|
14022
|
-
merge(other) {
|
|
14023
|
-
return util_exports.merge(this, other);
|
|
14024
|
-
},
|
|
14025
|
-
pick(mask) {
|
|
14026
|
-
return util_exports.pick(this, mask);
|
|
14027
|
-
},
|
|
14028
|
-
omit(mask) {
|
|
14029
|
-
return util_exports.omit(this, mask);
|
|
14030
|
-
},
|
|
14031
|
-
partial(...args) {
|
|
14032
|
-
return util_exports.partial(ZodOptional, this, args[0]);
|
|
14033
|
-
},
|
|
14034
|
-
required(...args) {
|
|
14035
|
-
return util_exports.required(ZodNonOptional, this, args[0]);
|
|
14036
|
-
}
|
|
14037
|
-
});
|
|
13309
|
+
inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
|
|
13310
|
+
inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
|
|
13311
|
+
inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
|
|
13312
|
+
inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
|
|
13313
|
+
inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
|
|
13314
|
+
inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
|
|
13315
|
+
inst.extend = (incoming) => {
|
|
13316
|
+
return util_exports.extend(inst, incoming);
|
|
13317
|
+
};
|
|
13318
|
+
inst.safeExtend = (incoming) => {
|
|
13319
|
+
return util_exports.safeExtend(inst, incoming);
|
|
13320
|
+
};
|
|
13321
|
+
inst.merge = (other) => util_exports.merge(inst, other);
|
|
13322
|
+
inst.pick = (mask) => util_exports.pick(inst, mask);
|
|
13323
|
+
inst.omit = (mask) => util_exports.omit(inst, mask);
|
|
13324
|
+
inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
|
|
13325
|
+
inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
|
|
14038
13326
|
});
|
|
14039
13327
|
function object(shape, params) {
|
|
14040
13328
|
const def = {
|
|
@@ -14139,14 +13427,6 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
|
|
|
14139
13427
|
inst.valueType = def.valueType;
|
|
14140
13428
|
});
|
|
14141
13429
|
function record(keyType, valueType, params) {
|
|
14142
|
-
if (!valueType || !valueType._zod) {
|
|
14143
|
-
return new ZodRecord({
|
|
14144
|
-
type: "record",
|
|
14145
|
-
keyType: string2(),
|
|
14146
|
-
valueType: keyType,
|
|
14147
|
-
...util_exports.normalizeParams(valueType)
|
|
14148
|
-
});
|
|
14149
|
-
}
|
|
14150
13430
|
return new ZodRecord({
|
|
14151
13431
|
type: "record",
|
|
14152
13432
|
keyType,
|
|
@@ -14318,12 +13598,10 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
|
|
|
14318
13598
|
if (output instanceof Promise) {
|
|
14319
13599
|
return output.then((output2) => {
|
|
14320
13600
|
payload.value = output2;
|
|
14321
|
-
payload.fallback = true;
|
|
14322
13601
|
return payload;
|
|
14323
13602
|
});
|
|
14324
13603
|
}
|
|
14325
13604
|
payload.value = output;
|
|
14326
|
-
payload.fallback = true;
|
|
14327
13605
|
return payload;
|
|
14328
13606
|
};
|
|
14329
13607
|
});
|
|
@@ -14478,20 +13756,6 @@ function codec(in_, out, params) {
|
|
|
14478
13756
|
reverseTransform: params.encode
|
|
14479
13757
|
});
|
|
14480
13758
|
}
|
|
14481
|
-
function invertCodec(codec2) {
|
|
14482
|
-
const def = codec2._zod.def;
|
|
14483
|
-
return new ZodCodec({
|
|
14484
|
-
type: "pipe",
|
|
14485
|
-
in: def.out,
|
|
14486
|
-
out: def.in,
|
|
14487
|
-
transform: def.reverseTransform,
|
|
14488
|
-
reverseTransform: def.transform
|
|
14489
|
-
});
|
|
14490
|
-
}
|
|
14491
|
-
var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) => {
|
|
14492
|
-
ZodPipe.init(inst, def);
|
|
14493
|
-
$ZodPreprocess.init(inst, def);
|
|
14494
|
-
});
|
|
14495
13759
|
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
|
|
14496
13760
|
$ZodReadonly.init(inst, def);
|
|
14497
13761
|
ZodType.init(inst, def);
|
|
@@ -14571,8 +13835,8 @@ function custom(fn, _params) {
|
|
|
14571
13835
|
function refine(fn, _params = {}) {
|
|
14572
13836
|
return _refine(ZodCustom, fn, _params);
|
|
14573
13837
|
}
|
|
14574
|
-
function superRefine(fn
|
|
14575
|
-
return _superRefine(fn
|
|
13838
|
+
function superRefine(fn) {
|
|
13839
|
+
return _superRefine(fn);
|
|
14576
13840
|
}
|
|
14577
13841
|
var describe2 = describe;
|
|
14578
13842
|
var meta2 = meta;
|
|
@@ -14610,11 +13874,7 @@ function json(params) {
|
|
|
14610
13874
|
return jsonSchema;
|
|
14611
13875
|
}
|
|
14612
13876
|
function preprocess(fn, schema) {
|
|
14613
|
-
return
|
|
14614
|
-
type: "pipe",
|
|
14615
|
-
in: transform(fn),
|
|
14616
|
-
out: schema
|
|
14617
|
-
});
|
|
13877
|
+
return pipe(transform(fn), schema);
|
|
14618
13878
|
}
|
|
14619
13879
|
|
|
14620
13880
|
// ../../node_modules/zod/v4/classic/compat.js
|
|
@@ -15035,6 +14295,12 @@ function convertBaseSchema(schema, ctx) {
|
|
|
15035
14295
|
default:
|
|
15036
14296
|
throw new Error(`Unsupported type: ${type}`);
|
|
15037
14297
|
}
|
|
14298
|
+
if (schema.description) {
|
|
14299
|
+
zodSchema = zodSchema.describe(schema.description);
|
|
14300
|
+
}
|
|
14301
|
+
if (schema.default !== void 0) {
|
|
14302
|
+
zodSchema = zodSchema.default(schema.default);
|
|
14303
|
+
}
|
|
15038
14304
|
return zodSchema;
|
|
15039
14305
|
}
|
|
15040
14306
|
function convertSchema(schema, ctx) {
|
|
@@ -15071,9 +14337,6 @@ function convertSchema(schema, ctx) {
|
|
|
15071
14337
|
if (schema.readOnly === true) {
|
|
15072
14338
|
baseSchema = z.readonly(baseSchema);
|
|
15073
14339
|
}
|
|
15074
|
-
if (schema.default !== void 0) {
|
|
15075
|
-
baseSchema = baseSchema.default(schema.default);
|
|
15076
|
-
}
|
|
15077
14340
|
const extraMeta = {};
|
|
15078
14341
|
const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
|
|
15079
14342
|
for (const key of coreMetadataKeys) {
|
|
@@ -15095,32 +14358,23 @@ function convertSchema(schema, ctx) {
|
|
|
15095
14358
|
if (Object.keys(extraMeta).length > 0) {
|
|
15096
14359
|
ctx.registry.add(baseSchema, extraMeta);
|
|
15097
14360
|
}
|
|
15098
|
-
if (schema.description) {
|
|
15099
|
-
baseSchema = baseSchema.describe(schema.description);
|
|
15100
|
-
}
|
|
15101
14361
|
return baseSchema;
|
|
15102
14362
|
}
|
|
15103
14363
|
function fromJSONSchema(schema, params) {
|
|
15104
14364
|
if (typeof schema === "boolean") {
|
|
15105
14365
|
return schema ? z.any() : z.never();
|
|
15106
14366
|
}
|
|
15107
|
-
|
|
15108
|
-
|
|
15109
|
-
normalized = JSON.parse(JSON.stringify(schema));
|
|
15110
|
-
} catch {
|
|
15111
|
-
throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
|
|
15112
|
-
}
|
|
15113
|
-
const version3 = detectVersion(normalized, params?.defaultTarget);
|
|
15114
|
-
const defs = normalized.$defs || normalized.definitions || {};
|
|
14367
|
+
const version3 = detectVersion(schema, params?.defaultTarget);
|
|
14368
|
+
const defs = schema.$defs || schema.definitions || {};
|
|
15115
14369
|
const ctx = {
|
|
15116
14370
|
version: version3,
|
|
15117
14371
|
defs,
|
|
15118
14372
|
refs: /* @__PURE__ */ new Map(),
|
|
15119
14373
|
processing: /* @__PURE__ */ new Set(),
|
|
15120
|
-
rootSchema:
|
|
14374
|
+
rootSchema: schema,
|
|
15121
14375
|
registry: params?.registry ?? globalRegistry
|
|
15122
14376
|
};
|
|
15123
|
-
return convertSchema(
|
|
14377
|
+
return convertSchema(schema, ctx);
|
|
15124
14378
|
}
|
|
15125
14379
|
|
|
15126
14380
|
// ../../node_modules/zod/v4/classic/coerce.js
|
|
@@ -16759,6 +16013,9 @@ function hasScheduleExpression(config2) {
|
|
|
16759
16013
|
return config2.cron !== void 0 || config2.rate !== void 0;
|
|
16760
16014
|
}
|
|
16761
16015
|
|
|
16016
|
+
// .tmp/declarations.ts
|
|
16017
|
+
var PAGE_VISIBILITY = ["public", "guest", "authenticated", "group", "user"];
|
|
16018
|
+
|
|
16762
16019
|
// ../dsl-builders/src/apps/app-builder.ts
|
|
16763
16020
|
var app_builder_exports = {};
|
|
16764
16021
|
__export(app_builder_exports, {
|
|
@@ -23628,6 +22885,7 @@ ${errors.map((message) => `- ${message}`).join("\n")}`
|
|
|
23628
22885
|
};
|
|
23629
22886
|
}
|
|
23630
22887
|
export {
|
|
22888
|
+
PAGE_VISIBILITY,
|
|
23631
22889
|
PublishingTypeEnum,
|
|
23632
22890
|
app_builder_exports as appBuilder,
|
|
23633
22891
|
collectSecretIds,
|