openclaw
Version:
Multi-channel AI gateway with extensible messaging integrations
6,567 lines • 251 kB
JavaScript
import { r as __exportAll } from "./rolldown-runtime-Dr7-SnC6.js";
import { $ as ZodString, $a as $ZodCUID, $i as _positive, $n as uuid, $o as $ZodTuple, $r as _discriminatedUnion, $s as encodeAsync, $t as int, A as ZodJWT, Aa as _uuid, Ai as _mac, An as preprocess, Ao as $ZodNanoID, Ar as initializeContext, As as $ZodCheckOverwrite, At as boolean, B as ZodNull, Ba as $input, Bi as _nativeEnum, Bn as stringbool, Bo as $ZodPipe, Br as _check, Bs as _encode, Bt as discriminatedUnion, C as ZodExactOptional, Ca as _uint64, Cc as $constructor, Ci as _ksuid, Cn as nullish, Co as $ZodJWT, Cr as iso_exports, Cs as $ZodCheckMaxLength, Ct as _undefined$1, D as ZodIPv4, Da as _unknown, Di as _lowercase, Dn as partialRecord, Do as $ZodMAC, Dr as createToJSONSchemaMethod, Ds as $ZodCheckMinSize, Dt as base64, E as ZodGUID, Ea as _union, Ec as globalConfig, Ei as _literal, En as optional, Eo as $ZodLiteral, Er as createStandardJSONSchemaMethod, Es as $ZodCheckMinLength, Et as array, F as ZodMap, Fa as _xid, Fi as _minLength, Fn as schemas_exports, Fo as $ZodNumber, Fr as _base64, Fs as $ZodCheckStringFormat, Ft as cuid, G as ZodOptional, Ga as $ZodArray, Gi as _nonpositive, Gn as transform, Go as $ZodRecord, Gr as _coercedDate, Gs as _safeDecodeAsync, Gt as file, H as ZodNumber, Ha as globalRegistry, Hi as _never, Hn as superRefine, Ho as $ZodPreprocess, Hr as _cidrv6, Hs as _parse, Ht as email, I as ZodNaN, Ia as _xor, Ii as _minSize, In as set, Io as $ZodNumberFormat, Ir as _base64url, Is as $ZodCheckUpperCase, It as cuid2, J as ZodPreprocess, Ja as $ZodBigInt, Ji as _nullable, Jn as uint64, Jo as $ZodStringFormat, Jr as _cuid, Js as _safeParse, Jt as guid, K as ZodPipe, Ka as $ZodBase64, Ki as _normalize, Kn as tuple, Ko as $ZodSet, Kr as _coercedNumber, Ks as _safeEncode, Kt as float32, L as ZodNanoID, La as describe, Li as _multipleOf, Ln as strictObject, Lo as $ZodObject, Lr as _bigint, Ls as regexes_exports, Lt as custom, M as ZodLazy, Ma as _uuidv6, Mi as _maxLength, Mn as readonly, Mo as $ZodNonOptional, Mr as TimePrecision, Ms as $ZodCheckRegex, Mt as cidrv4, N as ZodLiteral, Na as _uuidv7, Ni as _maxSize, Nn as record, No as $ZodNull, Nr as _any, Ns as $ZodCheckSizeEquals, Nt as cidrv6, O as ZodIPv6, Oa as _uppercase, Oi as _lt, On as pipe, Oo as $ZodMap, Or as extractDefs, Os as $ZodCheckMultipleOf, Ot as base64url, P as ZodMAC, Pa as _void, Pi as _mime, Pn as refine, Po as $ZodNullable, Pr as _array, Ps as $ZodCheckStartsWith, Pt as codec, Q as ZodSet, Qa as $ZodCIDRv6, Qi as _pipe, Qn as url, Qo as $ZodTransform, Qr as _default, Qs as encode, Qt as httpUrl, R as ZodNever, Ra as meta, Ri as _nan, Rn as string, Ro as $ZodObjectJIT, Rr as _boolean, Rs as _decode, Rt as date, S as ZodEnum, Sa as _uint32, Sc as $brand, Si as _jwt, Sn as nullable, So as $ZodIntersection, Sr as ZodISOTime, Ss as $ZodCheckLowerCase, St as _null$1, T as ZodFunction, Ta as _undefined, Tc as config, Ti as _length, Tn as object, To as $ZodLazy, Tr as toJSONSchema, Ts as $ZodCheckMimeType, Tt as any, U as ZodNumberFormat, Ua as registry, Ui as _nonnegative, Un as symbol, Uo as $ZodPromise, Ur as _coercedBigint, Us as _parseAsync, Ut as emoji, V as ZodNullable, Va as $output, Vi as _negative, Vn as success, Vo as $ZodPrefault, Vr as _cidrv4, Vs as _encodeAsync, Vt as e164, W as ZodObject, Wa as $ZodAny, Wi as _nonoptional, Wn as templateLiteral, Wo as $ZodReadonly, Wr as _coercedBoolean, Ws as _safeDecode, Wt as exactOptional, X as ZodReadonly, Xa as $ZodBoolean, Xi as _optional, Xn as union, Xo as $ZodSymbol, Xr as _custom, Xs as decode, Xt as hex, Y as ZodPromise, Ya as $ZodBigIntFormat, Yi as _number, Yn as ulid, Yo as $ZodSuccess, Yr as _cuid2, Ys as _safeParseAsync, Yt as hash, Z as ZodRecord, Za as $ZodCIDRv4, Zi as _overwrite, Zn as unknown, Zo as $ZodTemplateLiteral, Zr as _date, Zs as decodeAsync, Zt as hostname, _ as ZodDefault, _a as _toLowerCase, _c as parsedType, _i as _ipv6, _n as nan, _o as $ZodIPv6, _r as ZodError, _s as $ZodCheckEndsWith, _t as _catch$1, a as ZodBigInt, aa as _regex, ac as safeEncodeAsync, ai as _file, an as ipv6, ao as $ZodDate, ar as decode$1, as as $ZodUnion, at as ZodTuple, b as ZodEmail, ba as _trim, bc as $ZodAsyncError, bi as _isoDuration, bn as never, bo as $ZodISODuration, br as ZodISODateTime, bs as $ZodCheckLengthEquals, bt as _function, c as ZodCIDRv4, ca as _slugify, cc as $ZodError, ci as _gt, cn as keyof, co as $ZodE164, cr as encodeAsync$1, cs as $ZodXID, ct as ZodURL, d as ZodCUID2, da as _stringFormat, dc as formatError, di as _includes, dn as literal, do as $ZodEnum, dr as safeDecode$1, ds as isValidBase64URL, dt as ZodUnion, ea as _promise, ec as parse, ei as _e164, en as int32, eo as $ZodCUID2, er as uuidv4, es as $ZodType, et as ZodStringFormat, f as ZodCatch, fa as _stringbool, fc as prettifyError, fi as _int, fn as looseObject, fo as $ZodExactOptional, fr as safeDecodeAsync$1, fs as isValidJWT, ft as ZodUnknown, g as ZodDate, ga as _templateLiteral, gc as joinValues, gi as _ipv4, gn as meta$1, go as $ZodIPv4, gr as safeParseAsync$1, gs as $ZodCheckBigIntFormat, gt as _ZodString, h as ZodCustomStringFormat, ha as _symbol, hc as clone, hi as _intersection, hn as map, ho as $ZodGUID, hr as safeParse$1, hs as $ZodCheck, ht as ZodXor, i as ZodBase64URL, ia as _refine, ic as safeEncode, ii as _enum, in as ipv4, io as $ZodCustomStringFormat, ir as xor, is as $ZodUndefined, it as ZodTransform, j as ZodKSUID, ja as _uuidv4, ji as _map, jn as promise, jo as $ZodNever, jr as process, js as $ZodCheckProperty, jt as check, k as ZodIntersection, ka as _url, ki as _lte, kn as prefault, ko as $ZodNaN, kr as finalize, ks as $ZodCheckNumberFormat, kt as bigint, l as ZodCIDRv6, la as _startsWith, lc as $ZodRealError, li as _gte, ln as ksuid, lo as $ZodEmail, lr as parse$1, ls as $ZodXor, lt as ZodUUID, m as ZodCustom, ma as _superRefine, mc as treeifyError, mi as _int64, mn as mac, mo as $ZodFunction, mr as safeEncodeAsync$1, ms as Doc, mt as ZodXID, n as ZodArray, na as _readonly, nc as safeDecode, ni as _emoji, nn as intersection, no as $ZodCodec, nr as uuidv7, ns as $ZodURL, nt as ZodSymbol, o as ZodBigIntFormat, oa as _set, oc as safeParse, oi as _float32, on as json, oo as $ZodDefault, or as decodeAsync$1, os as $ZodUnknown, ot as ZodType, p as ZodCodec, pa as _success, pc as toDotPath, pi as _int32, pn as looseRecord, po as $ZodFile, pr as safeEncode$1, ps as version, pt as ZodVoid, q as ZodPrefault, qa as $ZodBase64URL, qi as _null, qn as uint32, qo as $ZodString, qr as _coercedString, qs as _safeEncodeAsync, qt as float64, r as ZodBase64, ra as _record, rc as safeDecodeAsync, ri as _endsWith, rn as invertCodec, ro as $ZodCustom, rr as xid, rs as $ZodUUID, rt as ZodTemplateLiteral, s as ZodBoolean, sa as _size, sc as safeParseAsync, si as _float64, sn as jwt, so as $ZodDiscriminatedUnion, sr as encode$1, ss as $ZodVoid, st as ZodULID, t as ZodAny, ta as _property, tc as parseAsync, ti as _email, tn as int64, to as $ZodCatch, tr as uuidv6, ts as $ZodULID, tt as ZodSuccess, u as ZodCUID, ua as _string, uc as flattenError, ui as _guid, un as lazy, uo as $ZodEmoji, ur as parseAsync$1, us as isValidBase64, ut as ZodUndefined, v as ZodDiscriminatedUnion, va as _toUpperCase, vc as stringifyPrimitive, vi as _isoDate, vn as nanoid, vo as $ZodISODate, vr as ZodRealError, vs as $ZodCheckGreaterThan, vt as _default$1, w as ZodFile, wa as _ulid, wc as NEVER, wi as _lazy, wn as number, wo as $ZodKSUID, wr as allProcessors, ws as $ZodCheckMaxSize, wt as _void$1, x as ZodEmoji, xa as _tuple, xc as $ZodEncodeError, xi as _isoTime, xn as nonoptional, xo as $ZodISOTime, xr as ZodISODuration, xs as $ZodCheckLessThan, xt as _instanceof, y as ZodE164, ya as _transform, yc as util_exports, yi as _isoDateTime, yn as nativeEnum, yo as $ZodISODateTime, yr as ZodISODate, ys as $ZodCheckIncludes, yt as _enum$1, z as ZodNonOptional, za as $ZodRegistry, zi as _nanoid, zn as stringFormat, zo as $ZodOptional, zr as _catch, zs as _decodeAsync, zt as describe$1 } from "./schemas-zxit8y5H.js";
import { t as en_default } from "./en-BUzq-y2n.js";
import { i as setErrorMap, n as ZodIssueCode, r as getErrorMap, t as ZodFirstPartyTypeKind } from "./compat-rDmN5zKF.js";
import { t as coerce_exports } from "./coerce-Drr1hytz.js";
import "./plugin-entry-zfBGJaNO.js";
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ar.js
const error$48 = () => {
const Sizable = {
string: {
unit: "حرف",
verb: "أن يحوي"
},
file: {
unit: "بايت",
verb: "أن يحوي"
},
array: {
unit: "عنصر",
verb: "أن يحوي"
},
set: {
unit: "عنصر",
verb: "أن يحوي"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "مدخل",
email: "بريد إلكتروني",
url: "رابط",
emoji: "إيموجي",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "تاريخ ووقت بمعيار ISO",
date: "تاريخ بمعيار ISO",
time: "وقت بمعيار ISO",
duration: "مدة بمعيار ISO",
ipv4: "عنوان IPv4",
ipv6: "عنوان IPv6",
cidrv4: "مدى عناوين بصيغة IPv4",
cidrv6: "مدى عناوين بصيغة IPv6",
base64: "نَص بترميز base64-encoded",
base64url: "نَص بترميز base64url-encoded",
json_string: "نَص على هيئة JSON",
e164: "رقم هاتف بمعيار E.164",
jwt: "JWT",
template_literal: "مدخل"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `مدخلات غير مقبولة: يفترض إدخال instanceof ${issue.expected}، ولكن تم إدخال ${received}`;
return `مدخلات غير مقبولة: يفترض إدخال ${expected}، ولكن تم إدخال ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `مدخلات غير مقبولة: يفترض إدخال ${stringifyPrimitive(issue.values[0])}`;
return `اختيار غير مقبول: يتوقع انتقاء أحد هذه الخيارات: ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return ` أكبر من اللازم: يفترض أن تكون ${issue.origin ?? "القيمة"} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "عنصر"}`;
return `أكبر من اللازم: يفترض أن تكون ${issue.origin ?? "القيمة"} ${adj} ${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `أصغر من اللازم: يفترض لـ ${issue.origin} أن يكون ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
return `أصغر من اللازم: يفترض لـ ${issue.origin} أن يكون ${adj} ${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `نَص غير مقبول: يجب أن يبدأ بـ "${issue.prefix}"`;
if (_issue.format === "ends_with") return `نَص غير مقبول: يجب أن ينتهي بـ "${_issue.suffix}"`;
if (_issue.format === "includes") return `نَص غير مقبول: يجب أن يتضمَّن "${_issue.includes}"`;
if (_issue.format === "regex") return `نَص غير مقبول: يجب أن يطابق النمط ${_issue.pattern}`;
return `${FormatDictionary[_issue.format] ?? issue.format} غير مقبول`;
}
case "not_multiple_of": return `رقم غير مقبول: يجب أن يكون من مضاعفات ${issue.divisor}`;
case "unrecognized_keys": return `معرف${issue.keys.length > 1 ? "ات" : ""} غريب${issue.keys.length > 1 ? "ة" : ""}: ${joinValues(issue.keys, "، ")}`;
case "invalid_key": return `معرف غير مقبول في ${issue.origin}`;
case "invalid_union": return "مدخل غير مقبول";
case "invalid_element": return `مدخل غير مقبول في ${issue.origin}`;
default: return "مدخل غير مقبول";
}
};
};
function ar_default() {
return { localeError: error$48() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/az.js
const error$47 = () => {
const Sizable = {
string: {
unit: "simvol",
verb: "olmalıdır"
},
file: {
unit: "bayt",
verb: "olmalıdır"
},
array: {
unit: "element",
verb: "olmalıdır"
},
set: {
unit: "element",
verb: "olmalıdır"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "input",
email: "email address",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO datetime",
date: "ISO date",
time: "ISO time",
duration: "ISO duration",
ipv4: "IPv4 address",
ipv6: "IPv6 address",
cidrv4: "IPv4 range",
cidrv6: "IPv6 range",
base64: "base64-encoded string",
base64url: "base64url-encoded string",
json_string: "JSON string",
e164: "E.164 number",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Yanlış dəyər: gözlənilən instanceof ${issue.expected}, daxil olan ${received}`;
return `Yanlış dəyər: gözlənilən ${expected}, daxil olan ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Yanlış dəyər: gözlənilən ${stringifyPrimitive(issue.values[0])}`;
return `Yanlış seçim: aşağıdakılardan biri olmalıdır: ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Çox böyük: gözlənilən ${issue.origin ?? "dəyər"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "element"}`;
return `Çox böyük: gözlənilən ${issue.origin ?? "dəyər"} ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Çox kiçik: gözlənilən ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Çox kiçik: gözlənilən ${issue.origin} ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Yanlış mətn: "${_issue.prefix}" ilə başlamalıdır`;
if (_issue.format === "ends_with") return `Yanlış mətn: "${_issue.suffix}" ilə bitməlidir`;
if (_issue.format === "includes") return `Yanlış mətn: "${_issue.includes}" daxil olmalıdır`;
if (_issue.format === "regex") return `Yanlış mətn: ${_issue.pattern} şablonuna uyğun olmalıdır`;
return `Yanlış ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Yanlış ədəd: ${issue.divisor} ilə bölünə bilən olmalıdır`;
case "unrecognized_keys": return `Tanınmayan açar${issue.keys.length > 1 ? "lar" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `${issue.origin} daxilində yanlış açar`;
case "invalid_union": return "Yanlış dəyər";
case "invalid_element": return `${issue.origin} daxilində yanlış dəyər`;
default: return `Yanlış dəyər`;
}
};
};
function az_default() {
return { localeError: error$47() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/be.js
function getBelarusianPlural(count, one, few, many) {
const absCount = Math.abs(count);
const lastDigit = absCount % 10;
const lastTwoDigits = absCount % 100;
if (lastTwoDigits >= 11 && lastTwoDigits <= 19) return many;
if (lastDigit === 1) return one;
if (lastDigit >= 2 && lastDigit <= 4) return few;
return many;
}
const error$46 = () => {
const Sizable = {
string: {
unit: {
one: "сімвал",
few: "сімвалы",
many: "сімвалаў"
},
verb: "мець"
},
array: {
unit: {
one: "элемент",
few: "элементы",
many: "элементаў"
},
verb: "мець"
},
set: {
unit: {
one: "элемент",
few: "элементы",
many: "элементаў"
},
verb: "мець"
},
file: {
unit: {
one: "байт",
few: "байты",
many: "байтаў"
},
verb: "мець"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "увод",
email: "email адрас",
url: "URL",
emoji: "эмодзі",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO дата і час",
date: "ISO дата",
time: "ISO час",
duration: "ISO працягласць",
ipv4: "IPv4 адрас",
ipv6: "IPv6 адрас",
cidrv4: "IPv4 дыяпазон",
cidrv6: "IPv6 дыяпазон",
base64: "радок у фармаце base64",
base64url: "радок у фармаце base64url",
json_string: "JSON радок",
e164: "нумар E.164",
jwt: "JWT",
template_literal: "увод"
};
const TypeDictionary = {
nan: "NaN",
number: "лік",
array: "масіў"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Няправільны ўвод: чакаўся instanceof ${issue.expected}, атрымана ${received}`;
return `Няправільны ўвод: чакаўся ${expected}, атрымана ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Няправільны ўвод: чакалася ${stringifyPrimitive(issue.values[0])}`;
return `Няправільны варыянт: чакаўся адзін з ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) {
const unit = getBelarusianPlural(Number(issue.maximum), sizing.unit.one, sizing.unit.few, sizing.unit.many);
return `Занадта вялікі: чакалася, што ${issue.origin ?? "значэнне"} павінна ${sizing.verb} ${adj}${issue.maximum.toString()} ${unit}`;
}
return `Занадта вялікі: чакалася, што ${issue.origin ?? "значэнне"} павінна быць ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) {
const unit = getBelarusianPlural(Number(issue.minimum), sizing.unit.one, sizing.unit.few, sizing.unit.many);
return `Занадта малы: чакалася, што ${issue.origin} павінна ${sizing.verb} ${adj}${issue.minimum.toString()} ${unit}`;
}
return `Занадта малы: чакалася, што ${issue.origin} павінна быць ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Няправільны радок: павінен пачынацца з "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Няправільны радок: павінен заканчвацца на "${_issue.suffix}"`;
if (_issue.format === "includes") return `Няправільны радок: павінен змяшчаць "${_issue.includes}"`;
if (_issue.format === "regex") return `Няправільны радок: павінен адпавядаць шаблону ${_issue.pattern}`;
return `Няправільны ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Няправільны лік: павінен быць кратным ${issue.divisor}`;
case "unrecognized_keys": return `Нераспазнаны ${issue.keys.length > 1 ? "ключы" : "ключ"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Няправільны ключ у ${issue.origin}`;
case "invalid_union": return "Няправільны ўвод";
case "invalid_element": return `Няправільнае значэнне ў ${issue.origin}`;
default: return `Няправільны ўвод`;
}
};
};
function be_default() {
return { localeError: error$46() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/bg.js
const error$45 = () => {
const Sizable = {
string: {
unit: "символа",
verb: "да съдържа"
},
file: {
unit: "байта",
verb: "да съдържа"
},
array: {
unit: "елемента",
verb: "да съдържа"
},
set: {
unit: "елемента",
verb: "да съдържа"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "вход",
email: "имейл адрес",
url: "URL",
emoji: "емоджи",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO време",
date: "ISO дата",
time: "ISO време",
duration: "ISO продължителност",
ipv4: "IPv4 адрес",
ipv6: "IPv6 адрес",
cidrv4: "IPv4 диапазон",
cidrv6: "IPv6 диапазон",
base64: "base64-кодиран низ",
base64url: "base64url-кодиран низ",
json_string: "JSON низ",
e164: "E.164 номер",
jwt: "JWT",
template_literal: "вход"
};
const TypeDictionary = {
nan: "NaN",
number: "число",
array: "масив"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Невалиден вход: очакван instanceof ${issue.expected}, получен ${received}`;
return `Невалиден вход: очакван ${expected}, получен ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Невалиден вход: очакван ${stringifyPrimitive(issue.values[0])}`;
return `Невалидна опция: очаквано едно от ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Твърде голямо: очаква се ${issue.origin ?? "стойност"} да съдържа ${adj}${issue.maximum.toString()} ${sizing.unit ?? "елемента"}`;
return `Твърде голямо: очаква се ${issue.origin ?? "стойност"} да бъде ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Твърде малко: очаква се ${issue.origin} да съдържа ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Твърде малко: очаква се ${issue.origin} да бъде ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Невалиден низ: трябва да започва с "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Невалиден низ: трябва да завършва с "${_issue.suffix}"`;
if (_issue.format === "includes") return `Невалиден низ: трябва да включва "${_issue.includes}"`;
if (_issue.format === "regex") return `Невалиден низ: трябва да съвпада с ${_issue.pattern}`;
let invalid_adj = "Невалиден";
if (_issue.format === "emoji") invalid_adj = "Невалидно";
if (_issue.format === "datetime") invalid_adj = "Невалидно";
if (_issue.format === "date") invalid_adj = "Невалидна";
if (_issue.format === "time") invalid_adj = "Невалидно";
if (_issue.format === "duration") invalid_adj = "Невалидна";
return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Невалидно число: трябва да бъде кратно на ${issue.divisor}`;
case "unrecognized_keys": return `Неразпознат${issue.keys.length > 1 ? "и" : ""} ключ${issue.keys.length > 1 ? "ове" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Невалиден ключ в ${issue.origin}`;
case "invalid_union": return "Невалиден вход";
case "invalid_element": return `Невалидна стойност в ${issue.origin}`;
default: return `Невалиден вход`;
}
};
};
function bg_default() {
return { localeError: error$45() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ca.js
const error$44 = () => {
const Sizable = {
string: {
unit: "caràcters",
verb: "contenir"
},
file: {
unit: "bytes",
verb: "contenir"
},
array: {
unit: "elements",
verb: "contenir"
},
set: {
unit: "elements",
verb: "contenir"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "entrada",
email: "adreça electrònica",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "data i hora ISO",
date: "data ISO",
time: "hora ISO",
duration: "durada ISO",
ipv4: "adreça IPv4",
ipv6: "adreça IPv6",
cidrv4: "rang IPv4",
cidrv6: "rang IPv6",
base64: "cadena codificada en base64",
base64url: "cadena codificada en base64url",
json_string: "cadena JSON",
e164: "número E.164",
jwt: "JWT",
template_literal: "entrada"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Tipus invàlid: s'esperava instanceof ${issue.expected}, s'ha rebut ${received}`;
return `Tipus invàlid: s'esperava ${expected}, s'ha rebut ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Valor invàlid: s'esperava ${stringifyPrimitive(issue.values[0])}`;
return `Opció invàlida: s'esperava una de ${joinValues(issue.values, " o ")}`;
case "too_big": {
const adj = issue.inclusive ? "com a màxim" : "menys de";
const sizing = getSizing(issue.origin);
if (sizing) return `Massa gran: s'esperava que ${issue.origin ?? "el valor"} contingués ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
return `Massa gran: s'esperava que ${issue.origin ?? "el valor"} fos ${adj} ${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? "com a mínim" : "més de";
const sizing = getSizing(issue.origin);
if (sizing) return `Massa petit: s'esperava que ${issue.origin} contingués ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
return `Massa petit: s'esperava que ${issue.origin} fos ${adj} ${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Format invàlid: ha de començar amb "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Format invàlid: ha d'acabar amb "${_issue.suffix}"`;
if (_issue.format === "includes") return `Format invàlid: ha d'incloure "${_issue.includes}"`;
if (_issue.format === "regex") return `Format invàlid: ha de coincidir amb el patró ${_issue.pattern}`;
return `Format invàlid per a ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Número invàlid: ha de ser múltiple de ${issue.divisor}`;
case "unrecognized_keys": return `Clau${issue.keys.length > 1 ? "s" : ""} no reconeguda${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Clau invàlida a ${issue.origin}`;
case "invalid_union": return "Entrada invàlida";
case "invalid_element": return `Element invàlid a ${issue.origin}`;
default: return `Entrada invàlida`;
}
};
};
function ca_default() {
return { localeError: error$44() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/cs.js
const error$43 = () => {
const Sizable = {
string: {
unit: "znaků",
verb: "mít"
},
file: {
unit: "bajtů",
verb: "mít"
},
array: {
unit: "prvků",
verb: "mít"
},
set: {
unit: "prvků",
verb: "mít"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "regulární výraz",
email: "e-mailová adresa",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "datum a čas ve formátu ISO",
date: "datum ve formátu ISO",
time: "čas ve formátu ISO",
duration: "doba trvání ISO",
ipv4: "IPv4 adresa",
ipv6: "IPv6 adresa",
cidrv4: "rozsah IPv4",
cidrv6: "rozsah IPv6",
base64: "řetězec zakódovaný ve formátu base64",
base64url: "řetězec zakódovaný ve formátu base64url",
json_string: "řetězec ve formátu JSON",
e164: "číslo E.164",
jwt: "JWT",
template_literal: "vstup"
};
const TypeDictionary = {
nan: "NaN",
number: "číslo",
string: "řetězec",
function: "funkce",
array: "pole"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Neplatný vstup: očekáváno instanceof ${issue.expected}, obdrženo ${received}`;
return `Neplatný vstup: očekáváno ${expected}, obdrženo ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Neplatný vstup: očekáváno ${stringifyPrimitive(issue.values[0])}`;
return `Neplatná možnost: očekávána jedna z hodnot ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Hodnota je příliš velká: ${issue.origin ?? "hodnota"} musí mít ${adj}${issue.maximum.toString()} ${sizing.unit ?? "prvků"}`;
return `Hodnota je příliš velká: ${issue.origin ?? "hodnota"} musí být ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Hodnota je příliš malá: ${issue.origin ?? "hodnota"} musí mít ${adj}${issue.minimum.toString()} ${sizing.unit ?? "prvků"}`;
return `Hodnota je příliš malá: ${issue.origin ?? "hodnota"} musí být ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Neplatný řetězec: musí začínat na "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Neplatný řetězec: musí končit na "${_issue.suffix}"`;
if (_issue.format === "includes") return `Neplatný řetězec: musí obsahovat "${_issue.includes}"`;
if (_issue.format === "regex") return `Neplatný řetězec: musí odpovídat vzoru ${_issue.pattern}`;
return `Neplatný formát ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Neplatné číslo: musí být násobkem ${issue.divisor}`;
case "unrecognized_keys": return `Neznámé klíče: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Neplatný klíč v ${issue.origin}`;
case "invalid_union": return "Neplatný vstup";
case "invalid_element": return `Neplatná hodnota v ${issue.origin}`;
default: return `Neplatný vstup`;
}
};
};
function cs_default() {
return { localeError: error$43() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/da.js
const error$42 = () => {
const Sizable = {
string: {
unit: "tegn",
verb: "havde"
},
file: {
unit: "bytes",
verb: "havde"
},
array: {
unit: "elementer",
verb: "indeholdt"
},
set: {
unit: "elementer",
verb: "indeholdt"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "input",
email: "e-mailadresse",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO dato- og klokkeslæt",
date: "ISO-dato",
time: "ISO-klokkeslæt",
duration: "ISO-varighed",
ipv4: "IPv4-område",
ipv6: "IPv6-område",
cidrv4: "IPv4-spektrum",
cidrv6: "IPv6-spektrum",
base64: "base64-kodet streng",
base64url: "base64url-kodet streng",
json_string: "JSON-streng",
e164: "E.164-nummer",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = {
nan: "NaN",
string: "streng",
number: "tal",
boolean: "boolean",
array: "liste",
object: "objekt",
set: "sæt",
file: "fil"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Ugyldigt input: forventede instanceof ${issue.expected}, fik ${received}`;
return `Ugyldigt input: forventede ${expected}, fik ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Ugyldig værdi: forventede ${stringifyPrimitive(issue.values[0])}`;
return `Ugyldigt valg: forventede en af følgende ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
const origin = TypeDictionary[issue.origin] ?? issue.origin;
if (sizing) return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "elementer"}`;
return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
const origin = TypeDictionary[issue.origin] ?? issue.origin;
if (sizing) return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
return `For lille: forventede ${origin} havde ${adj} ${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Ugyldig streng: skal starte med "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Ugyldig streng: skal ende med "${_issue.suffix}"`;
if (_issue.format === "includes") return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
if (_issue.format === "regex") return `Ugyldig streng: skal matche mønsteret ${_issue.pattern}`;
return `Ugyldig ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Ugyldigt tal: skal være deleligt med ${issue.divisor}`;
case "unrecognized_keys": return `${issue.keys.length > 1 ? "Ukendte nøgler" : "Ukendt nøgle"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Ugyldig nøgle i ${issue.origin}`;
case "invalid_union": return "Ugyldigt input: matcher ingen af de tilladte typer";
case "invalid_element": return `Ugyldig værdi i ${issue.origin}`;
default: return `Ugyldigt input`;
}
};
};
function da_default() {
return { localeError: error$42() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/de.js
const error$41 = () => {
const Sizable = {
string: {
unit: "Zeichen",
verb: "zu haben"
},
file: {
unit: "Bytes",
verb: "zu haben"
},
array: {
unit: "Elemente",
verb: "zu haben"
},
set: {
unit: "Elemente",
verb: "zu haben"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "Eingabe",
email: "E-Mail-Adresse",
url: "URL",
emoji: "Emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO-Datum und -Uhrzeit",
date: "ISO-Datum",
time: "ISO-Uhrzeit",
duration: "ISO-Dauer",
ipv4: "IPv4-Adresse",
ipv6: "IPv6-Adresse",
cidrv4: "IPv4-Bereich",
cidrv6: "IPv6-Bereich",
base64: "Base64-codierter String",
base64url: "Base64-URL-codierter String",
json_string: "JSON-String",
e164: "E.164-Nummer",
jwt: "JWT",
template_literal: "Eingabe"
};
const TypeDictionary = {
nan: "NaN",
number: "Zahl",
array: "Array"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Ungültige Eingabe: erwartet instanceof ${issue.expected}, erhalten ${received}`;
return `Ungültige Eingabe: erwartet ${expected}, erhalten ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Ungültige Eingabe: erwartet ${stringifyPrimitive(issue.values[0])}`;
return `Ungültige Option: erwartet eine von ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Zu groß: erwartet, dass ${issue.origin ?? "Wert"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "Elemente"} hat`;
return `Zu groß: erwartet, dass ${issue.origin ?? "Wert"} ${adj}${issue.maximum.toString()} ist`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Zu klein: erwartet, dass ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit} hat`;
return `Zu klein: erwartet, dass ${issue.origin} ${adj}${issue.minimum.toString()} ist`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Ungültiger String: muss mit "${_issue.prefix}" beginnen`;
if (_issue.format === "ends_with") return `Ungültiger String: muss mit "${_issue.suffix}" enden`;
if (_issue.format === "includes") return `Ungültiger String: muss "${_issue.includes}" enthalten`;
if (_issue.format === "regex") return `Ungültiger String: muss dem Muster ${_issue.pattern} entsprechen`;
return `Ungültig: ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Ungültige Zahl: muss ein Vielfaches von ${issue.divisor} sein`;
case "unrecognized_keys": return `${issue.keys.length > 1 ? "Unbekannte Schlüssel" : "Unbekannter Schlüssel"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Ungültiger Schlüssel in ${issue.origin}`;
case "invalid_union": return "Ungültige Eingabe";
case "invalid_element": return `Ungültiger Wert in ${issue.origin}`;
default: return `Ungültige Eingabe`;
}
};
};
function de_default() {
return { localeError: error$41() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/el.js
const error$40 = () => {
const Sizable = {
string: {
unit: "χαρακτήρες",
verb: "να έχει"
},
file: {
unit: "bytes",
verb: "να έχει"
},
array: {
unit: "στοιχεία",
verb: "να έχει"
},
set: {
unit: "στοιχεία",
verb: "να έχει"
},
map: {
unit: "καταχωρήσεις",
verb: "να έχει"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "είσοδος",
email: "διεύθυνση email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO ημερομηνία και ώρα",
date: "ISO ημερομηνία",
time: "ISO ώρα",
duration: "ISO διάρκεια",
ipv4: "διεύθυνση IPv4",
ipv6: "διεύθυνση IPv6",
mac: "διεύθυνση MAC",
cidrv4: "εύρος IPv4",
cidrv6: "εύρος IPv6",
base64: "συμβολοσειρά κωδικοποιημένη σε base64",
base64url: "συμβολοσειρά κωδικοποιημένη σε base64url",
json_string: "συμβολοσειρά JSON",
e164: "αριθμός E.164",
jwt: "JWT",
template_literal: "είσοδος"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (typeof issue.expected === "string" && /^[A-Z]/.test(issue.expected)) return `Μη έγκυρη είσοδος: αναμενόταν instanceof ${issue.expected}, λήφθηκε ${received}`;
return `Μη έγκυρη είσοδος: αναμενόταν ${expected}, λήφθηκε ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Μη έγκυρη είσοδος: αναμενόταν ${stringifyPrimitive(issue.values[0])}`;
return `Μη έγκυρη επιλογή: αναμενόταν ένα από ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Πολύ μεγάλο: αναμενόταν ${issue.origin ?? "τιμή"} να έχει ${adj}${issue.maximum.toString()} ${sizing.unit ?? "στοιχεία"}`;
return `Πολύ μεγάλο: αναμενόταν ${issue.origin ?? "τιμή"} να είναι ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Πολύ μικρό: αναμενόταν ${issue.origin} να έχει ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Πολύ μικρό: αναμενόταν ${issue.origin} να είναι ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Μη έγκυρη συμβολοσειρά: πρέπει να ξεκινά με "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Μη έγκυρη συμβολοσειρά: πρέπει να τελειώνει με "${_issue.suffix}"`;
if (_issue.format === "includes") return `Μη έγκυρη συμβολοσειρά: πρέπει να περιέχει "${_issue.includes}"`;
if (_issue.format === "regex") return `Μη έγκυρη συμβολοσειρά: πρέπει να ταιριάζει με το μοτίβο ${_issue.pattern}`;
return `Μη έγκυρο: ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Μη έγκυρος αριθμός: πρέπει να είναι πολλαπλάσιο του ${issue.divisor}`;
case "unrecognized_keys": return `Άγνωστ${issue.keys.length > 1 ? "α" : "ο"} κλειδ${issue.keys.length > 1 ? "ιά" : "ί"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Μη έγκυρο κλειδί στο ${issue.origin}`;
case "invalid_union": return "Μη έγκυρη είσοδος";
case "invalid_element": return `Μη έγκυρη τιμή στο ${issue.origin}`;
default: return `Μη έγκυρη είσοδος`;
}
};
};
function el_default() {
return { localeError: error$40() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/eo.js
const error$39 = () => {
const Sizable = {
string: {
unit: "karaktrojn",
verb: "havi"
},
file: {
unit: "bajtojn",
verb: "havi"
},
array: {
unit: "elementojn",
verb: "havi"
},
set: {
unit: "elementojn",
verb: "havi"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "enigo",
email: "retadreso",
url: "URL",
emoji: "emoĝio",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO-datotempo",
date: "ISO-dato",
time: "ISO-tempo",
duration: "ISO-daŭro",
ipv4: "IPv4-adreso",
ipv6: "IPv6-adreso",
cidrv4: "IPv4-rango",
cidrv6: "IPv6-rango",
base64: "64-ume kodita karaktraro",
base64url: "URL-64-ume kodita karaktraro",
json_string: "JSON-karaktraro",
e164: "E.164-nombro",
jwt: "JWT",
template_literal: "enigo"
};
const TypeDictionary = {
nan: "NaN",
number: "nombro",
array: "tabelo",
null: "senvalora"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Nevalida enigo: atendiĝis instanceof ${issue.expected}, riceviĝis ${received}`;
return `Nevalida enigo: atendiĝis ${expected}, riceviĝis ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Nevalida enigo: atendiĝis ${stringifyPrimitive(issue.values[0])}`;
return `Nevalida opcio: atendiĝis unu el ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Tro granda: atendiĝis ke ${issue.origin ?? "valoro"} havu ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementojn"}`;
return `Tro granda: atendiĝis ke ${issue.origin ?? "valoro"} havu ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Tro malgranda: atendiĝis ke ${issue.origin} havu ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Tro malgranda: atendiĝis ke ${issue.origin} estu ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Nevalida karaktraro: devas komenciĝi per "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Nevalida karaktraro: devas finiĝi per "${_issue.suffix}"`;
if (_issue.format === "includes") return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`;
if (_issue.format === "regex") return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;
return `Nevalida ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Nevalida nombro: devas esti oblo de ${issue.divisor}`;
case "unrecognized_keys": return `Nekonata${issue.keys.length > 1 ? "j" : ""} ŝlosilo${issue.keys.length > 1 ? "j" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Nevalida ŝlosilo en ${issue.origin}`;
case "invalid_union": return "Nevalida enigo";
case "invalid_element": return `Nevalida valoro en ${issue.origin}`;
default: return `Nevalida enigo`;
}
};
};
function eo_default() {
return { localeError: error$39() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/es.js
const error$38 = () => {
const Sizable = {
string: {
unit: "caracteres",
verb: "tener"
},
file: {
unit: "bytes",
verb: "tener"
},
array: {
unit: "elementos",
verb: "tener"
},
set: {
unit: "elementos",
verb: "tener"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "entrada",
email: "dirección de correo electrónico",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "fecha y hora ISO",
date: "fecha ISO",
time: "hora ISO",
duration: "duración ISO",
ipv4: "dirección IPv4",
ipv6: "dirección IPv6",
cidrv4: "rango IPv4",
cidrv6: "rango IPv6",
base64: "cadena codificada en base64",
base64url: "URL codificada en base64",
json_string: "cadena JSON",
e164: "número E.164",
jwt: "JWT",
template_literal: "entrada"
};
const TypeDictionary = {
nan: "NaN",
string: "texto",
number: "número",
boolean: "booleano",
array: "arreglo",
object: "objeto",
set: "conjunto",
file: "archivo",
date: "fecha",
bigint: "número grande",
symbol: "símbolo",
undefined: "indefinido",
null: "nulo",
function: "función",
map: "mapa",
record: "registro",
tuple: "tupla",
enum: "enumeración",
union: "unión",
literal: "literal",
promise: "promesa",
void: "vacío",
never: "nunca",
unknown: "desconocido",
any: "cualquiera"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Entrada inválida: se esperaba instanceof ${issue.expected}, recibido ${received}`;
return `Entrada inválida: se esperaba ${expected}, recibido ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Entrada inválida: se esperaba ${stringifyPrimitive(issue.values[0])}`;
return `Opción inválida: se esperaba una de ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
const origin = TypeDictionary[issue.origin] ?? issue.origin;
if (sizing) return `Demasiado grande: se esperaba que ${origin ?? "valor"} tuviera ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementos"}`;
return `Demasiado grande: se esperaba que ${origin ?? "valor"} fuera ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
const origin = TypeDictionary[issue.origin] ?? issue.origin;
if (sizing) return `Demasiado pequeño: se esperaba que ${origin} tuviera ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Demasiado pequeño: se esperaba que ${origin} fuera ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Cadena inválida: debe comenzar con "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Cadena inválida: debe terminar en "${_issue.suffix}"`;
if (_issue.format === "includes") return `Cadena inválida: debe incluir "${_issue.includes}"`;
if (_issue.format === "regex") return `Cadena inválida: debe coincidir con el patrón ${_issue.pattern}`;
return `Inválido ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Número inválido: debe ser múltiplo de ${issue.divisor}`;
case "unrecognized_keys": return `Llave${issue.keys.length > 1 ? "s" : ""} desconocida${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Llave inválida en ${TypeDictionary[issue.origin] ?? issue.origin}`;
case "invalid_union": return "Entrada inválida";
case "invalid_element": return `Valor inválido en ${TypeDictionary[issue.origin] ?? issue.origin}`;
default: return `Entrada inválida`;
}
};
};
function es_default() {
return { localeError: error$38() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/fa.js
const error$37 = () => {
const Sizable = {
string: {
unit: "کاراکتر",
verb: "داشته باشد"
},
file: {
unit: "بایت",
verb: "داشته باشد"
},
array: {
unit: "آیتم",
verb: "داشته باشد"
},
set: {
unit: "آیتم",
verb: "داشته باشد"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ورودی",
email: "آدرس ایمیل",
url: "URL",
emoji: "ایموجی",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "تاریخ و زمان ایزو",
date: "تاریخ ایزو",
time: "زمان ایزو",
duration: "مدت زمان ایزو",
ipv4: "IPv4 آدرس",
ipv6: "IPv6 آدرس",
cidrv4: "IPv4 دامنه",
cidrv6: "IPv6 دامنه",
base64: "base64-encoded رشته",
base64url: "base64url-encoded رشته",
json_string: "JSON رشته",
e164: "E.164 عدد",
jwt: "JWT",
template_literal: "ورودی"
};
const TypeDictionary = {
nan: "NaN",
number: "عدد",
array: "آرایه"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `ورودی نامعتبر: میبایست instanceof ${issue.expected} میبود، ${received} دریافت شد`;
return `ورودی نامعتبر: میبایست ${expected} میبود، ${received} دریافت شد`;
}
case "invalid_value":
if (issue.values.length === 1) return `ورودی نامعتبر: میبایست ${stringifyPrimitive(issue.values[0])} میبود`;
return `گزینه نامعتبر: میبایست یکی از ${joinValues(issue.values, "|")} میبود`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `خیلی بزرگ: ${issue.origin ?? "مقدار"} باید ${adj}${issue.maximum.toString()} ${sizing.unit ?? "عنصر"} باشد`;
return `خیلی بزرگ: ${issue.origin ?? "مقدار"} باید ${adj}${issue.maximum.toString()} باشد`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `خیلی کوچک: ${issue.origin} باید ${adj}${issue.minimum.toString()} ${sizing.unit} باشد`;
return `خیلی کوچک: ${issue.origin} باید ${adj}${issue.minimum.toString()} باشد`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `رشته نامعتبر: باید با "${_issue.prefix}" شروع شود`;
if (_issue.format === "ends_with") return `رشته نامعتبر: باید با "${_issue.suffix}" تمام شود`;
if (_issue.format === "includes") return `رشته نامعتبر: باید شامل "${_issue.includes}" باشد`;
if (_issue.format === "regex") return `رشته نامعتبر: باید با الگوی ${_issue.pattern} مطابقت داشته باشد`;
return `${FormatDictionary[_issue.format] ?? issue.format} نامعتبر`;
}
case "not_multiple_of": return `عدد نامعتبر: باید مضرب ${issue.divisor} باشد`;
case "unrecognized_keys": return `کلید${issue.keys.length > 1 ? "های" : ""} ناشناس: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `کلید ناشناس در ${issue.origin}`;
case "invalid_union": return `ورودی نامعتبر`;
case "invalid_element": return `مقدار نامعتبر در ${issue.origin}`;
default: return `ورودی نامعتبر`;
}
};
};
function fa_default() {
return { localeError: error$37() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/fi.js
const error$36 = () => {
const Sizable = {
string: {
unit: "merkkiä",
subject: "merkkijonon"
},
file: {
unit: "tavua",
subject: "tiedoston"
},
array: {
unit: "alkiota",
subject: "listan"
},
set: {
unit: "alkiota",
subject: "joukon"
},
number: {
unit: "",
subject: "luvun"
},
bigint: {
unit: "",
subject: "suuren kokonaisluvun"
},
int: {
unit: "",
subject: "kokonaisluvun"
},
date: {
unit: "",
subject: "päivämäärän"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "säännöllinen lauseke",
email: "sähköpostiosoite",
url: "URL-osoite",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO-aikaleima",
date: "ISO-päivämäärä",
time: "ISO-aika",
duration: "ISO-kesto",
ipv4: "IPv4-osoite",
ipv6: "IPv6-osoite",
cidrv4: "IPv4-alue",
cidrv6: "IPv6-alue",
base64: "base64-koodattu merkkijono",
base64url: "base64url-koodattu merkkijono",
json_string: "JSON-merkkijono",
e164: "E.164-luku",
jwt: "JWT",
template_literal: "templaattimerkkijono"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Virheellinen tyyppi: odotettiin instanceof ${issue.expected}, oli ${received}`;
return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Virheellinen syöte: täytyy olla ${stringifyPrimitive(issue.values[0])}`;
return `Virheellinen valinta: täytyy olla yksi seuraavista: ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Liian suuri: ${sizing.subject} täytyy olla ${adj}${issue.maximum.toString()} ${sizing.unit}`.trim();
return `Liian suuri: arvon täytyy olla ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Liian pieni: ${sizing.subject} täytyy olla ${adj}${issue.minimum.toString()} ${sizing.unit}`.trim();
return `Liian pieni: arvon täytyy olla ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Virheellinen syöte: täytyy alkaa "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Virheellinen syöte: täytyy loppua "${_issue.suffix}"`;
if (_issue.format === "includes") return `Virheellinen syöte: täytyy sisältää "${_issue.includes}"`;
if (_issue.format === "regex") return `Virheellinen syöte: täytyy vastata säännöllistä lauseketta ${_issue.pattern}`;
return `Virheellinen ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Virheellinen luku: täytyy olla luvun ${issue.divisor} monikerta`;
case "unrecognized_keys": return `${issue.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return "Virheellinen avain tietueessa";
case "invalid_union": return "Virheellinen unioni";
case "invalid_element": return "Virheellinen arvo joukossa";
default: return `Virheellinen syöte`;
}
};
};
function fi_default() {
return { localeError: error$36() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/fr.js
const error$35 = () => {
const Sizable = {
string: {
unit: "caractères",
verb: "avoir"
},
file: {
unit: "octets",
verb: "avoir"
},
array: {
unit: "éléments",
verb: "avoir"
},
set: {
unit: "éléments",
verb: "avoir"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "entrée",
email: "adresse e-mail",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "date et heure ISO",
date: "date ISO",
time: "heure ISO",
duration: "durée ISO",
ipv4: "adresse IPv4",
ipv6: "adresse IPv6",
cidrv4: "plage IPv4",
cidrv6: "plage IPv6",
base64: "chaîne encodée en base64",
base64url: "chaîne encodée en base64url",
json_string: "chaîne JSON",
e164: "numéro E.164",
jwt: "JWT",
template_literal: "entrée"
};
const TypeDictionary = {
string: "chaîne",
number: "nombre",
int: "entier",
boolean: "booléen",
bigint: "grand entier",
symbol: "symbole",
undefined: "indéfini",
null: "null",
never: "jamais",
void: "vide",
date: "date",
array: "tableau",
object: "objet",
tuple: "tuple",
record: "enregistrement",
map: "carte",
set: "ensemble",
file: "fichier",
nonoptional: "non-optionnel",
nan: "NaN",
function: "fonction"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Entrée invalide : instanceof ${issue.expected} attendu, ${received} reçu`;
return `Entrée invalide : ${expected} attendu, ${received} reçu`;
}
case "invalid_value":
if (issue.values.length === 1) return `Entrée invalide : ${stringifyPrimitive(issue.values[0])} attendu`;
return `Option invalide : une valeur parmi ${joinValues(issue.values, "|")} attendue`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Trop grand : ${TypeDictionary[issue.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "élément(s)"}`;
return `Trop grand : ${TypeDictionary[issue.origin] ?? "valeur"} doit être ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Trop petit : ${TypeDictionary[issue.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Trop petit : ${TypeDictionary[issue.origin] ?? "valeur"} doit être ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Chaîne invalide : doit commencer par "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Chaîne invalide : doit se terminer par "${_issue.suffix}"`;
if (_issue.format === "includes") return `Chaîne invalide : doit inclure "${_issue.includes}"`;
if (_issue.format === "regex") return `Chaîne invalide : doit correspondre au modèle ${_issue.pattern}`;
return `${FormatDictionary[_issue.format] ?? issue.format} invalide`;
}
case "not_multiple_of": return `Nombre invalide : doit être un multiple de ${issue.divisor}`;
case "unrecognized_keys": return `Clé${issue.keys.length > 1 ? "s" : ""} non reconnue${issue.keys.length > 1 ? "s" : ""} : ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Clé invalide dans ${issue.origin}`;
case "invalid_union": return "Entrée invalide";
case "invalid_element": return `Valeur invalide dans ${issue.origin}`;
default: return `Entrée invalide`;
}
};
};
function fr_default() {
return { localeError: error$35() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/fr-CA.js
const error$34 = () => {
const Sizable = {
string: {
unit: "caractères",
verb: "avoir"
},
file: {
unit: "octets",
verb: "avoir"
},
array: {
unit: "éléments",
verb: "avoir"
},
set: {
unit: "éléments",
verb: "avoir"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "entrée",
email: "adresse courriel",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "date-heure ISO",
date: "date ISO",
time: "heure ISO",
duration: "durée ISO",
ipv4: "adresse IPv4",
ipv6: "adresse IPv6",
cidrv4: "plage IPv4",
cidrv6: "plage IPv6",
base64: "chaîne encodée en base64",
base64url: "chaîne encodée en base64url",
json_string: "chaîne JSON",
e164: "numéro E.164",
jwt: "JWT",
template_literal: "entrée"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Entrée invalide : attendu instanceof ${issue.expected}, reçu ${received}`;
return `Entrée invalide : attendu ${expected}, reçu ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Entrée invalide : attendu ${stringifyPrimitive(issue.values[0])}`;
return `Option invalide : attendu l'une des valeurs suivantes ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "≤" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Trop grand : attendu que ${issue.origin ?? "la valeur"} ait ${adj}${issue.maximum.toString()} ${sizing.unit}`;
return `Trop grand : attendu que ${issue.origin ?? "la valeur"} soit ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? "≥" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Trop petit : attendu que ${issue.origin} ait ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Trop petit : attendu que ${issue.origin} soit ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Chaîne invalide : doit commencer par "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Chaîne invalide : doit se terminer par "${_issue.suffix}"`;
if (_issue.format === "includes") return `Chaîne invalide : doit inclure "${_issue.includes}"`;
if (_issue.format === "regex") return `Chaîne invalide : doit correspondre au motif ${_issue.pattern}`;
return `${FormatDictionary[_issue.format] ?? issue.format} invalide`;
}
case "not_multiple_of": return `Nombre invalide : doit être un multiple de ${issue.divisor}`;
case "unrecognized_keys": return `Clé${issue.keys.length > 1 ? "s" : ""} non reconnue${issue.keys.length > 1 ? "s" : ""} : ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Clé invalide dans ${issue.origin}`;
case "invalid_union": return "Entrée invalide";
case "invalid_element": return `Valeur invalide dans ${issue.origin}`;
default: return `Entrée invalide`;
}
};
};
function fr_CA_default() {
return { localeError: error$34() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/he.js
const error$33 = () => {
const TypeNames = {
string: {
label: "מחרוזת",
gender: "f"
},
number: {
label: "מספר",
gender: "m"
},
boolean: {
label: "ערך בוליאני",
gender: "m"
},
bigint: {
label: "BigInt",
gender: "m"
},
date: {
label: "תאריך",
gender: "m"
},
array: {
label: "מערך",
gender: "m"
},
object: {
label: "אובייקט",
gender: "m"
},
null: {
label: "ערך ריק (null)",
gender: "m"
},
undefined: {
label: "ערך לא מוגדר (undefined)",
gender: "m"
},
symbol: {
label: "סימבול (Symbol)",
gender: "m"
},
function: {
label: "פונקציה",
gender: "f"
},
map: {
label: "מפה (Map)",
gender: "f"
},
set: {
label: "קבוצה (Set)",
gender: "f"
},
file: {
label: "קובץ",
gender: "m"
},
promise: {
label: "Promise",
gender: "m"
},
NaN: {
label: "NaN",
gender: "m"
},
unknown: {
label: "ערך לא ידוע",
gender: "m"
},
value: {
label: "ערך",
gender: "m"
}
};
const Sizable = {
string: {
unit: "תווים",
shortLabel: "קצר",
longLabel: "ארוך"
},
file: {
unit: "בייטים",
shortLabel: "קטן",
longLabel: "גדול"
},
array: {
unit: "פריטים",
shortLabel: "קטן",
longLabel: "גדול"
},
set: {
unit: "פריטים",
shortLabel: "קטן",
longLabel: "גדול"
},
number: {
unit: "",
shortLabel: "קטן",
longLabel: "גדול"
}
};
const typeEntry = (t) => t ? TypeNames[t] : void 0;
const typeLabel = (t) => {
const e = typeEntry(t);
if (e) return e.label;
return t ?? TypeNames.unknown.label;
};
const withDefinite = (t) => `ה${typeLabel(t)}`;
const verbFor = (t) => {
return (typeEntry(t)?.gender ?? "m") === "f" ? "צריכה להיות" : "צריך להיות";
};
const getSizing = (origin) => {
if (!origin) return null;
return Sizable[origin] ?? null;
};
const FormatDictionary = {
regex: {
label: "קלט",
gender: "m"
},
email: {
label: "כתובת אימייל",
gender: "f"
},
url: {
label: "כתובת רשת",
gender: "f"
},
emoji: {
label: "אימוג'י",
gender: "m"
},
uuid: {
label: "UUID",
gender: "m"
},
nanoid: {
label: "nanoid",
gender: "m"
},
guid: {
label: "GUID",
gender: "m"
},
cuid: {
label: "cuid",
gender: "m"
},
cuid2: {
label: "cuid2",
gender: "m"
},
ulid: {
label: "ULID",
gender: "m"
},
xid: {
label: "XID",
gender: "m"
},
ksuid: {
label: "KSUID",
gender: "m"
},
datetime: {
label: "תאריך וזמן ISO",
gender: "m"
},
date: {
label: "תאריך ISO",
gender: "m"
},
time: {
label: "זמן ISO",
gender: "m"
},
duration: {
label: "משך זמן ISO",
gender: "m"
},
ipv4: {
label: "כתובת IPv4",
gender: "f"
},
ipv6: {
label: "כתובת IPv6",
gender: "f"
},
cidrv4: {
label: "טווח IPv4",
gender: "m"
},
cidrv6: {
label: "טווח IPv6",
gender: "m"
},
base64: {
label: "מחרוזת בבסיס 64",
gender: "f"
},
base64url: {
label: "מחרוזת בבסיס 64 לכתובות רשת",
gender: "f"
},
json_string: {
label: "מחרוזת JSON",
gender: "f"
},
e164: {
label: "מספר E.164",
gender: "m"
},
jwt: {
label: "JWT",
gender: "m"
},
ends_with: {
label: "קלט",
gender: "m"
},
includes: {
label: "קלט",
gender: "m"
},
lowercase: {
label: "קלט",
gender: "m"
},
starts_with: {
label: "קלט",
gender: "m"
},
uppercase: {
label: "קלט",
gender: "m"
}
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expectedKey = issue.expected;
const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel(expectedKey);
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `קלט לא תקין: צריך להיות instanceof ${issue.expected}, התקבל ${received}`;
return `קלט לא תקין: צריך להיות ${expected}, התקבל ${received}`;
}
case "invalid_value": {
if (issue.values.length === 1) return `ערך לא תקין: הערך חייב להיות ${stringifyPrimitive(issue.values[0])}`;
const stringified = issue.values.map((v) => stringifyPrimitive(v));
if (issue.values.length === 2) return `ערך לא תקין: האפשרויות המתאימות הן ${stringified[0]} או ${stringified[1]}`;
const lastValue = stringified[stringified.length - 1];
return `ערך לא תקין: האפשרויות המתאימות הן ${stringified.slice(0, -1).join(", ")} או ${lastValue}`;
}
case "too_big": {
const sizing = getSizing(issue.origin);
const subject = withDefinite(issue.origin ?? "value");
if (issue.origin === "string") return `${sizing?.longLabel ?? "ארוך"} מדי: ${subject} צריכה להכיל ${issue.maximum.toString()} ${sizing?.unit ?? ""} ${issue.inclusive ? "או פחות" : "לכל היותר"}`.trim();
if (issue.origin === "number") return `גדול מדי: ${subject} צריך להיות ${issue.inclusive ? `קטן או שווה ל-${issue.maximum}` : `קטן מ-${issue.maximum}`}`;
if (issue.origin === "array" || issue.origin === "set") return `גדול מדי: ${subject} ${issue.origin === "set" ? "צריכה" : "צריך"} להכיל ${issue.inclusive ? `${issue.maximum} ${sizing?.unit ?? ""} או פחות` : `פחות מ-${issue.maximum} ${sizing?.unit ?? ""}`}`.trim();
const adj = issue.inclusive ? "<=" : "<";
const be = verbFor(issue.origin ?? "value");
if (sizing?.unit) return `${sizing.longLabel} מדי: ${subject} ${be} ${adj}${issue.maximum.toString()} ${sizing.unit}`;
return `${sizing?.longLabel ?? "גדול"} מדי: ${subject} ${be} ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const sizing = getSizing(issue.origin);
const subject = withDefinite(issue.origin ?? "value");
if (issue.origin === "string") return `${sizing?.shortLabel ?? "קצר"} מדי: ${subject} צריכה להכיל ${issue.minimum.toString()} ${sizing?.unit ?? ""} ${issue.inclusive ? "או יותר" : "לפחות"}`.trim();
if (issue.origin === "number") return `קטן מדי: ${subject} צריך להיות ${issue.inclusive ? `גדול או שווה ל-${issue.minimum}` : `גדול מ-${issue.minimum}`}`;
if (issue.origin === "array" || issue.origin === "set") {
const verb = issue.origin === "set" ? "צריכה" : "צריך";
if (issue.minimum === 1 && issue.inclusive) return `קטן מדי: ${subject} ${verb} להכיל ${issue.origin === "set" ? "לפחות פריט אחד" : "לפחות פריט אחד"}`;
return `קטן מדי: ${subject} ${verb} להכיל ${issue.inclusive ? `${issue.minimum} ${sizing?.unit ?? ""} או יותר` : `יותר מ-${issue.minimum} ${sizing?.unit ?? ""}`}`.trim();
}
const adj = issue.inclusive ? ">=" : ">";
const be = verbFor(issue.origin ?? "value");
if (sizing?.unit) return `${sizing.shortLabel} מדי: ${subject} ${be} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `${sizing?.shortLabel ?? "קטן"} מדי: ${subject} ${be} ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `המחרוזת חייבת להתחיל ב "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `המחרוזת חייבת להסתיים ב "${_issue.suffix}"`;
if (_issue.format === "includes") return `המחרוזת חייבת לכלול "${_issue.includes}"`;
if (_issue.format === "regex") return `המחרוזת חייבת להתאים לתבנית ${_issue.pattern}`;
const nounEntry = FormatDictionary[_issue.format];
return `${nounEntry?.label ?? _issue.format} לא ${(nounEntry?.gender ?? "m") === "f" ? "תקינה" : "תקין"}`;
}
case "not_multiple_of": return `מספר לא תקין: חייב להיות מכפלה של ${issue.divisor}`;
case "unrecognized_keys": return `מפתח${issue.keys.length > 1 ? "ות" : ""} לא מזוה${issue.keys.length > 1 ? "ים" : "ה"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `שדה לא תקין באובייקט`;
case "invalid_union": return "קלט לא תקין";
case "invalid_element": return `ערך לא תקין ב${withDefinite(issue.origin ?? "array")}`;
default: return `קלט לא תקין`;
}
};
};
function he_default() {
return { localeError: error$33() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/hr.js
const error$32 = () => {
const Sizable = {
string: {
unit: "znakova",
verb: "imati"
},
file: {
unit: "bajtova",
verb: "imati"
},
array: {
unit: "stavki",
verb: "imati"
},
set: {
unit: "stavki",
verb: "imati"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "unos",
email: "email adresa",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO datum i vrijeme",
date: "ISO datum",
time: "ISO vrijeme",
duration: "ISO trajanje",
ipv4: "IPv4 adresa",
ipv6: "IPv6 adresa",
cidrv4: "IPv4 raspon",
cidrv6: "IPv6 raspon",
base64: "base64 kodirani tekst",
base64url: "base64url kodirani tekst",
json_string: "JSON tekst",
e164: "E.164 broj",
jwt: "JWT",
template_literal: "unos"
};
const TypeDictionary = {
nan: "NaN",
string: "tekst",
number: "broj",
boolean: "boolean",
array: "niz",
object: "objekt",
set: "skup",
file: "datoteka",
date: "datum",
bigint: "bigint",
symbol: "simbol",
undefined: "undefined",
null: "null",
function: "funkcija",
map: "mapa"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Neispravan unos: očekuje se instanceof ${issue.expected}, a primljeno je ${received}`;
return `Neispravan unos: očekuje se ${expected}, a primljeno je ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Neispravna vrijednost: očekivano ${stringifyPrimitive(issue.values[0])}`;
return `Neispravna opcija: očekivano jedno od ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
const origin = TypeDictionary[issue.origin] ?? issue.origin;
if (sizing) return `Preveliko: očekivano da ${origin ?? "vrijednost"} ima ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elemenata"}`;
return `Preveliko: očekivano da ${origin ?? "vrijednost"} bude ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
const origin = TypeDictionary[issue.origin] ?? issue.origin;
if (sizing) return `Premalo: očekivano da ${origin} ima ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Premalo: očekivano da ${origin} bude ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Neispravan tekst: mora započinjati s "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Neispravan tekst: mora završavati s "${_issue.suffix}"`;
if (_issue.format === "includes") return `Neispravan tekst: mora sadržavati "${_issue.includes}"`;
if (_issue.format === "regex") return `Neispravan tekst: mora odgovarati uzorku ${_issue.pattern}`;
return `Neispravna ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Neispravan broj: mora biti višekratnik od ${issue.divisor}`;
case "unrecognized_keys": return `Neprepoznat${issue.keys.length > 1 ? "i ključevi" : " ključ"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Neispravan ključ u ${TypeDictionary[issue.origin] ?? issue.origin}`;
case "invalid_union": return "Neispravan unos";
case "invalid_element": return `Neispravna vrijednost u ${TypeDictionary[issue.origin] ?? issue.origin}`;
default: return `Neispravan unos`;
}
};
};
function hr_default() {
return { localeError: error$32() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/hu.js
const error$31 = () => {
const Sizable = {
string: {
unit: "karakter",
verb: "legyen"
},
file: {
unit: "byte",
verb: "legyen"
},
array: {
unit: "elem",
verb: "legyen"
},
set: {
unit: "elem",
verb: "legyen"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "bemenet",
email: "email cím",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO időbélyeg",
date: "ISO dátum",
time: "ISO idő",
duration: "ISO időintervallum",
ipv4: "IPv4 cím",
ipv6: "IPv6 cím",
cidrv4: "IPv4 tartomány",
cidrv6: "IPv6 tartomány",
base64: "base64-kódolt string",
base64url: "base64url-kódolt string",
json_string: "JSON string",
e164: "E.164 szám",
jwt: "JWT",
template_literal: "bemenet"
};
const TypeDictionary = {
nan: "NaN",
number: "szám",
array: "tömb"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Érvénytelen bemenet: a várt érték instanceof ${issue.expected}, a kapott érték ${received}`;
return `Érvénytelen bemenet: a várt érték ${expected}, a kapott érték ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Érvénytelen bemenet: a várt érték ${stringifyPrimitive(issue.values[0])}`;
return `Érvénytelen opció: valamelyik érték várt ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Túl nagy: ${issue.origin ?? "érték"} mérete túl nagy ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elem"}`;
return `Túl nagy: a bemeneti érték ${issue.origin ?? "érték"} túl nagy: ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Túl kicsi: a bemeneti érték ${issue.origin} mérete túl kicsi ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Túl kicsi: a bemeneti érték ${issue.origin} túl kicsi ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Érvénytelen string: "${_issue.prefix}" értékkel kell kezdődnie`;
if (_issue.format === "ends_with") return `Érvénytelen string: "${_issue.suffix}" értékkel kell végződnie`;
if (_issue.format === "includes") return `Érvénytelen string: "${_issue.includes}" értéket kell tartalmaznia`;
if (_issue.format === "regex") return `Érvénytelen string: ${_issue.pattern} mintának kell megfelelnie`;
return `Érvénytelen ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Érvénytelen szám: ${issue.divisor} többszörösének kell lennie`;
case "unrecognized_keys": return `Ismeretlen kulcs${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Érvénytelen kulcs ${issue.origin}`;
case "invalid_union": return "Érvénytelen bemenet";
case "invalid_element": return `Érvénytelen érték: ${issue.origin}`;
default: return `Érvénytelen bemenet`;
}
};
};
function hu_default() {
return { localeError: error$31() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/hy.js
function getArmenianPlural(count, one, many) {
return Math.abs(count) === 1 ? one : many;
}
function withDefiniteArticle(word) {
if (!word) return "";
const vowels = [
"ա",
"ե",
"ը",
"ի",
"ո",
"ու",
"օ"
];
const lastChar = word[word.length - 1];
return word + (vowels.includes(lastChar) ? "ն" : "ը");
}
const error$30 = () => {
const Sizable = {
string: {
unit: {
one: "նշան",
many: "նշաններ"
},
verb: "ունենալ"
},
file: {
unit: {
one: "բայթ",
many: "բայթեր"
},
verb: "ունենալ"
},
array: {
unit: {
one: "տարր",
many: "տարրեր"
},
verb: "ունենալ"
},
set: {
unit: {
one: "տարր",
many: "տարրեր"
},
verb: "ունենալ"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "մուտք",
email: "էլ. հասցե",
url: "URL",
emoji: "էմոջի",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO ամսաթիվ և ժամ",
date: "ISO ամսաթիվ",
time: "ISO ժամ",
duration: "ISO տևողություն",
ipv4: "IPv4 հասցե",
ipv6: "IPv6 հասցե",
cidrv4: "IPv4 միջակայք",
cidrv6: "IPv6 միջակայք",
base64: "base64 ձևաչափով տող",
base64url: "base64url ձևաչափով տող",
json_string: "JSON տող",
e164: "E.164 համար",
jwt: "JWT",
template_literal: "մուտք"
};
const TypeDictionary = {
nan: "NaN",
number: "թիվ",
array: "զանգված"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Սխալ մուտքագրում․ սպասվում էր instanceof ${issue.expected}, ստացվել է ${received}`;
return `Սխալ մուտքագրում․ սպասվում էր ${expected}, ստացվել է ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Սխալ մուտքագրում․ սպասվում էր ${stringifyPrimitive(issue.values[1])}`;
return `Սխալ տարբերակ․ սպասվում էր հետևյալներից մեկը՝ ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) {
const unit = getArmenianPlural(Number(issue.maximum), sizing.unit.one, sizing.unit.many);
return `Չափազանց մեծ արժեք․ սպասվում է, որ ${withDefiniteArticle(issue.origin ?? "արժեք")} կունենա ${adj}${issue.maximum.toString()} ${unit}`;
}
return `Չափազանց մեծ արժեք․ սպասվում է, որ ${withDefiniteArticle(issue.origin ?? "արժեք")} լինի ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) {
const unit = getArmenianPlural(Number(issue.minimum), sizing.unit.one, sizing.unit.many);
return `Չափազանց փոքր արժեք․ սպասվում է, որ ${withDefiniteArticle(issue.origin)} կունենա ${adj}${issue.minimum.toString()} ${unit}`;
}
return `Չափազանց փոքր արժեք․ սպասվում է, որ ${withDefiniteArticle(issue.origin)} լինի ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Սխալ տող․ պետք է սկսվի "${_issue.prefix}"-ով`;
if (_issue.format === "ends_with") return `Սխալ տող․ պետք է ավարտվի "${_issue.suffix}"-ով`;
if (_issue.format === "includes") return `Սխալ տող․ պետք է պարունակի "${_issue.includes}"`;
if (_issue.format === "regex") return `Սխալ տող․ պետք է համապատասխանի ${_issue.pattern} ձևաչափին`;
return `Սխալ ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Սխալ թիվ․ պետք է բազմապատիկ լինի ${issue.divisor}-ի`;
case "unrecognized_keys": return `Չճանաչված բանալի${issue.keys.length > 1 ? "ներ" : ""}. ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Սխալ բանալի ${withDefiniteArticle(issue.origin)}-ում`;
case "invalid_union": return "Սխալ մուտքագրում";
case "invalid_element": return `Սխալ արժեք ${withDefiniteArticle(issue.origin)}-ում`;
default: return `Սխալ մուտքագրում`;
}
};
};
function hy_default() {
return { localeError: error$30() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/id.js
const error$29 = () => {
const Sizable = {
string: {
unit: "karakter",
verb: "memiliki"
},
file: {
unit: "byte",
verb: "memiliki"
},
array: {
unit: "item",
verb: "memiliki"
},
set: {
unit: "item",
verb: "memiliki"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "input",
email: "alamat email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "tanggal dan waktu format ISO",
date: "tanggal format ISO",
time: "jam format ISO",
duration: "durasi format ISO",
ipv4: "alamat IPv4",
ipv6: "alamat IPv6",
cidrv4: "rentang alamat IPv4",
cidrv6: "rentang alamat IPv6",
base64: "string dengan enkode base64",
base64url: "string dengan enkode base64url",
json_string: "string JSON",
e164: "angka E.164",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Input tidak valid: diharapkan instanceof ${issue.expected}, diterima ${received}`;
return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Input tidak valid: diharapkan ${stringifyPrimitive(issue.values[0])}`;
return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Terlalu besar: diharapkan ${issue.origin ?? "value"} memiliki ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elemen"}`;
return `Terlalu besar: diharapkan ${issue.origin ?? "value"} menjadi ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Terlalu kecil: diharapkan ${issue.origin} memiliki ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Terlalu kecil: diharapkan ${issue.origin} menjadi ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `String tidak valid: harus dimulai dengan "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `String tidak valid: harus berakhir dengan "${_issue.suffix}"`;
if (_issue.format === "includes") return `String tidak valid: harus menyertakan "${_issue.includes}"`;
if (_issue.format === "regex") return `String tidak valid: harus sesuai pola ${_issue.pattern}`;
return `${FormatDictionary[_issue.format] ?? issue.format} tidak valid`;
}
case "not_multiple_of": return `Angka tidak valid: harus kelipatan dari ${issue.divisor}`;
case "unrecognized_keys": return `Kunci tidak dikenali ${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Kunci tidak valid di ${issue.origin}`;
case "invalid_union": return "Input tidak valid";
case "invalid_element": return `Nilai tidak valid di ${issue.origin}`;
default: return `Input tidak valid`;
}
};
};
function id_default() {
return { localeError: error$29() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/is.js
const error$28 = () => {
const Sizable = {
string: {
unit: "stafi",
verb: "að hafa"
},
file: {
unit: "bæti",
verb: "að hafa"
},
array: {
unit: "hluti",
verb: "að hafa"
},
set: {
unit: "hluti",
verb: "að hafa"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "gildi",
email: "netfang",
url: "vefslóð",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO dagsetning og tími",
date: "ISO dagsetning",
time: "ISO tími",
duration: "ISO tímalengd",
ipv4: "IPv4 address",
ipv6: "IPv6 address",
cidrv4: "IPv4 range",
cidrv6: "IPv6 range",
base64: "base64-encoded strengur",
base64url: "base64url-encoded strengur",
json_string: "JSON strengur",
e164: "E.164 tölugildi",
jwt: "JWT",
template_literal: "gildi"
};
const TypeDictionary = {
nan: "NaN",
number: "númer",
array: "fylki"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Rangt gildi: Þú slóst inn ${received} þar sem á að vera instanceof ${issue.expected}`;
return `Rangt gildi: Þú slóst inn ${received} þar sem á að vera ${expected}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Rangt gildi: gert ráð fyrir ${stringifyPrimitive(issue.values[0])}`;
return `Ógilt val: má vera eitt af eftirfarandi ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Of stórt: gert er ráð fyrir að ${issue.origin ?? "gildi"} hafi ${adj}${issue.maximum.toString()} ${sizing.unit ?? "hluti"}`;
return `Of stórt: gert er ráð fyrir að ${issue.origin ?? "gildi"} sé ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Of lítið: gert er ráð fyrir að ${issue.origin} hafi ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Of lítið: gert er ráð fyrir að ${issue.origin} sé ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Ógildur strengur: verður að byrja á "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Ógildur strengur: verður að enda á "${_issue.suffix}"`;
if (_issue.format === "includes") return `Ógildur strengur: verður að innihalda "${_issue.includes}"`;
if (_issue.format === "regex") return `Ógildur strengur: verður að fylgja mynstri ${_issue.pattern}`;
return `Rangt ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Röng tala: verður að vera margfeldi af ${issue.divisor}`;
case "unrecognized_keys": return `Óþekkt ${issue.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Rangur lykill í ${issue.origin}`;
case "invalid_union": return "Rangt gildi";
case "invalid_element": return `Rangt gildi í ${issue.origin}`;
default: return `Rangt gildi`;
}
};
};
function is_default() {
return { localeError: error$28() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/it.js
const error$27 = () => {
const Sizable = {
string: {
unit: "caratteri",
verb: "avere"
},
file: {
unit: "byte",
verb: "avere"
},
array: {
unit: "elementi",
verb: "avere"
},
set: {
unit: "elementi",
verb: "avere"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "input",
email: "indirizzo email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "data e ora ISO",
date: "data ISO",
time: "ora ISO",
duration: "durata ISO",
ipv4: "indirizzo IPv4",
ipv6: "indirizzo IPv6",
cidrv4: "intervallo IPv4",
cidrv6: "intervallo IPv6",
base64: "stringa codificata in base64",
base64url: "URL codificata in base64",
json_string: "stringa JSON",
e164: "numero E.164",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = {
nan: "NaN",
number: "numero",
array: "vettore"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Input non valido: atteso instanceof ${issue.expected}, ricevuto ${received}`;
return `Input non valido: atteso ${expected}, ricevuto ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Input non valido: atteso ${stringifyPrimitive(issue.values[0])}`;
return `Opzione non valida: atteso uno tra ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Troppo grande: ${issue.origin ?? "valore"} deve avere ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementi"}`;
return `Troppo grande: ${issue.origin ?? "valore"} deve essere ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Troppo piccolo: ${issue.origin} deve avere ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Troppo piccolo: ${issue.origin} deve essere ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Stringa non valida: deve iniziare con "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Stringa non valida: deve terminare con "${_issue.suffix}"`;
if (_issue.format === "includes") return `Stringa non valida: deve includere "${_issue.includes}"`;
if (_issue.format === "regex") return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
return `Input non valido: ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Numero non valido: deve essere un multiplo di ${issue.divisor}`;
case "unrecognized_keys": return `Chiav${issue.keys.length > 1 ? "i" : "e"} non riconosciut${issue.keys.length > 1 ? "e" : "a"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Chiave non valida in ${issue.origin}`;
case "invalid_union": return "Input non valido";
case "invalid_element": return `Valore non valido in ${issue.origin}`;
default: return `Input non valido`;
}
};
};
function it_default() {
return { localeError: error$27() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ja.js
const error$26 = () => {
const Sizable = {
string: {
unit: "文字",
verb: "である"
},
file: {
unit: "バイト",
verb: "である"
},
array: {
unit: "要素",
verb: "である"
},
set: {
unit: "要素",
verb: "である"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "入力値",
email: "メールアドレス",
url: "URL",
emoji: "絵文字",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO日時",
date: "ISO日付",
time: "ISO時刻",
duration: "ISO期間",
ipv4: "IPv4アドレス",
ipv6: "IPv6アドレス",
cidrv4: "IPv4範囲",
cidrv6: "IPv6範囲",
base64: "base64エンコード文字列",
base64url: "base64urlエンコード文字列",
json_string: "JSON文字列",
e164: "E.164番号",
jwt: "JWT",
template_literal: "入力値"
};
const TypeDictionary = {
nan: "NaN",
number: "数値",
array: "配列"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `無効な入力: instanceof ${issue.expected}が期待されましたが、${received}が入力されました`;
return `無効な入力: ${expected}が期待されましたが、${received}が入力されました`;
}
case "invalid_value":
if (issue.values.length === 1) return `無効な入力: ${stringifyPrimitive(issue.values[0])}が期待されました`;
return `無効な選択: ${joinValues(issue.values, "、")}のいずれかである必要があります`;
case "too_big": {
const adj = issue.inclusive ? "以下である" : "より小さい";
const sizing = getSizing(issue.origin);
if (sizing) return `大きすぎる値: ${issue.origin ?? "値"}は${issue.maximum.toString()}${sizing.unit ?? "要素"}${adj}必要があります`;
return `大きすぎる値: ${issue.origin ?? "値"}は${issue.maximum.toString()}${adj}必要があります`;
}
case "too_small": {
const adj = issue.inclusive ? "以上である" : "より大きい";
const sizing = getSizing(issue.origin);
if (sizing) return `小さすぎる値: ${issue.origin}は${issue.minimum.toString()}${sizing.unit}${adj}必要があります`;
return `小さすぎる値: ${issue.origin}は${issue.minimum.toString()}${adj}必要があります`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `無効な文字列: "${_issue.prefix}"で始まる必要があります`;
if (_issue.format === "ends_with") return `無効な文字列: "${_issue.suffix}"で終わる必要があります`;
if (_issue.format === "includes") return `無効な文字列: "${_issue.includes}"を含む必要があります`;
if (_issue.format === "regex") return `無効な文字列: パターン${_issue.pattern}に一致する必要があります`;
return `無効な${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `無効な数値: ${issue.divisor}の倍数である必要があります`;
case "unrecognized_keys": return `認識されていないキー${issue.keys.length > 1 ? "群" : ""}: ${joinValues(issue.keys, "、")}`;
case "invalid_key": return `${issue.origin}内の無効なキー`;
case "invalid_union": return "無効な入力";
case "invalid_element": return `${issue.origin}内の無効な値`;
default: return `無効な入力`;
}
};
};
function ja_default() {
return { localeError: error$26() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ka.js
const error$25 = () => {
const Sizable = {
string: {
unit: "სიმბოლო",
verb: "უნდა შეიცავდეს"
},
file: {
unit: "ბაიტი",
verb: "უნდა შეიცავდეს"
},
array: {
unit: "ელემენტი",
verb: "უნდა შეიცავდეს"
},
set: {
unit: "ელემენტი",
verb: "უნდა შეიცავდეს"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "შეყვანა",
email: "ელ-ფოსტის მისამართი",
url: "URL",
emoji: "ემოჯი",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "თარიღი-დრო",
date: "თარიღი",
time: "დრო",
duration: "ხანგრძლივობა",
ipv4: "IPv4 მისამართი",
ipv6: "IPv6 მისამართი",
cidrv4: "IPv4 დიაპაზონი",
cidrv6: "IPv6 დიაპაზონი",
base64: "base64-კოდირებული ველი",
base64url: "base64url-კოდირებული ველი",
json_string: "JSON ველი",
e164: "E.164 ნომერი",
jwt: "JWT",
template_literal: "შეყვანა"
};
const TypeDictionary = {
nan: "NaN",
number: "რიცხვი",
string: "ველი",
boolean: "ბულეანი",
function: "ფუნქცია",
array: "მასივი"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `არასწორი შეყვანა: მოსალოდნელი instanceof ${issue.expected}, მიღებული ${received}`;
return `არასწორი შეყვანა: მოსალოდნელი ${expected}, მიღებული ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `არასწორი შეყვანა: მოსალოდნელი ${stringifyPrimitive(issue.values[0])}`;
return `არასწორი ვარიანტი: მოსალოდნელია ერთ-ერთი ${joinValues(issue.values, "|")}-დან`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `ზედმეტად დიდი: მოსალოდნელი ${issue.origin ?? "მნიშვნელობა"} ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit}`;
return `ზედმეტად დიდი: მოსალოდნელი ${issue.origin ?? "მნიშვნელობა"} იყოს ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `ზედმეტად პატარა: მოსალოდნელი ${issue.origin} ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `ზედმეტად პატარა: მოსალოდნელი ${issue.origin} იყოს ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `არასწორი ველი: უნდა იწყებოდეს "${_issue.prefix}"-ით`;
if (_issue.format === "ends_with") return `არასწორი ველი: უნდა მთავრდებოდეს "${_issue.suffix}"-ით`;
if (_issue.format === "includes") return `არასწორი ველი: უნდა შეიცავდეს "${_issue.includes}"-ს`;
if (_issue.format === "regex") return `არასწორი ველი: უნდა შეესაბამებოდეს შაბლონს ${_issue.pattern}`;
return `არასწორი ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `არასწორი რიცხვი: უნდა იყოს ${issue.divisor}-ის ჯერადი`;
case "unrecognized_keys": return `უცნობი გასაღებ${issue.keys.length > 1 ? "ები" : "ი"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `არასწორი გასაღები ${issue.origin}-ში`;
case "invalid_union": return "არასწორი შეყვანა";
case "invalid_element": return `არასწორი მნიშვნელობა ${issue.origin}-ში`;
default: return `არასწორი შეყვანა`;
}
};
};
function ka_default() {
return { localeError: error$25() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/km.js
const error$24 = () => {
const Sizable = {
string: {
unit: "តួអក្សរ",
verb: "គួរមាន"
},
file: {
unit: "បៃ",
verb: "គួរមាន"
},
array: {
unit: "ធាតុ",
verb: "គួរមាន"
},
set: {
unit: "ធាតុ",
verb: "គួរមាន"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ទិន្នន័យបញ្ចូល",
email: "អាសយដ្ឋានអ៊ីមែល",
url: "URL",
emoji: "សញ្ញាអារម្មណ៍",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "កាលបរិច្ឆេទ និងម៉ោង ISO",
date: "កាលបរិច្ឆេទ ISO",
time: "ម៉ោង ISO",
duration: "រយៈពេល ISO",
ipv4: "អាសយដ្ឋាន IPv4",
ipv6: "អាសយដ្ឋាន IPv6",
cidrv4: "ដែនអាសយដ្ឋាន IPv4",
cidrv6: "ដែនអាសយដ្ឋាន IPv6",
base64: "ខ្សែអក្សរអ៊ិកូដ base64",
base64url: "ខ្សែអក្សរអ៊ិកូដ base64url",
json_string: "ខ្សែអក្សរ JSON",
e164: "លេខ E.164",
jwt: "JWT",
template_literal: "ទិន្នន័យបញ្ចូល"
};
const TypeDictionary = {
nan: "NaN",
number: "លេខ",
array: "អារេ (Array)",
null: "គ្មានតម្លៃ (null)"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `ទិន្នន័យបញ្ចូលមិនត្រឹមត្រូវ៖ ត្រូវការ instanceof ${issue.expected} ប៉ុន្តែទទួលបាន ${received}`;
return `ទិន្នន័យបញ្ចូលមិនត្រឹមត្រូវ៖ ត្រូវការ ${expected} ប៉ុន្តែទទួលបាន ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `ទិន្នន័យបញ្ចូលមិនត្រឹមត្រូវ៖ ត្រូវការ ${stringifyPrimitive(issue.values[0])}`;
return `ជម្រើសមិនត្រឹមត្រូវ៖ ត្រូវជាមួយក្នុងចំណោម ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `ធំពេក៖ ត្រូវការ ${issue.origin ?? "តម្លៃ"} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "ធាតុ"}`;
return `ធំពេក៖ ត្រូវការ ${issue.origin ?? "តម្លៃ"} ${adj} ${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `តូចពេក៖ ត្រូវការ ${issue.origin} ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
return `តូចពេក៖ ត្រូវការ ${issue.origin} ${adj} ${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `ខ្សែអក្សរមិនត្រឹមត្រូវ៖ ត្រូវចាប់ផ្តើមដោយ "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `ខ្សែអក្សរមិនត្រឹមត្រូវ៖ ត្រូវបញ្ចប់ដោយ "${_issue.suffix}"`;
if (_issue.format === "includes") return `ខ្សែអក្សរមិនត្រឹមត្រូវ៖ ត្រូវមាន "${_issue.includes}"`;
if (_issue.format === "regex") return `ខ្សែអក្សរមិនត្រឹមត្រូវ៖ ត្រូវតែផ្គូផ្គងនឹងទម្រង់ដែលបានកំណត់ ${_issue.pattern}`;
return `មិនត្រឹមត្រូវ៖ ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `លេខមិនត្រឹមត្រូវ៖ ត្រូវតែជាពហុគុណនៃ ${issue.divisor}`;
case "unrecognized_keys": return `រកឃើញសោមិនស្គាល់៖ ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `សោមិនត្រឹមត្រូវនៅក្នុង ${issue.origin}`;
case "invalid_union": return `ទិន្នន័យមិនត្រឹមត្រូវ`;
case "invalid_element": return `ទិន្នន័យមិនត្រឹមត្រូវនៅក្នុង ${issue.origin}`;
default: return `ទិន្នន័យមិនត្រឹមត្រូវ`;
}
};
};
function km_default() {
return { localeError: error$24() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/kh.js
/** @deprecated Use `km` instead. */
function kh_default() {
return km_default();
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ko.js
const error$23 = () => {
const Sizable = {
string: {
unit: "문자",
verb: "to have"
},
file: {
unit: "바이트",
verb: "to have"
},
array: {
unit: "개",
verb: "to have"
},
set: {
unit: "개",
verb: "to have"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "입력",
email: "이메일 주소",
url: "URL",
emoji: "이모지",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO 날짜시간",
date: "ISO 날짜",
time: "ISO 시간",
duration: "ISO 기간",
ipv4: "IPv4 주소",
ipv6: "IPv6 주소",
cidrv4: "IPv4 범위",
cidrv6: "IPv6 범위",
base64: "base64 인코딩 문자열",
base64url: "base64url 인코딩 문자열",
json_string: "JSON 문자열",
e164: "E.164 번호",
jwt: "JWT",
template_literal: "입력"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `잘못된 입력: 예상 타입은 instanceof ${issue.expected}, 받은 타입은 ${received}입니다`;
return `잘못된 입력: 예상 타입은 ${expected}, 받은 타입은 ${received}입니다`;
}
case "invalid_value":
if (issue.values.length === 1) return `잘못된 입력: 값은 ${stringifyPrimitive(issue.values[0])} 이어야 합니다`;
return `잘못된 옵션: ${joinValues(issue.values, "또는 ")} 중 하나여야 합니다`;
case "too_big": {
const adj = issue.inclusive ? "이하" : "미만";
const suffix = adj === "미만" ? "이어야 합니다" : "여야 합니다";
const sizing = getSizing(issue.origin);
const unit = sizing?.unit ?? "요소";
if (sizing) return `${issue.origin ?? "값"}이 너무 큽니다: ${issue.maximum.toString()}${unit} ${adj}${suffix}`;
return `${issue.origin ?? "값"}이 너무 큽니다: ${issue.maximum.toString()} ${adj}${suffix}`;
}
case "too_small": {
const adj = issue.inclusive ? "이상" : "초과";
const suffix = adj === "이상" ? "이어야 합니다" : "여야 합니다";
const sizing = getSizing(issue.origin);
const unit = sizing?.unit ?? "요소";
if (sizing) return `${issue.origin ?? "값"}이 너무 작습니다: ${issue.minimum.toString()}${unit} ${adj}${suffix}`;
return `${issue.origin ?? "값"}이 너무 작습니다: ${issue.minimum.toString()} ${adj}${suffix}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `잘못된 문자열: "${_issue.prefix}"(으)로 시작해야 합니다`;
if (_issue.format === "ends_with") return `잘못된 문자열: "${_issue.suffix}"(으)로 끝나야 합니다`;
if (_issue.format === "includes") return `잘못된 문자열: "${_issue.includes}"을(를) 포함해야 합니다`;
if (_issue.format === "regex") return `잘못된 문자열: 정규식 ${_issue.pattern} 패턴과 일치해야 합니다`;
return `잘못된 ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `잘못된 숫자: ${issue.divisor}의 배수여야 합니다`;
case "unrecognized_keys": return `인식할 수 없는 키: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `잘못된 키: ${issue.origin}`;
case "invalid_union": return `잘못된 입력`;
case "invalid_element": return `잘못된 값: ${issue.origin}`;
default: return `잘못된 입력`;
}
};
};
function ko_default() {
return { localeError: error$23() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/lt.js
const capitalizeFirstCharacter = (text) => {
return text.charAt(0).toUpperCase() + text.slice(1);
};
function getUnitTypeFromNumber(number) {
const abs = Math.abs(number);
const last = abs % 10;
const last2 = abs % 100;
if (last2 >= 11 && last2 <= 19 || last === 0) return "many";
if (last === 1) return "one";
return "few";
}
const error$22 = () => {
const Sizable = {
string: {
unit: {
one: "simbolis",
few: "simboliai",
many: "simbolių"
},
verb: {
smaller: {
inclusive: "turi būti ne ilgesnė kaip",
notInclusive: "turi būti trumpesnė kaip"
},
bigger: {
inclusive: "turi būti ne trumpesnė kaip",
notInclusive: "turi būti ilgesnė kaip"
}
}
},
file: {
unit: {
one: "baitas",
few: "baitai",
many: "baitų"
},
verb: {
smaller: {
inclusive: "turi būti ne didesnis kaip",
notInclusive: "turi būti mažesnis kaip"
},
bigger: {
inclusive: "turi būti ne mažesnis kaip",
notInclusive: "turi būti didesnis kaip"
}
}
},
array: {
unit: {
one: "elementą",
few: "elementus",
many: "elementų"
},
verb: {
smaller: {
inclusive: "turi turėti ne daugiau kaip",
notInclusive: "turi turėti mažiau kaip"
},
bigger: {
inclusive: "turi turėti ne mažiau kaip",
notInclusive: "turi turėti daugiau kaip"
}
}
},
set: {
unit: {
one: "elementą",
few: "elementus",
many: "elementų"
},
verb: {
smaller: {
inclusive: "turi turėti ne daugiau kaip",
notInclusive: "turi turėti mažiau kaip"
},
bigger: {
inclusive: "turi turėti ne mažiau kaip",
notInclusive: "turi turėti daugiau kaip"
}
}
}
};
function getSizing(origin, unitType, inclusive, targetShouldBe) {
const result = Sizable[origin] ?? null;
if (result === null) return result;
return {
unit: result.unit[unitType],
verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
};
}
const FormatDictionary = {
regex: "įvestis",
email: "el. pašto adresas",
url: "URL",
emoji: "jaustukas",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO data ir laikas",
date: "ISO data",
time: "ISO laikas",
duration: "ISO trukmė",
ipv4: "IPv4 adresas",
ipv6: "IPv6 adresas",
cidrv4: "IPv4 tinklo prefiksas (CIDR)",
cidrv6: "IPv6 tinklo prefiksas (CIDR)",
base64: "base64 užkoduota eilutė",
base64url: "base64url užkoduota eilutė",
json_string: "JSON eilutė",
e164: "E.164 numeris",
jwt: "JWT",
template_literal: "įvestis"
};
const TypeDictionary = {
nan: "NaN",
number: "skaičius",
bigint: "sveikasis skaičius",
string: "eilutė",
boolean: "loginė reikšmė",
undefined: "neapibrėžta reikšmė",
function: "funkcija",
symbol: "simbolis",
array: "masyvas",
object: "objektas",
null: "nulinė reikšmė"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Gautas tipas ${received}, o tikėtasi - instanceof ${issue.expected}`;
return `Gautas tipas ${received}, o tikėtasi - ${expected}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Privalo būti ${stringifyPrimitive(issue.values[0])}`;
return `Privalo būti vienas iš ${joinValues(issue.values, "|")} pasirinkimų`;
case "too_big": {
const origin = TypeDictionary[issue.origin] ?? issue.origin;
const sizing = getSizing(issue.origin, getUnitTypeFromNumber(Number(issue.maximum)), issue.inclusive ?? false, "smaller");
if (sizing?.verb) return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} ${sizing.verb} ${issue.maximum.toString()} ${sizing.unit ?? "elementų"}`;
const adj = issue.inclusive ? "ne didesnis kaip" : "mažesnis kaip";
return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} turi būti ${adj} ${issue.maximum.toString()} ${sizing?.unit}`;
}
case "too_small": {
const origin = TypeDictionary[issue.origin] ?? issue.origin;
const sizing = getSizing(issue.origin, getUnitTypeFromNumber(Number(issue.minimum)), issue.inclusive ?? false, "bigger");
if (sizing?.verb) return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} ${sizing.verb} ${issue.minimum.toString()} ${sizing.unit ?? "elementų"}`;
const adj = issue.inclusive ? "ne mažesnis kaip" : "didesnis kaip";
return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} turi būti ${adj} ${issue.minimum.toString()} ${sizing?.unit}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Eilutė privalo prasidėti "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Eilutė privalo pasibaigti "${_issue.suffix}"`;
if (_issue.format === "includes") return `Eilutė privalo įtraukti "${_issue.includes}"`;
if (_issue.format === "regex") return `Eilutė privalo atitikti ${_issue.pattern}`;
return `Neteisingas ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Skaičius privalo būti ${issue.divisor} kartotinis.`;
case "unrecognized_keys": return `Neatpažint${issue.keys.length > 1 ? "i" : "as"} rakt${issue.keys.length > 1 ? "ai" : "as"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return "Rastas klaidingas raktas";
case "invalid_union": return "Klaidinga įvestis";
case "invalid_element": {
const origin = TypeDictionary[issue.origin] ?? issue.origin;
return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} turi klaidingą įvestį`;
}
default: return "Klaidinga įvestis";
}
};
};
function lt_default() {
return { localeError: error$22() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/mk.js
const error$21 = () => {
const Sizable = {
string: {
unit: "знаци",
verb: "да имаат"
},
file: {
unit: "бајти",
verb: "да имаат"
},
array: {
unit: "ставки",
verb: "да имаат"
},
set: {
unit: "ставки",
verb: "да имаат"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "внес",
email: "адреса на е-пошта",
url: "URL",
emoji: "емоџи",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO датум и време",
date: "ISO датум",
time: "ISO време",
duration: "ISO времетраење",
ipv4: "IPv4 адреса",
ipv6: "IPv6 адреса",
cidrv4: "IPv4 опсег",
cidrv6: "IPv6 опсег",
base64: "base64-енкодирана низа",
base64url: "base64url-енкодирана низа",
json_string: "JSON низа",
e164: "E.164 број",
jwt: "JWT",
template_literal: "внес"
};
const TypeDictionary = {
nan: "NaN",
number: "број",
array: "низа"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Грешен внес: се очекува instanceof ${issue.expected}, примено ${received}`;
return `Грешен внес: се очекува ${expected}, примено ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
return `Грешана опција: се очекува една ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Премногу голем: се очекува ${issue.origin ?? "вредноста"} да има ${adj}${issue.maximum.toString()} ${sizing.unit ?? "елементи"}`;
return `Премногу голем: се очекува ${issue.origin ?? "вредноста"} да биде ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Премногу мал: се очекува ${issue.origin} да има ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Премногу мал: се очекува ${issue.origin} да биде ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Неважечка низа: мора да започнува со "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Неважечка низа: мора да завршува со "${_issue.suffix}"`;
if (_issue.format === "includes") return `Неважечка низа: мора да вклучува "${_issue.includes}"`;
if (_issue.format === "regex") return `Неважечка низа: мора да одгоара на патернот ${_issue.pattern}`;
return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Грешен број: мора да биде делив со ${issue.divisor}`;
case "unrecognized_keys": return `${issue.keys.length > 1 ? "Непрепознаени клучеви" : "Непрепознаен клуч"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Грешен клуч во ${issue.origin}`;
case "invalid_union": return "Грешен внес";
case "invalid_element": return `Грешна вредност во ${issue.origin}`;
default: return `Грешен внес`;
}
};
};
function mk_default() {
return { localeError: error$21() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ms.js
const error$20 = () => {
const Sizable = {
string: {
unit: "aksara",
verb: "mempunyai"
},
file: {
unit: "bait",
verb: "mempunyai"
},
array: {
unit: "elemen",
verb: "mempunyai"
},
set: {
unit: "elemen",
verb: "mempunyai"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "input",
email: "alamat e-mel",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "tarikh masa ISO",
date: "tarikh ISO",
time: "masa ISO",
duration: "tempoh ISO",
ipv4: "alamat IPv4",
ipv6: "alamat IPv6",
cidrv4: "julat IPv4",
cidrv6: "julat IPv6",
base64: "string dikodkan base64",
base64url: "string dikodkan base64url",
json_string: "string JSON",
e164: "nombor E.164",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = {
nan: "NaN",
number: "nombor"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Input tidak sah: dijangka instanceof ${issue.expected}, diterima ${received}`;
return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Input tidak sah: dijangka ${stringifyPrimitive(issue.values[0])}`;
return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Terlalu besar: dijangka ${issue.origin ?? "nilai"} ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elemen"}`;
return `Terlalu besar: dijangka ${issue.origin ?? "nilai"} adalah ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Terlalu kecil: dijangka ${issue.origin} ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Terlalu kecil: dijangka ${issue.origin} adalah ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `String tidak sah: mesti bermula dengan "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `String tidak sah: mesti berakhir dengan "${_issue.suffix}"`;
if (_issue.format === "includes") return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
if (_issue.format === "regex") return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
return `${FormatDictionary[_issue.format] ?? issue.format} tidak sah`;
}
case "not_multiple_of": return `Nombor tidak sah: perlu gandaan ${issue.divisor}`;
case "unrecognized_keys": return `Kunci tidak dikenali: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Kunci tidak sah dalam ${issue.origin}`;
case "invalid_union": return "Input tidak sah";
case "invalid_element": return `Nilai tidak sah dalam ${issue.origin}`;
default: return `Input tidak sah`;
}
};
};
function ms_default() {
return { localeError: error$20() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/nl.js
const error$19 = () => {
const Sizable = {
string: {
unit: "tekens",
verb: "heeft"
},
file: {
unit: "bytes",
verb: "heeft"
},
array: {
unit: "elementen",
verb: "heeft"
},
set: {
unit: "elementen",
verb: "heeft"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "invoer",
email: "emailadres",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO datum en tijd",
date: "ISO datum",
time: "ISO tijd",
duration: "ISO duur",
ipv4: "IPv4-adres",
ipv6: "IPv6-adres",
cidrv4: "IPv4-bereik",
cidrv6: "IPv6-bereik",
base64: "base64-gecodeerde tekst",
base64url: "base64 URL-gecodeerde tekst",
json_string: "JSON string",
e164: "E.164-nummer",
jwt: "JWT",
template_literal: "invoer"
};
const TypeDictionary = {
nan: "NaN",
number: "getal"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Ongeldige invoer: verwacht instanceof ${issue.expected}, ontving ${received}`;
return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue.values[0])}`;
return `Ongeldige optie: verwacht één van ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
const longName = issue.origin === "date" ? "laat" : issue.origin === "string" ? "lang" : "groot";
if (sizing) return `Te ${longName}: verwacht dat ${issue.origin ?? "waarde"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementen"} ${sizing.verb}`;
return `Te ${longName}: verwacht dat ${issue.origin ?? "waarde"} ${adj}${issue.maximum.toString()} is`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
const shortName = issue.origin === "date" ? "vroeg" : issue.origin === "string" ? "kort" : "klein";
if (sizing) return `Te ${shortName}: verwacht dat ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
return `Te ${shortName}: verwacht dat ${issue.origin} ${adj}${issue.minimum.toString()} is`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Ongeldige tekst: moet met "${_issue.prefix}" beginnen`;
if (_issue.format === "ends_with") return `Ongeldige tekst: moet op "${_issue.suffix}" eindigen`;
if (_issue.format === "includes") return `Ongeldige tekst: moet "${_issue.includes}" bevatten`;
if (_issue.format === "regex") return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;
return `Ongeldig: ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Ongeldig getal: moet een veelvoud van ${issue.divisor} zijn`;
case "unrecognized_keys": return `Onbekende key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Ongeldige key in ${issue.origin}`;
case "invalid_union": return "Ongeldige invoer";
case "invalid_element": return `Ongeldige waarde in ${issue.origin}`;
default: return `Ongeldige invoer`;
}
};
};
function nl_default() {
return { localeError: error$19() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/no.js
const error$18 = () => {
const Sizable = {
string: {
unit: "tegn",
verb: "å ha"
},
file: {
unit: "bytes",
verb: "å ha"
},
array: {
unit: "elementer",
verb: "å inneholde"
},
set: {
unit: "elementer",
verb: "å inneholde"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "input",
email: "e-postadresse",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO dato- og klokkeslett",
date: "ISO-dato",
time: "ISO-klokkeslett",
duration: "ISO-varighet",
ipv4: "IPv4-område",
ipv6: "IPv6-område",
cidrv4: "IPv4-spekter",
cidrv6: "IPv6-spekter",
base64: "base64-enkodet streng",
base64url: "base64url-enkodet streng",
json_string: "JSON-streng",
e164: "E.164-nummer",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = {
nan: "NaN",
number: "tall",
array: "liste"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Ugyldig input: forventet instanceof ${issue.expected}, fikk ${received}`;
return `Ugyldig input: forventet ${expected}, fikk ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Ugyldig verdi: forventet ${stringifyPrimitive(issue.values[0])}`;
return `Ugyldig valg: forventet en av ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `For stor(t): forventet ${issue.origin ?? "value"} til å ha ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementer"}`;
return `For stor(t): forventet ${issue.origin ?? "value"} til å ha ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `For lite(n): forventet ${issue.origin} til å ha ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `For lite(n): forventet ${issue.origin} til å ha ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Ugyldig streng: må starte med "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Ugyldig streng: må ende med "${_issue.suffix}"`;
if (_issue.format === "includes") return `Ugyldig streng: må inneholde "${_issue.includes}"`;
if (_issue.format === "regex") return `Ugyldig streng: må matche mønsteret ${_issue.pattern}`;
return `Ugyldig ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Ugyldig tall: må være et multiplum av ${issue.divisor}`;
case "unrecognized_keys": return `${issue.keys.length > 1 ? "Ukjente nøkler" : "Ukjent nøkkel"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Ugyldig nøkkel i ${issue.origin}`;
case "invalid_union": return "Ugyldig input";
case "invalid_element": return `Ugyldig verdi i ${issue.origin}`;
default: return `Ugyldig input`;
}
};
};
function no_default() {
return { localeError: error$18() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ota.js
const error$17 = () => {
const Sizable = {
string: {
unit: "harf",
verb: "olmalıdır"
},
file: {
unit: "bayt",
verb: "olmalıdır"
},
array: {
unit: "unsur",
verb: "olmalıdır"
},
set: {
unit: "unsur",
verb: "olmalıdır"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "giren",
email: "epostagâh",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO hengâmı",
date: "ISO tarihi",
time: "ISO zamanı",
duration: "ISO müddeti",
ipv4: "IPv4 nişânı",
ipv6: "IPv6 nişânı",
cidrv4: "IPv4 menzili",
cidrv6: "IPv6 menzili",
base64: "base64-şifreli metin",
base64url: "base64url-şifreli metin",
json_string: "JSON metin",
e164: "E.164 sayısı",
jwt: "JWT",
template_literal: "giren"
};
const TypeDictionary = {
nan: "NaN",
number: "numara",
array: "saf",
null: "gayb"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Fâsit giren: umulan instanceof ${issue.expected}, alınan ${received}`;
return `Fâsit giren: umulan ${expected}, alınan ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Fâsit giren: umulan ${stringifyPrimitive(issue.values[0])}`;
return `Fâsit tercih: mûteberler ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Fazla büyük: ${issue.origin ?? "value"}, ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"} sahip olmalıydı.`;
return `Fazla büyük: ${issue.origin ?? "value"}, ${adj}${issue.maximum.toString()} olmalıydı.`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Fazla küçük: ${issue.origin}, ${adj}${issue.minimum.toString()} ${sizing.unit} sahip olmalıydı.`;
return `Fazla küçük: ${issue.origin}, ${adj}${issue.minimum.toString()} olmalıydı.`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Fâsit metin: "${_issue.prefix}" ile başlamalı.`;
if (_issue.format === "ends_with") return `Fâsit metin: "${_issue.suffix}" ile bitmeli.`;
if (_issue.format === "includes") return `Fâsit metin: "${_issue.includes}" ihtivâ etmeli.`;
if (_issue.format === "regex") return `Fâsit metin: ${_issue.pattern} nakşına uymalı.`;
return `Fâsit ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Fâsit sayı: ${issue.divisor} katı olmalıydı.`;
case "unrecognized_keys": return `Tanınmayan anahtar ${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `${issue.origin} için tanınmayan anahtar var.`;
case "invalid_union": return "Giren tanınamadı.";
case "invalid_element": return `${issue.origin} için tanınmayan kıymet var.`;
default: return `Kıymet tanınamadı.`;
}
};
};
function ota_default() {
return { localeError: error$17() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ps.js
const error$16 = () => {
const Sizable = {
string: {
unit: "توکي",
verb: "ولري"
},
file: {
unit: "بایټس",
verb: "ولري"
},
array: {
unit: "توکي",
verb: "ولري"
},
set: {
unit: "توکي",
verb: "ولري"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ورودي",
email: "بریښنالیک",
url: "یو آر ال",
emoji: "ایموجي",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "نیټه او وخت",
date: "نېټه",
time: "وخت",
duration: "موده",
ipv4: "د IPv4 پته",
ipv6: "د IPv6 پته",
cidrv4: "د IPv4 ساحه",
cidrv6: "د IPv6 ساحه",
base64: "base64-encoded متن",
base64url: "base64url-encoded متن",
json_string: "JSON متن",
e164: "د E.164 شمېره",
jwt: "JWT",
template_literal: "ورودي"
};
const TypeDictionary = {
nan: "NaN",
number: "عدد",
array: "ارې"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `ناسم ورودي: باید instanceof ${issue.expected} وای, مګر ${received} ترلاسه شو`;
return `ناسم ورودي: باید ${expected} وای, مګر ${received} ترلاسه شو`;
}
case "invalid_value":
if (issue.values.length === 1) return `ناسم ورودي: باید ${stringifyPrimitive(issue.values[0])} وای`;
return `ناسم انتخاب: باید یو له ${joinValues(issue.values, "|")} څخه وای`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `ډیر لوی: ${issue.origin ?? "ارزښت"} باید ${adj}${issue.maximum.toString()} ${sizing.unit ?? "عنصرونه"} ولري`;
return `ډیر لوی: ${issue.origin ?? "ارزښت"} باید ${adj}${issue.maximum.toString()} وي`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `ډیر کوچنی: ${issue.origin} باید ${adj}${issue.minimum.toString()} ${sizing.unit} ولري`;
return `ډیر کوچنی: ${issue.origin} باید ${adj}${issue.minimum.toString()} وي`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `ناسم متن: باید د "${_issue.prefix}" سره پیل شي`;
if (_issue.format === "ends_with") return `ناسم متن: باید د "${_issue.suffix}" سره پای ته ورسيږي`;
if (_issue.format === "includes") return `ناسم متن: باید "${_issue.includes}" ولري`;
if (_issue.format === "regex") return `ناسم متن: باید د ${_issue.pattern} سره مطابقت ولري`;
return `${FormatDictionary[_issue.format] ?? issue.format} ناسم دی`;
}
case "not_multiple_of": return `ناسم عدد: باید د ${issue.divisor} مضرب وي`;
case "unrecognized_keys": return `ناسم ${issue.keys.length > 1 ? "کلیډونه" : "کلیډ"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `ناسم کلیډ په ${issue.origin} کې`;
case "invalid_union": return `ناسمه ورودي`;
case "invalid_element": return `ناسم عنصر په ${issue.origin} کې`;
default: return `ناسمه ورودي`;
}
};
};
function ps_default() {
return { localeError: error$16() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/pl.js
const error$15 = () => {
const Sizable = {
string: {
unit: "znaków",
verb: "mieć"
},
file: {
unit: "bajtów",
verb: "mieć"
},
array: {
unit: "elementów",
verb: "mieć"
},
set: {
unit: "elementów",
verb: "mieć"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "wyrażenie",
email: "adres email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "data i godzina w formacie ISO",
date: "data w formacie ISO",
time: "godzina w formacie ISO",
duration: "czas trwania ISO",
ipv4: "adres IPv4",
ipv6: "adres IPv6",
cidrv4: "zakres IPv4",
cidrv6: "zakres IPv6",
base64: "ciąg znaków zakodowany w formacie base64",
base64url: "ciąg znaków zakodowany w formacie base64url",
json_string: "ciąg znaków w formacie JSON",
e164: "liczba E.164",
jwt: "JWT",
template_literal: "wejście"
};
const TypeDictionary = {
nan: "NaN",
number: "liczba",
array: "tablica"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Nieprawidłowe dane wejściowe: oczekiwano instanceof ${issue.expected}, otrzymano ${received}`;
return `Nieprawidłowe dane wejściowe: oczekiwano ${expected}, otrzymano ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Nieprawidłowe dane wejściowe: oczekiwano ${stringifyPrimitive(issue.values[0])}`;
return `Nieprawidłowa opcja: oczekiwano jednej z wartości ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Za duża wartość: oczekiwano, że ${issue.origin ?? "wartość"} będzie mieć ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementów"}`;
return `Zbyt duż(y/a/e): oczekiwano, że ${issue.origin ?? "wartość"} będzie wynosić ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Za mała wartość: oczekiwano, że ${issue.origin ?? "wartość"} będzie mieć ${adj}${issue.minimum.toString()} ${sizing.unit ?? "elementów"}`;
return `Zbyt mał(y/a/e): oczekiwano, że ${issue.origin ?? "wartość"} będzie wynosić ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Nieprawidłowy ciąg znaków: musi zaczynać się od "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Nieprawidłowy ciąg znaków: musi kończyć się na "${_issue.suffix}"`;
if (_issue.format === "includes") return `Nieprawidłowy ciąg znaków: musi zawierać "${_issue.includes}"`;
if (_issue.format === "regex") return `Nieprawidłowy ciąg znaków: musi odpowiadać wzorcowi ${_issue.pattern}`;
return `Nieprawidłow(y/a/e) ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Nieprawidłowa liczba: musi być wielokrotnością ${issue.divisor}`;
case "unrecognized_keys": return `Nierozpoznane klucze${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Nieprawidłowy klucz w ${issue.origin}`;
case "invalid_union": return "Nieprawidłowe dane wejściowe";
case "invalid_element": return `Nieprawidłowa wartość w ${issue.origin}`;
default: return `Nieprawidłowe dane wejściowe`;
}
};
};
function pl_default() {
return { localeError: error$15() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/pt.js
const error$14 = () => {
const Sizable = {
string: {
unit: "caracteres",
verb: "ter"
},
file: {
unit: "bytes",
verb: "ter"
},
array: {
unit: "itens",
verb: "ter"
},
set: {
unit: "itens",
verb: "ter"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "padrão",
email: "endereço de e-mail",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "data e hora ISO",
date: "data ISO",
time: "hora ISO",
duration: "duração ISO",
ipv4: "endereço IPv4",
ipv6: "endereço IPv6",
cidrv4: "faixa de IPv4",
cidrv6: "faixa de IPv6",
base64: "texto codificado em base64",
base64url: "URL codificada em base64",
json_string: "texto JSON",
e164: "número E.164",
jwt: "JWT",
template_literal: "entrada"
};
const TypeDictionary = {
nan: "NaN",
number: "número",
null: "nulo"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Tipo inválido: esperado instanceof ${issue.expected}, recebido ${received}`;
return `Tipo inválido: esperado ${expected}, recebido ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Entrada inválida: esperado ${stringifyPrimitive(issue.values[0])}`;
return `Opção inválida: esperada uma das ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Muito grande: esperado que ${issue.origin ?? "valor"} tivesse ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementos"}`;
return `Muito grande: esperado que ${issue.origin ?? "valor"} fosse ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Muito pequeno: esperado que ${issue.origin} tivesse ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Muito pequeno: esperado que ${issue.origin} fosse ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Texto inválido: deve começar com "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Texto inválido: deve terminar com "${_issue.suffix}"`;
if (_issue.format === "includes") return `Texto inválido: deve incluir "${_issue.includes}"`;
if (_issue.format === "regex") return `Texto inválido: deve corresponder ao padrão ${_issue.pattern}`;
return `${FormatDictionary[_issue.format] ?? issue.format} inválido`;
}
case "not_multiple_of": return `Número inválido: deve ser múltiplo de ${issue.divisor}`;
case "unrecognized_keys": return `Chave${issue.keys.length > 1 ? "s" : ""} desconhecida${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Chave inválida em ${issue.origin}`;
case "invalid_union": return "Entrada inválida";
case "invalid_element": return `Valor inválido em ${issue.origin}`;
default: return `Campo inválido`;
}
};
};
function pt_default() {
return { localeError: error$14() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ro.js
const error$13 = () => {
const Sizable = {
string: {
unit: "caractere",
verb: "să aibă"
},
file: {
unit: "octeți",
verb: "să aibă"
},
array: {
unit: "elemente",
verb: "să aibă"
},
set: {
unit: "elemente",
verb: "să aibă"
},
map: {
unit: "intrări",
verb: "să aibă"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "intrare",
email: "adresă de email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "dată și oră ISO",
date: "dată ISO",
time: "oră ISO",
duration: "durată ISO",
ipv4: "adresă IPv4",
ipv6: "adresă IPv6",
mac: "adresă MAC",
cidrv4: "interval IPv4",
cidrv6: "interval IPv6",
base64: "șir codat base64",
base64url: "șir codat base64url",
json_string: "șir JSON",
e164: "număr E.164",
jwt: "JWT",
template_literal: "intrare"
};
const TypeDictionary = {
nan: "NaN",
string: "șir",
number: "număr",
boolean: "boolean",
function: "funcție",
array: "matrice",
object: "obiect",
undefined: "nedefinit",
symbol: "simbol",
bigint: "număr mare",
void: "void",
never: "never",
map: "hartă",
set: "set"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
return `Intrare invalidă: așteptat ${expected}, primit ${TypeDictionary[receivedType] ?? receivedType}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Intrare invalidă: așteptat ${stringifyPrimitive(issue.values[0])}`;
return `Opțiune invalidă: așteptat una dintre ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Prea mare: așteptat ca ${issue.origin ?? "valoarea"} ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elemente"}`;
return `Prea mare: așteptat ca ${issue.origin ?? "valoarea"} să fie ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Prea mic: așteptat ca ${issue.origin} ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Prea mic: așteptat ca ${issue.origin} să fie ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Șir invalid: trebuie să înceapă cu "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Șir invalid: trebuie să se termine cu "${_issue.suffix}"`;
if (_issue.format === "includes") return `Șir invalid: trebuie să includă "${_issue.includes}"`;
if (_issue.format === "regex") return `Șir invalid: trebuie să se potrivească cu modelul ${_issue.pattern}`;
return `Format invalid: ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Număr invalid: trebuie să fie multiplu de ${issue.divisor}`;
case "unrecognized_keys": return `Chei nerecunoscute: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Cheie invalidă în ${issue.origin}`;
case "invalid_union": return "Intrare invalidă";
case "invalid_element": return `Valoare invalidă în ${issue.origin}`;
default: return `Intrare invalidă`;
}
};
};
function ro_default() {
return { localeError: error$13() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ru.js
function getRussianPlural(count, one, few, many) {
const absCount = Math.abs(count);
const lastDigit = absCount % 10;
const lastTwoDigits = absCount % 100;
if (lastTwoDigits >= 11 && lastTwoDigits <= 19) return many;
if (lastDigit === 1) return one;
if (lastDigit >= 2 && lastDigit <= 4) return few;
return many;
}
const error$12 = () => {
const Sizable = {
string: {
unit: {
one: "символ",
few: "символа",
many: "символов"
},
verb: "иметь"
},
file: {
unit: {
one: "байт",
few: "байта",
many: "байт"
},
verb: "иметь"
},
array: {
unit: {
one: "элемент",
few: "элемента",
many: "элементов"
},
verb: "иметь"
},
set: {
unit: {
one: "элемент",
few: "элемента",
many: "элементов"
},
verb: "иметь"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ввод",
email: "email адрес",
url: "URL",
emoji: "эмодзи",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO дата и время",
date: "ISO дата",
time: "ISO время",
duration: "ISO длительность",
ipv4: "IPv4 адрес",
ipv6: "IPv6 адрес",
cidrv4: "IPv4 диапазон",
cidrv6: "IPv6 диапазон",
base64: "строка в формате base64",
base64url: "строка в формате base64url",
json_string: "JSON строка",
e164: "номер E.164",
jwt: "JWT",
template_literal: "ввод"
};
const TypeDictionary = {
nan: "NaN",
number: "число",
array: "массив"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Неверный ввод: ожидалось instanceof ${issue.expected}, получено ${received}`;
return `Неверный ввод: ожидалось ${expected}, получено ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Неверный ввод: ожидалось ${stringifyPrimitive(issue.values[0])}`;
return `Неверный вариант: ожидалось одно из ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) {
const unit = getRussianPlural(Number(issue.maximum), sizing.unit.one, sizing.unit.few, sizing.unit.many);
return `Слишком большое значение: ожидалось, что ${issue.origin ?? "значение"} будет иметь ${adj}${issue.maximum.toString()} ${unit}`;
}
return `Слишком большое значение: ожидалось, что ${issue.origin ?? "значение"} будет ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) {
const unit = getRussianPlural(Number(issue.minimum), sizing.unit.one, sizing.unit.few, sizing.unit.many);
return `Слишком маленькое значение: ожидалось, что ${issue.origin} будет иметь ${adj}${issue.minimum.toString()} ${unit}`;
}
return `Слишком маленькое значение: ожидалось, что ${issue.origin} будет ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Неверная строка: должна начинаться с "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Неверная строка: должна заканчиваться на "${_issue.suffix}"`;
if (_issue.format === "includes") return `Неверная строка: должна содержать "${_issue.includes}"`;
if (_issue.format === "regex") return `Неверная строка: должна соответствовать шаблону ${_issue.pattern}`;
return `Неверный ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Неверное число: должно быть кратным ${issue.divisor}`;
case "unrecognized_keys": return `Нераспознанн${issue.keys.length > 1 ? "ые" : "ый"} ключ${issue.keys.length > 1 ? "и" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Неверный ключ в ${issue.origin}`;
case "invalid_union": return "Неверные входные данные";
case "invalid_element": return `Неверное значение в ${issue.origin}`;
default: return `Неверные входные данные`;
}
};
};
function ru_default() {
return { localeError: error$12() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/sl.js
const error$11 = () => {
const Sizable = {
string: {
unit: "znakov",
verb: "imeti"
},
file: {
unit: "bajtov",
verb: "imeti"
},
array: {
unit: "elementov",
verb: "imeti"
},
set: {
unit: "elementov",
verb: "imeti"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "vnos",
email: "e-poštni naslov",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO datum in čas",
date: "ISO datum",
time: "ISO čas",
duration: "ISO trajanje",
ipv4: "IPv4 naslov",
ipv6: "IPv6 naslov",
cidrv4: "obseg IPv4",
cidrv6: "obseg IPv6",
base64: "base64 kodiran niz",
base64url: "base64url kodiran niz",
json_string: "JSON niz",
e164: "E.164 številka",
jwt: "JWT",
template_literal: "vnos"
};
const TypeDictionary = {
nan: "NaN",
number: "število",
array: "tabela"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Neveljaven vnos: pričakovano instanceof ${issue.expected}, prejeto ${received}`;
return `Neveljaven vnos: pričakovano ${expected}, prejeto ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Neveljaven vnos: pričakovano ${stringifyPrimitive(issue.values[0])}`;
return `Neveljavna možnost: pričakovano eno izmed ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Preveliko: pričakovano, da bo ${issue.origin ?? "vrednost"} imelo ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elementov"}`;
return `Preveliko: pričakovano, da bo ${issue.origin ?? "vrednost"} ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Premajhno: pričakovano, da bo ${issue.origin} imelo ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Premajhno: pričakovano, da bo ${issue.origin} ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Neveljaven niz: mora se začeti z "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Neveljaven niz: mora se končati z "${_issue.suffix}"`;
if (_issue.format === "includes") return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
if (_issue.format === "regex") return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
return `Neveljaven ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Neveljavno število: mora biti večkratnik ${issue.divisor}`;
case "unrecognized_keys": return `Neprepoznan${issue.keys.length > 1 ? "i ključi" : " ključ"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Neveljaven ključ v ${issue.origin}`;
case "invalid_union": return "Neveljaven vnos";
case "invalid_element": return `Neveljavna vrednost v ${issue.origin}`;
default: return "Neveljaven vnos";
}
};
};
function sl_default() {
return { localeError: error$11() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/sv.js
const error$10 = () => {
const Sizable = {
string: {
unit: "tecken",
verb: "att ha"
},
file: {
unit: "bytes",
verb: "att ha"
},
array: {
unit: "objekt",
verb: "att innehålla"
},
set: {
unit: "objekt",
verb: "att innehålla"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "reguljärt uttryck",
email: "e-postadress",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO-datum och tid",
date: "ISO-datum",
time: "ISO-tid",
duration: "ISO-varaktighet",
ipv4: "IPv4-intervall",
ipv6: "IPv6-intervall",
cidrv4: "IPv4-spektrum",
cidrv6: "IPv6-spektrum",
base64: "base64-kodad sträng",
base64url: "base64url-kodad sträng",
json_string: "JSON-sträng",
e164: "E.164-nummer",
jwt: "JWT",
template_literal: "mall-literal"
};
const TypeDictionary = {
nan: "NaN",
number: "antal",
array: "lista"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Ogiltig inmatning: förväntat instanceof ${issue.expected}, fick ${received}`;
return `Ogiltig inmatning: förväntat ${expected}, fick ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Ogiltig inmatning: förväntat ${stringifyPrimitive(issue.values[0])}`;
return `Ogiltigt val: förväntade en av ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `För stor(t): förväntade ${issue.origin ?? "värdet"} att ha ${adj}${issue.maximum.toString()} ${sizing.unit ?? "element"}`;
return `För stor(t): förväntat ${issue.origin ?? "värdet"} att ha ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `För lite(t): förväntade ${issue.origin ?? "värdet"} att ha ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `För lite(t): förväntade ${issue.origin ?? "värdet"} att ha ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Ogiltig sträng: måste börja med "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Ogiltig sträng: måste sluta med "${_issue.suffix}"`;
if (_issue.format === "includes") return `Ogiltig sträng: måste innehålla "${_issue.includes}"`;
if (_issue.format === "regex") return `Ogiltig sträng: måste matcha mönstret "${_issue.pattern}"`;
return `Ogiltig(t) ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Ogiltigt tal: måste vara en multipel av ${issue.divisor}`;
case "unrecognized_keys": return `${issue.keys.length > 1 ? "Okända nycklar" : "Okänd nyckel"}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Ogiltig nyckel i ${issue.origin ?? "värdet"}`;
case "invalid_union": return "Ogiltig input";
case "invalid_element": return `Ogiltigt värde i ${issue.origin ?? "värdet"}`;
default: return `Ogiltig input`;
}
};
};
function sv_default() {
return { localeError: error$10() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ta.js
const error$9 = () => {
const Sizable = {
string: {
unit: "எழுத்துக்கள்",
verb: "கொண்டிருக்க வேண்டும்"
},
file: {
unit: "பைட்டுகள்",
verb: "கொண்டிருக்க வேண்டும்"
},
array: {
unit: "உறுப்புகள்",
verb: "கொண்டிருக்க வேண்டும்"
},
set: {
unit: "உறுப்புகள்",
verb: "கொண்டிருக்க வேண்டும்"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "உள்ளீடு",
email: "மின்னஞ்சல் முகவரி",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO தேதி நேரம்",
date: "ISO தேதி",
time: "ISO நேரம்",
duration: "ISO கால அளவு",
ipv4: "IPv4 முகவரி",
ipv6: "IPv6 முகவரி",
cidrv4: "IPv4 வரம்பு",
cidrv6: "IPv6 வரம்பு",
base64: "base64-encoded சரம்",
base64url: "base64url-encoded சரம்",
json_string: "JSON சரம்",
e164: "E.164 எண்",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = {
nan: "NaN",
number: "எண்",
array: "அணி",
null: "வெறுமை"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `தவறான உள்ளீடு: எதிர்பார்க்கப்பட்டது instanceof ${issue.expected}, பெறப்பட்டது ${received}`;
return `தவறான உள்ளீடு: எதிர்பார்க்கப்பட்டது ${expected}, பெறப்பட்டது ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `தவறான உள்ளீடு: எதிர்பார்க்கப்பட்டது ${stringifyPrimitive(issue.values[0])}`;
return `தவறான விருப்பம்: எதிர்பார்க்கப்பட்டது ${joinValues(issue.values, "|")} இல் ஒன்று`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `மிக பெரியது: எதிர்பார்க்கப்பட்டது ${issue.origin ?? "மதிப்பு"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "உறுப்புகள்"} ஆக இருக்க வேண்டும்`;
return `மிக பெரியது: எதிர்பார்க்கப்பட்டது ${issue.origin ?? "மதிப்பு"} ${adj}${issue.maximum.toString()} ஆக இருக்க வேண்டும்`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `மிகச் சிறியது: எதிர்பார்க்கப்பட்டது ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit} ஆக இருக்க வேண்டும்`;
return `மிகச் சிறியது: எதிர்பார்க்கப்பட்டது ${issue.origin} ${adj}${issue.minimum.toString()} ஆக இருக்க வேண்டும்`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `தவறான சரம்: "${_issue.prefix}" இல் தொடங்க வேண்டும்`;
if (_issue.format === "ends_with") return `தவறான சரம்: "${_issue.suffix}" இல் முடிவடைய வேண்டும்`;
if (_issue.format === "includes") return `தவறான சரம்: "${_issue.includes}" ஐ உள்ளடக்க வேண்டும்`;
if (_issue.format === "regex") return `தவறான சரம்: ${_issue.pattern} முறைபாட்டுடன் பொருந்த வேண்டும்`;
return `தவறான ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `தவறான எண்: ${issue.divisor} இன் பலமாக இருக்க வேண்டும்`;
case "unrecognized_keys": return `அடையாளம் தெரியாத விசை${issue.keys.length > 1 ? "கள்" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `${issue.origin} இல் தவறான விசை`;
case "invalid_union": return "தவறான உள்ளீடு";
case "invalid_element": return `${issue.origin} இல் தவறான மதிப்பு`;
default: return `தவறான உள்ளீடு`;
}
};
};
function ta_default() {
return { localeError: error$9() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/th.js
const error$8 = () => {
const Sizable = {
string: {
unit: "ตัวอักษร",
verb: "ควรมี"
},
file: {
unit: "ไบต์",
verb: "ควรมี"
},
array: {
unit: "รายการ",
verb: "ควรมี"
},
set: {
unit: "รายการ",
verb: "ควรมี"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ข้อมูลที่ป้อน",
email: "ที่อยู่อีเมล",
url: "URL",
emoji: "อิโมจิ",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "วันที่เวลาแบบ ISO",
date: "วันที่แบบ ISO",
time: "เวลาแบบ ISO",
duration: "ช่วงเวลาแบบ ISO",
ipv4: "ที่อยู่ IPv4",
ipv6: "ที่อยู่ IPv6",
cidrv4: "ช่วง IP แบบ IPv4",
cidrv6: "ช่วง IP แบบ IPv6",
base64: "ข้อความแบบ Base64",
base64url: "ข้อความแบบ Base64 สำหรับ URL",
json_string: "ข้อความแบบ JSON",
e164: "เบอร์โทรศัพท์ระหว่างประเทศ (E.164)",
jwt: "โทเคน JWT",
template_literal: "ข้อมูลที่ป้อน"
};
const TypeDictionary = {
nan: "NaN",
number: "ตัวเลข",
array: "อาร์เรย์ (Array)",
null: "ไม่มีค่า (null)"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `ประเภทข้อมูลไม่ถูกต้อง: ควรเป็น instanceof ${issue.expected} แต่ได้รับ ${received}`;
return `ประเภทข้อมูลไม่ถูกต้อง: ควรเป็น ${expected} แต่ได้รับ ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `ค่าไม่ถูกต้อง: ควรเป็น ${stringifyPrimitive(issue.values[0])}`;
return `ตัวเลือกไม่ถูกต้อง: ควรเป็นหนึ่งใน ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "ไม่เกิน" : "น้อยกว่า";
const sizing = getSizing(issue.origin);
if (sizing) return `เกินกำหนด: ${issue.origin ?? "ค่า"} ควรมี${adj} ${issue.maximum.toString()} ${sizing.unit ?? "รายการ"}`;
return `เกินกำหนด: ${issue.origin ?? "ค่า"} ควรมี${adj} ${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? "อย่างน้อย" : "มากกว่า";
const sizing = getSizing(issue.origin);
if (sizing) return `น้อยกว่ากำหนด: ${issue.origin} ควรมี${adj} ${issue.minimum.toString()} ${sizing.unit}`;
return `น้อยกว่ากำหนด: ${issue.origin} ควรมี${adj} ${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `รูปแบบไม่ถูกต้อง: ข้อความต้องขึ้นต้นด้วย "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `รูปแบบไม่ถูกต้อง: ข้อความต้องลงท้ายด้วย "${_issue.suffix}"`;
if (_issue.format === "includes") return `รูปแบบไม่ถูกต้อง: ข้อความต้องมี "${_issue.includes}" อยู่ในข้อความ`;
if (_issue.format === "regex") return `รูปแบบไม่ถูกต้อง: ต้องตรงกับรูปแบบที่กำหนด ${_issue.pattern}`;
return `รูปแบบไม่ถูกต้อง: ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `ตัวเลขไม่ถูกต้อง: ต้องเป็นจำนวนที่หารด้วย ${issue.divisor} ได้ลงตัว`;
case "unrecognized_keys": return `พบคีย์ที่ไม่รู้จัก: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `คีย์ไม่ถูกต้องใน ${issue.origin}`;
case "invalid_union": return "ข้อมูลไม่ถูกต้อง: ไม่ตรงกับรูปแบบยูเนียนที่กำหนดไว้";
case "invalid_element": return `ข้อมูลไม่ถูกต้องใน ${issue.origin}`;
default: return `ข้อมูลไม่ถูกต้อง`;
}
};
};
function th_default() {
return { localeError: error$8() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/tr.js
const error$7 = () => {
const Sizable = {
string: {
unit: "karakter",
verb: "olmalı"
},
file: {
unit: "bayt",
verb: "olmalı"
},
array: {
unit: "öğe",
verb: "olmalı"
},
set: {
unit: "öğe",
verb: "olmalı"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "girdi",
email: "e-posta adresi",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO tarih ve saat",
date: "ISO tarih",
time: "ISO saat",
duration: "ISO süre",
ipv4: "IPv4 adresi",
ipv6: "IPv6 adresi",
cidrv4: "IPv4 aralığı",
cidrv6: "IPv6 aralığı",
base64: "base64 ile şifrelenmiş metin",
base64url: "base64url ile şifrelenmiş metin",
json_string: "JSON dizesi",
e164: "E.164 sayısı",
jwt: "JWT",
template_literal: "Şablon dizesi"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Geçersiz değer: beklenen instanceof ${issue.expected}, alınan ${received}`;
return `Geçersiz değer: beklenen ${expected}, alınan ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Geçersiz değer: beklenen ${stringifyPrimitive(issue.values[0])}`;
return `Geçersiz seçenek: aşağıdakilerden biri olmalı: ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Çok büyük: beklenen ${issue.origin ?? "değer"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "öğe"}`;
return `Çok büyük: beklenen ${issue.origin ?? "değer"} ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Çok küçük: beklenen ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Çok küçük: beklenen ${issue.origin} ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Geçersiz metin: "${_issue.prefix}" ile başlamalı`;
if (_issue.format === "ends_with") return `Geçersiz metin: "${_issue.suffix}" ile bitmeli`;
if (_issue.format === "includes") return `Geçersiz metin: "${_issue.includes}" içermeli`;
if (_issue.format === "regex") return `Geçersiz metin: ${_issue.pattern} desenine uymalı`;
return `Geçersiz ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Geçersiz sayı: ${issue.divisor} ile tam bölünebilmeli`;
case "unrecognized_keys": return `Tanınmayan anahtar${issue.keys.length > 1 ? "lar" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `${issue.origin} içinde geçersiz anahtar`;
case "invalid_union": return "Geçersiz değer";
case "invalid_element": return `${issue.origin} içinde geçersiz değer`;
default: return `Geçersiz değer`;
}
};
};
function tr_default() {
return { localeError: error$7() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/uk.js
const error$6 = () => {
const Sizable = {
string: {
unit: "символів",
verb: "матиме"
},
file: {
unit: "байтів",
verb: "матиме"
},
array: {
unit: "елементів",
verb: "матиме"
},
set: {
unit: "елементів",
verb: "матиме"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "вхідні дані",
email: "адреса електронної пошти",
url: "URL",
emoji: "емодзі",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "дата та час ISO",
date: "дата ISO",
time: "час ISO",
duration: "тривалість ISO",
ipv4: "адреса IPv4",
ipv6: "адреса IPv6",
cidrv4: "діапазон IPv4",
cidrv6: "діапазон IPv6",
base64: "рядок у кодуванні base64",
base64url: "рядок у кодуванні base64url",
json_string: "рядок JSON",
e164: "номер E.164",
jwt: "JWT",
template_literal: "вхідні дані"
};
const TypeDictionary = {
nan: "NaN",
number: "число",
array: "масив"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Неправильні вхідні дані: очікується instanceof ${issue.expected}, отримано ${received}`;
return `Неправильні вхідні дані: очікується ${expected}, отримано ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Неправильні вхідні дані: очікується ${stringifyPrimitive(issue.values[0])}`;
return `Неправильна опція: очікується одне з ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Занадто велике: очікується, що ${issue.origin ?? "значення"} ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "елементів"}`;
return `Занадто велике: очікується, що ${issue.origin ?? "значення"} буде ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Занадто мале: очікується, що ${issue.origin} ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Занадто мале: очікується, що ${issue.origin} буде ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Неправильний рядок: повинен починатися з "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Неправильний рядок: повинен закінчуватися на "${_issue.suffix}"`;
if (_issue.format === "includes") return `Неправильний рядок: повинен містити "${_issue.includes}"`;
if (_issue.format === "regex") return `Неправильний рядок: повинен відповідати шаблону ${_issue.pattern}`;
return `Неправильний ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Неправильне число: повинно бути кратним ${issue.divisor}`;
case "unrecognized_keys": return `Нерозпізнаний ключ${issue.keys.length > 1 ? "і" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Неправильний ключ у ${issue.origin}`;
case "invalid_union": return "Неправильні вхідні дані";
case "invalid_element": return `Неправильне значення у ${issue.origin}`;
default: return `Неправильні вхідні дані`;
}
};
};
function uk_default() {
return { localeError: error$6() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ua.js
/** @deprecated Use `uk` instead. */
function ua_default() {
return uk_default();
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ur.js
const error$5 = () => {
const Sizable = {
string: {
unit: "حروف",
verb: "ہونا"
},
file: {
unit: "بائٹس",
verb: "ہونا"
},
array: {
unit: "آئٹمز",
verb: "ہونا"
},
set: {
unit: "آئٹمز",
verb: "ہونا"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ان پٹ",
email: "ای میل ایڈریس",
url: "یو آر ایل",
emoji: "ایموجی",
uuid: "یو یو آئی ڈی",
uuidv4: "یو یو آئی ڈی وی 4",
uuidv6: "یو یو آئی ڈی وی 6",
nanoid: "نینو آئی ڈی",
guid: "جی یو آئی ڈی",
cuid: "سی یو آئی ڈی",
cuid2: "سی یو آئی ڈی 2",
ulid: "یو ایل آئی ڈی",
xid: "ایکس آئی ڈی",
ksuid: "کے ایس یو آئی ڈی",
datetime: "آئی ایس او ڈیٹ ٹائم",
date: "آئی ایس او تاریخ",
time: "آئی ایس او وقت",
duration: "آئی ایس او مدت",
ipv4: "آئی پی وی 4 ایڈریس",
ipv6: "آئی پی وی 6 ایڈریس",
cidrv4: "آئی پی وی 4 رینج",
cidrv6: "آئی پی وی 6 رینج",
base64: "بیس 64 ان کوڈڈ سٹرنگ",
base64url: "بیس 64 یو آر ایل ان کوڈڈ سٹرنگ",
json_string: "جے ایس او این سٹرنگ",
e164: "ای 164 نمبر",
jwt: "جے ڈبلیو ٹی",
template_literal: "ان پٹ"
};
const TypeDictionary = {
nan: "NaN",
number: "نمبر",
array: "آرے",
null: "نل"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `غلط ان پٹ: instanceof ${issue.expected} متوقع تھا، ${received} موصول ہوا`;
return `غلط ان پٹ: ${expected} متوقع تھا، ${received} موصول ہوا`;
}
case "invalid_value":
if (issue.values.length === 1) return `غلط ان پٹ: ${stringifyPrimitive(issue.values[0])} متوقع تھا`;
return `غلط آپشن: ${joinValues(issue.values, "|")} میں سے ایک متوقع تھا`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `بہت بڑا: ${issue.origin ?? "ویلیو"} کے ${adj}${issue.maximum.toString()} ${sizing.unit ?? "عناصر"} ہونے متوقع تھے`;
return `بہت بڑا: ${issue.origin ?? "ویلیو"} کا ${adj}${issue.maximum.toString()} ہونا متوقع تھا`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `بہت چھوٹا: ${issue.origin} کے ${adj}${issue.minimum.toString()} ${sizing.unit} ہونے متوقع تھے`;
return `بہت چھوٹا: ${issue.origin} کا ${adj}${issue.minimum.toString()} ہونا متوقع تھا`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `غلط سٹرنگ: "${_issue.prefix}" سے شروع ہونا چاہیے`;
if (_issue.format === "ends_with") return `غلط سٹرنگ: "${_issue.suffix}" پر ختم ہونا چاہیے`;
if (_issue.format === "includes") return `غلط سٹرنگ: "${_issue.includes}" شامل ہونا چاہیے`;
if (_issue.format === "regex") return `غلط سٹرنگ: پیٹرن ${_issue.pattern} سے میچ ہونا چاہیے`;
return `غلط ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `غلط نمبر: ${issue.divisor} کا مضاعف ہونا چاہیے`;
case "unrecognized_keys": return `غیر تسلیم شدہ کی${issue.keys.length > 1 ? "ز" : ""}: ${joinValues(issue.keys, "، ")}`;
case "invalid_key": return `${issue.origin} میں غلط کی`;
case "invalid_union": return "غلط ان پٹ";
case "invalid_element": return `${issue.origin} میں غلط ویلیو`;
default: return `غلط ان پٹ`;
}
};
};
function ur_default() {
return { localeError: error$5() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/uz.js
const error$4 = () => {
const Sizable = {
string: {
unit: "belgi",
verb: "bo‘lishi kerak"
},
file: {
unit: "bayt",
verb: "bo‘lishi kerak"
},
array: {
unit: "element",
verb: "bo‘lishi kerak"
},
set: {
unit: "element",
verb: "bo‘lishi kerak"
},
map: {
unit: "yozuv",
verb: "bo‘lishi kerak"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "kirish",
email: "elektron pochta manzili",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO sana va vaqti",
date: "ISO sana",
time: "ISO vaqt",
duration: "ISO davomiylik",
ipv4: "IPv4 manzil",
ipv6: "IPv6 manzil",
mac: "MAC manzil",
cidrv4: "IPv4 diapazon",
cidrv6: "IPv6 diapazon",
base64: "base64 kodlangan satr",
base64url: "base64url kodlangan satr",
json_string: "JSON satr",
e164: "E.164 raqam",
jwt: "JWT",
template_literal: "kirish"
};
const TypeDictionary = {
nan: "NaN",
number: "raqam",
array: "massiv"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Noto‘g‘ri kirish: kutilgan instanceof ${issue.expected}, qabul qilingan ${received}`;
return `Noto‘g‘ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Noto‘g‘ri kirish: kutilgan ${stringifyPrimitive(issue.values[0])}`;
return `Noto‘g‘ri variant: quyidagilardan biri kutilgan ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Juda katta: kutilgan ${issue.origin ?? "qiymat"} ${adj}${issue.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
return `Juda katta: kutilgan ${issue.origin ?? "qiymat"} ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Juda kichik: kutilgan ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
return `Juda kichik: kutilgan ${issue.origin} ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Noto‘g‘ri satr: "${_issue.prefix}" bilan boshlanishi kerak`;
if (_issue.format === "ends_with") return `Noto‘g‘ri satr: "${_issue.suffix}" bilan tugashi kerak`;
if (_issue.format === "includes") return `Noto‘g‘ri satr: "${_issue.includes}" ni o‘z ichiga olishi kerak`;
if (_issue.format === "regex") return `Noto‘g‘ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;
return `Noto‘g‘ri ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Noto‘g‘ri raqam: ${issue.divisor} ning karralisi bo‘lishi kerak`;
case "unrecognized_keys": return `Noma’lum kalit${issue.keys.length > 1 ? "lar" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `${issue.origin} dagi kalit noto‘g‘ri`;
case "invalid_union": return "Noto‘g‘ri kirish";
case "invalid_element": return `${issue.origin} da noto‘g‘ri qiymat`;
default: return `Noto‘g‘ri kirish`;
}
};
};
function uz_default() {
return { localeError: error$4() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/vi.js
const error$3 = () => {
const Sizable = {
string: {
unit: "ký tự",
verb: "có"
},
file: {
unit: "byte",
verb: "có"
},
array: {
unit: "phần tử",
verb: "có"
},
set: {
unit: "phần tử",
verb: "có"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "đầu vào",
email: "địa chỉ email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ngày giờ ISO",
date: "ngày ISO",
time: "giờ ISO",
duration: "khoảng thời gian ISO",
ipv4: "địa chỉ IPv4",
ipv6: "địa chỉ IPv6",
cidrv4: "dải IPv4",
cidrv6: "dải IPv6",
base64: "chuỗi mã hóa base64",
base64url: "chuỗi mã hóa base64url",
json_string: "chuỗi JSON",
e164: "số E.164",
jwt: "JWT",
template_literal: "đầu vào"
};
const TypeDictionary = {
nan: "NaN",
number: "số",
array: "mảng"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Đầu vào không hợp lệ: mong đợi instanceof ${issue.expected}, nhận được ${received}`;
return `Đầu vào không hợp lệ: mong đợi ${expected}, nhận được ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Đầu vào không hợp lệ: mong đợi ${stringifyPrimitive(issue.values[0])}`;
return `Tùy chọn không hợp lệ: mong đợi một trong các giá trị ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Quá lớn: mong đợi ${issue.origin ?? "giá trị"} ${sizing.verb} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "phần tử"}`;
return `Quá lớn: mong đợi ${issue.origin ?? "giá trị"} ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Quá nhỏ: mong đợi ${issue.origin} ${sizing.verb} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Quá nhỏ: mong đợi ${issue.origin} ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Chuỗi không hợp lệ: phải bắt đầu bằng "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Chuỗi không hợp lệ: phải kết thúc bằng "${_issue.suffix}"`;
if (_issue.format === "includes") return `Chuỗi không hợp lệ: phải bao gồm "${_issue.includes}"`;
if (_issue.format === "regex") return `Chuỗi không hợp lệ: phải khớp với mẫu ${_issue.pattern}`;
return `${FormatDictionary[_issue.format] ?? issue.format} không hợp lệ`;
}
case "not_multiple_of": return `Số không hợp lệ: phải là bội số của ${issue.divisor}`;
case "unrecognized_keys": return `Khóa không được nhận dạng: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Khóa không hợp lệ trong ${issue.origin}`;
case "invalid_union": return "Đầu vào không hợp lệ";
case "invalid_element": return `Giá trị không hợp lệ trong ${issue.origin}`;
default: return `Đầu vào không hợp lệ`;
}
};
};
function vi_default() {
return { localeError: error$3() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/zh-CN.js
const error$2 = () => {
const Sizable = {
string: {
unit: "字符",
verb: "包含"
},
file: {
unit: "字节",
verb: "包含"
},
array: {
unit: "项",
verb: "包含"
},
set: {
unit: "项",
verb: "包含"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "输入",
email: "电子邮件",
url: "URL",
emoji: "表情符号",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO日期时间",
date: "ISO日期",
time: "ISO时间",
duration: "ISO时长",
ipv4: "IPv4地址",
ipv6: "IPv6地址",
cidrv4: "IPv4网段",
cidrv6: "IPv6网段",
base64: "base64编码字符串",
base64url: "base64url编码字符串",
json_string: "JSON字符串",
e164: "E.164号码",
jwt: "JWT",
template_literal: "输入"
};
const TypeDictionary = {
nan: "NaN",
number: "数字",
array: "数组",
null: "空值(null)"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `无效输入：期望 instanceof ${issue.expected}，实际接收 ${received}`;
return `无效输入：期望 ${expected}，实际接收 ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `无效输入：期望 ${stringifyPrimitive(issue.values[0])}`;
return `无效选项：期望以下之一 ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `数值过大：期望 ${issue.origin ?? "值"} ${adj}${issue.maximum.toString()} ${sizing.unit ?? "个元素"}`;
return `数值过大：期望 ${issue.origin ?? "值"} ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `数值过小：期望 ${issue.origin} ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `数值过小：期望 ${issue.origin} ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `无效字符串：必须以 "${_issue.prefix}" 开头`;
if (_issue.format === "ends_with") return `无效字符串：必须以 "${_issue.suffix}" 结尾`;
if (_issue.format === "includes") return `无效字符串：必须包含 "${_issue.includes}"`;
if (_issue.format === "regex") return `无效字符串：必须满足正则表达式 ${_issue.pattern}`;
return `无效${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `无效数字：必须是 ${issue.divisor} 的倍数`;
case "unrecognized_keys": return `出现未知的键(key): ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `${issue.origin} 中的键(key)无效`;
case "invalid_union": return "无效输入";
case "invalid_element": return `${issue.origin} 中包含无效值(value)`;
default: return `无效输入`;
}
};
};
function zh_CN_default() {
return { localeError: error$2() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/zh-TW.js
const error$1 = () => {
const Sizable = {
string: {
unit: "字元",
verb: "擁有"
},
file: {
unit: "位元組",
verb: "擁有"
},
array: {
unit: "項目",
verb: "擁有"
},
set: {
unit: "項目",
verb: "擁有"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "輸入",
email: "郵件地址",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO 日期時間",
date: "ISO 日期",
time: "ISO 時間",
duration: "ISO 期間",
ipv4: "IPv4 位址",
ipv6: "IPv6 位址",
cidrv4: "IPv4 範圍",
cidrv6: "IPv6 範圍",
base64: "base64 編碼字串",
base64url: "base64url 編碼字串",
json_string: "JSON 字串",
e164: "E.164 數值",
jwt: "JWT",
template_literal: "輸入"
};
const TypeDictionary = { nan: "NaN" };
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `無效的輸入值：預期為 instanceof ${issue.expected}，但收到 ${received}`;
return `無效的輸入值：預期為 ${expected}，但收到 ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `無效的輸入值：預期為 ${stringifyPrimitive(issue.values[0])}`;
return `無效的選項：預期為以下其中之一 ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `數值過大：預期 ${issue.origin ?? "值"} 應為 ${adj}${issue.maximum.toString()} ${sizing.unit ?? "個元素"}`;
return `數值過大：預期 ${issue.origin ?? "值"} 應為 ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `數值過小：預期 ${issue.origin} 應為 ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `數值過小：預期 ${issue.origin} 應為 ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `無效的字串：必須以 "${_issue.prefix}" 開頭`;
if (_issue.format === "ends_with") return `無效的字串：必須以 "${_issue.suffix}" 結尾`;
if (_issue.format === "includes") return `無效的字串：必須包含 "${_issue.includes}"`;
if (_issue.format === "regex") return `無效的字串：必須符合格式 ${_issue.pattern}`;
return `無效的 ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `無效的數字：必須為 ${issue.divisor} 的倍數`;
case "unrecognized_keys": return `無法識別的鍵值${issue.keys.length > 1 ? "們" : ""}：${joinValues(issue.keys, "、")}`;
case "invalid_key": return `${issue.origin} 中有無效的鍵值`;
case "invalid_union": return "無效的輸入值";
case "invalid_element": return `${issue.origin} 中有無效的值`;
default: return `無效的輸入值`;
}
};
};
function zh_TW_default() {
return { localeError: error$1() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/yo.js
const error = () => {
const Sizable = {
string: {
unit: "àmi",
verb: "ní"
},
file: {
unit: "bytes",
verb: "ní"
},
array: {
unit: "nkan",
verb: "ní"
},
set: {
unit: "nkan",
verb: "ní"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ẹ̀rọ ìbáwọlé",
email: "àdírẹ́sì ìmẹ́lì",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "àkókò ISO",
date: "ọjọ́ ISO",
time: "àkókò ISO",
duration: "àkókò tó pé ISO",
ipv4: "àdírẹ́sì IPv4",
ipv6: "àdírẹ́sì IPv6",
cidrv4: "àgbègbè IPv4",
cidrv6: "àgbègbè IPv6",
base64: "ọ̀rọ̀ tí a kọ́ ní base64",
base64url: "ọ̀rọ̀ base64url",
json_string: "ọ̀rọ̀ JSON",
e164: "nọ́mbà E.164",
jwt: "JWT",
template_literal: "ẹ̀rọ ìbáwọlé"
};
const TypeDictionary = {
nan: "NaN",
number: "nọ́mbà",
array: "akopọ"
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
if (/^[A-Z]/.test(issue.expected)) return `Ìbáwọlé aṣìṣe: a ní láti fi instanceof ${issue.expected}, àmọ̀ a rí ${received}`;
return `Ìbáwọlé aṣìṣe: a ní láti fi ${expected}, àmọ̀ a rí ${received}`;
}
case "invalid_value":
if (issue.values.length === 1) return `Ìbáwọlé aṣìṣe: a ní láti fi ${stringifyPrimitive(issue.values[0])}`;
return `Àṣàyàn aṣìṣe: yan ọ̀kan lára ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Tó pọ̀ jù: a ní láti jẹ́ pé ${issue.origin ?? "iye"} ${sizing.verb} ${adj}${issue.maximum} ${sizing.unit}`;
return `Tó pọ̀ jù: a ní láti jẹ́ ${adj}${issue.maximum}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Kéré ju: a ní láti jẹ́ pé ${issue.origin} ${sizing.verb} ${adj}${issue.minimum} ${sizing.unit}`;
return `Kéré ju: a ní láti jẹ́ ${adj}${issue.minimum}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bẹ̀rẹ̀ pẹ̀lú "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ parí pẹ̀lú "${_issue.suffix}"`;
if (_issue.format === "includes") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ ní "${_issue.includes}"`;
if (_issue.format === "regex") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bá àpẹẹrẹ mu ${_issue.pattern}`;
return `Aṣìṣe: ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Nọ́mbà aṣìṣe: gbọ́dọ̀ jẹ́ èyà pípín ti ${issue.divisor}`;
case "unrecognized_keys": return `Bọtìnì àìmọ̀: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Bọtìnì aṣìṣe nínú ${issue.origin}`;
case "invalid_union": return "Ìbáwọlé aṣìṣe";
case "invalid_element": return `Iye aṣìṣe nínú ${issue.origin}`;
default: return "Ìbáwọlé aṣìṣe";
}
};
};
function yo_default() {
return { localeError: error() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/index.js
var locales_exports = /* @__PURE__ */ __exportAll({
ar: () => ar_default,
az: () => az_default,
be: () => be_default,
bg: () => bg_default,
ca: () => ca_default,
cs: () => cs_default,
da: () => da_default,
de: () => de_default,
el: () => el_default,
en: () => en_default,
eo: () => eo_default,
es: () => es_default,
fa: () => fa_default,
fi: () => fi_default,
fr: () => fr_default,
frCA: () => fr_CA_default,
he: () => he_default,
hr: () => hr_default,
hu: () => hu_default,
hy: () => hy_default,
id: () => id_default,
is: () => is_default,
it: () => it_default,
ja: () => ja_default,
ka: () => ka_default,
kh: () => kh_default,
km: () => km_default,
ko: () => ko_default,
lt: () => lt_default,
mk: () => mk_default,
ms: () => ms_default,
nl: () => nl_default,
no: () => no_default,
ota: () => ota_default,
pl: () => pl_default,
ps: () => ps_default,
pt: () => pt_default,
ro: () => ro_default,
ru: () => ru_default,
sl: () => sl_default,
sv: () => sv_default,
ta: () => ta_default,
th: () => th_default,
tr: () => tr_default,
ua: () => ua_default,
uk: () => uk_default,
ur: () => ur_default,
uz: () => uz_default,
vi: () => vi_default,
yo: () => yo_default,
zhCN: () => zh_CN_default,
zhTW: () => zh_TW_default
});
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/json-schema-generator.js
/**
* Legacy class-based interface for JSON Schema generation.
* This class wraps the new functional implementation to provide backward compatibility.
*
* @deprecated Use the `toJSONSchema` function instead for new code.
*
* @example
* ```typescript
* // Legacy usage (still supported)
* const gen = new JSONSchemaGenerator({ target: "draft-07" });
* gen.process(schema);
* const result = gen.emit(schema);
*
* // Preferred modern usage
* const result = toJSONSchema(schema, { target: "draft-07" });
* ```
*/
var JSONSchemaGenerator = class {
/** @deprecated Access via ctx instead */
get metadataRegistry() {
return this.ctx.metadataRegistry;
}
/** @deprecated Access via ctx instead */
get target() {
return this.ctx.target;
}
/** @deprecated Access via ctx instead */
get unrepresentable() {
return this.ctx.unrepresentable;
}
/** @deprecated Access via ctx instead */
get override() {
return this.ctx.override;
}
/** @deprecated Access via ctx instead */
get io() {
return this.ctx.io;
}
/** @deprecated Access via ctx instead */
get counter() {
return this.ctx.counter;
}
set counter(value) {
this.ctx.counter = value;
}
/** @deprecated Access via ctx instead */
get seen() {
return this.ctx.seen;
}
constructor(params) {
let normalizedTarget = params?.target ?? "draft-2020-12";
if (normalizedTarget === "draft-4") normalizedTarget = "draft-04";
if (normalizedTarget === "draft-7") normalizedTarget = "draft-07";
this.ctx = initializeContext({
processors: allProcessors,
target: normalizedTarget,
...params?.metadata && { metadata: params.metadata },
...params?.unrepresentable && { unrepresentable: params.unrepresentable },
...params?.override && { override: params.override },
...params?.io && { io: params.io }
});
}
/**
* Process a schema to prepare it for JSON Schema generation.
* This must be called before emit().
*/
process(schema, _params = {
path: [],
schemaPath: []
}) {
return process(schema, this.ctx, _params);
}
/**
* Emit the final JSON Schema after processing.
* Must call process() first.
*/
emit(schema, _params) {
if (_params) {
if (_params.cycles) this.ctx.cycles = _params.cycles;
if (_params.reused) this.ctx.reused = _params.reused;
if (_params.external) this.ctx.external = _params.external;
}
extractDefs(this.ctx, schema);
const { "~standard": _, ...plainResult } = finalize(this.ctx, schema);
return plainResult;
}
};
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/json-schema.js
var json_schema_exports = /* @__PURE__ */ __exportAll({});
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/index.js
var core_exports = /* @__PURE__ */ __exportAll({
$ZodAny: () => $ZodAny,
$ZodArray: () => $ZodArray,
$ZodAsyncError: () => $ZodAsyncError,
$ZodBase64: () => $ZodBase64,
$ZodBase64URL: () => $ZodBase64URL,
$ZodBigInt: () => $ZodBigInt,
$ZodBigIntFormat: () => $ZodBigIntFormat,
$ZodBoolean: () => $ZodBoolean,
$ZodCIDRv4: () => $ZodCIDRv4,
$ZodCIDRv6: () => $ZodCIDRv6,
$ZodCUID: () => $ZodCUID,
$ZodCUID2: () => $ZodCUID2,
$ZodCatch: () => $ZodCatch,
$ZodCheck: () => $ZodCheck,
$ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
$ZodCheckEndsWith: () => $ZodCheckEndsWith,
$ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
$ZodCheckIncludes: () => $ZodCheckIncludes,
$ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
$ZodCheckLessThan: () => $ZodCheckLessThan,
$ZodCheckLowerCase: () => $ZodCheckLowerCase,
$ZodCheckMaxLength: () => $ZodCheckMaxLength,
$ZodCheckMaxSize: () => $ZodCheckMaxSize,
$ZodCheckMimeType: () => $ZodCheckMimeType,
$ZodCheckMinLength: () => $ZodCheckMinLength,
$ZodCheckMinSize: () => $ZodCheckMinSize,
$ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
$ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
$ZodCheckOverwrite: () => $ZodCheckOverwrite,
$ZodCheckProperty: () => $ZodCheckProperty,
$ZodCheckRegex: () => $ZodCheckRegex,
$ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
$ZodCheckStartsWith: () => $ZodCheckStartsWith,
$ZodCheckStringFormat: () => $ZodCheckStringFormat,
$ZodCheckUpperCase: () => $ZodCheckUpperCase,
$ZodCodec: () => $ZodCodec,
$ZodCustom: () => $ZodCustom,
$ZodCustomStringFormat: () => $ZodCustomStringFormat,
$ZodDate: () => $ZodDate,
$ZodDefault: () => $ZodDefault,
$ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
$ZodE164: () => $ZodE164,
$ZodEmail: () => $ZodEmail,
$ZodEmoji: () => $ZodEmoji,
$ZodEncodeError: () => $ZodEncodeError,
$ZodEnum: () => $ZodEnum,
$ZodError: () => $ZodError,
$ZodExactOptional: () => $ZodExactOptional,
$ZodFile: () => $ZodFile,
$ZodFunction: () => $ZodFunction,
$ZodGUID: () => $ZodGUID,
$ZodIPv4: () => $ZodIPv4,
$ZodIPv6: () => $ZodIPv6,
$ZodISODate: () => $ZodISODate,
$ZodISODateTime: () => $ZodISODateTime,
$ZodISODuration: () => $ZodISODuration,
$ZodISOTime: () => $ZodISOTime,
$ZodIntersection: () => $ZodIntersection,
$ZodJWT: () => $ZodJWT,
$ZodKSUID: () => $ZodKSUID,
$ZodLazy: () => $ZodLazy,
$ZodLiteral: () => $ZodLiteral,
$ZodMAC: () => $ZodMAC,
$ZodMap: () => $ZodMap,
$ZodNaN: () => $ZodNaN,
$ZodNanoID: () => $ZodNanoID,
$ZodNever: () => $ZodNever,
$ZodNonOptional: () => $ZodNonOptional,
$ZodNull: () => $ZodNull,
$ZodNullable: () => $ZodNullable,
$ZodNumber: () => $ZodNumber,
$ZodNumberFormat: () => $ZodNumberFormat,
$ZodObject: () => $ZodObject,
$ZodObjectJIT: () => $ZodObjectJIT,
$ZodOptional: () => $ZodOptional,
$ZodPipe: () => $ZodPipe,
$ZodPrefault: () => $ZodPrefault,
$ZodPreprocess: () => $ZodPreprocess,
$ZodPromise: () => $ZodPromise,
$ZodReadonly: () => $ZodReadonly,
$ZodRealError: () => $ZodRealError,
$ZodRecord: () => $ZodRecord,
$ZodRegistry: () => $ZodRegistry,
$ZodSet: () => $ZodSet,
$ZodString: () => $ZodString,
$ZodStringFormat: () => $ZodStringFormat,
$ZodSuccess: () => $ZodSuccess,
$ZodSymbol: () => $ZodSymbol,
$ZodTemplateLiteral: () => $ZodTemplateLiteral,
$ZodTransform: () => $ZodTransform,
$ZodTuple: () => $ZodTuple,
$ZodType: () => $ZodType,
$ZodULID: () => $ZodULID,
$ZodURL: () => $ZodURL,
$ZodUUID: () => $ZodUUID,
$ZodUndefined: () => $ZodUndefined,
$ZodUnion: () => $ZodUnion,
$ZodUnknown: () => $ZodUnknown,
$ZodVoid: () => $ZodVoid,
$ZodXID: () => $ZodXID,
$ZodXor: () => $ZodXor,
$brand: () => $brand,
$constructor: () => $constructor,
$input: () => $input,
$output: () => $output,
Doc: () => Doc,
JSONSchema: () => json_schema_exports,
JSONSchemaGenerator: () => JSONSchemaGenerator,
NEVER: () => NEVER,
TimePrecision: () => TimePrecision,
_any: () => _any,
_array: () => _array,
_base64: () => _base64,
_base64url: () => _base64url,
_bigint: () => _bigint,
_boolean: () => _boolean,
_catch: () => _catch,
_check: () => _check,
_cidrv4: () => _cidrv4,
_cidrv6: () => _cidrv6,
_coercedBigint: () => _coercedBigint,
_coercedBoolean: () => _coercedBoolean,
_coercedDate: () => _coercedDate,
_coercedNumber: () => _coercedNumber,
_coercedString: () => _coercedString,
_cuid: () => _cuid,
_cuid2: () => _cuid2,
_custom: () => _custom,
_date: () => _date,
_decode: () => _decode,
_decodeAsync: () => _decodeAsync,
_default: () => _default,
_discriminatedUnion: () => _discriminatedUnion,
_e164: () => _e164,
_email: () => _email,
_emoji: () => _emoji,
_encode: () => _encode,
_encodeAsync: () => _encodeAsync,
_endsWith: () => _endsWith,
_enum: () => _enum,
_file: () => _file,
_float32: () => _float32,
_float64: () => _float64,
_gt: () => _gt,
_gte: () => _gte,
_guid: () => _guid,
_includes: () => _includes,
_int: () => _int,
_int32: () => _int32,
_int64: () => _int64,
_intersection: () => _intersection,
_ipv4: () => _ipv4,
_ipv6: () => _ipv6,
_isoDate: () => _isoDate,
_isoDateTime: () => _isoDateTime,
_isoDuration: () => _isoDuration,
_isoTime: () => _isoTime,
_jwt: () => _jwt,
_ksuid: () => _ksuid,
_lazy: () => _lazy,
_length: () => _length,
_literal: () => _literal,
_lowercase: () => _lowercase,
_lt: () => _lt,
_lte: () => _lte,
_mac: () => _mac,
_map: () => _map,
_max: () => _lte,
_maxLength: () => _maxLength,
_maxSize: () => _maxSize,
_mime: () => _mime,
_min: () => _gte,
_minLength: () => _minLength,
_minSize: () => _minSize,
_multipleOf: () => _multipleOf,
_nan: () => _nan,
_nanoid: () => _nanoid,
_nativeEnum: () => _nativeEnum,
_negative: () => _negative,
_never: () => _never,
_nonnegative: () => _nonnegative,
_nonoptional: () => _nonoptional,
_nonpositive: () => _nonpositive,
_normalize: () => _normalize,
_null: () => _null,
_nullable: () => _nullable,
_number: () => _number,
_optional: () => _optional,
_overwrite: () => _overwrite,
_parse: () => _parse,
_parseAsync: () => _parseAsync,
_pipe: () => _pipe,
_positive: () => _positive,
_promise: () => _promise,
_property: () => _property,
_readonly: () => _readonly,
_record: () => _record,
_refine: () => _refine,
_regex: () => _regex,
_safeDecode: () => _safeDecode,
_safeDecodeAsync: () => _safeDecodeAsync,
_safeEncode: () => _safeEncode,
_safeEncodeAsync: () => _safeEncodeAsync,
_safeParse: () => _safeParse,
_safeParseAsync: () => _safeParseAsync,
_set: () => _set,
_size: () => _size,
_slugify: () => _slugify,
_startsWith: () => _startsWith,
_string: () => _string,
_stringFormat: () => _stringFormat,
_stringbool: () => _stringbool,
_success: () => _success,
_superRefine: () => _superRefine,
_symbol: () => _symbol,
_templateLiteral: () => _templateLiteral,
_toLowerCase: () => _toLowerCase,
_toUpperCase: () => _toUpperCase,
_transform: () => _transform,
_trim: () => _trim,
_tuple: () => _tuple,
_uint32: () => _uint32,
_uint64: () => _uint64,
_ulid: () => _ulid,
_undefined: () => _undefined,
_union: () => _union,
_unknown: () => _unknown,
_uppercase: () => _uppercase,
_url: () => _url,
_uuid: () => _uuid,
_uuidv4: () => _uuidv4,
_uuidv6: () => _uuidv6,
_uuidv7: () => _uuidv7,
_void: () => _void,
_xid: () => _xid,
_xor: () => _xor,
clone: () => clone,
config: () => config,
createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
createToJSONSchemaMethod: () => createToJSONSchemaMethod,
decode: () => decode,
decodeAsync: () => decodeAsync,
describe: () => describe,
encode: () => encode,
encodeAsync: () => encodeAsync,
extractDefs: () => extractDefs,
finalize: () => finalize,
flattenError: () => flattenError,
formatError: () => formatError,
globalConfig: () => globalConfig,
globalRegistry: () => globalRegistry,
initializeContext: () => initializeContext,
isValidBase64: () => isValidBase64,
isValidBase64URL: () => isValidBase64URL,
isValidJWT: () => isValidJWT,
locales: () => locales_exports,
meta: () => meta,
parse: () => parse,
parseAsync: () => parseAsync,
prettifyError: () => prettifyError,
process: () => process,
regexes: () => regexes_exports,
registry: () => registry,
safeDecode: () => safeDecode,
safeDecodeAsync: () => safeDecodeAsync,
safeEncode: () => safeEncode,
safeEncodeAsync: () => safeEncodeAsync,
safeParse: () => safeParse,
safeParseAsync: () => safeParseAsync,
toDotPath: () => toDotPath,
toJSONSchema: () => toJSONSchema,
treeifyError: () => treeifyError,
util: () => util_exports,
version: () => version
});
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/checks.js
var checks_exports = /* @__PURE__ */ __exportAll({
endsWith: () => _endsWith,
gt: () => _gt,
gte: () => _gte,
includes: () => _includes,
length: () => _length,
lowercase: () => _lowercase,
lt: () => _lt,
lte: () => _lte,
maxLength: () => _maxLength,
maxSize: () => _maxSize,
mime: () => _mime,
minLength: () => _minLength,
minSize: () => _minSize,
multipleOf: () => _multipleOf,
negative: () => _negative,
nonnegative: () => _nonnegative,
nonpositive: () => _nonpositive,
normalize: () => _normalize,
overwrite: () => _overwrite,
positive: () => _positive,
property: () => _property,
regex: () => _regex,
size: () => _size,
slugify: () => _slugify,
startsWith: () => _startsWith,
toLowerCase: () => _toLowerCase,
toUpperCase: () => _toUpperCase,
trim: () => _trim,
uppercase: () => _uppercase
});
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/from-json-schema.js
const z = {
...schemas_exports,
...checks_exports,
iso: iso_exports
};
const RECOGNIZED_KEYS = /*@__PURE__*/ new Set([
"$schema",
"$ref",
"$defs",
"definitions",
"$id",
"id",
"$comment",
"$anchor",
"$vocabulary",
"$dynamicRef",
"$dynamicAnchor",
"type",
"enum",
"const",
"anyOf",
"oneOf",
"allOf",
"not",
"properties",
"required",
"additionalProperties",
"patternProperties",
"propertyNames",
"minProperties",
"maxProperties",
"items",
"prefixItems",
"additionalItems",
"minItems",
"maxItems",
"uniqueItems",
"contains",
"minContains",
"maxContains",
"minLength",
"maxLength",
"pattern",
"format",
"minimum",
"maximum",
"exclusiveMinimum",
"exclusiveMaximum",
"multipleOf",
"description",
"default",
"contentEncoding",
"contentMediaType",
"contentSchema",
"unevaluatedItems",
"unevaluatedProperties",
"if",
"then",
"else",
"dependentSchemas",
"dependentRequired",
"nullable",
"readOnly"
]);
function detectVersion(schema, defaultTarget) {
const $schema = schema.$schema;
if ($schema === "https://json-schema.org/draft/2020-12/schema") return "draft-2020-12";
if ($schema === "http://json-schema.org/draft-07/schema#") return "draft-7";
if ($schema === "http://json-schema.org/draft-04/schema#") return "draft-4";
return defaultTarget ?? "draft-2020-12";
}
function resolveRef(ref, ctx) {
if (!ref.startsWith("#")) throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
const path = ref.slice(1).split("/").filter(Boolean);
if (path.length === 0) return ctx.rootSchema;
const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
if (path[0] === defsKey) {
const key = path[1];
if (!key || !ctx.defs[key]) throw new Error(`Reference not found: ${ref}`);
return ctx.defs[key];
}
throw new Error(`Reference not found: ${ref}`);
}
function convertBaseSchema(schema, ctx) {
if (schema.not !== void 0) {
if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) return z.never();
throw new Error("not is not supported in Zod (except { not: {} } for never)");
}
if (schema.unevaluatedItems !== void 0) throw new Error("unevaluatedItems is not supported");
if (schema.unevaluatedProperties !== void 0) throw new Error("unevaluatedProperties is not supported");
if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) throw new Error("Conditional schemas (if/then/else) are not supported");
if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) throw new Error("dependentSchemas and dependentRequired are not supported");
if (schema.$ref) {
const refPath = schema.$ref;
if (ctx.refs.has(refPath)) return ctx.refs.get(refPath);
if (ctx.processing.has(refPath)) return z.lazy(() => {
if (!ctx.refs.has(refPath)) throw new Error(`Circular reference not resolved: ${refPath}`);
return ctx.refs.get(refPath);
});
ctx.processing.add(refPath);
const zodSchema = convertSchema(resolveRef(refPath, ctx), ctx);
ctx.refs.set(refPath, zodSchema);
ctx.processing.delete(refPath);
return zodSchema;
}
if (schema.enum !== void 0) {
const enumValues = schema.enum;
if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) return z.null();
if (enumValues.length === 0) return z.never();
if (enumValues.length === 1) return z.literal(enumValues[0]);
if (enumValues.every((v) => typeof v === "string")) return z.enum(enumValues);
const literalSchemas = enumValues.map((v) => z.literal(v));
if (literalSchemas.length < 2) return literalSchemas[0];
return z.union([
literalSchemas[0],
literalSchemas[1],
...literalSchemas.slice(2)
]);
}
if (schema.const !== void 0) return z.literal(schema.const);
const type = schema.type;
if (Array.isArray(type)) {
const typeSchemas = type.map((t) => {
return convertBaseSchema({
...schema,
type: t
}, ctx);
});
if (typeSchemas.length === 0) return z.never();
if (typeSchemas.length === 1) return typeSchemas[0];
return z.union(typeSchemas);
}
if (!type) return z.any();
let zodSchema;
switch (type) {
case "string": {
let stringSchema = z.string();
if (schema.format) {
const format = schema.format;
if (format === "email") stringSchema = stringSchema.check(z.email());
else if (format === "uri" || format === "uri-reference") stringSchema = stringSchema.check(z.url());
else if (format === "uuid" || format === "guid") stringSchema = stringSchema.check(z.uuid());
else if (format === "date-time") stringSchema = stringSchema.check(z.iso.datetime());
else if (format === "date") stringSchema = stringSchema.check(z.iso.date());
else if (format === "time") stringSchema = stringSchema.check(z.iso.time());
else if (format === "duration") stringSchema = stringSchema.check(z.iso.duration());
else if (format === "ipv4") stringSchema = stringSchema.check(z.ipv4());
else if (format === "ipv6") stringSchema = stringSchema.check(z.ipv6());
else if (format === "mac") stringSchema = stringSchema.check(z.mac());
else if (format === "cidr") stringSchema = stringSchema.check(z.cidrv4());
else if (format === "cidr-v6") stringSchema = stringSchema.check(z.cidrv6());
else if (format === "base64") stringSchema = stringSchema.check(z.base64());
else if (format === "base64url") stringSchema = stringSchema.check(z.base64url());
else if (format === "e164") stringSchema = stringSchema.check(z.e164());
else if (format === "jwt") stringSchema = stringSchema.check(z.jwt());
else if (format === "emoji") stringSchema = stringSchema.check(z.emoji());
else if (format === "nanoid") stringSchema = stringSchema.check(z.nanoid());
else if (format === "cuid") stringSchema = stringSchema.check(z.cuid());
else if (format === "cuid2") stringSchema = stringSchema.check(z.cuid2());
else if (format === "ulid") stringSchema = stringSchema.check(z.ulid());
else if (format === "xid") stringSchema = stringSchema.check(z.xid());
else if (format === "ksuid") stringSchema = stringSchema.check(z.ksuid());
}
if (typeof schema.minLength === "number") stringSchema = stringSchema.min(schema.minLength);
if (typeof schema.maxLength === "number") stringSchema = stringSchema.max(schema.maxLength);
if (schema.pattern) stringSchema = stringSchema.regex(new RegExp(schema.pattern));
zodSchema = stringSchema;
break;
}
case "number":
case "integer": {
let numberSchema = type === "integer" ? z.number().int() : z.number();
if (typeof schema.minimum === "number") numberSchema = numberSchema.min(schema.minimum);
if (typeof schema.maximum === "number") numberSchema = numberSchema.max(schema.maximum);
if (typeof schema.exclusiveMinimum === "number") numberSchema = numberSchema.gt(schema.exclusiveMinimum);
else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") numberSchema = numberSchema.gt(schema.minimum);
if (typeof schema.exclusiveMaximum === "number") numberSchema = numberSchema.lt(schema.exclusiveMaximum);
else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") numberSchema = numberSchema.lt(schema.maximum);
if (typeof schema.multipleOf === "number") numberSchema = numberSchema.multipleOf(schema.multipleOf);
zodSchema = numberSchema;
break;
}
case "boolean":
zodSchema = z.boolean();
break;
case "null":
zodSchema = z.null();
break;
case "object": {
const shape = {};
const properties = schema.properties || {};
const requiredSet = new Set(schema.required || []);
for (const [key, propSchema] of Object.entries(properties)) {
const propZodSchema = convertSchema(propSchema, ctx);
shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
}
if (schema.propertyNames) {
const keySchema = convertSchema(schema.propertyNames, ctx);
const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
if (Object.keys(shape).length === 0) {
zodSchema = z.record(keySchema, valueSchema);
break;
}
const objectSchema = z.object(shape).passthrough();
const recordSchema = z.looseRecord(keySchema, valueSchema);
zodSchema = z.intersection(objectSchema, recordSchema);
break;
}
if (schema.patternProperties) {
const patternProps = schema.patternProperties;
const patternKeys = Object.keys(patternProps);
const looseRecords = [];
for (const pattern of patternKeys) {
const patternValue = convertSchema(patternProps[pattern], ctx);
const keySchema = z.string().regex(new RegExp(pattern));
looseRecords.push(z.looseRecord(keySchema, patternValue));
}
const schemasToIntersect = [];
if (Object.keys(shape).length > 0) schemasToIntersect.push(z.object(shape).passthrough());
schemasToIntersect.push(...looseRecords);
if (schemasToIntersect.length === 0) zodSchema = z.object({}).passthrough();
else if (schemasToIntersect.length === 1) zodSchema = schemasToIntersect[0];
else {
let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
for (let i = 2; i < schemasToIntersect.length; i++) result = z.intersection(result, schemasToIntersect[i]);
zodSchema = result;
}
break;
}
const objectSchema = z.object(shape);
if (schema.additionalProperties === false) zodSchema = objectSchema.strict();
else if (typeof schema.additionalProperties === "object") zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
else zodSchema = objectSchema.passthrough();
break;
}
case "array": {
const prefixItems = schema.prefixItems;
const items = schema.items;
if (prefixItems && Array.isArray(prefixItems)) {
const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
else zodSchema = z.tuple(tupleItems);
if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
} else if (Array.isArray(items)) {
const tupleItems = items.map((item) => convertSchema(item, ctx));
const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
else zodSchema = z.tuple(tupleItems);
if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
} else if (items !== void 0) {
const element = convertSchema(items, ctx);
let arraySchema = z.array(element);
if (typeof schema.minItems === "number") arraySchema = arraySchema.min(schema.minItems);
if (typeof schema.maxItems === "number") arraySchema = arraySchema.max(schema.maxItems);
zodSchema = arraySchema;
} else zodSchema = z.array(z.any());
break;
}
default: throw new Error(`Unsupported type: ${type}`);
}
return zodSchema;
}
function convertSchema(schema, ctx) {
if (typeof schema === "boolean") return schema ? z.any() : z.never();
let baseSchema = convertBaseSchema(schema, ctx);
const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
if (schema.anyOf && Array.isArray(schema.anyOf)) {
const options = schema.anyOf.map((s) => convertSchema(s, ctx));
const anyOfUnion = z.union(options);
baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
}
if (schema.oneOf && Array.isArray(schema.oneOf)) {
const options = schema.oneOf.map((s) => convertSchema(s, ctx));
const oneOfUnion = z.xor(options);
baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
}
if (schema.allOf && Array.isArray(schema.allOf)) {
if (schema.allOf.length === 0) baseSchema = hasExplicitType ? baseSchema : z.any();
else {
let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
const startIdx = hasExplicitType ? 0 : 1;
for (let i = startIdx; i < schema.allOf.length; i++) result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
baseSchema = result;
}
}
if (schema.nullable === true && ctx.version === "openapi-3.0") baseSchema = z.nullable(baseSchema);
if (schema.readOnly === true) baseSchema = z.readonly(baseSchema);
if (schema.default !== void 0) baseSchema = baseSchema.default(schema.default);
const extraMeta = {};
for (const key of [
"$id",
"id",
"$comment",
"$anchor",
"$vocabulary",
"$dynamicRef",
"$dynamicAnchor"
]) if (key in schema) extraMeta[key] = schema[key];
for (const key of [
"contentEncoding",
"contentMediaType",
"contentSchema"
]) if (key in schema) extraMeta[key] = schema[key];
for (const key of Object.keys(schema)) if (!RECOGNIZED_KEYS.has(key)) extraMeta[key] = schema[key];
if (Object.keys(extraMeta).length > 0) ctx.registry.add(baseSchema, extraMeta);
if (schema.description) baseSchema = baseSchema.describe(schema.description);
return baseSchema;
}
/**
* Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */
function fromJSONSchema(schema, params) {
if (typeof schema === "boolean") return schema ? z.any() : z.never();
let normalized;
try {
normalized = JSON.parse(JSON.stringify(schema));
} catch {
throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
}
const ctx = {
version: detectVersion(normalized, params?.defaultTarget),
defs: normalized.$defs || normalized.definitions || {},
refs: /* @__PURE__ */ new Map(),
processing: /* @__PURE__ */ new Set(),
rootSchema: normalized,
registry: params?.registry ?? globalRegistry
};
return convertSchema(normalized, ctx);
}
//#endregion
//#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
var external_exports = /* @__PURE__ */ __exportAll({
$brand: () => $brand,
$input: () => $input,
$output: () => $output,
NEVER: () => NEVER,
TimePrecision: () => TimePrecision,
ZodAny: () => ZodAny,
ZodArray: () => ZodArray,
ZodBase64: () => ZodBase64,
ZodBase64URL: () => ZodBase64URL,
ZodBigInt: () => ZodBigInt,
ZodBigIntFormat: () => ZodBigIntFormat,
ZodBoolean: () => ZodBoolean,
ZodCIDRv4: () => ZodCIDRv4,
ZodCIDRv6: () => ZodCIDRv6,
ZodCUID: () => ZodCUID,
ZodCUID2: () => ZodCUID2,
ZodCatch: () => ZodCatch,
ZodCodec: () => ZodCodec,
ZodCustom: () => ZodCustom,
ZodCustomStringFormat: () => ZodCustomStringFormat,
ZodDate: () => ZodDate,
ZodDefault: () => ZodDefault,
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
ZodE164: () => ZodE164,
ZodEmail: () => ZodEmail,
ZodEmoji: () => ZodEmoji,
ZodEnum: () => ZodEnum,
ZodError: () => ZodError,
ZodExactOptional: () => ZodExactOptional,
ZodFile: () => ZodFile,
ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
ZodFunction: () => ZodFunction,
ZodGUID: () => ZodGUID,
ZodIPv4: () => ZodIPv4,
ZodIPv6: () => ZodIPv6,
ZodISODate: () => ZodISODate,
ZodISODateTime: () => ZodISODateTime,
ZodISODuration: () => ZodISODuration,
ZodISOTime: () => ZodISOTime,
ZodIntersection: () => ZodIntersection,
ZodIssueCode: () => ZodIssueCode,
ZodJWT: () => ZodJWT,
ZodKSUID: () => ZodKSUID,
ZodLazy: () => ZodLazy,
ZodLiteral: () => ZodLiteral,
ZodMAC: () => ZodMAC,
ZodMap: () => ZodMap,
ZodNaN: () => ZodNaN,
ZodNanoID: () => ZodNanoID,
ZodNever: () => ZodNever,
ZodNonOptional: () => ZodNonOptional,
ZodNull: () => ZodNull,
ZodNullable: () => ZodNullable,
ZodNumber: () => ZodNumber,
ZodNumberFormat: () => ZodNumberFormat,
ZodObject: () => ZodObject,
ZodOptional: () => ZodOptional,
ZodPipe: () => ZodPipe,
ZodPrefault: () => ZodPrefault,
ZodPreprocess: () => ZodPreprocess,
ZodPromise: () => ZodPromise,
ZodReadonly: () => ZodReadonly,
ZodRealError: () => ZodRealError,
ZodRecord: () => ZodRecord,
ZodSet: () => ZodSet,
ZodString: () => ZodString,
ZodStringFormat: () => ZodStringFormat,
ZodSuccess: () => ZodSuccess,
ZodSymbol: () => ZodSymbol,
ZodTemplateLiteral: () => ZodTemplateLiteral,
ZodTransform: () => ZodTransform,
ZodTuple: () => ZodTuple,
ZodType: () => ZodType,
ZodULID: () => ZodULID,
ZodURL: () => ZodURL,
ZodUUID: () => ZodUUID,
ZodUndefined: () => ZodUndefined,
ZodUnion: () => ZodUnion,
ZodUnknown: () => ZodUnknown,
ZodVoid: () => ZodVoid,
ZodXID: () => ZodXID,
ZodXor: () => ZodXor,
_ZodString: () => _ZodString,
_default: () => _default$1,
_function: () => _function,
any: () => any,
array: () => array,
base64: () => base64,
base64url: () => base64url,
bigint: () => bigint,
boolean: () => boolean,
catch: () => _catch$1,
check: () => check,
cidrv4: () => cidrv4,
cidrv6: () => cidrv6,
clone: () => clone,
codec: () => codec,
coerce: () => coerce_exports,
config: () => config,
core: () => core_exports,
cuid: () => cuid,
cuid2: () => cuid2,
custom: () => custom,
date: () => date,
decode: () => decode$1,
decodeAsync: () => decodeAsync$1,
describe: () => describe$1,
discriminatedUnion: () => discriminatedUnion,
e164: () => e164,
email: () => email,
emoji: () => emoji,
encode: () => encode$1,
encodeAsync: () => encodeAsync$1,
endsWith: () => _endsWith,
enum: () => _enum$1,
exactOptional: () => exactOptional,
file: () => file,
flattenError: () => flattenError,
float32: () => float32,
float64: () => float64,
formatError: () => formatError,
fromJSONSchema: () => fromJSONSchema,
function: () => _function,
getErrorMap: () => getErrorMap,
globalRegistry: () => globalRegistry,
gt: () => _gt,
gte: () => _gte,
guid: () => guid,
hash: () => hash,
hex: () => hex,
hostname: () => hostname,
httpUrl: () => httpUrl,
includes: () => _includes,
instanceof: () => _instanceof,
int: () => int,
int32: () => int32,
int64: () => int64,
intersection: () => intersection,
invertCodec: () => invertCodec,
ipv4: () => ipv4,
ipv6: () => ipv6,
iso: () => iso_exports,
json: () => json,
jwt: () => jwt,
keyof: () => keyof,
ksuid: () => ksuid,
lazy: () => lazy,
length: () => _length,
literal: () => literal,
locales: () => locales_exports,
looseObject: () => looseObject,
looseRecord: () => looseRecord,
lowercase: () => _lowercase,
lt: () => _lt,
lte: () => _lte,
mac: () => mac,
map: () => map,
maxLength: () => _maxLength,
maxSize: () => _maxSize,
meta: () => meta$1,
mime: () => _mime,
minLength: () => _minLength,
minSize: () => _minSize,
multipleOf: () => _multipleOf,
nan: () => nan,
nanoid: () => nanoid,
nativeEnum: () => nativeEnum,
negative: () => _negative,
never: () => never,
nonnegative: () => _nonnegative,
nonoptional: () => nonoptional,
nonpositive: () => _nonpositive,
normalize: () => _normalize,
null: () => _null$1,
nullable: () => nullable,
nullish: () => nullish,
number: () => number,
object: () => object,
optional: () => optional,
overwrite: () => _overwrite,
parse: () => parse$1,
parseAsync: () => parseAsync$1,
partialRecord: () => partialRecord,
pipe: () => pipe,
positive: () => _positive,
prefault: () => prefault,
preprocess: () => preprocess,
prettifyError: () => prettifyError,
promise: () => promise,
property: () => _property,
readonly: () => readonly,
record: () => record,
refine: () => refine,
regex: () => _regex,
regexes: () => regexes_exports,
registry: () => registry,
safeDecode: () => safeDecode$1,
safeDecodeAsync: () => safeDecodeAsync$1,
safeEncode: () => safeEncode$1,
safeEncodeAsync: () => safeEncodeAsync$1,
safeParse: () => safeParse$1,
safeParseAsync: () => safeParseAsync$1,
set: () => set,
setErrorMap: () => setErrorMap,
size: () => _size,
slugify: () => _slugify,
startsWith: () => _startsWith,
strictObject: () => strictObject,
string: () => string,
stringFormat: () => stringFormat,
stringbool: () => stringbool,
success: () => success,
superRefine: () => superRefine,
symbol: () => symbol,
templateLiteral: () => templateLiteral,
toJSONSchema: () => toJSONSchema,
toLowerCase: () => _toLowerCase,
toUpperCase: () => _toUpperCase,
transform: () => transform,
treeifyError: () => treeifyError,
trim: () => _trim,
tuple: () => tuple,
uint32: () => uint32,
uint64: () => uint64,
ulid: () => ulid,
undefined: () => _undefined$1,
union: () => union,
unknown: () => unknown,
uppercase: () => _uppercase,
url: () => url,
util: () => util_exports,
uuid: () => uuid,
uuidv4: () => uuidv4,
uuidv6: () => uuidv6,
uuidv7: () => uuidv7,
void: () => _void$1,
xid: () => xid,
xor: () => xor
});
config(en_default());
//#endregion
export { external_exports as t };