28745 lines
1.0 MiB
28745 lines
1.0 MiB
// @bun
|
|
var __defProp = Object.defineProperty;
|
|
var __returnValue = (v) => v;
|
|
function __exportSetter(name, newValue) {
|
|
this[name] = __returnValue.bind(null, newValue);
|
|
}
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, {
|
|
get: all[name],
|
|
enumerable: true,
|
|
configurable: true,
|
|
set: __exportSetter.bind(all, name)
|
|
});
|
|
};
|
|
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
|
|
|
|
// src/shared/logger.ts
|
|
var exports_logger = {};
|
|
__export(exports_logger, {
|
|
log: () => log,
|
|
getLogFilePath: () => getLogFilePath
|
|
});
|
|
import * as fs from "fs";
|
|
import * as os from "os";
|
|
import * as path from "path";
|
|
function flush() {
|
|
if (buffer.length === 0)
|
|
return;
|
|
const data = buffer.join("");
|
|
buffer = [];
|
|
try {
|
|
fs.appendFileSync(logFile, data);
|
|
} catch {}
|
|
}
|
|
function scheduleFlush() {
|
|
if (flushTimer)
|
|
return;
|
|
flushTimer = setTimeout(() => {
|
|
flushTimer = null;
|
|
flush();
|
|
}, FLUSH_INTERVAL_MS);
|
|
}
|
|
function log(message, data) {
|
|
try {
|
|
const timestamp = new Date().toISOString();
|
|
const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
|
|
`;
|
|
buffer.push(logEntry);
|
|
if (buffer.length >= BUFFER_SIZE_LIMIT) {
|
|
flush();
|
|
} else {
|
|
scheduleFlush();
|
|
}
|
|
} catch {}
|
|
}
|
|
function getLogFilePath() {
|
|
return logFile;
|
|
}
|
|
var logFile, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
|
|
var init_logger = __esm(() => {
|
|
logFile = path.join(os.tmpdir(), "tmux-utils.log");
|
|
buffer = [];
|
|
});
|
|
|
|
// node_modules/zod/v4/classic/external.js
|
|
var exports_external = {};
|
|
__export(exports_external, {
|
|
xor: () => xor,
|
|
xid: () => xid2,
|
|
void: () => _void2,
|
|
uuidv7: () => uuidv7,
|
|
uuidv6: () => uuidv6,
|
|
uuidv4: () => uuidv4,
|
|
uuid: () => uuid2,
|
|
util: () => exports_util,
|
|
url: () => url,
|
|
uppercase: () => _uppercase,
|
|
unknown: () => unknown,
|
|
union: () => union,
|
|
undefined: () => _undefined3,
|
|
ulid: () => ulid2,
|
|
uint64: () => uint64,
|
|
uint32: () => uint32,
|
|
tuple: () => tuple,
|
|
trim: () => _trim,
|
|
treeifyError: () => treeifyError,
|
|
transform: () => transform,
|
|
toUpperCase: () => _toUpperCase,
|
|
toLowerCase: () => _toLowerCase,
|
|
toJSONSchema: () => toJSONSchema,
|
|
templateLiteral: () => templateLiteral,
|
|
symbol: () => symbol,
|
|
superRefine: () => superRefine,
|
|
success: () => success,
|
|
stringbool: () => stringbool,
|
|
stringFormat: () => stringFormat,
|
|
string: () => string2,
|
|
strictObject: () => strictObject,
|
|
startsWith: () => _startsWith,
|
|
slugify: () => _slugify,
|
|
size: () => _size,
|
|
setErrorMap: () => setErrorMap,
|
|
set: () => set,
|
|
safeParseAsync: () => safeParseAsync2,
|
|
safeParse: () => safeParse2,
|
|
safeEncodeAsync: () => safeEncodeAsync2,
|
|
safeEncode: () => safeEncode2,
|
|
safeDecodeAsync: () => safeDecodeAsync2,
|
|
safeDecode: () => safeDecode2,
|
|
registry: () => registry,
|
|
regexes: () => exports_regexes,
|
|
regex: () => _regex,
|
|
refine: () => refine,
|
|
record: () => record,
|
|
readonly: () => readonly,
|
|
property: () => _property,
|
|
promise: () => promise,
|
|
prettifyError: () => prettifyError,
|
|
preprocess: () => preprocess,
|
|
prefault: () => prefault,
|
|
positive: () => _positive,
|
|
pipe: () => pipe,
|
|
partialRecord: () => partialRecord,
|
|
parseAsync: () => parseAsync2,
|
|
parse: () => parse3,
|
|
overwrite: () => _overwrite,
|
|
optional: () => optional,
|
|
object: () => object,
|
|
number: () => number2,
|
|
nullish: () => nullish2,
|
|
nullable: () => nullable,
|
|
null: () => _null3,
|
|
normalize: () => _normalize,
|
|
nonpositive: () => _nonpositive,
|
|
nonoptional: () => nonoptional,
|
|
nonnegative: () => _nonnegative,
|
|
never: () => never,
|
|
negative: () => _negative,
|
|
nativeEnum: () => nativeEnum,
|
|
nanoid: () => nanoid2,
|
|
nan: () => nan,
|
|
multipleOf: () => _multipleOf,
|
|
minSize: () => _minSize,
|
|
minLength: () => _minLength,
|
|
mime: () => _mime,
|
|
meta: () => meta2,
|
|
maxSize: () => _maxSize,
|
|
maxLength: () => _maxLength,
|
|
map: () => map,
|
|
mac: () => mac2,
|
|
lte: () => _lte,
|
|
lt: () => _lt,
|
|
lowercase: () => _lowercase,
|
|
looseRecord: () => looseRecord,
|
|
looseObject: () => looseObject,
|
|
locales: () => exports_locales,
|
|
literal: () => literal,
|
|
length: () => _length,
|
|
lazy: () => lazy,
|
|
ksuid: () => ksuid2,
|
|
keyof: () => keyof,
|
|
jwt: () => jwt,
|
|
json: () => json,
|
|
iso: () => exports_iso,
|
|
ipv6: () => ipv62,
|
|
ipv4: () => ipv42,
|
|
intersection: () => intersection,
|
|
int64: () => int64,
|
|
int32: () => int32,
|
|
int: () => int,
|
|
instanceof: () => _instanceof,
|
|
includes: () => _includes,
|
|
httpUrl: () => httpUrl,
|
|
hostname: () => hostname2,
|
|
hex: () => hex2,
|
|
hash: () => hash,
|
|
guid: () => guid2,
|
|
gte: () => _gte,
|
|
gt: () => _gt,
|
|
globalRegistry: () => globalRegistry,
|
|
getErrorMap: () => getErrorMap,
|
|
function: () => _function,
|
|
fromJSONSchema: () => fromJSONSchema,
|
|
formatError: () => formatError,
|
|
float64: () => float64,
|
|
float32: () => float32,
|
|
flattenError: () => flattenError,
|
|
file: () => file,
|
|
exactOptional: () => exactOptional,
|
|
enum: () => _enum2,
|
|
endsWith: () => _endsWith,
|
|
encodeAsync: () => encodeAsync2,
|
|
encode: () => encode2,
|
|
emoji: () => emoji2,
|
|
email: () => email2,
|
|
e164: () => e1642,
|
|
discriminatedUnion: () => discriminatedUnion,
|
|
describe: () => describe2,
|
|
decodeAsync: () => decodeAsync2,
|
|
decode: () => decode2,
|
|
date: () => date3,
|
|
custom: () => custom,
|
|
cuid2: () => cuid22,
|
|
cuid: () => cuid3,
|
|
core: () => exports_core2,
|
|
config: () => config,
|
|
coerce: () => exports_coerce,
|
|
codec: () => codec,
|
|
clone: () => clone,
|
|
cidrv6: () => cidrv62,
|
|
cidrv4: () => cidrv42,
|
|
check: () => check,
|
|
catch: () => _catch2,
|
|
boolean: () => boolean2,
|
|
bigint: () => bigint2,
|
|
base64url: () => base64url2,
|
|
base64: () => base642,
|
|
array: () => array,
|
|
any: () => any,
|
|
_function: () => _function,
|
|
_default: () => _default2,
|
|
_ZodString: () => _ZodString,
|
|
ZodXor: () => ZodXor,
|
|
ZodXID: () => ZodXID,
|
|
ZodVoid: () => ZodVoid,
|
|
ZodUnknown: () => ZodUnknown,
|
|
ZodUnion: () => ZodUnion,
|
|
ZodUndefined: () => ZodUndefined,
|
|
ZodUUID: () => ZodUUID,
|
|
ZodURL: () => ZodURL,
|
|
ZodULID: () => ZodULID,
|
|
ZodType: () => ZodType,
|
|
ZodTuple: () => ZodTuple,
|
|
ZodTransform: () => ZodTransform,
|
|
ZodTemplateLiteral: () => ZodTemplateLiteral,
|
|
ZodSymbol: () => ZodSymbol,
|
|
ZodSuccess: () => ZodSuccess,
|
|
ZodStringFormat: () => ZodStringFormat,
|
|
ZodString: () => ZodString,
|
|
ZodSet: () => ZodSet,
|
|
ZodRecord: () => ZodRecord,
|
|
ZodRealError: () => ZodRealError,
|
|
ZodReadonly: () => ZodReadonly,
|
|
ZodPromise: () => ZodPromise,
|
|
ZodPrefault: () => ZodPrefault,
|
|
ZodPipe: () => ZodPipe,
|
|
ZodOptional: () => ZodOptional,
|
|
ZodObject: () => ZodObject,
|
|
ZodNumberFormat: () => ZodNumberFormat,
|
|
ZodNumber: () => ZodNumber,
|
|
ZodNullable: () => ZodNullable,
|
|
ZodNull: () => ZodNull,
|
|
ZodNonOptional: () => ZodNonOptional,
|
|
ZodNever: () => ZodNever,
|
|
ZodNanoID: () => ZodNanoID,
|
|
ZodNaN: () => ZodNaN,
|
|
ZodMap: () => ZodMap,
|
|
ZodMAC: () => ZodMAC,
|
|
ZodLiteral: () => ZodLiteral,
|
|
ZodLazy: () => ZodLazy,
|
|
ZodKSUID: () => ZodKSUID,
|
|
ZodJWT: () => ZodJWT,
|
|
ZodIssueCode: () => ZodIssueCode,
|
|
ZodIntersection: () => ZodIntersection,
|
|
ZodISOTime: () => ZodISOTime,
|
|
ZodISODuration: () => ZodISODuration,
|
|
ZodISODateTime: () => ZodISODateTime,
|
|
ZodISODate: () => ZodISODate,
|
|
ZodIPv6: () => ZodIPv6,
|
|
ZodIPv4: () => ZodIPv4,
|
|
ZodGUID: () => ZodGUID,
|
|
ZodFunction: () => ZodFunction,
|
|
ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
|
|
ZodFile: () => ZodFile,
|
|
ZodExactOptional: () => ZodExactOptional,
|
|
ZodError: () => ZodError,
|
|
ZodEnum: () => ZodEnum,
|
|
ZodEmoji: () => ZodEmoji,
|
|
ZodEmail: () => ZodEmail,
|
|
ZodE164: () => ZodE164,
|
|
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
|
|
ZodDefault: () => ZodDefault,
|
|
ZodDate: () => ZodDate,
|
|
ZodCustomStringFormat: () => ZodCustomStringFormat,
|
|
ZodCustom: () => ZodCustom,
|
|
ZodCodec: () => ZodCodec,
|
|
ZodCatch: () => ZodCatch,
|
|
ZodCUID2: () => ZodCUID2,
|
|
ZodCUID: () => ZodCUID,
|
|
ZodCIDRv6: () => ZodCIDRv6,
|
|
ZodCIDRv4: () => ZodCIDRv4,
|
|
ZodBoolean: () => ZodBoolean,
|
|
ZodBigIntFormat: () => ZodBigIntFormat,
|
|
ZodBigInt: () => ZodBigInt,
|
|
ZodBase64URL: () => ZodBase64URL,
|
|
ZodBase64: () => ZodBase64,
|
|
ZodArray: () => ZodArray,
|
|
ZodAny: () => ZodAny,
|
|
TimePrecision: () => TimePrecision,
|
|
NEVER: () => NEVER,
|
|
$output: () => $output,
|
|
$input: () => $input,
|
|
$brand: () => $brand
|
|
});
|
|
|
|
// node_modules/zod/v4/core/index.js
|
|
var exports_core2 = {};
|
|
__export(exports_core2, {
|
|
version: () => version,
|
|
util: () => exports_util,
|
|
treeifyError: () => treeifyError,
|
|
toJSONSchema: () => toJSONSchema,
|
|
toDotPath: () => toDotPath,
|
|
safeParseAsync: () => safeParseAsync,
|
|
safeParse: () => safeParse,
|
|
safeEncodeAsync: () => safeEncodeAsync,
|
|
safeEncode: () => safeEncode,
|
|
safeDecodeAsync: () => safeDecodeAsync,
|
|
safeDecode: () => safeDecode,
|
|
registry: () => registry,
|
|
regexes: () => exports_regexes,
|
|
process: () => process2,
|
|
prettifyError: () => prettifyError,
|
|
parseAsync: () => parseAsync,
|
|
parse: () => parse,
|
|
meta: () => meta,
|
|
locales: () => exports_locales,
|
|
isValidJWT: () => isValidJWT,
|
|
isValidBase64URL: () => isValidBase64URL,
|
|
isValidBase64: () => isValidBase64,
|
|
initializeContext: () => initializeContext,
|
|
globalRegistry: () => globalRegistry,
|
|
globalConfig: () => globalConfig,
|
|
formatError: () => formatError,
|
|
flattenError: () => flattenError,
|
|
finalize: () => finalize,
|
|
extractDefs: () => extractDefs,
|
|
encodeAsync: () => encodeAsync,
|
|
encode: () => encode,
|
|
describe: () => describe,
|
|
decodeAsync: () => decodeAsync,
|
|
decode: () => decode,
|
|
createToJSONSchemaMethod: () => createToJSONSchemaMethod,
|
|
createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
|
|
config: () => config,
|
|
clone: () => clone,
|
|
_xor: () => _xor,
|
|
_xid: () => _xid,
|
|
_void: () => _void,
|
|
_uuidv7: () => _uuidv7,
|
|
_uuidv6: () => _uuidv6,
|
|
_uuidv4: () => _uuidv4,
|
|
_uuid: () => _uuid,
|
|
_url: () => _url,
|
|
_uppercase: () => _uppercase,
|
|
_unknown: () => _unknown,
|
|
_union: () => _union,
|
|
_undefined: () => _undefined2,
|
|
_ulid: () => _ulid,
|
|
_uint64: () => _uint64,
|
|
_uint32: () => _uint32,
|
|
_tuple: () => _tuple,
|
|
_trim: () => _trim,
|
|
_transform: () => _transform,
|
|
_toUpperCase: () => _toUpperCase,
|
|
_toLowerCase: () => _toLowerCase,
|
|
_templateLiteral: () => _templateLiteral,
|
|
_symbol: () => _symbol,
|
|
_superRefine: () => _superRefine,
|
|
_success: () => _success,
|
|
_stringbool: () => _stringbool,
|
|
_stringFormat: () => _stringFormat,
|
|
_string: () => _string,
|
|
_startsWith: () => _startsWith,
|
|
_slugify: () => _slugify,
|
|
_size: () => _size,
|
|
_set: () => _set,
|
|
_safeParseAsync: () => _safeParseAsync,
|
|
_safeParse: () => _safeParse,
|
|
_safeEncodeAsync: () => _safeEncodeAsync,
|
|
_safeEncode: () => _safeEncode,
|
|
_safeDecodeAsync: () => _safeDecodeAsync,
|
|
_safeDecode: () => _safeDecode,
|
|
_regex: () => _regex,
|
|
_refine: () => _refine,
|
|
_record: () => _record,
|
|
_readonly: () => _readonly,
|
|
_property: () => _property,
|
|
_promise: () => _promise,
|
|
_positive: () => _positive,
|
|
_pipe: () => _pipe,
|
|
_parseAsync: () => _parseAsync,
|
|
_parse: () => _parse,
|
|
_overwrite: () => _overwrite,
|
|
_optional: () => _optional,
|
|
_number: () => _number,
|
|
_nullable: () => _nullable,
|
|
_null: () => _null2,
|
|
_normalize: () => _normalize,
|
|
_nonpositive: () => _nonpositive,
|
|
_nonoptional: () => _nonoptional,
|
|
_nonnegative: () => _nonnegative,
|
|
_never: () => _never,
|
|
_negative: () => _negative,
|
|
_nativeEnum: () => _nativeEnum,
|
|
_nanoid: () => _nanoid,
|
|
_nan: () => _nan,
|
|
_multipleOf: () => _multipleOf,
|
|
_minSize: () => _minSize,
|
|
_minLength: () => _minLength,
|
|
_min: () => _gte,
|
|
_mime: () => _mime,
|
|
_maxSize: () => _maxSize,
|
|
_maxLength: () => _maxLength,
|
|
_max: () => _lte,
|
|
_map: () => _map,
|
|
_mac: () => _mac,
|
|
_lte: () => _lte,
|
|
_lt: () => _lt,
|
|
_lowercase: () => _lowercase,
|
|
_literal: () => _literal,
|
|
_length: () => _length,
|
|
_lazy: () => _lazy,
|
|
_ksuid: () => _ksuid,
|
|
_jwt: () => _jwt,
|
|
_isoTime: () => _isoTime,
|
|
_isoDuration: () => _isoDuration,
|
|
_isoDateTime: () => _isoDateTime,
|
|
_isoDate: () => _isoDate,
|
|
_ipv6: () => _ipv6,
|
|
_ipv4: () => _ipv4,
|
|
_intersection: () => _intersection,
|
|
_int64: () => _int64,
|
|
_int32: () => _int32,
|
|
_int: () => _int,
|
|
_includes: () => _includes,
|
|
_guid: () => _guid,
|
|
_gte: () => _gte,
|
|
_gt: () => _gt,
|
|
_float64: () => _float64,
|
|
_float32: () => _float32,
|
|
_file: () => _file,
|
|
_enum: () => _enum,
|
|
_endsWith: () => _endsWith,
|
|
_encodeAsync: () => _encodeAsync,
|
|
_encode: () => _encode,
|
|
_emoji: () => _emoji2,
|
|
_email: () => _email,
|
|
_e164: () => _e164,
|
|
_discriminatedUnion: () => _discriminatedUnion,
|
|
_default: () => _default,
|
|
_decodeAsync: () => _decodeAsync,
|
|
_decode: () => _decode,
|
|
_date: () => _date,
|
|
_custom: () => _custom,
|
|
_cuid2: () => _cuid2,
|
|
_cuid: () => _cuid,
|
|
_coercedString: () => _coercedString,
|
|
_coercedNumber: () => _coercedNumber,
|
|
_coercedDate: () => _coercedDate,
|
|
_coercedBoolean: () => _coercedBoolean,
|
|
_coercedBigint: () => _coercedBigint,
|
|
_cidrv6: () => _cidrv6,
|
|
_cidrv4: () => _cidrv4,
|
|
_check: () => _check,
|
|
_catch: () => _catch,
|
|
_boolean: () => _boolean,
|
|
_bigint: () => _bigint,
|
|
_base64url: () => _base64url,
|
|
_base64: () => _base64,
|
|
_array: () => _array,
|
|
_any: () => _any,
|
|
TimePrecision: () => TimePrecision,
|
|
NEVER: () => NEVER,
|
|
JSONSchemaGenerator: () => JSONSchemaGenerator,
|
|
JSONSchema: () => exports_json_schema,
|
|
Doc: () => Doc,
|
|
$output: () => $output,
|
|
$input: () => $input,
|
|
$constructor: () => $constructor,
|
|
$brand: () => $brand,
|
|
$ZodXor: () => $ZodXor,
|
|
$ZodXID: () => $ZodXID,
|
|
$ZodVoid: () => $ZodVoid,
|
|
$ZodUnknown: () => $ZodUnknown,
|
|
$ZodUnion: () => $ZodUnion,
|
|
$ZodUndefined: () => $ZodUndefined,
|
|
$ZodUUID: () => $ZodUUID,
|
|
$ZodURL: () => $ZodURL,
|
|
$ZodULID: () => $ZodULID,
|
|
$ZodType: () => $ZodType,
|
|
$ZodTuple: () => $ZodTuple,
|
|
$ZodTransform: () => $ZodTransform,
|
|
$ZodTemplateLiteral: () => $ZodTemplateLiteral,
|
|
$ZodSymbol: () => $ZodSymbol,
|
|
$ZodSuccess: () => $ZodSuccess,
|
|
$ZodStringFormat: () => $ZodStringFormat,
|
|
$ZodString: () => $ZodString,
|
|
$ZodSet: () => $ZodSet,
|
|
$ZodRegistry: () => $ZodRegistry,
|
|
$ZodRecord: () => $ZodRecord,
|
|
$ZodRealError: () => $ZodRealError,
|
|
$ZodReadonly: () => $ZodReadonly,
|
|
$ZodPromise: () => $ZodPromise,
|
|
$ZodPrefault: () => $ZodPrefault,
|
|
$ZodPipe: () => $ZodPipe,
|
|
$ZodOptional: () => $ZodOptional,
|
|
$ZodObjectJIT: () => $ZodObjectJIT,
|
|
$ZodObject: () => $ZodObject,
|
|
$ZodNumberFormat: () => $ZodNumberFormat,
|
|
$ZodNumber: () => $ZodNumber,
|
|
$ZodNullable: () => $ZodNullable,
|
|
$ZodNull: () => $ZodNull,
|
|
$ZodNonOptional: () => $ZodNonOptional,
|
|
$ZodNever: () => $ZodNever,
|
|
$ZodNanoID: () => $ZodNanoID,
|
|
$ZodNaN: () => $ZodNaN,
|
|
$ZodMap: () => $ZodMap,
|
|
$ZodMAC: () => $ZodMAC,
|
|
$ZodLiteral: () => $ZodLiteral,
|
|
$ZodLazy: () => $ZodLazy,
|
|
$ZodKSUID: () => $ZodKSUID,
|
|
$ZodJWT: () => $ZodJWT,
|
|
$ZodIntersection: () => $ZodIntersection,
|
|
$ZodISOTime: () => $ZodISOTime,
|
|
$ZodISODuration: () => $ZodISODuration,
|
|
$ZodISODateTime: () => $ZodISODateTime,
|
|
$ZodISODate: () => $ZodISODate,
|
|
$ZodIPv6: () => $ZodIPv6,
|
|
$ZodIPv4: () => $ZodIPv4,
|
|
$ZodGUID: () => $ZodGUID,
|
|
$ZodFunction: () => $ZodFunction,
|
|
$ZodFile: () => $ZodFile,
|
|
$ZodExactOptional: () => $ZodExactOptional,
|
|
$ZodError: () => $ZodError,
|
|
$ZodEnum: () => $ZodEnum,
|
|
$ZodEncodeError: () => $ZodEncodeError,
|
|
$ZodEmoji: () => $ZodEmoji,
|
|
$ZodEmail: () => $ZodEmail,
|
|
$ZodE164: () => $ZodE164,
|
|
$ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
|
|
$ZodDefault: () => $ZodDefault,
|
|
$ZodDate: () => $ZodDate,
|
|
$ZodCustomStringFormat: () => $ZodCustomStringFormat,
|
|
$ZodCustom: () => $ZodCustom,
|
|
$ZodCodec: () => $ZodCodec,
|
|
$ZodCheckUpperCase: () => $ZodCheckUpperCase,
|
|
$ZodCheckStringFormat: () => $ZodCheckStringFormat,
|
|
$ZodCheckStartsWith: () => $ZodCheckStartsWith,
|
|
$ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
|
|
$ZodCheckRegex: () => $ZodCheckRegex,
|
|
$ZodCheckProperty: () => $ZodCheckProperty,
|
|
$ZodCheckOverwrite: () => $ZodCheckOverwrite,
|
|
$ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
|
|
$ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
|
|
$ZodCheckMinSize: () => $ZodCheckMinSize,
|
|
$ZodCheckMinLength: () => $ZodCheckMinLength,
|
|
$ZodCheckMimeType: () => $ZodCheckMimeType,
|
|
$ZodCheckMaxSize: () => $ZodCheckMaxSize,
|
|
$ZodCheckMaxLength: () => $ZodCheckMaxLength,
|
|
$ZodCheckLowerCase: () => $ZodCheckLowerCase,
|
|
$ZodCheckLessThan: () => $ZodCheckLessThan,
|
|
$ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
|
|
$ZodCheckIncludes: () => $ZodCheckIncludes,
|
|
$ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
|
|
$ZodCheckEndsWith: () => $ZodCheckEndsWith,
|
|
$ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
|
|
$ZodCheck: () => $ZodCheck,
|
|
$ZodCatch: () => $ZodCatch,
|
|
$ZodCUID2: () => $ZodCUID2,
|
|
$ZodCUID: () => $ZodCUID,
|
|
$ZodCIDRv6: () => $ZodCIDRv6,
|
|
$ZodCIDRv4: () => $ZodCIDRv4,
|
|
$ZodBoolean: () => $ZodBoolean,
|
|
$ZodBigIntFormat: () => $ZodBigIntFormat,
|
|
$ZodBigInt: () => $ZodBigInt,
|
|
$ZodBase64URL: () => $ZodBase64URL,
|
|
$ZodBase64: () => $ZodBase64,
|
|
$ZodAsyncError: () => $ZodAsyncError,
|
|
$ZodArray: () => $ZodArray,
|
|
$ZodAny: () => $ZodAny
|
|
});
|
|
|
|
// node_modules/zod/v4/core/core.js
|
|
var NEVER = Object.freeze({
|
|
status: "aborted"
|
|
});
|
|
function $constructor(name, initializer, params) {
|
|
function init(inst, def) {
|
|
if (!inst._zod) {
|
|
Object.defineProperty(inst, "_zod", {
|
|
value: {
|
|
def,
|
|
constr: _,
|
|
traits: new Set
|
|
},
|
|
enumerable: false
|
|
});
|
|
}
|
|
if (inst._zod.traits.has(name)) {
|
|
return;
|
|
}
|
|
inst._zod.traits.add(name);
|
|
initializer(inst, def);
|
|
const proto = _.prototype;
|
|
const keys = Object.keys(proto);
|
|
for (let i = 0;i < keys.length; i++) {
|
|
const k = keys[i];
|
|
if (!(k in inst)) {
|
|
inst[k] = proto[k].bind(inst);
|
|
}
|
|
}
|
|
}
|
|
const Parent = params?.Parent ?? Object;
|
|
|
|
class Definition extends Parent {
|
|
}
|
|
Object.defineProperty(Definition, "name", { value: name });
|
|
function _(def) {
|
|
var _a;
|
|
const inst = params?.Parent ? new Definition : this;
|
|
init(inst, def);
|
|
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
|
for (const fn of inst._zod.deferred) {
|
|
fn();
|
|
}
|
|
return inst;
|
|
}
|
|
Object.defineProperty(_, "init", { value: init });
|
|
Object.defineProperty(_, Symbol.hasInstance, {
|
|
value: (inst) => {
|
|
if (params?.Parent && inst instanceof params.Parent)
|
|
return true;
|
|
return inst?._zod?.traits?.has(name);
|
|
}
|
|
});
|
|
Object.defineProperty(_, "name", { value: name });
|
|
return _;
|
|
}
|
|
var $brand = Symbol("zod_brand");
|
|
|
|
class $ZodAsyncError extends Error {
|
|
constructor() {
|
|
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
|
|
}
|
|
}
|
|
|
|
class $ZodEncodeError extends Error {
|
|
constructor(name) {
|
|
super(`Encountered unidirectional transform during encode: ${name}`);
|
|
this.name = "ZodEncodeError";
|
|
}
|
|
}
|
|
var globalConfig = {};
|
|
function config(newConfig) {
|
|
if (newConfig)
|
|
Object.assign(globalConfig, newConfig);
|
|
return globalConfig;
|
|
}
|
|
// node_modules/zod/v4/core/util.js
|
|
var exports_util = {};
|
|
__export(exports_util, {
|
|
unwrapMessage: () => unwrapMessage,
|
|
uint8ArrayToHex: () => uint8ArrayToHex,
|
|
uint8ArrayToBase64url: () => uint8ArrayToBase64url,
|
|
uint8ArrayToBase64: () => uint8ArrayToBase64,
|
|
stringifyPrimitive: () => stringifyPrimitive,
|
|
slugify: () => slugify,
|
|
shallowClone: () => shallowClone,
|
|
safeExtend: () => safeExtend,
|
|
required: () => required,
|
|
randomString: () => randomString,
|
|
propertyKeyTypes: () => propertyKeyTypes,
|
|
promiseAllObject: () => promiseAllObject,
|
|
primitiveTypes: () => primitiveTypes,
|
|
prefixIssues: () => prefixIssues,
|
|
pick: () => pick,
|
|
partial: () => partial,
|
|
parsedType: () => parsedType,
|
|
optionalKeys: () => optionalKeys,
|
|
omit: () => omit,
|
|
objectClone: () => objectClone,
|
|
numKeys: () => numKeys,
|
|
nullish: () => nullish,
|
|
normalizeParams: () => normalizeParams,
|
|
mergeDefs: () => mergeDefs,
|
|
merge: () => merge,
|
|
jsonStringifyReplacer: () => jsonStringifyReplacer,
|
|
joinValues: () => joinValues,
|
|
issue: () => issue,
|
|
isPlainObject: () => isPlainObject,
|
|
isObject: () => isObject,
|
|
hexToUint8Array: () => hexToUint8Array,
|
|
getSizableOrigin: () => getSizableOrigin,
|
|
getParsedType: () => getParsedType,
|
|
getLengthableOrigin: () => getLengthableOrigin,
|
|
getEnumValues: () => getEnumValues,
|
|
getElementAtPath: () => getElementAtPath,
|
|
floatSafeRemainder: () => floatSafeRemainder,
|
|
finalizeIssue: () => finalizeIssue,
|
|
extend: () => extend,
|
|
escapeRegex: () => escapeRegex,
|
|
esc: () => esc,
|
|
defineLazy: () => defineLazy,
|
|
createTransparentProxy: () => createTransparentProxy,
|
|
cloneDef: () => cloneDef,
|
|
clone: () => clone,
|
|
cleanRegex: () => cleanRegex,
|
|
cleanEnum: () => cleanEnum,
|
|
captureStackTrace: () => captureStackTrace,
|
|
cached: () => cached,
|
|
base64urlToUint8Array: () => base64urlToUint8Array,
|
|
base64ToUint8Array: () => base64ToUint8Array,
|
|
assignProp: () => assignProp,
|
|
assertNotEqual: () => assertNotEqual,
|
|
assertNever: () => assertNever,
|
|
assertIs: () => assertIs,
|
|
assertEqual: () => assertEqual,
|
|
assert: () => assert,
|
|
allowsEval: () => allowsEval,
|
|
aborted: () => aborted,
|
|
NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
|
|
Class: () => Class,
|
|
BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES
|
|
});
|
|
function assertEqual(val) {
|
|
return val;
|
|
}
|
|
function assertNotEqual(val) {
|
|
return val;
|
|
}
|
|
function assertIs(_arg) {}
|
|
function assertNever(_x) {
|
|
throw new Error("Unexpected value in exhaustive check");
|
|
}
|
|
function assert(_) {}
|
|
function getEnumValues(entries) {
|
|
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
|
|
const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
|
|
return values;
|
|
}
|
|
function joinValues(array, separator = "|") {
|
|
return array.map((val) => stringifyPrimitive(val)).join(separator);
|
|
}
|
|
function jsonStringifyReplacer(_, value) {
|
|
if (typeof value === "bigint")
|
|
return value.toString();
|
|
return value;
|
|
}
|
|
function cached(getter) {
|
|
const set = false;
|
|
return {
|
|
get value() {
|
|
if (!set) {
|
|
const value = getter();
|
|
Object.defineProperty(this, "value", { value });
|
|
return value;
|
|
}
|
|
throw new Error("cached value already set");
|
|
}
|
|
};
|
|
}
|
|
function nullish(input) {
|
|
return input === null || input === undefined;
|
|
}
|
|
function cleanRegex(source) {
|
|
const start = source.startsWith("^") ? 1 : 0;
|
|
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
|
return source.slice(start, end);
|
|
}
|
|
function floatSafeRemainder(val, step) {
|
|
const valDecCount = (val.toString().split(".")[1] || "").length;
|
|
const stepString = step.toString();
|
|
let stepDecCount = (stepString.split(".")[1] || "").length;
|
|
if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
|
|
const match = stepString.match(/\d?e-(\d?)/);
|
|
if (match?.[1]) {
|
|
stepDecCount = Number.parseInt(match[1]);
|
|
}
|
|
}
|
|
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
|
|
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
|
|
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
|
|
return valInt % stepInt / 10 ** decCount;
|
|
}
|
|
var EVALUATING = Symbol("evaluating");
|
|
function defineLazy(object, key, getter) {
|
|
let value = undefined;
|
|
Object.defineProperty(object, key, {
|
|
get() {
|
|
if (value === EVALUATING) {
|
|
return;
|
|
}
|
|
if (value === undefined) {
|
|
value = EVALUATING;
|
|
value = getter();
|
|
}
|
|
return value;
|
|
},
|
|
set(v) {
|
|
Object.defineProperty(object, key, {
|
|
value: v
|
|
});
|
|
},
|
|
configurable: true
|
|
});
|
|
}
|
|
function objectClone(obj) {
|
|
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
|
}
|
|
function assignProp(target, prop, value) {
|
|
Object.defineProperty(target, prop, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
function mergeDefs(...defs) {
|
|
const mergedDescriptors = {};
|
|
for (const def of defs) {
|
|
const descriptors = Object.getOwnPropertyDescriptors(def);
|
|
Object.assign(mergedDescriptors, descriptors);
|
|
}
|
|
return Object.defineProperties({}, mergedDescriptors);
|
|
}
|
|
function cloneDef(schema) {
|
|
return mergeDefs(schema._zod.def);
|
|
}
|
|
function getElementAtPath(obj, path) {
|
|
if (!path)
|
|
return obj;
|
|
return path.reduce((acc, key) => acc?.[key], obj);
|
|
}
|
|
function promiseAllObject(promisesObj) {
|
|
const keys = Object.keys(promisesObj);
|
|
const promises = keys.map((key) => promisesObj[key]);
|
|
return Promise.all(promises).then((results) => {
|
|
const resolvedObj = {};
|
|
for (let i = 0;i < keys.length; i++) {
|
|
resolvedObj[keys[i]] = results[i];
|
|
}
|
|
return resolvedObj;
|
|
});
|
|
}
|
|
function randomString(length = 10) {
|
|
const chars = "abcdefghijklmnopqrstuvwxyz";
|
|
let str = "";
|
|
for (let i = 0;i < length; i++) {
|
|
str += chars[Math.floor(Math.random() * chars.length)];
|
|
}
|
|
return str;
|
|
}
|
|
function esc(str) {
|
|
return JSON.stringify(str);
|
|
}
|
|
function slugify(input) {
|
|
return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
|
|
}
|
|
var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
|
|
function isObject(data) {
|
|
return typeof data === "object" && data !== null && !Array.isArray(data);
|
|
}
|
|
var allowsEval = cached(() => {
|
|
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
|
return false;
|
|
}
|
|
try {
|
|
const F = Function;
|
|
new F("");
|
|
return true;
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
});
|
|
function isPlainObject(o) {
|
|
if (isObject(o) === false)
|
|
return false;
|
|
const ctor = o.constructor;
|
|
if (ctor === undefined)
|
|
return true;
|
|
if (typeof ctor !== "function")
|
|
return true;
|
|
const prot = ctor.prototype;
|
|
if (isObject(prot) === false)
|
|
return false;
|
|
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function shallowClone(o) {
|
|
if (isPlainObject(o))
|
|
return { ...o };
|
|
if (Array.isArray(o))
|
|
return [...o];
|
|
return o;
|
|
}
|
|
function numKeys(data) {
|
|
let keyCount = 0;
|
|
for (const key in data) {
|
|
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
|
keyCount++;
|
|
}
|
|
}
|
|
return keyCount;
|
|
}
|
|
var getParsedType = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "undefined":
|
|
return "undefined";
|
|
case "string":
|
|
return "string";
|
|
case "number":
|
|
return Number.isNaN(data) ? "nan" : "number";
|
|
case "boolean":
|
|
return "boolean";
|
|
case "function":
|
|
return "function";
|
|
case "bigint":
|
|
return "bigint";
|
|
case "symbol":
|
|
return "symbol";
|
|
case "object":
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
|
|
return "promise";
|
|
}
|
|
if (typeof Map !== "undefined" && data instanceof Map) {
|
|
return "map";
|
|
}
|
|
if (typeof Set !== "undefined" && data instanceof Set) {
|
|
return "set";
|
|
}
|
|
if (typeof Date !== "undefined" && data instanceof Date) {
|
|
return "date";
|
|
}
|
|
if (typeof File !== "undefined" && data instanceof File) {
|
|
return "file";
|
|
}
|
|
return "object";
|
|
default:
|
|
throw new Error(`Unknown data type: ${t}`);
|
|
}
|
|
};
|
|
var propertyKeyTypes = new Set(["string", "number", "symbol"]);
|
|
var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
|
|
function escapeRegex(str) {
|
|
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
}
|
|
function clone(inst, def, params) {
|
|
const cl = new inst._zod.constr(def ?? inst._zod.def);
|
|
if (!def || params?.parent)
|
|
cl._zod.parent = inst;
|
|
return cl;
|
|
}
|
|
function normalizeParams(_params) {
|
|
const params = _params;
|
|
if (!params)
|
|
return {};
|
|
if (typeof params === "string")
|
|
return { error: () => params };
|
|
if (params?.message !== undefined) {
|
|
if (params?.error !== undefined)
|
|
throw new Error("Cannot specify both `message` and `error` params");
|
|
params.error = params.message;
|
|
}
|
|
delete params.message;
|
|
if (typeof params.error === "string")
|
|
return { ...params, error: () => params.error };
|
|
return params;
|
|
}
|
|
function createTransparentProxy(getter) {
|
|
let target;
|
|
return new Proxy({}, {
|
|
get(_, prop, receiver) {
|
|
target ?? (target = getter());
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
set(_, prop, value, receiver) {
|
|
target ?? (target = getter());
|
|
return Reflect.set(target, prop, value, receiver);
|
|
},
|
|
has(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.has(target, prop);
|
|
},
|
|
deleteProperty(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.deleteProperty(target, prop);
|
|
},
|
|
ownKeys(_) {
|
|
target ?? (target = getter());
|
|
return Reflect.ownKeys(target);
|
|
},
|
|
getOwnPropertyDescriptor(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.getOwnPropertyDescriptor(target, prop);
|
|
},
|
|
defineProperty(_, prop, descriptor) {
|
|
target ?? (target = getter());
|
|
return Reflect.defineProperty(target, prop, descriptor);
|
|
}
|
|
});
|
|
}
|
|
function stringifyPrimitive(value) {
|
|
if (typeof value === "bigint")
|
|
return value.toString() + "n";
|
|
if (typeof value === "string")
|
|
return `"${value}"`;
|
|
return `${value}`;
|
|
}
|
|
function optionalKeys(shape) {
|
|
return Object.keys(shape).filter((k) => {
|
|
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
|
|
});
|
|
}
|
|
var NUMBER_FORMAT_RANGES = {
|
|
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
|
|
int32: [-2147483648, 2147483647],
|
|
uint32: [0, 4294967295],
|
|
float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
|
|
float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
|
|
};
|
|
var BIGINT_FORMAT_RANGES = {
|
|
int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
|
|
uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
|
|
};
|
|
function pick(schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const checks = currDef.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
throw new Error(".pick() cannot be used on object schemas containing refinements");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const newShape = {};
|
|
for (const key in mask) {
|
|
if (!(key in currDef.shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
newShape[key] = currDef.shape[key];
|
|
}
|
|
assignProp(this, "shape", newShape);
|
|
return newShape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function omit(schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const checks = currDef.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
throw new Error(".omit() cannot be used on object schemas containing refinements");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const newShape = { ...schema._zod.def.shape };
|
|
for (const key in mask) {
|
|
if (!(key in currDef.shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
delete newShape[key];
|
|
}
|
|
assignProp(this, "shape", newShape);
|
|
return newShape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function extend(schema, shape) {
|
|
if (!isPlainObject(shape)) {
|
|
throw new Error("Invalid input to extend: expected a plain object");
|
|
}
|
|
const checks = schema._zod.def.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
const existingShape = schema._zod.def.shape;
|
|
for (const key in shape) {
|
|
if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
|
|
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
|
|
}
|
|
}
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...schema._zod.def.shape, ...shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
}
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function safeExtend(schema, shape) {
|
|
if (!isPlainObject(shape)) {
|
|
throw new Error("Invalid input to safeExtend: expected a plain object");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...schema._zod.def.shape, ...shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
}
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function merge(a, b) {
|
|
const def = mergeDefs(a._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
|
assignProp(this, "shape", _shape);
|
|
return _shape;
|
|
},
|
|
get catchall() {
|
|
return b._zod.def.catchall;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone(a, def);
|
|
}
|
|
function partial(Class, schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const checks = currDef.checks;
|
|
const hasChecks = checks && checks.length > 0;
|
|
if (hasChecks) {
|
|
throw new Error(".partial() cannot be used on object schemas containing refinements");
|
|
}
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const oldShape = schema._zod.def.shape;
|
|
const shape = { ...oldShape };
|
|
if (mask) {
|
|
for (const key in mask) {
|
|
if (!(key in oldShape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
shape[key] = Class ? new Class({
|
|
type: "optional",
|
|
innerType: oldShape[key]
|
|
}) : oldShape[key];
|
|
}
|
|
} else {
|
|
for (const key in oldShape) {
|
|
shape[key] = Class ? new Class({
|
|
type: "optional",
|
|
innerType: oldShape[key]
|
|
}) : oldShape[key];
|
|
}
|
|
}
|
|
assignProp(this, "shape", shape);
|
|
return shape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function required(Class, schema, mask) {
|
|
const def = mergeDefs(schema._zod.def, {
|
|
get shape() {
|
|
const oldShape = schema._zod.def.shape;
|
|
const shape = { ...oldShape };
|
|
if (mask) {
|
|
for (const key in mask) {
|
|
if (!(key in shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
shape[key] = new Class({
|
|
type: "nonoptional",
|
|
innerType: oldShape[key]
|
|
});
|
|
}
|
|
} else {
|
|
for (const key in oldShape) {
|
|
shape[key] = new Class({
|
|
type: "nonoptional",
|
|
innerType: oldShape[key]
|
|
});
|
|
}
|
|
}
|
|
assignProp(this, "shape", shape);
|
|
return shape;
|
|
}
|
|
});
|
|
return clone(schema, def);
|
|
}
|
|
function aborted(x, startIndex = 0) {
|
|
if (x.aborted === true)
|
|
return true;
|
|
for (let i = startIndex;i < x.issues.length; i++) {
|
|
if (x.issues[i]?.continue !== true) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function prefixIssues(path, issues) {
|
|
return issues.map((iss) => {
|
|
var _a;
|
|
(_a = iss).path ?? (_a.path = []);
|
|
iss.path.unshift(path);
|
|
return iss;
|
|
});
|
|
}
|
|
function unwrapMessage(message) {
|
|
return typeof message === "string" ? message : message?.message;
|
|
}
|
|
function finalizeIssue(iss, ctx, config2) {
|
|
const full = { ...iss, path: iss.path ?? [] };
|
|
if (!iss.message) {
|
|
const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
|
|
full.message = message;
|
|
}
|
|
delete full.inst;
|
|
delete full.continue;
|
|
if (!ctx?.reportInput) {
|
|
delete full.input;
|
|
}
|
|
return full;
|
|
}
|
|
function getSizableOrigin(input) {
|
|
if (input instanceof Set)
|
|
return "set";
|
|
if (input instanceof Map)
|
|
return "map";
|
|
if (input instanceof File)
|
|
return "file";
|
|
return "unknown";
|
|
}
|
|
function getLengthableOrigin(input) {
|
|
if (Array.isArray(input))
|
|
return "array";
|
|
if (typeof input === "string")
|
|
return "string";
|
|
return "unknown";
|
|
}
|
|
function parsedType(data) {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "nan" : "number";
|
|
}
|
|
case "object": {
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
const obj = data;
|
|
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
|
|
return obj.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
function issue(...args) {
|
|
const [iss, input, inst] = args;
|
|
if (typeof iss === "string") {
|
|
return {
|
|
message: iss,
|
|
code: "custom",
|
|
input,
|
|
inst
|
|
};
|
|
}
|
|
return { ...iss };
|
|
}
|
|
function cleanEnum(obj) {
|
|
return Object.entries(obj).filter(([k, _]) => {
|
|
return Number.isNaN(Number.parseInt(k, 10));
|
|
}).map((el) => el[1]);
|
|
}
|
|
function base64ToUint8Array(base64) {
|
|
const binaryString = atob(base64);
|
|
const bytes = new Uint8Array(binaryString.length);
|
|
for (let i = 0;i < binaryString.length; i++) {
|
|
bytes[i] = binaryString.charCodeAt(i);
|
|
}
|
|
return bytes;
|
|
}
|
|
function uint8ArrayToBase64(bytes) {
|
|
let binaryString = "";
|
|
for (let i = 0;i < bytes.length; i++) {
|
|
binaryString += String.fromCharCode(bytes[i]);
|
|
}
|
|
return btoa(binaryString);
|
|
}
|
|
function base64urlToUint8Array(base64url) {
|
|
const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
|
|
const padding = "=".repeat((4 - base64.length % 4) % 4);
|
|
return base64ToUint8Array(base64 + padding);
|
|
}
|
|
function uint8ArrayToBase64url(bytes) {
|
|
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
|
}
|
|
function hexToUint8Array(hex) {
|
|
const cleanHex = hex.replace(/^0x/, "");
|
|
if (cleanHex.length % 2 !== 0) {
|
|
throw new Error("Invalid hex string length");
|
|
}
|
|
const bytes = new Uint8Array(cleanHex.length / 2);
|
|
for (let i = 0;i < cleanHex.length; i += 2) {
|
|
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
|
}
|
|
return bytes;
|
|
}
|
|
function uint8ArrayToHex(bytes) {
|
|
return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
|
|
}
|
|
|
|
class Class {
|
|
constructor(..._args) {}
|
|
}
|
|
|
|
// node_modules/zod/v4/core/errors.js
|
|
var initializer = (inst, def) => {
|
|
inst.name = "$ZodError";
|
|
Object.defineProperty(inst, "_zod", {
|
|
value: inst._zod,
|
|
enumerable: false
|
|
});
|
|
Object.defineProperty(inst, "issues", {
|
|
value: def,
|
|
enumerable: false
|
|
});
|
|
inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
|
|
Object.defineProperty(inst, "toString", {
|
|
value: () => inst.message,
|
|
enumerable: false
|
|
});
|
|
};
|
|
var $ZodError = $constructor("$ZodError", initializer);
|
|
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
|
|
function flattenError(error, mapper = (issue2) => issue2.message) {
|
|
const fieldErrors = {};
|
|
const formErrors = [];
|
|
for (const sub of error.issues) {
|
|
if (sub.path.length > 0) {
|
|
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
|
|
fieldErrors[sub.path[0]].push(mapper(sub));
|
|
} else {
|
|
formErrors.push(mapper(sub));
|
|
}
|
|
}
|
|
return { formErrors, fieldErrors };
|
|
}
|
|
function formatError(error, mapper = (issue2) => issue2.message) {
|
|
const fieldErrors = { _errors: [] };
|
|
const processError = (error2) => {
|
|
for (const issue2 of error2.issues) {
|
|
if (issue2.code === "invalid_union" && issue2.errors.length) {
|
|
issue2.errors.map((issues) => processError({ issues }));
|
|
} else if (issue2.code === "invalid_key") {
|
|
processError({ issues: issue2.issues });
|
|
} else if (issue2.code === "invalid_element") {
|
|
processError({ issues: issue2.issues });
|
|
} else if (issue2.path.length === 0) {
|
|
fieldErrors._errors.push(mapper(issue2));
|
|
} else {
|
|
let curr = fieldErrors;
|
|
let i = 0;
|
|
while (i < issue2.path.length) {
|
|
const el = issue2.path[i];
|
|
const terminal = i === issue2.path.length - 1;
|
|
if (!terminal) {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
} else {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
curr[el]._errors.push(mapper(issue2));
|
|
}
|
|
curr = curr[el];
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
processError(error);
|
|
return fieldErrors;
|
|
}
|
|
function treeifyError(error, mapper = (issue2) => issue2.message) {
|
|
const result = { errors: [] };
|
|
const processError = (error2, path = []) => {
|
|
var _a, _b;
|
|
for (const issue2 of error2.issues) {
|
|
if (issue2.code === "invalid_union" && issue2.errors.length) {
|
|
issue2.errors.map((issues) => processError({ issues }, issue2.path));
|
|
} else if (issue2.code === "invalid_key") {
|
|
processError({ issues: issue2.issues }, issue2.path);
|
|
} else if (issue2.code === "invalid_element") {
|
|
processError({ issues: issue2.issues }, issue2.path);
|
|
} else {
|
|
const fullpath = [...path, ...issue2.path];
|
|
if (fullpath.length === 0) {
|
|
result.errors.push(mapper(issue2));
|
|
continue;
|
|
}
|
|
let curr = result;
|
|
let i = 0;
|
|
while (i < fullpath.length) {
|
|
const el = fullpath[i];
|
|
const terminal = i === fullpath.length - 1;
|
|
if (typeof el === "string") {
|
|
curr.properties ?? (curr.properties = {});
|
|
(_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
|
|
curr = curr.properties[el];
|
|
} else {
|
|
curr.items ?? (curr.items = []);
|
|
(_b = curr.items)[el] ?? (_b[el] = { errors: [] });
|
|
curr = curr.items[el];
|
|
}
|
|
if (terminal) {
|
|
curr.errors.push(mapper(issue2));
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
processError(error);
|
|
return result;
|
|
}
|
|
function toDotPath(_path) {
|
|
const segs = [];
|
|
const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
|
|
for (const seg of path) {
|
|
if (typeof seg === "number")
|
|
segs.push(`[${seg}]`);
|
|
else if (typeof seg === "symbol")
|
|
segs.push(`[${JSON.stringify(String(seg))}]`);
|
|
else if (/[^\w$]/.test(seg))
|
|
segs.push(`[${JSON.stringify(seg)}]`);
|
|
else {
|
|
if (segs.length)
|
|
segs.push(".");
|
|
segs.push(seg);
|
|
}
|
|
}
|
|
return segs.join("");
|
|
}
|
|
function prettifyError(error) {
|
|
const lines = [];
|
|
const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
|
|
for (const issue2 of issues) {
|
|
lines.push(`\u2716 ${issue2.message}`);
|
|
if (issue2.path?.length)
|
|
lines.push(` \u2192 at ${toDotPath(issue2.path)}`);
|
|
}
|
|
return lines.join(`
|
|
`);
|
|
}
|
|
|
|
// node_modules/zod/v4/core/parse.js
|
|
var _parse = (_Err) => (schema, value, _ctx, _params) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
|
|
const result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
throw new $ZodAsyncError;
|
|
}
|
|
if (result.issues.length) {
|
|
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
|
|
captureStackTrace(e, _params?.callee);
|
|
throw e;
|
|
}
|
|
return result.value;
|
|
};
|
|
var parse = /* @__PURE__ */ _parse($ZodRealError);
|
|
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
|
let result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise)
|
|
result = await result;
|
|
if (result.issues.length) {
|
|
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
|
|
captureStackTrace(e, params?.callee);
|
|
throw e;
|
|
}
|
|
return result.value;
|
|
};
|
|
var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
|
|
var _safeParse = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
|
const result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
throw new $ZodAsyncError;
|
|
}
|
|
return result.issues.length ? {
|
|
success: false,
|
|
error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
|
|
} : { success: true, data: result.value };
|
|
};
|
|
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
|
|
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
|
let result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise)
|
|
result = await result;
|
|
return result.issues.length ? {
|
|
success: false,
|
|
error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
|
|
} : { success: true, data: result.value };
|
|
};
|
|
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
|
|
var _encode = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _parse(_Err)(schema, value, ctx);
|
|
};
|
|
var encode = /* @__PURE__ */ _encode($ZodRealError);
|
|
var _decode = (_Err) => (schema, value, _ctx) => {
|
|
return _parse(_Err)(schema, value, _ctx);
|
|
};
|
|
var decode = /* @__PURE__ */ _decode($ZodRealError);
|
|
var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _parseAsync(_Err)(schema, value, ctx);
|
|
};
|
|
var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
|
|
var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
return _parseAsync(_Err)(schema, value, _ctx);
|
|
};
|
|
var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
|
|
var _safeEncode = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _safeParse(_Err)(schema, value, ctx);
|
|
};
|
|
var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
|
|
var _safeDecode = (_Err) => (schema, value, _ctx) => {
|
|
return _safeParse(_Err)(schema, value, _ctx);
|
|
};
|
|
var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
|
|
var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _safeParseAsync(_Err)(schema, value, ctx);
|
|
};
|
|
var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
|
|
var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
|
|
return _safeParseAsync(_Err)(schema, value, _ctx);
|
|
};
|
|
var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
|
|
// node_modules/zod/v4/core/regexes.js
|
|
var exports_regexes = {};
|
|
__export(exports_regexes, {
|
|
xid: () => xid,
|
|
uuid7: () => uuid7,
|
|
uuid6: () => uuid6,
|
|
uuid4: () => uuid4,
|
|
uuid: () => uuid,
|
|
uppercase: () => uppercase,
|
|
unicodeEmail: () => unicodeEmail,
|
|
undefined: () => _undefined,
|
|
ulid: () => ulid,
|
|
time: () => time,
|
|
string: () => string,
|
|
sha512_hex: () => sha512_hex,
|
|
sha512_base64url: () => sha512_base64url,
|
|
sha512_base64: () => sha512_base64,
|
|
sha384_hex: () => sha384_hex,
|
|
sha384_base64url: () => sha384_base64url,
|
|
sha384_base64: () => sha384_base64,
|
|
sha256_hex: () => sha256_hex,
|
|
sha256_base64url: () => sha256_base64url,
|
|
sha256_base64: () => sha256_base64,
|
|
sha1_hex: () => sha1_hex,
|
|
sha1_base64url: () => sha1_base64url,
|
|
sha1_base64: () => sha1_base64,
|
|
rfc5322Email: () => rfc5322Email,
|
|
number: () => number,
|
|
null: () => _null,
|
|
nanoid: () => nanoid,
|
|
md5_hex: () => md5_hex,
|
|
md5_base64url: () => md5_base64url,
|
|
md5_base64: () => md5_base64,
|
|
mac: () => mac,
|
|
lowercase: () => lowercase,
|
|
ksuid: () => ksuid,
|
|
ipv6: () => ipv6,
|
|
ipv4: () => ipv4,
|
|
integer: () => integer,
|
|
idnEmail: () => idnEmail,
|
|
html5Email: () => html5Email,
|
|
hostname: () => hostname,
|
|
hex: () => hex,
|
|
guid: () => guid,
|
|
extendedDuration: () => extendedDuration,
|
|
emoji: () => emoji,
|
|
email: () => email,
|
|
e164: () => e164,
|
|
duration: () => duration,
|
|
domain: () => domain,
|
|
datetime: () => datetime,
|
|
date: () => date,
|
|
cuid2: () => cuid2,
|
|
cuid: () => cuid,
|
|
cidrv6: () => cidrv6,
|
|
cidrv4: () => cidrv4,
|
|
browserEmail: () => browserEmail,
|
|
boolean: () => boolean,
|
|
bigint: () => bigint,
|
|
base64url: () => base64url,
|
|
base64: () => base64
|
|
});
|
|
var cuid = /^[cC][^\s-]{8,}$/;
|
|
var cuid2 = /^[0-9a-z]+$/;
|
|
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
|
|
var xid = /^[0-9a-vA-V]{20}$/;
|
|
var ksuid = /^[A-Za-z0-9]{27}$/;
|
|
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
|
|
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
|
var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
|
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
|
var uuid = (version) => {
|
|
if (!version)
|
|
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
|
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
|
};
|
|
var uuid4 = /* @__PURE__ */ uuid(4);
|
|
var uuid6 = /* @__PURE__ */ uuid(6);
|
|
var uuid7 = /* @__PURE__ */ uuid(7);
|
|
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
|
|
var html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
|
var rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
|
|
var unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
|
|
var idnEmail = unicodeEmail;
|
|
var browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
|
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
|
|
function emoji() {
|
|
return new RegExp(_emoji, "u");
|
|
}
|
|
var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
|
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
|
|
var mac = (delimiter) => {
|
|
const escapedDelim = escapeRegex(delimiter ?? ":");
|
|
return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
|
|
};
|
|
var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
|
|
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
|
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
|
|
var base64url = /^[A-Za-z0-9_-]*$/;
|
|
var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
|
|
var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
|
|
var e164 = /^\+[1-9]\d{6,14}$/;
|
|
var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
|
|
var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
|
|
function timeSource(args) {
|
|
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
|
|
const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
|
|
return regex;
|
|
}
|
|
function time(args) {
|
|
return new RegExp(`^${timeSource(args)}$`);
|
|
}
|
|
function datetime(args) {
|
|
const time2 = timeSource({ precision: args.precision });
|
|
const opts = ["Z"];
|
|
if (args.local)
|
|
opts.push("");
|
|
if (args.offset)
|
|
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
|
|
const timeRegex = `${time2}(?:${opts.join("|")})`;
|
|
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
|
|
}
|
|
var string = (params) => {
|
|
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
|
return new RegExp(`^${regex}$`);
|
|
};
|
|
var bigint = /^-?\d+n?$/;
|
|
var integer = /^-?\d+$/;
|
|
var number = /^-?\d+(?:\.\d+)?$/;
|
|
var boolean = /^(?:true|false)$/i;
|
|
var _null = /^null$/i;
|
|
var _undefined = /^undefined$/i;
|
|
var lowercase = /^[^A-Z]*$/;
|
|
var uppercase = /^[^a-z]*$/;
|
|
var hex = /^[0-9a-fA-F]*$/;
|
|
function fixedBase64(bodyLength, padding) {
|
|
return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
|
|
}
|
|
function fixedBase64url(length) {
|
|
return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
|
|
}
|
|
var md5_hex = /^[0-9a-fA-F]{32}$/;
|
|
var md5_base64 = /* @__PURE__ */ fixedBase64(22, "==");
|
|
var md5_base64url = /* @__PURE__ */ fixedBase64url(22);
|
|
var sha1_hex = /^[0-9a-fA-F]{40}$/;
|
|
var sha1_base64 = /* @__PURE__ */ fixedBase64(27, "=");
|
|
var sha1_base64url = /* @__PURE__ */ fixedBase64url(27);
|
|
var sha256_hex = /^[0-9a-fA-F]{64}$/;
|
|
var sha256_base64 = /* @__PURE__ */ fixedBase64(43, "=");
|
|
var sha256_base64url = /* @__PURE__ */ fixedBase64url(43);
|
|
var sha384_hex = /^[0-9a-fA-F]{96}$/;
|
|
var sha384_base64 = /* @__PURE__ */ fixedBase64(64, "");
|
|
var sha384_base64url = /* @__PURE__ */ fixedBase64url(64);
|
|
var sha512_hex = /^[0-9a-fA-F]{128}$/;
|
|
var sha512_base64 = /* @__PURE__ */ fixedBase64(86, "==");
|
|
var sha512_base64url = /* @__PURE__ */ fixedBase64url(86);
|
|
|
|
// node_modules/zod/v4/core/checks.js
|
|
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
|
|
var _a;
|
|
inst._zod ?? (inst._zod = {});
|
|
inst._zod.def = def;
|
|
(_a = inst._zod).onattach ?? (_a.onattach = []);
|
|
});
|
|
var numericOriginMap = {
|
|
number: "number",
|
|
bigint: "bigint",
|
|
object: "date"
|
|
};
|
|
var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const origin = numericOriginMap[typeof def.value];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
|
|
if (def.value < curr) {
|
|
if (def.inclusive)
|
|
bag.maximum = def.value;
|
|
else
|
|
bag.exclusiveMaximum = def.value;
|
|
}
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_big",
|
|
maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const origin = numericOriginMap[typeof def.value];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
|
|
if (def.value > curr) {
|
|
if (def.inclusive)
|
|
bag.minimum = def.value;
|
|
else
|
|
bag.exclusiveMinimum = def.value;
|
|
}
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_small",
|
|
minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
var _a;
|
|
(_a = inst2._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (typeof payload.value !== typeof def.value)
|
|
throw new Error("Cannot mix number and bigint in multiple_of check.");
|
|
const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
|
|
if (isMultiple)
|
|
return;
|
|
payload.issues.push({
|
|
origin: typeof payload.value,
|
|
code: "not_multiple_of",
|
|
divisor: def.value,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
def.format = def.format || "float64";
|
|
const isInt = def.format?.includes("int");
|
|
const origin = isInt ? "int" : "number";
|
|
const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
bag.minimum = minimum;
|
|
bag.maximum = maximum;
|
|
if (isInt)
|
|
bag.pattern = integer;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
if (isInt) {
|
|
if (!Number.isInteger(input)) {
|
|
payload.issues.push({
|
|
expected: origin,
|
|
format: def.format,
|
|
code: "invalid_type",
|
|
continue: false,
|
|
input,
|
|
inst
|
|
});
|
|
return;
|
|
}
|
|
if (!Number.isSafeInteger(input)) {
|
|
if (input > 0) {
|
|
payload.issues.push({
|
|
input,
|
|
code: "too_big",
|
|
maximum: Number.MAX_SAFE_INTEGER,
|
|
note: "Integers must be within the safe integer range.",
|
|
inst,
|
|
origin,
|
|
inclusive: true,
|
|
continue: !def.abort
|
|
});
|
|
} else {
|
|
payload.issues.push({
|
|
input,
|
|
code: "too_small",
|
|
minimum: Number.MIN_SAFE_INTEGER,
|
|
note: "Integers must be within the safe integer range.",
|
|
inst,
|
|
origin,
|
|
inclusive: true,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (input < minimum) {
|
|
payload.issues.push({
|
|
origin: "number",
|
|
input,
|
|
code: "too_small",
|
|
minimum,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
if (input > maximum) {
|
|
payload.issues.push({
|
|
origin: "number",
|
|
input,
|
|
code: "too_big",
|
|
maximum,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
bag.minimum = minimum;
|
|
bag.maximum = maximum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
if (input < minimum) {
|
|
payload.issues.push({
|
|
origin: "bigint",
|
|
input,
|
|
code: "too_small",
|
|
minimum,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
if (input > maximum) {
|
|
payload.issues.push({
|
|
origin: "bigint",
|
|
input,
|
|
code: "too_big",
|
|
maximum,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.size !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
|
|
if (def.maximum < curr)
|
|
inst2._zod.bag.maximum = def.maximum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const size = input.size;
|
|
if (size <= def.maximum)
|
|
return;
|
|
payload.issues.push({
|
|
origin: getSizableOrigin(input),
|
|
code: "too_big",
|
|
maximum: def.maximum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.size !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
|
|
if (def.minimum > curr)
|
|
inst2._zod.bag.minimum = def.minimum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const size = input.size;
|
|
if (size >= def.minimum)
|
|
return;
|
|
payload.issues.push({
|
|
origin: getSizableOrigin(input),
|
|
code: "too_small",
|
|
minimum: def.minimum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.size !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.minimum = def.size;
|
|
bag.maximum = def.size;
|
|
bag.size = def.size;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const size = input.size;
|
|
if (size === def.size)
|
|
return;
|
|
const tooBig = size > def.size;
|
|
payload.issues.push({
|
|
origin: getSizableOrigin(input),
|
|
...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
|
|
inclusive: true,
|
|
exact: true,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
|
|
if (def.maximum < curr)
|
|
inst2._zod.bag.maximum = def.maximum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length <= def.maximum)
|
|
return;
|
|
const origin = getLengthableOrigin(input);
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_big",
|
|
maximum: def.maximum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
|
|
if (def.minimum > curr)
|
|
inst2._zod.bag.minimum = def.minimum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length >= def.minimum)
|
|
return;
|
|
const origin = getLengthableOrigin(input);
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_small",
|
|
minimum: def.minimum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
|
|
var _a;
|
|
$ZodCheck.init(inst, def);
|
|
(_a = inst._zod.def).when ?? (_a.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.minimum = def.length;
|
|
bag.maximum = def.length;
|
|
bag.length = def.length;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length === def.length)
|
|
return;
|
|
const origin = getLengthableOrigin(input);
|
|
const tooBig = length > def.length;
|
|
payload.issues.push({
|
|
origin,
|
|
...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
|
|
inclusive: true,
|
|
exact: true,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
|
|
var _a, _b;
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
if (def.pattern) {
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(def.pattern);
|
|
}
|
|
});
|
|
if (def.pattern)
|
|
(_a = inst._zod).check ?? (_a.check = (payload) => {
|
|
def.pattern.lastIndex = 0;
|
|
if (def.pattern.test(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: def.format,
|
|
input: payload.value,
|
|
...def.pattern ? { pattern: def.pattern.toString() } : {},
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
});
|
|
else
|
|
(_b = inst._zod).check ?? (_b.check = () => {});
|
|
});
|
|
var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
def.pattern.lastIndex = 0;
|
|
if (def.pattern.test(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "regex",
|
|
input: payload.value,
|
|
pattern: def.pattern.toString(),
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = lowercase);
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = uppercase);
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const escapedRegex = escapeRegex(def.includes);
|
|
const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
|
|
def.pattern = pattern;
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.includes(def.includes, def.position))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "includes",
|
|
includes: def.includes,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
|
|
def.pattern ?? (def.pattern = pattern);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.startsWith(def.prefix))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "starts_with",
|
|
prefix: def.prefix,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
|
|
def.pattern ?? (def.pattern = pattern);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.endsWith(def.suffix))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "ends_with",
|
|
suffix: def.suffix,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
function handleCheckPropertyResult(result, payload, property) {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues(property, result.issues));
|
|
}
|
|
}
|
|
var $ZodCheckProperty = /* @__PURE__ */ $constructor("$ZodCheckProperty", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
const result = def.schema._zod.run({
|
|
value: payload.value[def.property],
|
|
issues: []
|
|
}, {});
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property));
|
|
}
|
|
handleCheckPropertyResult(result, payload, def.property);
|
|
return;
|
|
};
|
|
});
|
|
var $ZodCheckMimeType = /* @__PURE__ */ $constructor("$ZodCheckMimeType", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
const mimeSet = new Set(def.mime);
|
|
inst._zod.onattach.push((inst2) => {
|
|
inst2._zod.bag.mime = def.mime;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (mimeSet.has(payload.value.type))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values: def.mime,
|
|
input: payload.value.type,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
payload.value = def.tx(payload.value);
|
|
};
|
|
});
|
|
|
|
// node_modules/zod/v4/core/doc.js
|
|
class Doc {
|
|
constructor(args = []) {
|
|
this.content = [];
|
|
this.indent = 0;
|
|
if (this)
|
|
this.args = args;
|
|
}
|
|
indented(fn) {
|
|
this.indent += 1;
|
|
fn(this);
|
|
this.indent -= 1;
|
|
}
|
|
write(arg) {
|
|
if (typeof arg === "function") {
|
|
arg(this, { execution: "sync" });
|
|
arg(this, { execution: "async" });
|
|
return;
|
|
}
|
|
const content = arg;
|
|
const lines = content.split(`
|
|
`).filter((x) => x);
|
|
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
|
|
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
|
|
for (const line of dedented) {
|
|
this.content.push(line);
|
|
}
|
|
}
|
|
compile() {
|
|
const F = Function;
|
|
const args = this?.args;
|
|
const content = this?.content ?? [``];
|
|
const lines = [...content.map((x) => ` ${x}`)];
|
|
return new F(...args, lines.join(`
|
|
`));
|
|
}
|
|
}
|
|
|
|
// node_modules/zod/v4/core/versions.js
|
|
var version = {
|
|
major: 4,
|
|
minor: 3,
|
|
patch: 6
|
|
};
|
|
|
|
// node_modules/zod/v4/core/schemas.js
|
|
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
|
|
var _a;
|
|
inst ?? (inst = {});
|
|
inst._zod.def = def;
|
|
inst._zod.bag = inst._zod.bag || {};
|
|
inst._zod.version = version;
|
|
const checks = [...inst._zod.def.checks ?? []];
|
|
if (inst._zod.traits.has("$ZodCheck")) {
|
|
checks.unshift(inst);
|
|
}
|
|
for (const ch of checks) {
|
|
for (const fn of ch._zod.onattach) {
|
|
fn(inst);
|
|
}
|
|
}
|
|
if (checks.length === 0) {
|
|
(_a = inst._zod).deferred ?? (_a.deferred = []);
|
|
inst._zod.deferred?.push(() => {
|
|
inst._zod.run = inst._zod.parse;
|
|
});
|
|
} else {
|
|
const runChecks = (payload, checks2, ctx) => {
|
|
let isAborted = aborted(payload);
|
|
let asyncResult;
|
|
for (const ch of checks2) {
|
|
if (ch._zod.def.when) {
|
|
const shouldRun = ch._zod.def.when(payload);
|
|
if (!shouldRun)
|
|
continue;
|
|
} else if (isAborted) {
|
|
continue;
|
|
}
|
|
const currLen = payload.issues.length;
|
|
const _ = ch._zod.check(payload);
|
|
if (_ instanceof Promise && ctx?.async === false) {
|
|
throw new $ZodAsyncError;
|
|
}
|
|
if (asyncResult || _ instanceof Promise) {
|
|
asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
|
|
await _;
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
return;
|
|
if (!isAborted)
|
|
isAborted = aborted(payload, currLen);
|
|
});
|
|
} else {
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
continue;
|
|
if (!isAborted)
|
|
isAborted = aborted(payload, currLen);
|
|
}
|
|
}
|
|
if (asyncResult) {
|
|
return asyncResult.then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
return payload;
|
|
};
|
|
const handleCanaryResult = (canary, payload, ctx) => {
|
|
if (aborted(canary)) {
|
|
canary.aborted = true;
|
|
return canary;
|
|
}
|
|
const checkResult = runChecks(payload, checks, ctx);
|
|
if (checkResult instanceof Promise) {
|
|
if (ctx.async === false)
|
|
throw new $ZodAsyncError;
|
|
return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
|
|
}
|
|
return inst._zod.parse(checkResult, ctx);
|
|
};
|
|
inst._zod.run = (payload, ctx) => {
|
|
if (ctx.skipChecks) {
|
|
return inst._zod.parse(payload, ctx);
|
|
}
|
|
if (ctx.direction === "backward") {
|
|
const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
|
|
if (canary instanceof Promise) {
|
|
return canary.then((canary2) => {
|
|
return handleCanaryResult(canary2, payload, ctx);
|
|
});
|
|
}
|
|
return handleCanaryResult(canary, payload, ctx);
|
|
}
|
|
const result = inst._zod.parse(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
if (ctx.async === false)
|
|
throw new $ZodAsyncError;
|
|
return result.then((result2) => runChecks(result2, checks, ctx));
|
|
}
|
|
return runChecks(result, checks, ctx);
|
|
};
|
|
}
|
|
defineLazy(inst, "~standard", () => ({
|
|
validate: (value) => {
|
|
try {
|
|
const r = safeParse(inst, value);
|
|
return r.success ? { value: r.data } : { issues: r.error?.issues };
|
|
} catch (_) {
|
|
return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
|
|
}
|
|
},
|
|
vendor: "zod",
|
|
version: 1
|
|
}));
|
|
});
|
|
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
|
|
inst._zod.parse = (payload, _) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = String(payload.value);
|
|
} catch (_2) {}
|
|
if (typeof payload.value === "string")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "string",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
|
|
$ZodCheckStringFormat.init(inst, def);
|
|
$ZodString.init(inst, def);
|
|
});
|
|
var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = guid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
|
|
if (def.version) {
|
|
const versionMap = {
|
|
v1: 1,
|
|
v2: 2,
|
|
v3: 3,
|
|
v4: 4,
|
|
v5: 5,
|
|
v6: 6,
|
|
v7: 7,
|
|
v8: 8
|
|
};
|
|
const v = versionMap[def.version];
|
|
if (v === undefined)
|
|
throw new Error(`Invalid UUID version: "${def.version}"`);
|
|
def.pattern ?? (def.pattern = uuid(v));
|
|
} else
|
|
def.pattern ?? (def.pattern = uuid());
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
|
|
def.pattern ?? (def.pattern = email);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
const trimmed = payload.value.trim();
|
|
const url = new URL(trimmed);
|
|
if (def.hostname) {
|
|
def.hostname.lastIndex = 0;
|
|
if (!def.hostname.test(url.hostname)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid hostname",
|
|
pattern: def.hostname.source,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
}
|
|
if (def.protocol) {
|
|
def.protocol.lastIndex = 0;
|
|
if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid protocol",
|
|
pattern: def.protocol.source,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
}
|
|
if (def.normalize) {
|
|
payload.value = url.href;
|
|
} else {
|
|
payload.value = trimmed;
|
|
}
|
|
return;
|
|
} catch (_) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
|
|
def.pattern ?? (def.pattern = emoji());
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = nanoid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cuid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cuid2);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ulid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = xid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ksuid);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = datetime(def));
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
|
|
def.pattern ?? (def.pattern = date);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = time(def));
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
|
|
def.pattern ?? (def.pattern = duration);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ipv4);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.format = `ipv4`;
|
|
});
|
|
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ipv6);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.format = `ipv6`;
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
new URL(`http://[${payload.value}]`);
|
|
} catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "ipv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodMAC = /* @__PURE__ */ $constructor("$ZodMAC", (inst, def) => {
|
|
def.pattern ?? (def.pattern = mac(def.delimiter));
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.format = `mac`;
|
|
});
|
|
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cidrv4);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cidrv6);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
const parts = payload.value.split("/");
|
|
try {
|
|
if (parts.length !== 2)
|
|
throw new Error;
|
|
const [address, prefix] = parts;
|
|
if (!prefix)
|
|
throw new Error;
|
|
const prefixNum = Number(prefix);
|
|
if (`${prefixNum}` !== prefix)
|
|
throw new Error;
|
|
if (prefixNum < 0 || prefixNum > 128)
|
|
throw new Error;
|
|
new URL(`http://[${address}]`);
|
|
} catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "cidrv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
function isValidBase64(data) {
|
|
if (data === "")
|
|
return true;
|
|
if (data.length % 4 !== 0)
|
|
return false;
|
|
try {
|
|
atob(data);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
|
|
def.pattern ?? (def.pattern = base64);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.contentEncoding = "base64";
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase64(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
function isValidBase64URL(data) {
|
|
if (!base64url.test(data))
|
|
return false;
|
|
const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
|
|
const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "=");
|
|
return isValidBase64(padded);
|
|
}
|
|
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
|
|
def.pattern ?? (def.pattern = base64url);
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.bag.contentEncoding = "base64url";
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase64URL(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
|
|
def.pattern ?? (def.pattern = e164);
|
|
$ZodStringFormat.init(inst, def);
|
|
});
|
|
function isValidJWT(token, algorithm = null) {
|
|
try {
|
|
const tokensParts = token.split(".");
|
|
if (tokensParts.length !== 3)
|
|
return false;
|
|
const [header] = tokensParts;
|
|
if (!header)
|
|
return false;
|
|
const parsedHeader = JSON.parse(atob(header));
|
|
if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
|
|
return false;
|
|
if (!parsedHeader.alg)
|
|
return false;
|
|
if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
|
|
return false;
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
if (isValidJWT(payload.value, def.alg))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "jwt",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringFormat", (inst, def) => {
|
|
$ZodStringFormat.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
if (def.fn(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: def.format,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = inst._zod.bag.pattern ?? number;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Number(payload.value);
|
|
} catch (_) {}
|
|
const input = payload.value;
|
|
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
|
|
return payload;
|
|
}
|
|
const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : undefined : undefined;
|
|
payload.issues.push({
|
|
expected: "number",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
...received ? { received } : {}
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
|
|
$ZodCheckNumberFormat.init(inst, def);
|
|
$ZodNumber.init(inst, def);
|
|
});
|
|
var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = boolean;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Boolean(payload.value);
|
|
} catch (_) {}
|
|
const input = payload.value;
|
|
if (typeof input === "boolean")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "boolean",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = bigint;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = BigInt(payload.value);
|
|
} catch (_) {}
|
|
if (typeof payload.value === "bigint")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "bigint",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigIntFormat", (inst, def) => {
|
|
$ZodCheckBigIntFormat.init(inst, def);
|
|
$ZodBigInt.init(inst, def);
|
|
});
|
|
var $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "symbol")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "symbol",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = _undefined;
|
|
inst._zod.values = new Set([undefined]);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.optout = "optional";
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "undefined")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "undefined",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.pattern = _null;
|
|
inst._zod.values = new Set([null]);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (input === null)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "null",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload) => payload;
|
|
});
|
|
var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload) => payload;
|
|
});
|
|
var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
payload.issues.push({
|
|
expected: "never",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "undefined")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "void",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce) {
|
|
try {
|
|
payload.value = new Date(payload.value);
|
|
} catch (_err) {}
|
|
}
|
|
const input = payload.value;
|
|
const isDate = input instanceof Date;
|
|
const isValidDate = isDate && !Number.isNaN(input.getTime());
|
|
if (isValidDate)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "date",
|
|
code: "invalid_type",
|
|
input,
|
|
...isDate ? { received: "Invalid Date" } : {},
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
function handleArrayResult(result, final, index) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...prefixIssues(index, result.issues));
|
|
}
|
|
final.value[index] = result.value;
|
|
}
|
|
var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!Array.isArray(input)) {
|
|
payload.issues.push({
|
|
expected: "array",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = Array(input.length);
|
|
const proms = [];
|
|
for (let i = 0;i < input.length; i++) {
|
|
const item = input[i];
|
|
const result = def.element._zod.run({
|
|
value: item,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
|
|
} else {
|
|
handleArrayResult(result, payload, i);
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
function handlePropertyResult(result, final, key, input, isOptionalOut) {
|
|
if (result.issues.length) {
|
|
if (isOptionalOut && !(key in input)) {
|
|
return;
|
|
}
|
|
final.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
if (result.value === undefined) {
|
|
if (key in input) {
|
|
final.value[key] = undefined;
|
|
}
|
|
} else {
|
|
final.value[key] = result.value;
|
|
}
|
|
}
|
|
function normalizeDef(def) {
|
|
const keys = Object.keys(def.shape);
|
|
for (const k of keys) {
|
|
if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
|
|
throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
|
|
}
|
|
}
|
|
const okeys = optionalKeys(def.shape);
|
|
return {
|
|
...def,
|
|
keys,
|
|
keySet: new Set(keys),
|
|
numKeys: keys.length,
|
|
optionalKeys: new Set(okeys)
|
|
};
|
|
}
|
|
function handleCatchall(proms, input, payload, ctx, def, inst) {
|
|
const unrecognized = [];
|
|
const keySet = def.keySet;
|
|
const _catchall = def.catchall._zod;
|
|
const t = _catchall.def.type;
|
|
const isOptionalOut = _catchall.optout === "optional";
|
|
for (const key in input) {
|
|
if (keySet.has(key))
|
|
continue;
|
|
if (t === "never") {
|
|
unrecognized.push(key);
|
|
continue;
|
|
}
|
|
const r = _catchall.run({ value: input[key], issues: [] }, ctx);
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
|
|
} else {
|
|
handlePropertyResult(r, payload, key, input, isOptionalOut);
|
|
}
|
|
}
|
|
if (unrecognized.length) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
keys: unrecognized,
|
|
input,
|
|
inst
|
|
});
|
|
}
|
|
if (!proms.length)
|
|
return payload;
|
|
return Promise.all(proms).then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const desc = Object.getOwnPropertyDescriptor(def, "shape");
|
|
if (!desc?.get) {
|
|
const sh = def.shape;
|
|
Object.defineProperty(def, "shape", {
|
|
get: () => {
|
|
const newSh = { ...sh };
|
|
Object.defineProperty(def, "shape", {
|
|
value: newSh
|
|
});
|
|
return newSh;
|
|
}
|
|
});
|
|
}
|
|
const _normalized = cached(() => normalizeDef(def));
|
|
defineLazy(inst._zod, "propValues", () => {
|
|
const shape = def.shape;
|
|
const propValues = {};
|
|
for (const key in shape) {
|
|
const field = shape[key]._zod;
|
|
if (field.values) {
|
|
propValues[key] ?? (propValues[key] = new Set);
|
|
for (const v of field.values)
|
|
propValues[key].add(v);
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const isObject2 = isObject;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject2(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = {};
|
|
const proms = [];
|
|
const shape = value.shape;
|
|
for (const key of value.keys) {
|
|
const el = shape[key];
|
|
const isOptionalOut = el._zod.optout === "optional";
|
|
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
|
|
} else {
|
|
handlePropertyResult(r, payload, key, input, isOptionalOut);
|
|
}
|
|
}
|
|
if (!catchall) {
|
|
return proms.length ? Promise.all(proms).then(() => payload) : payload;
|
|
}
|
|
return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
|
|
};
|
|
});
|
|
var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
|
|
$ZodObject.init(inst, def);
|
|
const superParse = inst._zod.parse;
|
|
const _normalized = cached(() => normalizeDef(def));
|
|
const generateFastpass = (shape) => {
|
|
const doc = new Doc(["shape", "payload", "ctx"]);
|
|
const normalized = _normalized.value;
|
|
const parseStr = (key) => {
|
|
const k = esc(key);
|
|
return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
|
|
};
|
|
doc.write(`const input = payload.value;`);
|
|
const ids = Object.create(null);
|
|
let counter = 0;
|
|
for (const key of normalized.keys) {
|
|
ids[key] = `key_${counter++}`;
|
|
}
|
|
doc.write(`const newResult = {};`);
|
|
for (const key of normalized.keys) {
|
|
const id = ids[key];
|
|
const k = esc(key);
|
|
const schema = shape[key];
|
|
const isOptionalOut = schema?._zod?.optout === "optional";
|
|
doc.write(`const ${id} = ${parseStr(key)};`);
|
|
if (isOptionalOut) {
|
|
doc.write(`
|
|
if (${id}.issues.length) {
|
|
if (${k} in input) {
|
|
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
})));
|
|
}
|
|
}
|
|
|
|
if (${id}.value === undefined) {
|
|
if (${k} in input) {
|
|
newResult[${k}] = undefined;
|
|
}
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
|
|
`);
|
|
} else {
|
|
doc.write(`
|
|
if (${id}.issues.length) {
|
|
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
})));
|
|
}
|
|
|
|
if (${id}.value === undefined) {
|
|
if (${k} in input) {
|
|
newResult[${k}] = undefined;
|
|
}
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
|
|
`);
|
|
}
|
|
}
|
|
doc.write(`payload.value = newResult;`);
|
|
doc.write(`return payload;`);
|
|
const fn = doc.compile();
|
|
return (payload, ctx) => fn(shape, payload, ctx);
|
|
};
|
|
let fastpass;
|
|
const isObject2 = isObject;
|
|
const jit = !globalConfig.jitless;
|
|
const allowsEval2 = allowsEval;
|
|
const fastEnabled = jit && allowsEval2.value;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject2(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
|
|
if (!fastpass)
|
|
fastpass = generateFastpass(def.shape);
|
|
payload = fastpass(payload, ctx);
|
|
if (!catchall)
|
|
return payload;
|
|
return handleCatchall([], input, payload, ctx, value, inst);
|
|
}
|
|
return superParse(payload, ctx);
|
|
};
|
|
});
|
|
function handleUnionResults(results, final, inst, ctx) {
|
|
for (const result of results) {
|
|
if (result.issues.length === 0) {
|
|
final.value = result.value;
|
|
return final;
|
|
}
|
|
}
|
|
const nonaborted = results.filter((r) => !aborted(r));
|
|
if (nonaborted.length === 1) {
|
|
final.value = nonaborted[0].value;
|
|
return nonaborted[0];
|
|
}
|
|
final.issues.push({
|
|
code: "invalid_union",
|
|
input: final.value,
|
|
inst,
|
|
errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
|
|
});
|
|
return final;
|
|
}
|
|
var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
|
|
defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
|
|
defineLazy(inst._zod, "values", () => {
|
|
if (def.options.every((o) => o._zod.values)) {
|
|
return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
|
|
}
|
|
return;
|
|
});
|
|
defineLazy(inst._zod, "pattern", () => {
|
|
if (def.options.every((o) => o._zod.pattern)) {
|
|
const patterns = def.options.map((o) => o._zod.pattern);
|
|
return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
|
|
}
|
|
return;
|
|
});
|
|
const single = def.options.length === 1;
|
|
const first = def.options[0]._zod.run;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (single) {
|
|
return first(payload, ctx);
|
|
}
|
|
let async = false;
|
|
const results = [];
|
|
for (const option of def.options) {
|
|
const result = option._zod.run({
|
|
value: payload.value,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
results.push(result);
|
|
async = true;
|
|
} else {
|
|
if (result.issues.length === 0)
|
|
return result;
|
|
results.push(result);
|
|
}
|
|
}
|
|
if (!async)
|
|
return handleUnionResults(results, payload, inst, ctx);
|
|
return Promise.all(results).then((results2) => {
|
|
return handleUnionResults(results2, payload, inst, ctx);
|
|
});
|
|
};
|
|
});
|
|
function handleExclusiveUnionResults(results, final, inst, ctx) {
|
|
const successes = results.filter((r) => r.issues.length === 0);
|
|
if (successes.length === 1) {
|
|
final.value = successes[0].value;
|
|
return final;
|
|
}
|
|
if (successes.length === 0) {
|
|
final.issues.push({
|
|
code: "invalid_union",
|
|
input: final.value,
|
|
inst,
|
|
errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
|
|
});
|
|
} else {
|
|
final.issues.push({
|
|
code: "invalid_union",
|
|
input: final.value,
|
|
inst,
|
|
errors: [],
|
|
inclusive: false
|
|
});
|
|
}
|
|
return final;
|
|
}
|
|
var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
|
|
$ZodUnion.init(inst, def);
|
|
def.inclusive = false;
|
|
const single = def.options.length === 1;
|
|
const first = def.options[0]._zod.run;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (single) {
|
|
return first(payload, ctx);
|
|
}
|
|
let async = false;
|
|
const results = [];
|
|
for (const option of def.options) {
|
|
const result = option._zod.run({
|
|
value: payload.value,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
results.push(result);
|
|
async = true;
|
|
} else {
|
|
results.push(result);
|
|
}
|
|
}
|
|
if (!async)
|
|
return handleExclusiveUnionResults(results, payload, inst, ctx);
|
|
return Promise.all(results).then((results2) => {
|
|
return handleExclusiveUnionResults(results2, payload, inst, ctx);
|
|
});
|
|
};
|
|
});
|
|
var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
|
|
def.inclusive = false;
|
|
$ZodUnion.init(inst, def);
|
|
const _super = inst._zod.parse;
|
|
defineLazy(inst._zod, "propValues", () => {
|
|
const propValues = {};
|
|
for (const option of def.options) {
|
|
const pv = option._zod.propValues;
|
|
if (!pv || Object.keys(pv).length === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
|
|
for (const [k, v] of Object.entries(pv)) {
|
|
if (!propValues[k])
|
|
propValues[k] = new Set;
|
|
for (const val of v) {
|
|
propValues[k].add(val);
|
|
}
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const disc = cached(() => {
|
|
const opts = def.options;
|
|
const map = new Map;
|
|
for (const o of opts) {
|
|
const values = o._zod.propValues?.[def.discriminator];
|
|
if (!values || values.size === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
|
|
for (const v of values) {
|
|
if (map.has(v)) {
|
|
throw new Error(`Duplicate discriminator value "${String(v)}"`);
|
|
}
|
|
map.set(v, o);
|
|
}
|
|
}
|
|
return map;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!isObject(input)) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "object",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const opt = disc.value.get(input?.[def.discriminator]);
|
|
if (opt) {
|
|
return opt._zod.run(payload, ctx);
|
|
}
|
|
if (def.unionFallback) {
|
|
return _super(payload, ctx);
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_union",
|
|
errors: [],
|
|
note: "No matching discriminator",
|
|
discriminator: def.discriminator,
|
|
input,
|
|
path: [def.discriminator],
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
const left = def.left._zod.run({ value: input, issues: [] }, ctx);
|
|
const right = def.right._zod.run({ value: input, issues: [] }, ctx);
|
|
const async = left instanceof Promise || right instanceof Promise;
|
|
if (async) {
|
|
return Promise.all([left, right]).then(([left2, right2]) => {
|
|
return handleIntersectionResults(payload, left2, right2);
|
|
});
|
|
}
|
|
return handleIntersectionResults(payload, left, right);
|
|
};
|
|
});
|
|
function mergeValues(a, b) {
|
|
if (a === b) {
|
|
return { valid: true, data: a };
|
|
}
|
|
if (a instanceof Date && b instanceof Date && +a === +b) {
|
|
return { valid: true, data: a };
|
|
}
|
|
if (isPlainObject(a) && isPlainObject(b)) {
|
|
const bKeys = Object.keys(b);
|
|
const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
|
|
const newObj = { ...a, ...b };
|
|
for (const key of sharedKeys) {
|
|
const sharedValue = mergeValues(a[key], b[key]);
|
|
if (!sharedValue.valid) {
|
|
return {
|
|
valid: false,
|
|
mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
|
|
};
|
|
}
|
|
newObj[key] = sharedValue.data;
|
|
}
|
|
return { valid: true, data: newObj };
|
|
}
|
|
if (Array.isArray(a) && Array.isArray(b)) {
|
|
if (a.length !== b.length) {
|
|
return { valid: false, mergeErrorPath: [] };
|
|
}
|
|
const newArray = [];
|
|
for (let index = 0;index < a.length; index++) {
|
|
const itemA = a[index];
|
|
const itemB = b[index];
|
|
const sharedValue = mergeValues(itemA, itemB);
|
|
if (!sharedValue.valid) {
|
|
return {
|
|
valid: false,
|
|
mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
|
|
};
|
|
}
|
|
newArray.push(sharedValue.data);
|
|
}
|
|
return { valid: true, data: newArray };
|
|
}
|
|
return { valid: false, mergeErrorPath: [] };
|
|
}
|
|
function handleIntersectionResults(result, left, right) {
|
|
const unrecKeys = new Map;
|
|
let unrecIssue;
|
|
for (const iss of left.issues) {
|
|
if (iss.code === "unrecognized_keys") {
|
|
unrecIssue ?? (unrecIssue = iss);
|
|
for (const k of iss.keys) {
|
|
if (!unrecKeys.has(k))
|
|
unrecKeys.set(k, {});
|
|
unrecKeys.get(k).l = true;
|
|
}
|
|
} else {
|
|
result.issues.push(iss);
|
|
}
|
|
}
|
|
for (const iss of right.issues) {
|
|
if (iss.code === "unrecognized_keys") {
|
|
for (const k of iss.keys) {
|
|
if (!unrecKeys.has(k))
|
|
unrecKeys.set(k, {});
|
|
unrecKeys.get(k).r = true;
|
|
}
|
|
} else {
|
|
result.issues.push(iss);
|
|
}
|
|
}
|
|
const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
|
|
if (bothKeys.length && unrecIssue) {
|
|
result.issues.push({ ...unrecIssue, keys: bothKeys });
|
|
}
|
|
if (aborted(result))
|
|
return result;
|
|
const merged = mergeValues(left.value, right.value);
|
|
if (!merged.valid) {
|
|
throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);
|
|
}
|
|
result.value = merged.data;
|
|
return result;
|
|
}
|
|
var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const items = def.items;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!Array.isArray(input)) {
|
|
payload.issues.push({
|
|
input,
|
|
inst,
|
|
expected: "tuple",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = [];
|
|
const proms = [];
|
|
const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
|
|
const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
|
|
if (!def.rest) {
|
|
const tooBig = input.length > items.length;
|
|
const tooSmall = input.length < optStart - 1;
|
|
if (tooBig || tooSmall) {
|
|
payload.issues.push({
|
|
...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
|
|
input,
|
|
inst,
|
|
origin: "array"
|
|
});
|
|
return payload;
|
|
}
|
|
}
|
|
let i = -1;
|
|
for (const item of items) {
|
|
i++;
|
|
if (i >= input.length) {
|
|
if (i >= optStart)
|
|
continue;
|
|
}
|
|
const result = item._zod.run({
|
|
value: input[i],
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
|
|
} else {
|
|
handleTupleResult(result, payload, i);
|
|
}
|
|
}
|
|
if (def.rest) {
|
|
const rest = input.slice(items.length);
|
|
for (const el of rest) {
|
|
i++;
|
|
const result = def.rest._zod.run({
|
|
value: el,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
|
|
} else {
|
|
handleTupleResult(result, payload, i);
|
|
}
|
|
}
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleTupleResult(result, final, index) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...prefixIssues(index, result.issues));
|
|
}
|
|
final.value[index] = result.value;
|
|
}
|
|
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!isPlainObject(input)) {
|
|
payload.issues.push({
|
|
expected: "record",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
const values = def.keyType._zod.values;
|
|
if (values) {
|
|
payload.value = {};
|
|
const recordKeys = new Set;
|
|
for (const key of values) {
|
|
if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
|
|
recordKeys.add(typeof key === "number" ? key.toString() : key);
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => {
|
|
if (result2.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result2.issues));
|
|
}
|
|
payload.value[key] = result2.value;
|
|
}));
|
|
} else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[key] = result.value;
|
|
}
|
|
}
|
|
}
|
|
let unrecognized;
|
|
for (const key in input) {
|
|
if (!recordKeys.has(key)) {
|
|
unrecognized = unrecognized ?? [];
|
|
unrecognized.push(key);
|
|
}
|
|
}
|
|
if (unrecognized && unrecognized.length > 0) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
input,
|
|
inst,
|
|
keys: unrecognized
|
|
});
|
|
}
|
|
} else {
|
|
payload.value = {};
|
|
for (const key of Reflect.ownKeys(input)) {
|
|
if (key === "__proto__")
|
|
continue;
|
|
let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
if (keyResult instanceof Promise) {
|
|
throw new Error("Async schemas not supported in object keys currently");
|
|
}
|
|
const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
|
|
if (checkNumericKey) {
|
|
const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
|
|
if (retryResult instanceof Promise) {
|
|
throw new Error("Async schemas not supported in object keys currently");
|
|
}
|
|
if (retryResult.issues.length === 0) {
|
|
keyResult = retryResult;
|
|
}
|
|
}
|
|
if (keyResult.issues.length) {
|
|
if (def.mode === "loose") {
|
|
payload.value[key] = input[key];
|
|
} else {
|
|
payload.issues.push({
|
|
code: "invalid_key",
|
|
origin: "record",
|
|
issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
|
|
input: key,
|
|
path: [key],
|
|
inst
|
|
});
|
|
}
|
|
continue;
|
|
}
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => {
|
|
if (result2.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result2.issues));
|
|
}
|
|
payload.value[keyResult.value] = result2.value;
|
|
}));
|
|
} else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues(key, result.issues));
|
|
}
|
|
payload.value[keyResult.value] = result.value;
|
|
}
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!(input instanceof Map)) {
|
|
payload.issues.push({
|
|
expected: "map",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
payload.value = new Map;
|
|
for (const [key, value] of input) {
|
|
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
|
|
if (keyResult instanceof Promise || valueResult instanceof Promise) {
|
|
proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
|
|
handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
|
|
}));
|
|
} else {
|
|
handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
|
|
}
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
|
|
if (keyResult.issues.length) {
|
|
if (propertyKeyTypes.has(typeof key)) {
|
|
final.issues.push(...prefixIssues(key, keyResult.issues));
|
|
} else {
|
|
final.issues.push({
|
|
code: "invalid_key",
|
|
origin: "map",
|
|
input,
|
|
inst,
|
|
issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
|
|
});
|
|
}
|
|
}
|
|
if (valueResult.issues.length) {
|
|
if (propertyKeyTypes.has(typeof key)) {
|
|
final.issues.push(...prefixIssues(key, valueResult.issues));
|
|
} else {
|
|
final.issues.push({
|
|
origin: "map",
|
|
code: "invalid_element",
|
|
input,
|
|
inst,
|
|
key,
|
|
issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
|
|
});
|
|
}
|
|
}
|
|
final.value.set(keyResult.value, valueResult.value);
|
|
}
|
|
var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!(input instanceof Set)) {
|
|
payload.issues.push({
|
|
input,
|
|
inst,
|
|
expected: "set",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
payload.value = new Set;
|
|
for (const item of input) {
|
|
const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleSetResult(result2, payload)));
|
|
} else
|
|
handleSetResult(result, payload);
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleSetResult(result, final) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...result.issues);
|
|
}
|
|
final.value.add(result.value);
|
|
}
|
|
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const values = getEnumValues(def.entries);
|
|
const valuesSet = new Set(values);
|
|
inst._zod.values = valuesSet;
|
|
inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (valuesSet.has(input)) {
|
|
return payload;
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values,
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
if (def.values.length === 0) {
|
|
throw new Error("Cannot create literal schema with no valid values");
|
|
}
|
|
const values = new Set(def.values);
|
|
inst._zod.values = values;
|
|
inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (values.has(input)) {
|
|
return payload;
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values: def.values,
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (input instanceof File)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "file",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
throw new $ZodEncodeError(inst.constructor.name);
|
|
}
|
|
const _out = def.transform(payload.value, payload);
|
|
if (ctx.async) {
|
|
const output = _out instanceof Promise ? _out : Promise.resolve(_out);
|
|
return output.then((output2) => {
|
|
payload.value = output2;
|
|
return payload;
|
|
});
|
|
}
|
|
if (_out instanceof Promise) {
|
|
throw new $ZodAsyncError;
|
|
}
|
|
payload.value = _out;
|
|
return payload;
|
|
};
|
|
});
|
|
function handleOptionalResult(result, input) {
|
|
if (result.issues.length && input === undefined) {
|
|
return { issues: [], value: undefined };
|
|
}
|
|
return result;
|
|
}
|
|
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.optout = "optional";
|
|
defineLazy(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;
|
|
});
|
|
defineLazy(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (def.innerType._zod.optin === "optional") {
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise)
|
|
return result.then((r) => handleOptionalResult(r, payload.value));
|
|
return handleOptionalResult(result, payload.value);
|
|
}
|
|
if (payload.value === undefined) {
|
|
return payload;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
|
|
$ZodOptional.init(inst, def);
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
defineLazy(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : undefined;
|
|
});
|
|
defineLazy(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (payload.value === null)
|
|
return payload;
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
return payload;
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleDefaultResult(result2, def));
|
|
}
|
|
return handleDefaultResult(result, def);
|
|
};
|
|
});
|
|
function handleDefaultResult(payload, def) {
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return payload;
|
|
}
|
|
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "values", () => {
|
|
const v = def.innerType._zod.values;
|
|
return v ? new Set([...v].filter((x) => x !== undefined)) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleNonOptionalResult(result2, inst));
|
|
}
|
|
return handleNonOptionalResult(result, inst);
|
|
};
|
|
});
|
|
function handleNonOptionalResult(payload, inst) {
|
|
if (!payload.issues.length && payload.value === undefined) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "nonoptional",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
}
|
|
return payload;
|
|
}
|
|
var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
throw new $ZodEncodeError("ZodSuccess");
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => {
|
|
payload.value = result2.issues.length === 0;
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = result.issues.length === 0;
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => {
|
|
payload.value = result2.value;
|
|
if (result2.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
|
|
},
|
|
input: payload.value
|
|
});
|
|
payload.issues = [];
|
|
}
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = result.value;
|
|
if (result.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
|
|
},
|
|
input: payload.value
|
|
});
|
|
payload.issues = [];
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
expected: "nan",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "values", () => def.in._zod.values);
|
|
defineLazy(inst._zod, "optin", () => def.in._zod.optin);
|
|
defineLazy(inst._zod, "optout", () => def.out._zod.optout);
|
|
defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
const right = def.out._zod.run(payload, ctx);
|
|
if (right instanceof Promise) {
|
|
return right.then((right2) => handlePipeResult(right2, def.in, ctx));
|
|
}
|
|
return handlePipeResult(right, def.in, ctx);
|
|
}
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left2) => handlePipeResult(left2, def.out, ctx));
|
|
}
|
|
return handlePipeResult(left, def.out, ctx);
|
|
};
|
|
});
|
|
function handlePipeResult(left, next, ctx) {
|
|
if (left.issues.length) {
|
|
left.aborted = true;
|
|
return left;
|
|
}
|
|
return next._zod.run({ value: left.value, issues: left.issues }, ctx);
|
|
}
|
|
var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "values", () => def.in._zod.values);
|
|
defineLazy(inst._zod, "optin", () => def.in._zod.optin);
|
|
defineLazy(inst._zod, "optout", () => def.out._zod.optout);
|
|
defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const direction = ctx.direction || "forward";
|
|
if (direction === "forward") {
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left2) => handleCodecAResult(left2, def, ctx));
|
|
}
|
|
return handleCodecAResult(left, def, ctx);
|
|
} else {
|
|
const right = def.out._zod.run(payload, ctx);
|
|
if (right instanceof Promise) {
|
|
return right.then((right2) => handleCodecAResult(right2, def, ctx));
|
|
}
|
|
return handleCodecAResult(right, def, ctx);
|
|
}
|
|
};
|
|
});
|
|
function handleCodecAResult(result, def, ctx) {
|
|
if (result.issues.length) {
|
|
result.aborted = true;
|
|
return result;
|
|
}
|
|
const direction = ctx.direction || "forward";
|
|
if (direction === "forward") {
|
|
const transformed = def.transform(result.value, result);
|
|
if (transformed instanceof Promise) {
|
|
return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
|
|
}
|
|
return handleCodecTxResult(result, transformed, def.out, ctx);
|
|
} else {
|
|
const transformed = def.reverseTransform(result.value, result);
|
|
if (transformed instanceof Promise) {
|
|
return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
|
|
}
|
|
return handleCodecTxResult(result, transformed, def.in, ctx);
|
|
}
|
|
}
|
|
function handleCodecTxResult(left, value, nextSchema, ctx) {
|
|
if (left.issues.length) {
|
|
left.aborted = true;
|
|
return left;
|
|
}
|
|
return nextSchema._zod.run({ value, issues: left.issues }, ctx);
|
|
}
|
|
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
|
|
defineLazy(inst._zod, "values", () => def.innerType._zod.values);
|
|
defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
|
|
defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then(handleReadonlyResult);
|
|
}
|
|
return handleReadonlyResult(result);
|
|
};
|
|
});
|
|
function handleReadonlyResult(payload) {
|
|
payload.value = Object.freeze(payload.value);
|
|
return payload;
|
|
}
|
|
var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
const regexParts = [];
|
|
for (const part of def.parts) {
|
|
if (typeof part === "object" && part !== null) {
|
|
if (!part._zod.pattern) {
|
|
throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
|
|
}
|
|
const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
|
|
if (!source)
|
|
throw new Error(`Invalid template literal part: ${part._zod.traits}`);
|
|
const start = source.startsWith("^") ? 1 : 0;
|
|
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
|
regexParts.push(source.slice(start, end));
|
|
} else if (part === null || primitiveTypes.has(typeof part)) {
|
|
regexParts.push(escapeRegex(`${part}`));
|
|
} else {
|
|
throw new Error(`Invalid template literal part: ${part}`);
|
|
}
|
|
}
|
|
inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "string") {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
expected: "string",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
inst._zod.pattern.lastIndex = 0;
|
|
if (!inst._zod.pattern.test(payload.value)) {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
code: "invalid_format",
|
|
format: def.format ?? "template_literal",
|
|
pattern: inst._zod.pattern.source
|
|
});
|
|
return payload;
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._def = def;
|
|
inst._zod.def = def;
|
|
inst.implement = (func) => {
|
|
if (typeof func !== "function") {
|
|
throw new Error("implement() must be called with a function");
|
|
}
|
|
return function(...args) {
|
|
const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
|
|
const result = Reflect.apply(func, this, parsedArgs);
|
|
if (inst._def.output) {
|
|
return parse(inst._def.output, result);
|
|
}
|
|
return result;
|
|
};
|
|
};
|
|
inst.implementAsync = (func) => {
|
|
if (typeof func !== "function") {
|
|
throw new Error("implementAsync() must be called with a function");
|
|
}
|
|
return async function(...args) {
|
|
const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
|
|
const result = await Reflect.apply(func, this, parsedArgs);
|
|
if (inst._def.output) {
|
|
return await parseAsync(inst._def.output, result);
|
|
}
|
|
return result;
|
|
};
|
|
};
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "function") {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "function",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
|
|
if (hasPromiseOutput) {
|
|
payload.value = inst.implementAsync(payload.value);
|
|
} else {
|
|
payload.value = inst.implement(payload.value);
|
|
}
|
|
return payload;
|
|
};
|
|
inst.input = (...args) => {
|
|
const F = inst.constructor;
|
|
if (Array.isArray(args[0])) {
|
|
return new F({
|
|
type: "function",
|
|
input: new $ZodTuple({
|
|
type: "tuple",
|
|
items: args[0],
|
|
rest: args[1]
|
|
}),
|
|
output: inst._def.output
|
|
});
|
|
}
|
|
return new F({
|
|
type: "function",
|
|
input: args[0],
|
|
output: inst._def.output
|
|
});
|
|
};
|
|
inst.output = (output) => {
|
|
const F = inst.constructor;
|
|
return new F({
|
|
type: "function",
|
|
input: inst._def.input,
|
|
output
|
|
});
|
|
};
|
|
return inst;
|
|
});
|
|
var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
|
|
};
|
|
});
|
|
var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
defineLazy(inst._zod, "innerType", () => def.getter());
|
|
defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
|
|
defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
|
|
defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? undefined);
|
|
defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? undefined);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const inner = inst._zod.innerType;
|
|
return inner._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
|
|
$ZodCheck.init(inst, def);
|
|
$ZodType.init(inst, def);
|
|
inst._zod.parse = (payload, _) => {
|
|
return payload;
|
|
};
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const r = def.fn(input);
|
|
if (r instanceof Promise) {
|
|
return r.then((r2) => handleRefineResult(r2, payload, input, inst));
|
|
}
|
|
handleRefineResult(r, payload, input, inst);
|
|
return;
|
|
};
|
|
});
|
|
function handleRefineResult(result, payload, input, inst) {
|
|
if (!result) {
|
|
const _iss = {
|
|
code: "custom",
|
|
input,
|
|
inst,
|
|
path: [...inst._zod.def.path ?? []],
|
|
continue: !inst._zod.def.abort
|
|
};
|
|
if (inst._zod.def.params)
|
|
_iss.params = inst._zod.def.params;
|
|
payload.issues.push(issue(_iss));
|
|
}
|
|
}
|
|
// node_modules/zod/v4/locales/index.js
|
|
var exports_locales = {};
|
|
__export(exports_locales, {
|
|
zhTW: () => zh_TW_default,
|
|
zhCN: () => zh_CN_default,
|
|
yo: () => yo_default,
|
|
vi: () => vi_default,
|
|
uz: () => uz_default,
|
|
ur: () => ur_default,
|
|
uk: () => uk_default,
|
|
ua: () => ua_default,
|
|
tr: () => tr_default,
|
|
th: () => th_default,
|
|
ta: () => ta_default,
|
|
sv: () => sv_default,
|
|
sl: () => sl_default,
|
|
ru: () => ru_default,
|
|
pt: () => pt_default,
|
|
ps: () => ps_default,
|
|
pl: () => pl_default,
|
|
ota: () => ota_default,
|
|
no: () => no_default,
|
|
nl: () => nl_default,
|
|
ms: () => ms_default,
|
|
mk: () => mk_default,
|
|
lt: () => lt_default,
|
|
ko: () => ko_default,
|
|
km: () => km_default,
|
|
kh: () => kh_default,
|
|
ka: () => ka_default,
|
|
ja: () => ja_default,
|
|
it: () => it_default,
|
|
is: () => is_default,
|
|
id: () => id_default,
|
|
hy: () => hy_default,
|
|
hu: () => hu_default,
|
|
he: () => he_default,
|
|
frCA: () => fr_CA_default,
|
|
fr: () => fr_default,
|
|
fi: () => fi_default,
|
|
fa: () => fa_default,
|
|
es: () => es_default,
|
|
eo: () => eo_default,
|
|
en: () => en_default,
|
|
de: () => de_default,
|
|
da: () => da_default,
|
|
cs: () => cs_default,
|
|
ca: () => ca_default,
|
|
bg: () => bg_default,
|
|
be: () => be_default,
|
|
az: () => az_default,
|
|
ar: () => ar_default
|
|
});
|
|
|
|
// node_modules/zod/v4/locales/ar.js
|
|
var error = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
|
|
file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
|
|
array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
|
|
set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0645\u062F\u062E\u0644",
|
|
email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A",
|
|
url: "\u0631\u0627\u0628\u0637",
|
|
emoji: "\u0625\u064A\u0645\u0648\u062C\u064A",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4",
|
|
ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6",
|
|
cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4",
|
|
cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6",
|
|
base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded",
|
|
base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded",
|
|
json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON",
|
|
e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0645\u062F\u062E\u0644"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 instanceof ${issue2.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
|
|
}
|
|
return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue2.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"}`;
|
|
return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue2.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue2.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue2.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${issue2.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`;
|
|
return `${FormatDictionary[_issue.format] ?? issue2.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u0645\u0639\u0631\u0641${issue2.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${issue2.keys.length > 1 ? "\u0629" : ""}: ${joinValues(issue2.keys, "\u060C ")}`;
|
|
case "invalid_key":
|
|
return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
|
|
case "invalid_element":
|
|
return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue2.origin}`;
|
|
default:
|
|
return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
|
|
}
|
|
};
|
|
};
|
|
function ar_default() {
|
|
return {
|
|
localeError: error()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/az.js
|
|
var error2 = () => {
|
|
const Sizable = {
|
|
string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
|
|
file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
|
|
array: { unit: "element", verb: "olmal\u0131d\u0131r" },
|
|
set: { unit: "element", verb: "olmal\u0131d\u0131r" }
|
|
};
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n instanceof ${issue2.expected}, daxil olan ${received}`;
|
|
}
|
|
return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${expected}, daxil olan ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue2.origin ?? "d\u0259y\u0259r"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "element"}`;
|
|
return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue2.origin ?? "d\u0259y\u0259r"} ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Yanl\u0131\u015F m\u0259tn: "${_issue.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`;
|
|
if (_issue.format === "ends_with")
|
|
return `Yanl\u0131\u015F m\u0259tn: "${_issue.suffix}" il\u0259 bitm\u0259lidir`;
|
|
if (_issue.format === "includes")
|
|
return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`;
|
|
if (_issue.format === "regex")
|
|
return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`;
|
|
return `Yanl\u0131\u015F ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Yanl\u0131\u015F \u0259d\u0259d: ${issue2.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`;
|
|
case "unrecognized_keys":
|
|
return `Tan\u0131nmayan a\xE7ar${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`;
|
|
case "invalid_union":
|
|
return "Yanl\u0131\u015F d\u0259y\u0259r";
|
|
case "invalid_element":
|
|
return `${issue2.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`;
|
|
default:
|
|
return `Yanl\u0131\u015F d\u0259y\u0259r`;
|
|
}
|
|
};
|
|
};
|
|
function az_default() {
|
|
return {
|
|
localeError: error2()
|
|
};
|
|
}
|
|
// 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;
|
|
}
|
|
var error3 = () => {
|
|
const Sizable = {
|
|
string: {
|
|
unit: {
|
|
one: "\u0441\u0456\u043C\u0432\u0430\u043B",
|
|
few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B",
|
|
many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
},
|
|
array: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
},
|
|
set: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
},
|
|
file: {
|
|
unit: {
|
|
one: "\u0431\u0430\u0439\u0442",
|
|
few: "\u0431\u0430\u0439\u0442\u044B",
|
|
many: "\u0431\u0430\u0439\u0442\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
}
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0443\u0432\u043E\u0434",
|
|
email: "email \u0430\u0434\u0440\u0430\u0441",
|
|
url: "URL",
|
|
emoji: "\u044D\u043C\u043E\u0434\u0437\u0456",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441",
|
|
date: "ISO \u0434\u0430\u0442\u0430",
|
|
time: "ISO \u0447\u0430\u0441",
|
|
duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C",
|
|
ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441",
|
|
ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441",
|
|
cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
|
|
cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
|
|
base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64",
|
|
base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url",
|
|
json_string: "JSON \u0440\u0430\u0434\u043E\u043A",
|
|
e164: "\u043D\u0443\u043C\u0430\u0440 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0443\u0432\u043E\u0434"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u043B\u0456\u043A",
|
|
array: "\u043C\u0430\u0441\u0456\u045E"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F instanceof ${issue2.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
|
|
}
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
const maxValue = Number(issue2.maximum);
|
|
const unit = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.maximum.toString()} ${unit}`;
|
|
}
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
const minValue = Number(issue2.minimum);
|
|
const unit = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.minimum.toString()} ${unit}`;
|
|
}
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${issue2.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434";
|
|
case "invalid_element":
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${issue2.origin}`;
|
|
default:
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434`;
|
|
}
|
|
};
|
|
};
|
|
function be_default() {
|
|
return {
|
|
localeError: error3()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/bg.js
|
|
var error4 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
|
|
file: { unit: "\u0431\u0430\u0439\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
|
|
array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
|
|
set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0432\u0445\u043E\u0434",
|
|
email: "\u0438\u043C\u0435\u0439\u043B \u0430\u0434\u0440\u0435\u0441",
|
|
url: "URL",
|
|
emoji: "\u0435\u043C\u043E\u0434\u0436\u0438",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0432\u0440\u0435\u043C\u0435",
|
|
date: "ISO \u0434\u0430\u0442\u0430",
|
|
time: "ISO \u0432\u0440\u0435\u043C\u0435",
|
|
duration: "ISO \u043F\u0440\u043E\u0434\u044A\u043B\u0436\u0438\u0442\u0435\u043B\u043D\u043E\u0441\u0442",
|
|
ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
|
|
ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
|
|
cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
|
|
cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
|
|
base64: "base64-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
|
|
base64url: "base64url-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
|
|
json_string: "JSON \u043D\u0438\u0437",
|
|
e164: "E.164 \u043D\u043E\u043C\u0435\u0440",
|
|
jwt: "JWT",
|
|
template_literal: "\u0432\u0445\u043E\u0434"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0447\u0438\u0441\u043B\u043E",
|
|
array: "\u043C\u0430\u0441\u0438\u0432"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
|
|
}
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u043E\u043F\u0446\u0438\u044F: \u043E\u0447\u0430\u043A\u0432\u0430\u043D\u043E \u0435\u0434\u043D\u043E \u043E\u0442 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430"}`;
|
|
return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u0432\u0430 \u0441 "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u0432\u044A\u0440\u0448\u0432\u0430 \u0441 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0432\u043A\u043B\u044E\u0447\u0432\u0430 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0441\u044A\u0432\u043F\u0430\u0434\u0430 \u0441 ${_issue.pattern}`;
|
|
let invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D";
|
|
if (_issue.format === "emoji")
|
|
invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
|
|
if (_issue.format === "datetime")
|
|
invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
|
|
if (_issue.format === "date")
|
|
invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
|
|
if (_issue.format === "time")
|
|
invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
|
|
if (_issue.format === "duration")
|
|
invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
|
|
return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E \u0447\u0438\u0441\u043B\u043E: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0431\u044A\u0434\u0435 \u043A\u0440\u0430\u0442\u043D\u043E \u043D\u0430 ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u041D\u0435\u0440\u0430\u0437\u043F\u043E\u0437\u043D\u0430\u0442${issue2.keys.length > 1 ? "\u0438" : ""} \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u043E\u0432\u0435" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043A\u043B\u044E\u0447 \u0432 ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434";
|
|
case "invalid_element":
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442 \u0432 ${issue2.origin}`;
|
|
default:
|
|
return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434`;
|
|
}
|
|
};
|
|
};
|
|
function bg_default() {
|
|
return {
|
|
localeError: error4()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/ca.js
|
|
var error5 = () => {
|
|
const Sizable = {
|
|
string: { unit: "car\xE0cters", 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\xE7a electr\xF2nica",
|
|
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\xE7a IPv4",
|
|
ipv6: "adre\xE7a IPv6",
|
|
cidrv4: "rang IPv4",
|
|
cidrv6: "rang IPv6",
|
|
base64: "cadena codificada en base64",
|
|
base64url: "cadena codificada en base64url",
|
|
json_string: "cadena JSON",
|
|
e164: "n\xFAmero E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entrada"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Tipus inv\xE0lid: s'esperava instanceof ${issue2.expected}, s'ha rebut ${received}`;
|
|
}
|
|
return `Tipus inv\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Valor inv\xE0lid: s'esperava ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Opci\xF3 inv\xE0lida: s'esperava una de ${joinValues(issue2.values, " o ")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "com a m\xE0xim" : "menys de";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Massa gran: s'esperava que ${issue2.origin ?? "el valor"} contingu\xE9s ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`;
|
|
return `Massa gran: s'esperava que ${issue2.origin ?? "el valor"} fos ${adj} ${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? "com a m\xEDnim" : "m\xE9s de";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Massa petit: s'esperava que ${issue2.origin} contingu\xE9s ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Massa petit: s'esperava que ${issue2.origin} fos ${adj} ${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `Format inv\xE0lid: ha de comen\xE7ar amb "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Format inv\xE0lid: ha d'acabar amb "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`;
|
|
return `Format inv\xE0lid per a ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Clau${issue2.keys.length > 1 ? "s" : ""} no reconeguda${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Clau inv\xE0lida a ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Entrada inv\xE0lida";
|
|
case "invalid_element":
|
|
return `Element inv\xE0lid a ${issue2.origin}`;
|
|
default:
|
|
return `Entrada inv\xE0lida`;
|
|
}
|
|
};
|
|
};
|
|
function ca_default() {
|
|
return {
|
|
localeError: error5()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/cs.js
|
|
var error6 = () => {
|
|
const Sizable = {
|
|
string: { unit: "znak\u016F", verb: "m\xEDt" },
|
|
file: { unit: "bajt\u016F", verb: "m\xEDt" },
|
|
array: { unit: "prvk\u016F", verb: "m\xEDt" },
|
|
set: { unit: "prvk\u016F", verb: "m\xEDt" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "regul\xE1rn\xED v\xFDraz",
|
|
email: "e-mailov\xE1 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 \u010Das ve form\xE1tu ISO",
|
|
date: "datum ve form\xE1tu ISO",
|
|
time: "\u010Das ve form\xE1tu ISO",
|
|
duration: "doba trv\xE1n\xED ISO",
|
|
ipv4: "IPv4 adresa",
|
|
ipv6: "IPv6 adresa",
|
|
cidrv4: "rozsah IPv4",
|
|
cidrv6: "rozsah IPv6",
|
|
base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64",
|
|
base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url",
|
|
json_string: "\u0159et\u011Bzec ve form\xE1tu JSON",
|
|
e164: "\u010D\xEDslo E.164",
|
|
jwt: "JWT",
|
|
template_literal: "vstup"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u010D\xEDslo",
|
|
string: "\u0159et\u011Bzec",
|
|
function: "funkce",
|
|
array: "pole"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no instanceof ${issue2.expected}, obdr\u017Eeno ${received}`;
|
|
}
|
|
return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${expected}, obdr\u017Eeno ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue2.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
|
|
}
|
|
return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue2.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue2.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue2.minimum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
|
|
}
|
|
return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue2.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`;
|
|
return `Neplatn\xFD form\xE1t ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Nezn\xE1m\xE9 kl\xED\u010De: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Neplatn\xFD kl\xED\u010D v ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Neplatn\xFD vstup";
|
|
case "invalid_element":
|
|
return `Neplatn\xE1 hodnota v ${issue2.origin}`;
|
|
default:
|
|
return `Neplatn\xFD vstup`;
|
|
}
|
|
};
|
|
};
|
|
function cs_default() {
|
|
return {
|
|
localeError: error6()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/da.js
|
|
var error7 = () => {
|
|
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\xE6t",
|
|
date: "ISO-dato",
|
|
time: "ISO-klokkesl\xE6t",
|
|
duration: "ISO-varighed",
|
|
ipv4: "IPv4-omr\xE5de",
|
|
ipv6: "IPv6-omr\xE5de",
|
|
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\xE6t",
|
|
file: "fil"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Ugyldigt input: forventede instanceof ${issue2.expected}, fik ${received}`;
|
|
}
|
|
return `Ugyldigt input: forventede ${expected}, fik ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Ugyldig v\xE6rdi: forventede ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Ugyldigt valg: forventede en af f\xF8lgende ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
if (sizing)
|
|
return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "elementer"}`;
|
|
return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
if (sizing) {
|
|
return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `For lille: forventede ${origin} havde ${adj} ${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
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\xF8nsteret ${_issue.pattern}`;
|
|
return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ugyldigt tal: skal v\xE6re deleligt med ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue2.keys.length > 1 ? "Ukendte n\xF8gler" : "Ukendt n\xF8gle"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ugyldig n\xF8gle i ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Ugyldigt input: matcher ingen af de tilladte typer";
|
|
case "invalid_element":
|
|
return `Ugyldig v\xE6rdi i ${issue2.origin}`;
|
|
default:
|
|
return `Ugyldigt input`;
|
|
}
|
|
};
|
|
};
|
|
function da_default() {
|
|
return {
|
|
localeError: error7()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/de.js
|
|
var error8 = () => {
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Ung\xFCltige Eingabe: erwartet instanceof ${issue2.expected}, erhalten ${received}`;
|
|
}
|
|
return `Ung\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Ung\xFCltige Eingabe: erwartet ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Ung\xFCltige Option: erwartet eine von ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Zu gro\xDF: erwartet, dass ${issue2.origin ?? "Wert"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "Elemente"} hat`;
|
|
return `Zu gro\xDF: erwartet, dass ${issue2.origin ?? "Wert"} ${adj}${issue2.maximum.toString()} ist`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} hat`;
|
|
}
|
|
return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ist`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Ung\xFCltiger String: muss mit "${_issue.prefix}" beginnen`;
|
|
if (_issue.format === "ends_with")
|
|
return `Ung\xFCltiger String: muss mit "${_issue.suffix}" enden`;
|
|
if (_issue.format === "includes")
|
|
return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`;
|
|
if (_issue.format === "regex")
|
|
return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;
|
|
return `Ung\xFCltig: ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue2.divisor} sein`;
|
|
case "unrecognized_keys":
|
|
return `${issue2.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ung\xFCltiger Schl\xFCssel in ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Ung\xFCltige Eingabe";
|
|
case "invalid_element":
|
|
return `Ung\xFCltiger Wert in ${issue2.origin}`;
|
|
default:
|
|
return `Ung\xFCltige Eingabe`;
|
|
}
|
|
};
|
|
};
|
|
function de_default() {
|
|
return {
|
|
localeError: error8()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/en.js
|
|
var error9 = () => {
|
|
const Sizable = {
|
|
string: { unit: "characters", verb: "to have" },
|
|
file: { unit: "bytes", verb: "to have" },
|
|
array: { unit: "items", verb: "to have" },
|
|
set: { unit: "items", verb: "to have" },
|
|
map: { unit: "entries", verb: "to have" }
|
|
};
|
|
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",
|
|
mac: "MAC 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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
return `Invalid input: expected ${expected}, received ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Invalid option: expected one of ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Too big: expected ${issue2.origin ?? "value"} to have ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`;
|
|
return `Too big: expected ${issue2.origin ?? "value"} to be ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `Invalid string: must start with "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Invalid string: must end with "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Invalid string: must include "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Invalid string: must match pattern ${_issue.pattern}`;
|
|
return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Invalid number: must be a multiple of ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Unrecognized key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Invalid key in ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Invalid input";
|
|
case "invalid_element":
|
|
return `Invalid value in ${issue2.origin}`;
|
|
default:
|
|
return `Invalid input`;
|
|
}
|
|
};
|
|
};
|
|
function en_default() {
|
|
return {
|
|
localeError: error9()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/eo.js
|
|
var error10 = () => {
|
|
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\u011Dio",
|
|
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\u016Dro",
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Nevalida enigo: atendi\u011Dis instanceof ${issue2.expected}, ricevi\u011Dis ${received}`;
|
|
}
|
|
return `Nevalida enigo: atendi\u011Dis ${expected}, ricevi\u011Dis ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Nevalida opcio: atendi\u011Dis unu el ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Tro granda: atendi\u011Dis ke ${issue2.origin ?? "valoro"} havu ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementojn"}`;
|
|
return `Tro granda: atendi\u011Dis ke ${issue2.origin ?? "valoro"} havu ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Tro malgranda: atendi\u011Dis ke ${issue2.origin} havu ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Tro malgranda: atendi\u011Dis ke ${issue2.origin} estu ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Nevalida karaktraro: devas komenci\u011Di per "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Nevalida karaktraro: devas fini\u011Di 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] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nevalida nombro: devas esti oblo de ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Nekonata${issue2.keys.length > 1 ? "j" : ""} \u015Dlosilo${issue2.keys.length > 1 ? "j" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Nevalida \u015Dlosilo en ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Nevalida enigo";
|
|
case "invalid_element":
|
|
return `Nevalida valoro en ${issue2.origin}`;
|
|
default:
|
|
return `Nevalida enigo`;
|
|
}
|
|
};
|
|
};
|
|
function eo_default() {
|
|
return {
|
|
localeError: error10()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/es.js
|
|
var error11 = () => {
|
|
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\xF3n de correo electr\xF3nico",
|
|
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\xF3n ISO",
|
|
ipv4: "direcci\xF3n IPv4",
|
|
ipv6: "direcci\xF3n IPv6",
|
|
cidrv4: "rango IPv4",
|
|
cidrv6: "rango IPv6",
|
|
base64: "cadena codificada en base64",
|
|
base64url: "URL codificada en base64",
|
|
json_string: "cadena JSON",
|
|
e164: "n\xFAmero E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entrada"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
string: "texto",
|
|
number: "n\xFAmero",
|
|
boolean: "booleano",
|
|
array: "arreglo",
|
|
object: "objeto",
|
|
set: "conjunto",
|
|
file: "archivo",
|
|
date: "fecha",
|
|
bigint: "n\xFAmero grande",
|
|
symbol: "s\xEDmbolo",
|
|
undefined: "indefinido",
|
|
null: "nulo",
|
|
function: "funci\xF3n",
|
|
map: "mapa",
|
|
record: "registro",
|
|
tuple: "tupla",
|
|
enum: "enumeraci\xF3n",
|
|
union: "uni\xF3n",
|
|
literal: "literal",
|
|
promise: "promesa",
|
|
void: "vac\xEDo",
|
|
never: "nunca",
|
|
unknown: "desconocido",
|
|
any: "cualquiera"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Entrada inv\xE1lida: se esperaba instanceof ${issue2.expected}, recibido ${received}`;
|
|
}
|
|
return `Entrada inv\xE1lida: se esperaba ${expected}, recibido ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
if (sizing)
|
|
return `Demasiado grande: se esperaba que ${origin ?? "valor"} tuviera ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementos"}`;
|
|
return `Demasiado grande: se esperaba que ${origin ?? "valor"} fuera ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
if (sizing) {
|
|
return `Demasiado peque\xF1o: se esperaba que ${origin} tuviera ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Demasiado peque\xF1o: se esperaba que ${origin} fuera ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Cadena inv\xE1lida: debe comenzar con "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Cadena inv\xE1lida: debe terminar en "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`;
|
|
return `Inv\xE1lido ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Llave${issue2.keys.length > 1 ? "s" : ""} desconocida${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Llave inv\xE1lida en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Entrada inv\xE1lida";
|
|
case "invalid_element":
|
|
return `Valor inv\xE1lido en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
|
|
default:
|
|
return `Entrada inv\xE1lida`;
|
|
}
|
|
};
|
|
};
|
|
function es_default() {
|
|
return {
|
|
localeError: error11()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/fa.js
|
|
var error12 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0648\u0631\u0648\u062F\u06CC",
|
|
email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644",
|
|
url: "URL",
|
|
emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
|
|
date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648",
|
|
time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
|
|
duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
|
|
ipv4: "IPv4 \u0622\u062F\u0631\u0633",
|
|
ipv6: "IPv6 \u0622\u062F\u0631\u0633",
|
|
cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647",
|
|
cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647",
|
|
base64: "base64-encoded \u0631\u0634\u062A\u0647",
|
|
base64url: "base64url-encoded \u0631\u0634\u062A\u0647",
|
|
json_string: "JSON \u0631\u0634\u062A\u0647",
|
|
e164: "E.164 \u0639\u062F\u062F",
|
|
jwt: "JWT",
|
|
template_literal: "\u0648\u0631\u0648\u062F\u06CC"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0639\u062F\u062F",
|
|
array: "\u0622\u0631\u0627\u06CC\u0647"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A instanceof ${issue2.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
|
|
}
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1) {
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${stringifyPrimitive(issue2.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`;
|
|
}
|
|
return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${joinValues(issue2.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue2.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue2.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`;
|
|
}
|
|
if (_issue.format === "ends_with") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`;
|
|
}
|
|
if (_issue.format === "includes") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${_issue.includes}" \u0628\u0627\u0634\u062F`;
|
|
}
|
|
if (_issue.format === "regex") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`;
|
|
}
|
|
return `${FormatDictionary[_issue.format] ?? issue2.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue2.divisor} \u0628\u0627\u0634\u062F`;
|
|
case "unrecognized_keys":
|
|
return `\u06A9\u0644\u06CC\u062F${issue2.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
|
|
case "invalid_element":
|
|
return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${issue2.origin}`;
|
|
default:
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
|
|
}
|
|
};
|
|
};
|
|
function fa_default() {
|
|
return {
|
|
localeError: error12()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/fi.js
|
|
var error13 = () => {
|
|
const Sizable = {
|
|
string: { unit: "merkki\xE4", 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\xE4iv\xE4m\xE4\xE4r\xE4n" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "s\xE4\xE4nn\xF6llinen lauseke",
|
|
email: "s\xE4hk\xF6postiosoite",
|
|
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\xE4iv\xE4m\xE4\xE4r\xE4",
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Virheellinen tyyppi: odotettiin instanceof ${issue2.expected}, oli ${received}`;
|
|
}
|
|
return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy olla ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Liian suuri: ${sizing.subject} t\xE4ytyy olla ${adj}${issue2.maximum.toString()} ${sizing.unit}`.trim();
|
|
}
|
|
return `Liian suuri: arvon t\xE4ytyy olla ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Liian pieni: ${sizing.subject} t\xE4ytyy olla ${adj}${issue2.minimum.toString()} ${sizing.unit}`.trim();
|
|
}
|
|
return `Liian pieni: arvon t\xE4ytyy olla ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${_issue.includes}"`;
|
|
if (_issue.format === "regex") {
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`;
|
|
}
|
|
return `Virheellinen ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Virheellinen luku: t\xE4ytyy olla luvun ${issue2.divisor} monikerta`;
|
|
case "unrecognized_keys":
|
|
return `${issue2.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${joinValues(issue2.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\xF6te`;
|
|
}
|
|
};
|
|
};
|
|
function fi_default() {
|
|
return {
|
|
localeError: error13()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/fr.js
|
|
var error14 = () => {
|
|
const Sizable = {
|
|
string: { unit: "caract\xE8res", verb: "avoir" },
|
|
file: { unit: "octets", verb: "avoir" },
|
|
array: { unit: "\xE9l\xE9ments", verb: "avoir" },
|
|
set: { unit: "\xE9l\xE9ments", verb: "avoir" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "entr\xE9e",
|
|
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\xE9e ISO",
|
|
ipv4: "adresse IPv4",
|
|
ipv6: "adresse IPv6",
|
|
cidrv4: "plage IPv4",
|
|
cidrv6: "plage IPv6",
|
|
base64: "cha\xEEne encod\xE9e en base64",
|
|
base64url: "cha\xEEne encod\xE9e en base64url",
|
|
json_string: "cha\xEEne JSON",
|
|
e164: "num\xE9ro E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entr\xE9e"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "nombre",
|
|
array: "tableau"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Entr\xE9e invalide : instanceof ${issue2.expected} attendu, ${received} re\xE7u`;
|
|
}
|
|
return `Entr\xE9e invalide : ${expected} attendu, ${received} re\xE7u`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Entr\xE9e invalide : ${stringifyPrimitive(issue2.values[0])} attendu`;
|
|
return `Option invalide : une valeur parmi ${joinValues(issue2.values, "|")} attendue`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Trop grand : ${issue2.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
|
|
return `Trop grand : ${issue2.origin ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`;
|
|
return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Cl\xE9${issue2.keys.length > 1 ? "s" : ""} non reconnue${issue2.keys.length > 1 ? "s" : ""} : ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Cl\xE9 invalide dans ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Entr\xE9e invalide";
|
|
case "invalid_element":
|
|
return `Valeur invalide dans ${issue2.origin}`;
|
|
default:
|
|
return `Entr\xE9e invalide`;
|
|
}
|
|
};
|
|
};
|
|
function fr_default() {
|
|
return {
|
|
localeError: error14()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/fr-CA.js
|
|
var error15 = () => {
|
|
const Sizable = {
|
|
string: { unit: "caract\xE8res", verb: "avoir" },
|
|
file: { unit: "octets", verb: "avoir" },
|
|
array: { unit: "\xE9l\xE9ments", verb: "avoir" },
|
|
set: { unit: "\xE9l\xE9ments", verb: "avoir" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "entr\xE9e",
|
|
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\xE9e ISO",
|
|
ipv4: "adresse IPv4",
|
|
ipv6: "adresse IPv6",
|
|
cidrv4: "plage IPv4",
|
|
cidrv6: "plage IPv6",
|
|
base64: "cha\xEEne encod\xE9e en base64",
|
|
base64url: "cha\xEEne encod\xE9e en base64url",
|
|
json_string: "cha\xEEne JSON",
|
|
e164: "num\xE9ro E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entr\xE9e"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Entr\xE9e invalide : attendu instanceof ${issue2.expected}, re\xE7u ${received}`;
|
|
}
|
|
return `Entr\xE9e invalide : attendu ${expected}, re\xE7u ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Entr\xE9e invalide : attendu ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Option invalide : attendu l'une des valeurs suivantes ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "\u2264" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Trop grand : attendu que ${issue2.origin ?? "la valeur"} ait ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
|
|
return `Trop grand : attendu que ${issue2.origin ?? "la valeur"} soit ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? "\u2265" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Trop petit : attendu que ${issue2.origin} ait ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Trop petit : attendu que ${issue2.origin} soit ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;
|
|
return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Cl\xE9${issue2.keys.length > 1 ? "s" : ""} non reconnue${issue2.keys.length > 1 ? "s" : ""} : ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Cl\xE9 invalide dans ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Entr\xE9e invalide";
|
|
case "invalid_element":
|
|
return `Valeur invalide dans ${issue2.origin}`;
|
|
default:
|
|
return `Entr\xE9e invalide`;
|
|
}
|
|
};
|
|
};
|
|
function fr_CA_default() {
|
|
return {
|
|
localeError: error15()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/he.js
|
|
var error16 = () => {
|
|
const TypeNames = {
|
|
string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
|
|
number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
|
|
boolean: { label: "\u05E2\u05E8\u05DA \u05D1\u05D5\u05DC\u05D9\u05D0\u05E0\u05D9", gender: "m" },
|
|
bigint: { label: "BigInt", gender: "m" },
|
|
date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA", gender: "m" },
|
|
array: { label: "\u05DE\u05E2\u05E8\u05DA", gender: "m" },
|
|
object: { label: "\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8", gender: "m" },
|
|
null: { label: "\u05E2\u05E8\u05DA \u05E8\u05D9\u05E7 (null)", gender: "m" },
|
|
undefined: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05DE\u05D5\u05D2\u05D3\u05E8 (undefined)", gender: "m" },
|
|
symbol: { label: "\u05E1\u05D9\u05DE\u05D1\u05D5\u05DC (Symbol)", gender: "m" },
|
|
function: { label: "\u05E4\u05D5\u05E0\u05E7\u05E6\u05D9\u05D4", gender: "f" },
|
|
map: { label: "\u05DE\u05E4\u05D4 (Map)", gender: "f" },
|
|
set: { label: "\u05E7\u05D1\u05D5\u05E6\u05D4 (Set)", gender: "f" },
|
|
file: { label: "\u05E7\u05D5\u05D1\u05E5", gender: "m" },
|
|
promise: { label: "Promise", gender: "m" },
|
|
NaN: { label: "NaN", gender: "m" },
|
|
unknown: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05D9\u05D3\u05D5\u05E2", gender: "m" },
|
|
value: { label: "\u05E2\u05E8\u05DA", gender: "m" }
|
|
};
|
|
const Sizable = {
|
|
string: { unit: "\u05EA\u05D5\u05D5\u05D9\u05DD", shortLabel: "\u05E7\u05E6\u05E8", longLabel: "\u05D0\u05E8\u05D5\u05DA" },
|
|
file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
|
|
array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
|
|
set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
|
|
number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
|
|
};
|
|
const typeEntry = (t) => t ? TypeNames[t] : undefined;
|
|
const typeLabel = (t) => {
|
|
const e = typeEntry(t);
|
|
if (e)
|
|
return e.label;
|
|
return t ?? TypeNames.unknown.label;
|
|
};
|
|
const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
|
|
const verbFor = (t) => {
|
|
const e = typeEntry(t);
|
|
const gender = e?.gender ?? "m";
|
|
return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
|
|
};
|
|
const getSizing = (origin) => {
|
|
if (!origin)
|
|
return null;
|
|
return Sizable[origin] ?? null;
|
|
};
|
|
const FormatDictionary = {
|
|
regex: { label: "\u05E7\u05DC\u05D8", gender: "m" },
|
|
email: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", gender: "f" },
|
|
url: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", gender: "f" },
|
|
emoji: { label: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9", 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: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO", gender: "m" },
|
|
date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO", gender: "m" },
|
|
time: { label: "\u05D6\u05DE\u05DF ISO", gender: "m" },
|
|
duration: { label: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO", gender: "m" },
|
|
ipv4: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4", gender: "f" },
|
|
ipv6: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6", gender: "f" },
|
|
cidrv4: { label: "\u05D8\u05D5\u05D5\u05D7 IPv4", gender: "m" },
|
|
cidrv6: { label: "\u05D8\u05D5\u05D5\u05D7 IPv6", gender: "m" },
|
|
base64: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64", gender: "f" },
|
|
base64url: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA", gender: "f" },
|
|
json_string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON", gender: "f" },
|
|
e164: { label: "\u05DE\u05E1\u05E4\u05E8 E.164", gender: "m" },
|
|
jwt: { label: "JWT", gender: "m" },
|
|
ends_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
|
|
includes: { label: "\u05E7\u05DC\u05D8", gender: "m" },
|
|
lowercase: { label: "\u05E7\u05DC\u05D8", gender: "m" },
|
|
starts_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
|
|
uppercase: { label: "\u05E7\u05DC\u05D8", gender: "m" }
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expectedKey = issue2.expected;
|
|
const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel(expectedKey);
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue2.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
|
|
}
|
|
return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
|
|
}
|
|
case "invalid_value": {
|
|
if (issue2.values.length === 1) {
|
|
return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05E2\u05E8\u05DA \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA ${stringifyPrimitive(issue2.values[0])}`;
|
|
}
|
|
const stringified = issue2.values.map((v) => stringifyPrimitive(v));
|
|
if (issue2.values.length === 2) {
|
|
return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${stringified[0]} \u05D0\u05D5 ${stringified[1]}`;
|
|
}
|
|
const lastValue = stringified[stringified.length - 1];
|
|
const restValues = stringified.slice(0, -1).join(", ");
|
|
return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${restValues} \u05D0\u05D5 ${lastValue}`;
|
|
}
|
|
case "too_big": {
|
|
const sizing = getSizing(issue2.origin);
|
|
const subject = withDefinite(issue2.origin ?? "value");
|
|
if (issue2.origin === "string") {
|
|
return `${sizing?.longLabel ?? "\u05D0\u05E8\u05D5\u05DA"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.maximum.toString()} ${sizing?.unit ?? ""} ${issue2.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim();
|
|
}
|
|
if (issue2.origin === "number") {
|
|
const comparison = issue2.inclusive ? `\u05E7\u05D8\u05DF \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.maximum}` : `\u05E7\u05D8\u05DF \u05DE-${issue2.maximum}`;
|
|
return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
|
|
}
|
|
if (issue2.origin === "array" || issue2.origin === "set") {
|
|
const verb = issue2.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
|
|
const comparison = issue2.inclusive ? `${issue2.maximum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue2.maximum} ${sizing?.unit ?? ""}`;
|
|
return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
|
|
}
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const be = verbFor(issue2.origin ?? "value");
|
|
if (sizing?.unit) {
|
|
return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const sizing = getSizing(issue2.origin);
|
|
const subject = withDefinite(issue2.origin ?? "value");
|
|
if (issue2.origin === "string") {
|
|
return `${sizing?.shortLabel ?? "\u05E7\u05E6\u05E8"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.minimum.toString()} ${sizing?.unit ?? ""} ${issue2.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim();
|
|
}
|
|
if (issue2.origin === "number") {
|
|
const comparison = issue2.inclusive ? `\u05D2\u05D3\u05D5\u05DC \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.minimum}` : `\u05D2\u05D3\u05D5\u05DC \u05DE-${issue2.minimum}`;
|
|
return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
|
|
}
|
|
if (issue2.origin === "array" || issue2.origin === "set") {
|
|
const verb = issue2.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
|
|
if (issue2.minimum === 1 && issue2.inclusive) {
|
|
const singularPhrase = issue2.origin === "set" ? "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3" : "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3";
|
|
return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${singularPhrase}`;
|
|
}
|
|
const comparison = issue2.inclusive ? `${issue2.minimum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue2.minimum} ${sizing?.unit ?? ""}`;
|
|
return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
|
|
}
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const be = verbFor(issue2.origin ?? "value");
|
|
if (sizing?.unit) {
|
|
return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1 "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
|
|
const nounEntry = FormatDictionary[_issue.format];
|
|
const noun = nounEntry?.label ?? _issue.format;
|
|
const gender = nounEntry?.gender ?? "m";
|
|
const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF";
|
|
return `${noun} \u05DC\u05D0 ${adjective}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u05DE\u05E4\u05EA\u05D7${issue2.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${issue2.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key": {
|
|
return `\u05E9\u05D3\u05D4 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8`;
|
|
}
|
|
case "invalid_union":
|
|
return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF";
|
|
case "invalid_element": {
|
|
const place = withDefinite(issue2.origin ?? "array");
|
|
return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${place}`;
|
|
}
|
|
default:
|
|
return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`;
|
|
}
|
|
};
|
|
};
|
|
function he_default() {
|
|
return {
|
|
localeError: error16()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/hu.js
|
|
var error17 = () => {
|
|
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\xEDm",
|
|
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\u0151b\xE9lyeg",
|
|
date: "ISO d\xE1tum",
|
|
time: "ISO id\u0151",
|
|
duration: "ISO id\u0151intervallum",
|
|
ipv4: "IPv4 c\xEDm",
|
|
ipv6: "IPv6 c\xEDm",
|
|
cidrv4: "IPv4 tartom\xE1ny",
|
|
cidrv6: "IPv6 tartom\xE1ny",
|
|
base64: "base64-k\xF3dolt string",
|
|
base64url: "base64url-k\xF3dolt string",
|
|
json_string: "JSON string",
|
|
e164: "E.164 sz\xE1m",
|
|
jwt: "JWT",
|
|
template_literal: "bemenet"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "sz\xE1m",
|
|
array: "t\xF6mb"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
|
|
}
|
|
return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `T\xFAl nagy: ${issue2.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elem"}`;
|
|
return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue2.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} m\xE9rete t\xFAl kicsi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} t\xFAl kicsi ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
|
|
if (_issue.format === "ends_with")
|
|
return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
|
|
if (_issue.format === "includes")
|
|
return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
|
|
if (_issue.format === "regex")
|
|
return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`;
|
|
return `\xC9rv\xE9nytelen ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\xC9rv\xE9nytelen sz\xE1m: ${issue2.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`;
|
|
case "unrecognized_keys":
|
|
return `Ismeretlen kulcs${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\xC9rv\xE9nytelen kulcs ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\xC9rv\xE9nytelen bemenet";
|
|
case "invalid_element":
|
|
return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${issue2.origin}`;
|
|
default:
|
|
return `\xC9rv\xE9nytelen bemenet`;
|
|
}
|
|
};
|
|
};
|
|
function hu_default() {
|
|
return {
|
|
localeError: error17()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/hy.js
|
|
function getArmenianPlural(count, one, many) {
|
|
return Math.abs(count) === 1 ? one : many;
|
|
}
|
|
function withDefiniteArticle(word) {
|
|
if (!word)
|
|
return "";
|
|
const vowels = ["\u0561", "\u0565", "\u0568", "\u056B", "\u0578", "\u0578\u0582", "\u0585"];
|
|
const lastChar = word[word.length - 1];
|
|
return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
|
|
}
|
|
var error18 = () => {
|
|
const Sizable = {
|
|
string: {
|
|
unit: {
|
|
one: "\u0576\u0577\u0561\u0576",
|
|
many: "\u0576\u0577\u0561\u0576\u0576\u0565\u0580"
|
|
},
|
|
verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
|
|
},
|
|
file: {
|
|
unit: {
|
|
one: "\u0562\u0561\u0575\u0569",
|
|
many: "\u0562\u0561\u0575\u0569\u0565\u0580"
|
|
},
|
|
verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
|
|
},
|
|
array: {
|
|
unit: {
|
|
one: "\u057F\u0561\u0580\u0580",
|
|
many: "\u057F\u0561\u0580\u0580\u0565\u0580"
|
|
},
|
|
verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
|
|
},
|
|
set: {
|
|
unit: {
|
|
one: "\u057F\u0561\u0580\u0580",
|
|
many: "\u057F\u0561\u0580\u0580\u0565\u0580"
|
|
},
|
|
verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
|
|
}
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0574\u0578\u0582\u057F\u0584",
|
|
email: "\u0567\u056C. \u0570\u0561\u057D\u0581\u0565",
|
|
url: "URL",
|
|
emoji: "\u0567\u0574\u0578\u057B\u056B",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E \u0587 \u056A\u0561\u0574",
|
|
date: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E",
|
|
time: "ISO \u056A\u0561\u0574",
|
|
duration: "ISO \u057F\u0587\u0578\u0572\u0578\u0582\u0569\u0575\u0578\u0582\u0576",
|
|
ipv4: "IPv4 \u0570\u0561\u057D\u0581\u0565",
|
|
ipv6: "IPv6 \u0570\u0561\u057D\u0581\u0565",
|
|
cidrv4: "IPv4 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
|
|
cidrv6: "IPv6 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
|
|
base64: "base64 \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
|
|
base64url: "base64url \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
|
|
json_string: "JSON \u057F\u0578\u0572",
|
|
e164: "E.164 \u0570\u0561\u0574\u0561\u0580",
|
|
jwt: "JWT",
|
|
template_literal: "\u0574\u0578\u0582\u057F\u0584"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0569\u056B\u057E",
|
|
array: "\u0566\u0561\u0576\u0563\u057E\u0561\u056E"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 instanceof ${issue2.expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
|
|
}
|
|
return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${stringifyPrimitive(issue2.values[1])}`;
|
|
return `\u054D\u056D\u0561\u056C \u057F\u0561\u0580\u0562\u0565\u0580\u0561\u056F\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 \u0570\u0565\u057F\u0587\u0575\u0561\u056C\u0576\u0565\u0580\u056B\u0581 \u0574\u0565\u056F\u0568\u055D ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
const maxValue = Number(issue2.maximum);
|
|
const unit = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many);
|
|
return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.maximum.toString()} ${unit}`;
|
|
}
|
|
return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
const minValue = Number(issue2.minimum);
|
|
const unit = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many);
|
|
return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.minimum.toString()} ${unit}`;
|
|
}
|
|
return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056C\u056B\u0576\u056B ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057D\u056F\u057D\u057E\u056B "${_issue.prefix}"-\u0578\u057E`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0561\u057E\u0561\u0580\u057F\u057E\u056B "${_issue.suffix}"-\u0578\u057E`;
|
|
if (_issue.format === "includes")
|
|
return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057A\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u056B "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0570\u0561\u0574\u0561\u057A\u0561\u057F\u0561\u057D\u056D\u0561\u0576\u056B ${_issue.pattern} \u0571\u0587\u0561\u0579\u0561\u0583\u056B\u0576`;
|
|
return `\u054D\u056D\u0561\u056C ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u054D\u056D\u0561\u056C \u0569\u056B\u057E\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0562\u0561\u0566\u0574\u0561\u057A\u0561\u057F\u056B\u056F \u056C\u056B\u0576\u056B ${issue2.divisor}-\u056B`;
|
|
case "unrecognized_keys":
|
|
return `\u0549\u0573\u0561\u0576\u0561\u0579\u057E\u0561\u056E \u0562\u0561\u0576\u0561\u056C\u056B${issue2.keys.length > 1 ? "\u0576\u0565\u0580" : ""}. ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u054D\u056D\u0561\u056C \u0562\u0561\u0576\u0561\u056C\u056B ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`;
|
|
case "invalid_union":
|
|
return "\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574";
|
|
case "invalid_element":
|
|
return `\u054D\u056D\u0561\u056C \u0561\u0580\u056A\u0565\u0584 ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`;
|
|
default:
|
|
return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574`;
|
|
}
|
|
};
|
|
};
|
|
function hy_default() {
|
|
return {
|
|
localeError: error18()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/id.js
|
|
var error19 = () => {
|
|
const Sizable = {
|
|
string: { unit: "karakter", verb: "memiliki" },
|
|
file: { unit: "byte", verb: "memiliki" },
|
|
array: { unit: "item", verb: "memiliki" },
|
|
set: { unit: "item", verb: "memiliki" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "input",
|
|
email: "alamat email",
|
|
url: "URL",
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Input tidak valid: diharapkan instanceof ${issue2.expected}, diterima ${received}`;
|
|
}
|
|
return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Input tidak valid: diharapkan ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Terlalu besar: diharapkan ${issue2.origin ?? "value"} memiliki ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemen"}`;
|
|
return `Terlalu besar: diharapkan ${issue2.origin ?? "value"} menjadi ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Terlalu kecil: diharapkan ${issue2.origin} memiliki ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Terlalu kecil: diharapkan ${issue2.origin} menjadi ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
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] ?? issue2.format} tidak valid`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Angka tidak valid: harus kelipatan dari ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Kunci tidak dikenali ${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Kunci tidak valid di ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Input tidak valid";
|
|
case "invalid_element":
|
|
return `Nilai tidak valid di ${issue2.origin}`;
|
|
default:
|
|
return `Input tidak valid`;
|
|
}
|
|
};
|
|
};
|
|
function id_default() {
|
|
return {
|
|
localeError: error19()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/is.js
|
|
var error20 = () => {
|
|
const Sizable = {
|
|
string: { unit: "stafi", verb: "a\xF0 hafa" },
|
|
file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
|
|
array: { unit: "hluti", verb: "a\xF0 hafa" },
|
|
set: { unit: "hluti", verb: "a\xF0 hafa" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "gildi",
|
|
email: "netfang",
|
|
url: "vefsl\xF3\xF0",
|
|
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\xEDmi",
|
|
date: "ISO dagsetning",
|
|
time: "ISO t\xEDmi",
|
|
duration: "ISO t\xEDmalengd",
|
|
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\xF6lugildi",
|
|
jwt: "JWT",
|
|
template_literal: "gildi"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "n\xFAmer",
|
|
array: "fylki"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera instanceof ${issue2.expected}`;
|
|
}
|
|
return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera ${expected}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\xD3gilt val: m\xE1 vera eitt af eftirfarandi ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin ?? "gildi"} hafi ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "hluti"}`;
|
|
return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin ?? "gildi"} s\xE9 ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin} hafi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin} s\xE9 ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 byrja \xE1 "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 enda \xE1 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`;
|
|
return `Rangt ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\xD3\xFEekkt ${issue2.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Rangur lykill \xED ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Rangt gildi";
|
|
case "invalid_element":
|
|
return `Rangt gildi \xED ${issue2.origin}`;
|
|
default:
|
|
return `Rangt gildi`;
|
|
}
|
|
};
|
|
};
|
|
function is_default() {
|
|
return {
|
|
localeError: error20()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/it.js
|
|
var error21 = () => {
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Input non valido: atteso instanceof ${issue2.expected}, ricevuto ${received}`;
|
|
}
|
|
return `Input non valido: atteso ${expected}, ricevuto ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Input non valido: atteso ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Opzione non valida: atteso uno tra ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Troppo grande: ${issue2.origin ?? "valore"} deve avere ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementi"}`;
|
|
return `Troppo grande: ${issue2.origin ?? "valore"} deve essere ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Troppo piccolo: ${issue2.origin} deve avere ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Troppo piccolo: ${issue2.origin} deve essere ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
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 `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Chiav${issue2.keys.length > 1 ? "i" : "e"} non riconosciut${issue2.keys.length > 1 ? "e" : "a"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Chiave non valida in ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Input non valido";
|
|
case "invalid_element":
|
|
return `Valore non valido in ${issue2.origin}`;
|
|
default:
|
|
return `Input non valido`;
|
|
}
|
|
};
|
|
};
|
|
function it_default() {
|
|
return {
|
|
localeError: error21()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/ja.js
|
|
var error22 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
|
|
file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
|
|
array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" },
|
|
set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u5165\u529B\u5024",
|
|
email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9",
|
|
url: "URL",
|
|
emoji: "\u7D75\u6587\u5B57",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO\u65E5\u6642",
|
|
date: "ISO\u65E5\u4ED8",
|
|
time: "ISO\u6642\u523B",
|
|
duration: "ISO\u671F\u9593",
|
|
ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9",
|
|
ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9",
|
|
cidrv4: "IPv4\u7BC4\u56F2",
|
|
cidrv6: "IPv6\u7BC4\u56F2",
|
|
base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
|
|
base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
|
|
json_string: "JSON\u6587\u5B57\u5217",
|
|
e164: "E.164\u756A\u53F7",
|
|
jwt: "JWT",
|
|
template_literal: "\u5165\u529B\u5024"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u6570\u5024",
|
|
array: "\u914D\u5217"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u7121\u52B9\u306A\u5165\u529B: instanceof ${issue2.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
|
|
}
|
|
return `\u7121\u52B9\u306A\u5165\u529B: ${expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u7121\u52B9\u306A\u5165\u529B: ${stringifyPrimitive(issue2.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`;
|
|
return `\u7121\u52B9\u306A\u9078\u629E: ${joinValues(issue2.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue2.origin ?? "\u5024"}\u306F${issue2.maximum.toString()}${sizing.unit ?? "\u8981\u7D20"}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue2.origin ?? "\u5024"}\u306F${issue2.maximum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue2.origin}\u306F${issue2.minimum.toString()}${sizing.unit}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue2.origin}\u306F${issue2.minimum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
if (_issue.format === "includes")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
if (_issue.format === "regex")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
return `\u7121\u52B9\u306A${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u7121\u52B9\u306A\u6570\u5024: ${issue2.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
case "unrecognized_keys":
|
|
return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${issue2.keys.length > 1 ? "\u7FA4" : ""}: ${joinValues(issue2.keys, "\u3001")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`;
|
|
case "invalid_union":
|
|
return "\u7121\u52B9\u306A\u5165\u529B";
|
|
case "invalid_element":
|
|
return `${issue2.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`;
|
|
default:
|
|
return `\u7121\u52B9\u306A\u5165\u529B`;
|
|
}
|
|
};
|
|
};
|
|
function ja_default() {
|
|
return {
|
|
localeError: error22()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/ka.js
|
|
var error23 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
|
|
email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
|
|
url: "URL",
|
|
emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD",
|
|
date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8",
|
|
time: "\u10D3\u10E0\u10DD",
|
|
duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0",
|
|
ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
|
|
ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
|
|
cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
|
|
cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
|
|
base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
|
|
jwt: "JWT",
|
|
template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
|
|
string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
|
|
function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
|
|
array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 instanceof ${issue2.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
|
|
}
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${joinValues(issue2.values, "|")}-\u10D3\u10D0\u10DC`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
|
|
if (_issue.format === "includes")
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
|
|
if (_issue.format === "regex")
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue2.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
|
|
case "unrecognized_keys":
|
|
return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue2.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue2.origin}-\u10E8\u10D8`;
|
|
case "invalid_union":
|
|
return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0";
|
|
case "invalid_element":
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue2.origin}-\u10E8\u10D8`;
|
|
default:
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`;
|
|
}
|
|
};
|
|
};
|
|
function ka_default() {
|
|
return {
|
|
localeError: error23()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/km.js
|
|
var error24 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
|
|
email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
|
|
url: "URL",
|
|
emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO",
|
|
date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO",
|
|
time: "\u1798\u17C9\u17C4\u1784 ISO",
|
|
duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO",
|
|
ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
|
|
ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
|
|
cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
|
|
cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
|
|
base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64",
|
|
base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url",
|
|
json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON",
|
|
e164: "\u179B\u17C1\u1781 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u179B\u17C1\u1781",
|
|
array: "\u17A2\u17B6\u179A\u17C1 (Array)",
|
|
null: "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A instanceof ${issue2.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
|
|
}
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "\u1792\u17B6\u178F\u17BB"}`;
|
|
return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
|
|
return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
|
|
case "invalid_element":
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`;
|
|
default:
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
|
|
}
|
|
};
|
|
};
|
|
function km_default() {
|
|
return {
|
|
localeError: error24()
|
|
};
|
|
}
|
|
|
|
// node_modules/zod/v4/locales/kh.js
|
|
function kh_default() {
|
|
return km_default();
|
|
}
|
|
// node_modules/zod/v4/locales/ko.js
|
|
var error25 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\uBB38\uC790", verb: "to have" },
|
|
file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
|
|
array: { unit: "\uAC1C", verb: "to have" },
|
|
set: { unit: "\uAC1C", verb: "to have" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\uC785\uB825",
|
|
email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
|
|
url: "URL",
|
|
emoji: "\uC774\uBAA8\uC9C0",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04",
|
|
date: "ISO \uB0A0\uC9DC",
|
|
time: "ISO \uC2DC\uAC04",
|
|
duration: "ISO \uAE30\uAC04",
|
|
ipv4: "IPv4 \uC8FC\uC18C",
|
|
ipv6: "IPv6 \uC8FC\uC18C",
|
|
cidrv4: "IPv4 \uBC94\uC704",
|
|
cidrv6: "IPv6 \uBC94\uC704",
|
|
base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
|
|
base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
|
|
json_string: "JSON \uBB38\uC790\uC5F4",
|
|
e164: "E.164 \uBC88\uD638",
|
|
jwt: "JWT",
|
|
template_literal: "\uC785\uB825"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 instanceof ${issue2.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
|
|
}
|
|
return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive(issue2.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
|
|
return `\uC798\uBABB\uB41C \uC635\uC158: ${joinValues(issue2.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
|
|
const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
|
|
const sizing = getSizing(issue2.origin);
|
|
const unit = sizing?.unit ?? "\uC694\uC18C";
|
|
if (sizing)
|
|
return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()}${unit} ${adj}${suffix}`;
|
|
return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()} ${adj}${suffix}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
|
|
const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
|
|
const sizing = getSizing(issue2.origin);
|
|
const unit = sizing?.unit ?? "\uC694\uC18C";
|
|
if (sizing) {
|
|
return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()}${unit} ${adj}${suffix}`;
|
|
}
|
|
return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()} ${adj}${suffix}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`;
|
|
if (_issue.format === "includes")
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
|
|
if (_issue.format === "regex")
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
|
|
return `\uC798\uBABB\uB41C ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue2.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
|
|
case "unrecognized_keys":
|
|
return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\uC798\uBABB\uB41C \uD0A4: ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return `\uC798\uBABB\uB41C \uC785\uB825`;
|
|
case "invalid_element":
|
|
return `\uC798\uBABB\uB41C \uAC12: ${issue2.origin}`;
|
|
default:
|
|
return `\uC798\uBABB\uB41C \uC785\uB825`;
|
|
}
|
|
};
|
|
};
|
|
function ko_default() {
|
|
return {
|
|
localeError: error25()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/lt.js
|
|
var capitalizeFirstCharacter = (text) => {
|
|
return text.charAt(0).toUpperCase() + text.slice(1);
|
|
};
|
|
function getUnitTypeFromNumber(number2) {
|
|
const abs = Math.abs(number2);
|
|
const last = abs % 10;
|
|
const last2 = abs % 100;
|
|
if (last2 >= 11 && last2 <= 19 || last === 0)
|
|
return "many";
|
|
if (last === 1)
|
|
return "one";
|
|
return "few";
|
|
}
|
|
var error26 = () => {
|
|
const Sizable = {
|
|
string: {
|
|
unit: {
|
|
one: "simbolis",
|
|
few: "simboliai",
|
|
many: "simboli\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip",
|
|
notInclusive: "turi b\u016Bti trumpesn\u0117 kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip",
|
|
notInclusive: "turi b\u016Bti ilgesn\u0117 kaip"
|
|
}
|
|
}
|
|
},
|
|
file: {
|
|
unit: {
|
|
one: "baitas",
|
|
few: "baitai",
|
|
many: "bait\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi b\u016Bti ne didesnis kaip",
|
|
notInclusive: "turi b\u016Bti ma\u017Eesnis kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip",
|
|
notInclusive: "turi b\u016Bti didesnis kaip"
|
|
}
|
|
}
|
|
},
|
|
array: {
|
|
unit: {
|
|
one: "element\u0105",
|
|
few: "elementus",
|
|
many: "element\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi tur\u0117ti ne daugiau kaip",
|
|
notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
|
|
notInclusive: "turi tur\u0117ti daugiau kaip"
|
|
}
|
|
}
|
|
},
|
|
set: {
|
|
unit: {
|
|
one: "element\u0105",
|
|
few: "elementus",
|
|
many: "element\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi tur\u0117ti ne daugiau kaip",
|
|
notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
|
|
notInclusive: "turi tur\u0117ti 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: "\u012Fvestis",
|
|
email: "el. pa\u0161to 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\u0117",
|
|
ipv4: "IPv4 adresas",
|
|
ipv6: "IPv6 adresas",
|
|
cidrv4: "IPv4 tinklo prefiksas (CIDR)",
|
|
cidrv6: "IPv6 tinklo prefiksas (CIDR)",
|
|
base64: "base64 u\u017Ekoduota eilut\u0117",
|
|
base64url: "base64url u\u017Ekoduota eilut\u0117",
|
|
json_string: "JSON eilut\u0117",
|
|
e164: "E.164 numeris",
|
|
jwt: "JWT",
|
|
template_literal: "\u012Fvestis"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "skai\u010Dius",
|
|
bigint: "sveikasis skai\u010Dius",
|
|
string: "eilut\u0117",
|
|
boolean: "login\u0117 reik\u0161m\u0117",
|
|
undefined: "neapibr\u0117\u017Eta reik\u0161m\u0117",
|
|
function: "funkcija",
|
|
symbol: "simbolis",
|
|
array: "masyvas",
|
|
object: "objektas",
|
|
null: "nulin\u0117 reik\u0161m\u0117"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Gautas tipas ${received}, o tik\u0117tasi - instanceof ${issue2.expected}`;
|
|
}
|
|
return `Gautas tipas ${received}, o tik\u0117tasi - ${expected}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Privalo b\u016Bti ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Privalo b\u016Bti vienas i\u0161 ${joinValues(issue2.values, "|")} pasirinkim\u0173`;
|
|
case "too_big": {
|
|
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.maximum)), issue2.inclusive ?? false, "smaller");
|
|
if (sizing?.verb)
|
|
return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue2.maximum.toString()} ${sizing.unit ?? "element\u0173"}`;
|
|
const adj = issue2.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
|
|
return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue2.maximum.toString()} ${sizing?.unit}`;
|
|
}
|
|
case "too_small": {
|
|
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.minimum)), issue2.inclusive ?? false, "bigger");
|
|
if (sizing?.verb)
|
|
return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue2.minimum.toString()} ${sizing.unit ?? "element\u0173"}`;
|
|
const adj = issue2.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
|
|
return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue2.minimum.toString()} ${sizing?.unit}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
|
|
return `Neteisingas ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Skai\u010Dius privalo b\u016Bti ${issue2.divisor} kartotinis.`;
|
|
case "unrecognized_keys":
|
|
return `Neatpa\u017Eint${issue2.keys.length > 1 ? "i" : "as"} rakt${issue2.keys.length > 1 ? "ai" : "as"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return "Rastas klaidingas raktas";
|
|
case "invalid_union":
|
|
return "Klaidinga \u012Fvestis";
|
|
case "invalid_element": {
|
|
const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
|
|
return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
|
|
}
|
|
default:
|
|
return "Klaidinga \u012Fvestis";
|
|
}
|
|
};
|
|
};
|
|
function lt_default() {
|
|
return {
|
|
localeError: error26()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/mk.js
|
|
var error27 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0432\u043D\u0435\u0441",
|
|
email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
|
|
url: "URL",
|
|
emoji: "\u0435\u043C\u043E\u045F\u0438",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435",
|
|
date: "ISO \u0434\u0430\u0442\u0443\u043C",
|
|
time: "ISO \u0432\u0440\u0435\u043C\u0435",
|
|
duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435",
|
|
ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430",
|
|
ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430",
|
|
cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433",
|
|
cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433",
|
|
base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
|
|
base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
|
|
json_string: "JSON \u043D\u0438\u0437\u0430",
|
|
e164: "E.164 \u0431\u0440\u043E\u0458",
|
|
jwt: "JWT",
|
|
template_literal: "\u0432\u043D\u0435\u0441"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0431\u0440\u043E\u0458",
|
|
array: "\u043D\u0438\u0437\u0430"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 instanceof ${issue2.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
|
|
}
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`;
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
|
|
return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue2.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441";
|
|
case "invalid_element":
|
|
return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${issue2.origin}`;
|
|
default:
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441`;
|
|
}
|
|
};
|
|
};
|
|
function mk_default() {
|
|
return {
|
|
localeError: error27()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/ms.js
|
|
var error28 = () => {
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Input tidak sah: dijangka instanceof ${issue2.expected}, diterima ${received}`;
|
|
}
|
|
return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Input tidak sah: dijangka ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Terlalu besar: dijangka ${issue2.origin ?? "nilai"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemen"}`;
|
|
return `Terlalu besar: dijangka ${issue2.origin ?? "nilai"} adalah ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Terlalu kecil: dijangka ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Terlalu kecil: dijangka ${issue2.origin} adalah ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
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] ?? issue2.format} tidak sah`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nombor tidak sah: perlu gandaan ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Kunci tidak dikenali: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Kunci tidak sah dalam ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Input tidak sah";
|
|
case "invalid_element":
|
|
return `Nilai tidak sah dalam ${issue2.origin}`;
|
|
default:
|
|
return `Input tidak sah`;
|
|
}
|
|
};
|
|
};
|
|
function ms_default() {
|
|
return {
|
|
localeError: error28()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/nl.js
|
|
var error29 = () => {
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Ongeldige invoer: verwacht instanceof ${issue2.expected}, ontving ${received}`;
|
|
}
|
|
return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Ongeldige optie: verwacht \xE9\xE9n van ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
const longName = issue2.origin === "date" ? "laat" : issue2.origin === "string" ? "lang" : "groot";
|
|
if (sizing)
|
|
return `Te ${longName}: verwacht dat ${issue2.origin ?? "waarde"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementen"} ${sizing.verb}`;
|
|
return `Te ${longName}: verwacht dat ${issue2.origin ?? "waarde"} ${adj}${issue2.maximum.toString()} is`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
const shortName = issue2.origin === "date" ? "vroeg" : issue2.origin === "string" ? "kort" : "klein";
|
|
if (sizing) {
|
|
return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
|
|
}
|
|
return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
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] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ongeldig getal: moet een veelvoud van ${issue2.divisor} zijn`;
|
|
case "unrecognized_keys":
|
|
return `Onbekende key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ongeldige key in ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Ongeldige invoer";
|
|
case "invalid_element":
|
|
return `Ongeldige waarde in ${issue2.origin}`;
|
|
default:
|
|
return `Ongeldige invoer`;
|
|
}
|
|
};
|
|
};
|
|
function nl_default() {
|
|
return {
|
|
localeError: error29()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/no.js
|
|
var error30 = () => {
|
|
const Sizable = {
|
|
string: { unit: "tegn", verb: "\xE5 ha" },
|
|
file: { unit: "bytes", verb: "\xE5 ha" },
|
|
array: { unit: "elementer", verb: "\xE5 inneholde" },
|
|
set: { unit: "elementer", verb: "\xE5 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\xE5de",
|
|
ipv6: "IPv6-omr\xE5de",
|
|
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 (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Ugyldig input: forventet instanceof ${issue2.expected}, fikk ${received}`;
|
|
}
|
|
return `Ugyldig input: forventet ${expected}, fikk ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Ugyldig verdi: forventet ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Ugyldig valg: forventet en av ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `For stor(t): forventet ${issue2.origin ?? "value"} til \xE5 ha ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementer"}`;
|
|
return `For stor(t): forventet ${issue2.origin ?? "value"} til \xE5 ha ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `For lite(n): forventet ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `For lite(n): forventet ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Ugyldig streng: m\xE5 starte med "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Ugyldig streng: m\xE5 ende med "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
|
|
return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue2.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ugyldig n\xF8kkel i ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Ugyldig input";
|
|
case "invalid_element":
|
|
return `Ugyldig verdi i ${issue2.origin}`;
|
|
default:
|
|
return `Ugyldig input`;
|
|
}
|
|
};
|
|
};
|
|
function no_default() {
|
|
return {
|
|
localeError: error30()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/ota.js
|
|
var error31 = () => {
|
|
const Sizable = {
|
|
string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
|
|
file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
|
|
array: { unit: "unsur", verb: "olmal\u0131d\u0131r" },
|
|
set: { unit: "unsur", verb: "olmal\u0131d\u0131r" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "giren",
|
|
email: "epostag\xE2h",
|
|
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\xE2m\u0131",
|
|
date: "ISO tarihi",
|
|
time: "ISO zaman\u0131",
|
|
duration: "ISO m\xFCddeti",
|
|
ipv4: "IPv4 ni\u015F\xE2n\u0131",
|
|
ipv6: "IPv6 ni\u015F\xE2n\u0131",
|
|
cidrv4: "IPv4 menzili",
|
|
cidrv6: "IPv6 menzili",
|
|
base64: "base64-\u015Fifreli metin",
|
|
base64url: "base64url-\u015Fifreli metin",
|
|
json_string: "JSON metin",
|
|
e164: "E.164 say\u0131s\u0131",
|
|
jwt: "JWT",
|
|
template_literal: "giren"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "numara",
|
|
array: "saf",
|
|
null: "gayb"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `F\xE2sit giren: umulan instanceof ${issue2.expected}, al\u0131nan ${received}`;
|
|
}
|
|
return `F\xE2sit giren: umulan ${expected}, al\u0131nan ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `F\xE2sit giren: umulan ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `F\xE2sit tercih: m\xFBteberler ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Fazla b\xFCy\xFCk: ${issue2.origin ?? "value"}, ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"} sahip olmal\u0131yd\u0131.`;
|
|
return `Fazla b\xFCy\xFCk: ${issue2.origin ?? "value"}, ${adj}${issue2.maximum.toString()} olmal\u0131yd\u0131.`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Fazla k\xFC\xE7\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`;
|
|
}
|
|
return `Fazla k\xFC\xE7\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} olmal\u0131yd\u0131.`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `F\xE2sit metin: "${_issue.prefix}" ile ba\u015Flamal\u0131.`;
|
|
if (_issue.format === "ends_with")
|
|
return `F\xE2sit metin: "${_issue.suffix}" ile bitmeli.`;
|
|
if (_issue.format === "includes")
|
|
return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
|
|
if (_issue.format === "regex")
|
|
return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
|
|
return `F\xE2sit ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `F\xE2sit say\u0131: ${issue2.divisor} kat\u0131 olmal\u0131yd\u0131.`;
|
|
case "unrecognized_keys":
|
|
return `Tan\u0131nmayan anahtar ${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} i\xE7in tan\u0131nmayan anahtar var.`;
|
|
case "invalid_union":
|
|
return "Giren tan\u0131namad\u0131.";
|
|
case "invalid_element":
|
|
return `${issue2.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`;
|
|
default:
|
|
return `K\u0131ymet tan\u0131namad\u0131.`;
|
|
}
|
|
};
|
|
};
|
|
function ota_default() {
|
|
return {
|
|
localeError: error31()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/ps.js
|
|
var error32 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
|
|
file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
|
|
array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
|
|
set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0648\u0631\u0648\u062F\u064A",
|
|
email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9",
|
|
url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644",
|
|
emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A",
|
|
date: "\u0646\u06D0\u067C\u0647",
|
|
time: "\u0648\u062E\u062A",
|
|
duration: "\u0645\u0648\u062F\u0647",
|
|
ipv4: "\u062F IPv4 \u067E\u062A\u0647",
|
|
ipv6: "\u062F IPv6 \u067E\u062A\u0647",
|
|
cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647",
|
|
cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647",
|
|
base64: "base64-encoded \u0645\u062A\u0646",
|
|
base64url: "base64url-encoded \u0645\u062A\u0646",
|
|
json_string: "JSON \u0645\u062A\u0646",
|
|
e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647",
|
|
jwt: "JWT",
|
|
template_literal: "\u0648\u0631\u0648\u062F\u064A"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0639\u062F\u062F",
|
|
array: "\u0627\u0631\u06D0"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F instanceof ${issue2.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
|
|
}
|
|
return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1) {
|
|
return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${stringifyPrimitive(issue2.values[0])} \u0648\u0627\u06CC`;
|
|
}
|
|
return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${joinValues(issue2.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue2.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`;
|
|
}
|
|
return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue2.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} \u0648\u064A`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0648\u0644\u0631\u064A`;
|
|
}
|
|
return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} \u0648\u064A`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`;
|
|
}
|
|
if (_issue.format === "ends_with") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`;
|
|
}
|
|
if (_issue.format === "includes") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${_issue.includes}" \u0648\u0644\u0631\u064A`;
|
|
}
|
|
if (_issue.format === "regex") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`;
|
|
}
|
|
return `${FormatDictionary[_issue.format] ?? issue2.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue2.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`;
|
|
case "unrecognized_keys":
|
|
return `\u0646\u0627\u0633\u0645 ${issue2.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${issue2.origin} \u06A9\u06D0`;
|
|
case "invalid_union":
|
|
return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
|
|
case "invalid_element":
|
|
return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${issue2.origin} \u06A9\u06D0`;
|
|
default:
|
|
return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
|
|
}
|
|
};
|
|
};
|
|
function ps_default() {
|
|
return {
|
|
localeError: error32()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/pl.js
|
|
var error33 = () => {
|
|
const Sizable = {
|
|
string: { unit: "znak\xF3w", verb: "mie\u0107" },
|
|
file: { unit: "bajt\xF3w", verb: "mie\u0107" },
|
|
array: { unit: "element\xF3w", verb: "mie\u0107" },
|
|
set: { unit: "element\xF3w", verb: "mie\u0107" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "wyra\u017Cenie",
|
|
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\u0105g znak\xF3w zakodowany w formacie base64",
|
|
base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url",
|
|
json_string: "ci\u0105g znak\xF3w w formacie JSON",
|
|
e164: "liczba E.164",
|
|
jwt: "JWT",
|
|
template_literal: "wej\u015Bcie"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "liczba",
|
|
array: "tablica"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano instanceof ${issue2.expected}, otrzymano ${received}`;
|
|
}
|
|
return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "element\xF3w"}`;
|
|
}
|
|
return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.minimum.toString()} ${sizing.unit ?? "element\xF3w"}`;
|
|
}
|
|
return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
|
|
return `Nieprawid\u0142ow(y/a/e) ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Nierozpoznane klucze${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Nieprawid\u0142owy klucz w ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Nieprawid\u0142owe dane wej\u015Bciowe";
|
|
case "invalid_element":
|
|
return `Nieprawid\u0142owa warto\u015B\u0107 w ${issue2.origin}`;
|
|
default:
|
|
return `Nieprawid\u0142owe dane wej\u015Bciowe`;
|
|
}
|
|
};
|
|
};
|
|
function pl_default() {
|
|
return {
|
|
localeError: error33()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/pt.js
|
|
var error34 = () => {
|
|
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\xE3o",
|
|
email: "endere\xE7o 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\xE7\xE3o ISO",
|
|
ipv4: "endere\xE7o IPv4",
|
|
ipv6: "endere\xE7o 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\xFAmero E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entrada"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "n\xFAmero",
|
|
null: "nulo"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Tipo inv\xE1lido: esperado instanceof ${issue2.expected}, recebido ${received}`;
|
|
}
|
|
return `Tipo inv\xE1lido: esperado ${expected}, recebido ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Entrada inv\xE1lida: esperado ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Muito grande: esperado que ${issue2.origin ?? "valor"} tivesse ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementos"}`;
|
|
return `Muito grande: esperado que ${issue2.origin ?? "valor"} fosse ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Muito pequeno: esperado que ${issue2.origin} tivesse ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Muito pequeno: esperado que ${issue2.origin} fosse ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Texto inv\xE1lido: deve come\xE7ar com "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Texto inv\xE1lido: deve terminar com "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
|
|
return `${FormatDictionary[_issue.format] ?? issue2.format} inv\xE1lido`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Chave${issue2.keys.length > 1 ? "s" : ""} desconhecida${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Chave inv\xE1lida em ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Entrada inv\xE1lida";
|
|
case "invalid_element":
|
|
return `Valor inv\xE1lido em ${issue2.origin}`;
|
|
default:
|
|
return `Campo inv\xE1lido`;
|
|
}
|
|
};
|
|
};
|
|
function pt_default() {
|
|
return {
|
|
localeError: error34()
|
|
};
|
|
}
|
|
// 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;
|
|
}
|
|
var error35 = () => {
|
|
const Sizable = {
|
|
string: {
|
|
unit: {
|
|
one: "\u0441\u0438\u043C\u0432\u043E\u043B",
|
|
few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430",
|
|
many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
},
|
|
file: {
|
|
unit: {
|
|
one: "\u0431\u0430\u0439\u0442",
|
|
few: "\u0431\u0430\u0439\u0442\u0430",
|
|
many: "\u0431\u0430\u0439\u0442"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
},
|
|
array: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
},
|
|
set: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
}
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0432\u0432\u043E\u0434",
|
|
email: "email \u0430\u0434\u0440\u0435\u0441",
|
|
url: "URL",
|
|
emoji: "\u044D\u043C\u043E\u0434\u0437\u0438",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F",
|
|
date: "ISO \u0434\u0430\u0442\u0430",
|
|
time: "ISO \u0432\u0440\u0435\u043C\u044F",
|
|
duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
|
|
ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
|
|
ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
|
|
cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
|
|
cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
|
|
base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64",
|
|
base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url",
|
|
json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430",
|
|
e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0432\u0432\u043E\u0434"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0447\u0438\u0441\u043B\u043E",
|
|
array: "\u043C\u0430\u0441\u0441\u0438\u0432"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
|
|
}
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
const maxValue = Number(issue2.maximum);
|
|
const unit = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.maximum.toString()} ${unit}`;
|
|
}
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
const minValue = Number(issue2.minimum);
|
|
const unit = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.minimum.toString()} ${unit}`;
|
|
}
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${issue2.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u0438" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435";
|
|
case "invalid_element":
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${issue2.origin}`;
|
|
default:
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435`;
|
|
}
|
|
};
|
|
};
|
|
function ru_default() {
|
|
return {
|
|
localeError: error35()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/sl.js
|
|
var error36 = () => {
|
|
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\u0161tni 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 \u010Das",
|
|
date: "ISO datum",
|
|
time: "ISO \u010Das",
|
|
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 \u0161tevilka",
|
|
jwt: "JWT",
|
|
template_literal: "vnos"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0161tevilo",
|
|
array: "tabela"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Neveljaven vnos: pri\u010Dakovano instanceof ${issue2.expected}, prejeto ${received}`;
|
|
}
|
|
return `Neveljaven vnos: pri\u010Dakovano ${expected}, prejeto ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Preveliko: pri\u010Dakovano, da bo ${issue2.origin ?? "vrednost"} imelo ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementov"}`;
|
|
return `Preveliko: pri\u010Dakovano, da bo ${issue2.origin ?? "vrednost"} ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Premajhno: pri\u010Dakovano, da bo ${issue2.origin} imelo ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Premajhno: pri\u010Dakovano, da bo ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `Neveljaven niz: mora se za\u010Deti z "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Neveljaven niz: mora se kon\u010Dati 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] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Neprepoznan${issue2.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Neveljaven klju\u010D v ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "Neveljaven vnos";
|
|
case "invalid_element":
|
|
return `Neveljavna vrednost v ${issue2.origin}`;
|
|
default:
|
|
return "Neveljaven vnos";
|
|
}
|
|
};
|
|
};
|
|
function sl_default() {
|
|
return {
|
|
localeError: error36()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/sv.js
|
|
var error37 = () => {
|
|
const Sizable = {
|
|
string: { unit: "tecken", verb: "att ha" },
|
|
file: { unit: "bytes", verb: "att ha" },
|
|
array: { unit: "objekt", verb: "att inneh\xE5lla" },
|
|
set: { unit: "objekt", verb: "att inneh\xE5lla" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "regulj\xE4rt 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\xE4ng",
|
|
base64url: "base64url-kodad str\xE4ng",
|
|
json_string: "JSON-str\xE4ng",
|
|
e164: "E.164-nummer",
|
|
jwt: "JWT",
|
|
template_literal: "mall-literal"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "antal",
|
|
array: "lista"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Ogiltig inmatning: f\xF6rv\xE4ntat instanceof ${issue2.expected}, fick ${received}`;
|
|
}
|
|
return `Ogiltig inmatning: f\xF6rv\xE4ntat ${expected}, fick ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Ogiltigt val: f\xF6rv\xE4ntade en av ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `F\xF6r stor(t): f\xF6rv\xE4ntade ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "element"}`;
|
|
}
|
|
return `F\xF6r stor(t): f\xF6rv\xE4ntat ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
|
|
return `Ogiltig(t) ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue2.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ogiltig nyckel i ${issue2.origin ?? "v\xE4rdet"}`;
|
|
case "invalid_union":
|
|
return "Ogiltig input";
|
|
case "invalid_element":
|
|
return `Ogiltigt v\xE4rde i ${issue2.origin ?? "v\xE4rdet"}`;
|
|
default:
|
|
return `Ogiltig input`;
|
|
}
|
|
};
|
|
};
|
|
function sv_default() {
|
|
return {
|
|
localeError: error37()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/ta.js
|
|
var error38 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
|
|
file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
|
|
array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
|
|
set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
|
|
email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
|
|
url: "URL",
|
|
emoji: "emoji",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
|
|
date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF",
|
|
time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
|
|
duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1",
|
|
ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
|
|
ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
|
|
cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
|
|
cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
|
|
base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
|
|
base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
|
|
json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD",
|
|
e164: "E.164 \u0B8E\u0BA3\u0BCD",
|
|
jwt: "JWT",
|
|
template_literal: "input"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0B8E\u0BA3\u0BCD",
|
|
array: "\u0B85\u0BA3\u0BBF",
|
|
null: "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 instanceof ${issue2.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
|
|
}
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${joinValues(issue2.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue2.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
if (_issue.format === "includes")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
if (_issue.format === "regex")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue2.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
case "unrecognized_keys":
|
|
return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${issue2.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`;
|
|
case "invalid_union":
|
|
return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1";
|
|
case "invalid_element":
|
|
return `${issue2.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`;
|
|
default:
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1`;
|
|
}
|
|
};
|
|
};
|
|
function ta_default() {
|
|
return {
|
|
localeError: error38()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/th.js
|
|
var error39 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
|
|
email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
|
|
url: "URL",
|
|
emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
|
|
date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO",
|
|
time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
|
|
duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
|
|
ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4",
|
|
ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6",
|
|
cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4",
|
|
cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6",
|
|
base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64",
|
|
base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL",
|
|
json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON",
|
|
e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)",
|
|
jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
|
|
template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02",
|
|
array: "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)",
|
|
null: "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 instanceof ${issue2.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
|
|
}
|
|
return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`;
|
|
return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
|
|
if (_issue.format === "regex")
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue2.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
|
|
case "unrecognized_keys":
|
|
return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49";
|
|
case "invalid_element":
|
|
return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue2.origin}`;
|
|
default:
|
|
return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07`;
|
|
}
|
|
};
|
|
};
|
|
function th_default() {
|
|
return {
|
|
localeError: error39()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/tr.js
|
|
var error40 = () => {
|
|
const Sizable = {
|
|
string: { unit: "karakter", verb: "olmal\u0131" },
|
|
file: { unit: "bayt", verb: "olmal\u0131" },
|
|
array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" },
|
|
set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }
|
|
};
|
|
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\xFCre",
|
|
ipv4: "IPv4 adresi",
|
|
ipv6: "IPv6 adresi",
|
|
cidrv4: "IPv4 aral\u0131\u011F\u0131",
|
|
cidrv6: "IPv6 aral\u0131\u011F\u0131",
|
|
base64: "base64 ile \u015Fifrelenmi\u015F metin",
|
|
base64url: "base64url ile \u015Fifrelenmi\u015F metin",
|
|
json_string: "JSON dizesi",
|
|
e164: "E.164 say\u0131s\u0131",
|
|
jwt: "JWT",
|
|
template_literal: "\u015Eablon dizesi"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Ge\xE7ersiz de\u011Fer: beklenen instanceof ${issue2.expected}, al\u0131nan ${received}`;
|
|
}
|
|
return `Ge\xE7ersiz de\u011Fer: beklenen ${expected}, al\u0131nan ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\xC7ok b\xFCy\xFCk: beklenen ${issue2.origin ?? "de\u011Fer"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xF6\u011Fe"}`;
|
|
return `\xC7ok b\xFCy\xFCk: beklenen ${issue2.origin ?? "de\u011Fer"} ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Ge\xE7ersiz metin: "${_issue.prefix}" ile ba\u015Flamal\u0131`;
|
|
if (_issue.format === "ends_with")
|
|
return `Ge\xE7ersiz metin: "${_issue.suffix}" ile bitmeli`;
|
|
if (_issue.format === "includes")
|
|
return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
|
|
if (_issue.format === "regex")
|
|
return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
|
|
return `Ge\xE7ersiz ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ge\xE7ersiz say\u0131: ${issue2.divisor} ile tam b\xF6l\xFCnebilmeli`;
|
|
case "unrecognized_keys":
|
|
return `Tan\u0131nmayan anahtar${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} i\xE7inde ge\xE7ersiz anahtar`;
|
|
case "invalid_union":
|
|
return "Ge\xE7ersiz de\u011Fer";
|
|
case "invalid_element":
|
|
return `${issue2.origin} i\xE7inde ge\xE7ersiz de\u011Fer`;
|
|
default:
|
|
return `Ge\xE7ersiz de\u011Fer`;
|
|
}
|
|
};
|
|
};
|
|
function tr_default() {
|
|
return {
|
|
localeError: error40()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/uk.js
|
|
var error41 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
|
|
email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
|
|
url: "URL",
|
|
emoji: "\u0435\u043C\u043E\u0434\u0437\u0456",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO",
|
|
date: "\u0434\u0430\u0442\u0430 ISO",
|
|
time: "\u0447\u0430\u0441 ISO",
|
|
duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO",
|
|
ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4",
|
|
ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6",
|
|
cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4",
|
|
cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6",
|
|
base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64",
|
|
base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url",
|
|
json_string: "\u0440\u044F\u0434\u043E\u043A JSON",
|
|
e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0447\u0438\u0441\u043B\u043E",
|
|
array: "\u043C\u0430\u0441\u0438\u0432"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F instanceof ${issue2.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
|
|
}
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`;
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin} \u0431\u0443\u0434\u0435 ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u0456" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456";
|
|
case "invalid_element":
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${issue2.origin}`;
|
|
default:
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456`;
|
|
}
|
|
};
|
|
};
|
|
function uk_default() {
|
|
return {
|
|
localeError: error41()
|
|
};
|
|
}
|
|
|
|
// node_modules/zod/v4/locales/ua.js
|
|
function ua_default() {
|
|
return uk_default();
|
|
}
|
|
// node_modules/zod/v4/locales/ur.js
|
|
var error42 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
|
|
file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
|
|
array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" },
|
|
set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0627\u0646 \u067E\u0679",
|
|
email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
|
|
url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
|
|
emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
|
|
uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4",
|
|
uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6",
|
|
nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2",
|
|
ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC",
|
|
xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC",
|
|
ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645",
|
|
date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E",
|
|
time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A",
|
|
duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A",
|
|
ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633",
|
|
ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633",
|
|
cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C",
|
|
cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C",
|
|
base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
|
|
base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
|
|
json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF",
|
|
e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631",
|
|
jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
|
|
template_literal: "\u0627\u0646 \u067E\u0679"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u0646\u0645\u0628\u0631",
|
|
array: "\u0622\u0631\u06D2",
|
|
null: "\u0646\u0644"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: instanceof ${issue2.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
|
|
}
|
|
return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive(issue2.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${joinValues(issue2.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue2.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
|
|
return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue2.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue2.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue2.origin} \u06A9\u06D2 ${adj}${issue2.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
|
|
}
|
|
return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue2.origin} \u06A9\u0627 ${adj}${issue2.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
if (_issue.format === "includes")
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
if (_issue.format === "regex")
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
return `\u063A\u0644\u0637 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue2.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
case "unrecognized_keys":
|
|
return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${issue2.keys.length > 1 ? "\u0632" : ""}: ${joinValues(issue2.keys, "\u060C ")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`;
|
|
case "invalid_union":
|
|
return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679";
|
|
case "invalid_element":
|
|
return `${issue2.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`;
|
|
default:
|
|
return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679`;
|
|
}
|
|
};
|
|
};
|
|
function ur_default() {
|
|
return {
|
|
localeError: error42()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/uz.js
|
|
var error43 = () => {
|
|
const Sizable = {
|
|
string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
|
|
file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
|
|
array: { unit: "element", verb: "bo\u2018lishi kerak" },
|
|
set: { unit: "element", verb: "bo\u2018lishi kerak" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "kirish",
|
|
email: "elektron pochta manzili",
|
|
url: "URL",
|
|
emoji: "emoji",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO sana va vaqti",
|
|
date: "ISO sana",
|
|
time: "ISO vaqt",
|
|
duration: "ISO davomiylik",
|
|
ipv4: "IPv4 manzil",
|
|
ipv6: "IPv6 manzil",
|
|
mac: "MAC manzil",
|
|
cidrv4: "IPv4 diapazon",
|
|
cidrv6: "IPv6 diapazon",
|
|
base64: "base64 kodlangan satr",
|
|
base64url: "base64url kodlangan satr",
|
|
json_string: "JSON satr",
|
|
e164: "E.164 raqam",
|
|
jwt: "JWT",
|
|
template_literal: "kirish"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "raqam",
|
|
array: "massiv"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `Noto\u2018g\u2018ri kirish: kutilgan instanceof ${issue2.expected}, qabul qilingan ${received}`;
|
|
}
|
|
return `Noto\u2018g\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `Noto\u2018g\u2018ri kirish: kutilgan ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `Noto\u2018g\u2018ri variant: quyidagilardan biri kutilgan ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Juda katta: kutilgan ${issue2.origin ?? "qiymat"} ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
|
|
return `Juda katta: kutilgan ${issue2.origin ?? "qiymat"} ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
|
|
}
|
|
return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Noto\u2018g\u2018ri satr: "${_issue.prefix}" bilan boshlanishi kerak`;
|
|
if (_issue.format === "ends_with")
|
|
return `Noto\u2018g\u2018ri satr: "${_issue.suffix}" bilan tugashi kerak`;
|
|
if (_issue.format === "includes")
|
|
return `Noto\u2018g\u2018ri satr: "${_issue.includes}" ni o\u2018z ichiga olishi kerak`;
|
|
if (_issue.format === "regex")
|
|
return `Noto\u2018g\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;
|
|
return `Noto\u2018g\u2018ri ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Noto\u2018g\u2018ri raqam: ${issue2.divisor} ning karralisi bo\u2018lishi kerak`;
|
|
case "unrecognized_keys":
|
|
return `Noma\u2019lum kalit${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} dagi kalit noto\u2018g\u2018ri`;
|
|
case "invalid_union":
|
|
return "Noto\u2018g\u2018ri kirish";
|
|
case "invalid_element":
|
|
return `${issue2.origin} da noto\u2018g\u2018ri qiymat`;
|
|
default:
|
|
return `Noto\u2018g\u2018ri kirish`;
|
|
}
|
|
};
|
|
};
|
|
function uz_default() {
|
|
return {
|
|
localeError: error43()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/vi.js
|
|
var error44 = () => {
|
|
const Sizable = {
|
|
string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
|
|
file: { unit: "byte", verb: "c\xF3" },
|
|
array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
|
|
set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u0111\u1EA7u v\xE0o",
|
|
email: "\u0111\u1ECBa ch\u1EC9 email",
|
|
url: "URL",
|
|
emoji: "emoji",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ng\xE0y gi\u1EDD ISO",
|
|
date: "ng\xE0y ISO",
|
|
time: "gi\u1EDD ISO",
|
|
duration: "kho\u1EA3ng th\u1EDDi gian ISO",
|
|
ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4",
|
|
ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6",
|
|
cidrv4: "d\u1EA3i IPv4",
|
|
cidrv6: "d\u1EA3i IPv6",
|
|
base64: "chu\u1ED7i m\xE3 h\xF3a base64",
|
|
base64url: "chu\u1ED7i m\xE3 h\xF3a base64url",
|
|
json_string: "chu\u1ED7i JSON",
|
|
e164: "s\u1ED1 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0111\u1EA7u v\xE0o"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "s\u1ED1",
|
|
array: "m\u1EA3ng"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i instanceof ${issue2.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
|
|
}
|
|
return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue2.origin ?? "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "ph\u1EA7n t\u1EED"}`;
|
|
return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue2.origin ?? "gi\xE1 tr\u1ECB"} ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
|
|
return `${FormatDictionary[_issue.format] ?? issue2.format} kh\xF4ng h\u1EE3p l\u1EC7`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7";
|
|
case "invalid_element":
|
|
return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue2.origin}`;
|
|
default:
|
|
return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7`;
|
|
}
|
|
};
|
|
};
|
|
function vi_default() {
|
|
return {
|
|
localeError: error44()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/zh-CN.js
|
|
var error45 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
|
|
file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
|
|
array: { unit: "\u9879", verb: "\u5305\u542B" },
|
|
set: { unit: "\u9879", verb: "\u5305\u542B" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u8F93\u5165",
|
|
email: "\u7535\u5B50\u90AE\u4EF6",
|
|
url: "URL",
|
|
emoji: "\u8868\u60C5\u7B26\u53F7",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO\u65E5\u671F\u65F6\u95F4",
|
|
date: "ISO\u65E5\u671F",
|
|
time: "ISO\u65F6\u95F4",
|
|
duration: "ISO\u65F6\u957F",
|
|
ipv4: "IPv4\u5730\u5740",
|
|
ipv6: "IPv6\u5730\u5740",
|
|
cidrv4: "IPv4\u7F51\u6BB5",
|
|
cidrv6: "IPv6\u7F51\u6BB5",
|
|
base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32",
|
|
base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32",
|
|
json_string: "JSON\u5B57\u7B26\u4E32",
|
|
e164: "E.164\u53F7\u7801",
|
|
jwt: "JWT",
|
|
template_literal: "\u8F93\u5165"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "\u6570\u5B57",
|
|
array: "\u6570\u7EC4",
|
|
null: "\u7A7A\u503C(null)"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B instanceof ${issue2.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
|
|
}
|
|
return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue2.origin ?? "\u503C"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u4E2A\u5143\u7D20"}`;
|
|
return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue2.origin ?? "\u503C"} ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.prefix}" \u5F00\u5934`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.suffix}" \u7ED3\u5C3E`;
|
|
if (_issue.format === "includes")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
|
|
return `\u65E0\u6548${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue2.divisor} \u7684\u500D\u6570`;
|
|
case "unrecognized_keys":
|
|
return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`;
|
|
case "invalid_union":
|
|
return "\u65E0\u6548\u8F93\u5165";
|
|
case "invalid_element":
|
|
return `${issue2.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`;
|
|
default:
|
|
return `\u65E0\u6548\u8F93\u5165`;
|
|
}
|
|
};
|
|
};
|
|
function zh_CN_default() {
|
|
return {
|
|
localeError: error45()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/zh-TW.js
|
|
var error46 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
|
|
file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
|
|
array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" },
|
|
set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u8F38\u5165",
|
|
email: "\u90F5\u4EF6\u5730\u5740",
|
|
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 \u65E5\u671F\u6642\u9593",
|
|
date: "ISO \u65E5\u671F",
|
|
time: "ISO \u6642\u9593",
|
|
duration: "ISO \u671F\u9593",
|
|
ipv4: "IPv4 \u4F4D\u5740",
|
|
ipv6: "IPv6 \u4F4D\u5740",
|
|
cidrv4: "IPv4 \u7BC4\u570D",
|
|
cidrv6: "IPv6 \u7BC4\u570D",
|
|
base64: "base64 \u7DE8\u78BC\u5B57\u4E32",
|
|
base64url: "base64url \u7DE8\u78BC\u5B57\u4E32",
|
|
json_string: "JSON \u5B57\u4E32",
|
|
e164: "E.164 \u6578\u503C",
|
|
jwt: "JWT",
|
|
template_literal: "\u8F38\u5165"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA instanceof ${issue2.expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
|
|
}
|
|
return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue2.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u500B\u5143\u7D20"}`;
|
|
return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue2.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing) {
|
|
return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue2.origin} \u61C9\u70BA ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue2.origin} \u61C9\u70BA ${adj}${issue2.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.prefix}" \u958B\u982D`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.suffix}" \u7D50\u5C3E`;
|
|
if (_issue.format === "includes")
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
|
|
return `\u7121\u6548\u7684 ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue2.divisor} \u7684\u500D\u6578`;
|
|
case "unrecognized_keys":
|
|
return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${issue2.keys.length > 1 ? "\u5011" : ""}\uFF1A${joinValues(issue2.keys, "\u3001")}`;
|
|
case "invalid_key":
|
|
return `${issue2.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`;
|
|
case "invalid_union":
|
|
return "\u7121\u6548\u7684\u8F38\u5165\u503C";
|
|
case "invalid_element":
|
|
return `${issue2.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`;
|
|
default:
|
|
return `\u7121\u6548\u7684\u8F38\u5165\u503C`;
|
|
}
|
|
};
|
|
};
|
|
function zh_TW_default() {
|
|
return {
|
|
localeError: error46()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/locales/yo.js
|
|
var error47 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\xE0mi", verb: "n\xED" },
|
|
file: { unit: "bytes", verb: "n\xED" },
|
|
array: { unit: "nkan", verb: "n\xED" },
|
|
set: { unit: "nkan", verb: "n\xED" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const FormatDictionary = {
|
|
regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9",
|
|
email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC",
|
|
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: "\xE0k\xF3k\xF2 ISO",
|
|
date: "\u1ECDj\u1ECD\u0301 ISO",
|
|
time: "\xE0k\xF3k\xF2 ISO",
|
|
duration: "\xE0k\xF3k\xF2 t\xF3 p\xE9 ISO",
|
|
ipv4: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv4",
|
|
ipv6: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv6",
|
|
cidrv4: "\xE0gb\xE8gb\xE8 IPv4",
|
|
cidrv6: "\xE0gb\xE8gb\xE8 IPv6",
|
|
base64: "\u1ECD\u0300r\u1ECD\u0300 t\xED a k\u1ECD\u0301 n\xED base64",
|
|
base64url: "\u1ECD\u0300r\u1ECD\u0300 base64url",
|
|
json_string: "\u1ECD\u0300r\u1ECD\u0300 JSON",
|
|
e164: "n\u1ECD\u0301mb\xE0 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9"
|
|
};
|
|
const TypeDictionary = {
|
|
nan: "NaN",
|
|
number: "n\u1ECD\u0301mb\xE0",
|
|
array: "akop\u1ECD"
|
|
};
|
|
return (issue2) => {
|
|
switch (issue2.code) {
|
|
case "invalid_type": {
|
|
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
|
|
const receivedType = parsedType(issue2.input);
|
|
const received = TypeDictionary[receivedType] ?? receivedType;
|
|
if (/^[A-Z]/.test(issue2.expected)) {
|
|
return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi instanceof ${issue2.expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
|
|
}
|
|
return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
|
|
}
|
|
case "invalid_value":
|
|
if (issue2.values.length === 1)
|
|
return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${stringifyPrimitive(issue2.values[0])}`;
|
|
return `\xC0\u1E63\xE0y\xE0n a\u1E63\xEC\u1E63e: yan \u1ECD\u0300kan l\xE1ra ${joinValues(issue2.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue2.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue2.origin ?? "iye"} ${sizing.verb} ${adj}${issue2.maximum} ${sizing.unit}`;
|
|
return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue2.maximum}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue2.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue2.origin);
|
|
if (sizing)
|
|
return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum} ${sizing.unit}`;
|
|
return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue2.minimum}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue2;
|
|
if (_issue.format === "starts_with")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\u1EB9\u0300r\u1EB9\u0300 p\u1EB9\u0300l\xFA "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 par\xED p\u1EB9\u0300l\xFA "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`;
|
|
return `A\u1E63\xEC\u1E63e: ${FormatDictionary[_issue.format] ?? issue2.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue2.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `B\u1ECDt\xECn\xEC \xE0\xECm\u1ECD\u0300: ${joinValues(issue2.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `B\u1ECDt\xECn\xEC a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue2.origin}`;
|
|
case "invalid_union":
|
|
return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
|
|
case "invalid_element":
|
|
return `Iye a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue2.origin}`;
|
|
default:
|
|
return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
|
|
}
|
|
};
|
|
};
|
|
function yo_default() {
|
|
return {
|
|
localeError: error47()
|
|
};
|
|
}
|
|
// node_modules/zod/v4/core/registries.js
|
|
var _a;
|
|
var $output = Symbol("ZodOutput");
|
|
var $input = Symbol("ZodInput");
|
|
|
|
class $ZodRegistry {
|
|
constructor() {
|
|
this._map = new WeakMap;
|
|
this._idmap = new Map;
|
|
}
|
|
add(schema, ..._meta) {
|
|
const meta = _meta[0];
|
|
this._map.set(schema, meta);
|
|
if (meta && typeof meta === "object" && "id" in meta) {
|
|
this._idmap.set(meta.id, schema);
|
|
}
|
|
return this;
|
|
}
|
|
clear() {
|
|
this._map = new WeakMap;
|
|
this._idmap = new Map;
|
|
return this;
|
|
}
|
|
remove(schema) {
|
|
const meta = this._map.get(schema);
|
|
if (meta && typeof meta === "object" && "id" in meta) {
|
|
this._idmap.delete(meta.id);
|
|
}
|
|
this._map.delete(schema);
|
|
return this;
|
|
}
|
|
get(schema) {
|
|
const p = schema._zod.parent;
|
|
if (p) {
|
|
const pm = { ...this.get(p) ?? {} };
|
|
delete pm.id;
|
|
const f = { ...pm, ...this._map.get(schema) };
|
|
return Object.keys(f).length ? f : undefined;
|
|
}
|
|
return this._map.get(schema);
|
|
}
|
|
has(schema) {
|
|
return this._map.has(schema);
|
|
}
|
|
}
|
|
function registry() {
|
|
return new $ZodRegistry;
|
|
}
|
|
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
|
|
var globalRegistry = globalThis.__zod_globalRegistry;
|
|
// node_modules/zod/v4/core/api.js
|
|
function _string(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _coercedString(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
coerce: true,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _email(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "email",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _guid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "guid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuidv4(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v4",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuidv6(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v6",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uuidv7(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v7",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _url(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _emoji2(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "emoji",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _nanoid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "nanoid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cuid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cuid2(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cuid2",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ulid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ulid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _xid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "xid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ksuid(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ksuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ipv4(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ipv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _ipv6(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "ipv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _mac(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "mac",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cidrv4(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cidrv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _cidrv6(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "cidrv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _base64(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "base64",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _base64url(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "base64url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _e164(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "e164",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _jwt(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "jwt",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
var TimePrecision = {
|
|
Any: null,
|
|
Minute: -1,
|
|
Second: 0,
|
|
Millisecond: 3,
|
|
Microsecond: 6
|
|
};
|
|
function _isoDateTime(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "datetime",
|
|
check: "string_format",
|
|
offset: false,
|
|
local: false,
|
|
precision: null,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _isoDate(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "date",
|
|
check: "string_format",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _isoTime(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "time",
|
|
check: "string_format",
|
|
precision: null,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _isoDuration(Class2, params) {
|
|
return new Class2({
|
|
type: "string",
|
|
format: "duration",
|
|
check: "string_format",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _number(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
checks: [],
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _coercedNumber(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
coerce: true,
|
|
checks: [],
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _int(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "safeint",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _float32(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "float32",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _float64(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "float64",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _int32(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "int32",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uint32(Class2, params) {
|
|
return new Class2({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "uint32",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _boolean(Class2, params) {
|
|
return new Class2({
|
|
type: "boolean",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _coercedBoolean(Class2, params) {
|
|
return new Class2({
|
|
type: "boolean",
|
|
coerce: true,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _bigint(Class2, params) {
|
|
return new Class2({
|
|
type: "bigint",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _coercedBigint(Class2, params) {
|
|
return new Class2({
|
|
type: "bigint",
|
|
coerce: true,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _int64(Class2, params) {
|
|
return new Class2({
|
|
type: "bigint",
|
|
check: "bigint_format",
|
|
abort: false,
|
|
format: "int64",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uint64(Class2, params) {
|
|
return new Class2({
|
|
type: "bigint",
|
|
check: "bigint_format",
|
|
abort: false,
|
|
format: "uint64",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _symbol(Class2, params) {
|
|
return new Class2({
|
|
type: "symbol",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _undefined2(Class2, params) {
|
|
return new Class2({
|
|
type: "undefined",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _null2(Class2, params) {
|
|
return new Class2({
|
|
type: "null",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _any(Class2) {
|
|
return new Class2({
|
|
type: "any"
|
|
});
|
|
}
|
|
function _unknown(Class2) {
|
|
return new Class2({
|
|
type: "unknown"
|
|
});
|
|
}
|
|
function _never(Class2, params) {
|
|
return new Class2({
|
|
type: "never",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _void(Class2, params) {
|
|
return new Class2({
|
|
type: "void",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _date(Class2, params) {
|
|
return new Class2({
|
|
type: "date",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _coercedDate(Class2, params) {
|
|
return new Class2({
|
|
type: "date",
|
|
coerce: true,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _nan(Class2, params) {
|
|
return new Class2({
|
|
type: "nan",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _lt(value, params) {
|
|
return new $ZodCheckLessThan({
|
|
check: "less_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: false
|
|
});
|
|
}
|
|
function _lte(value, params) {
|
|
return new $ZodCheckLessThan({
|
|
check: "less_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: true
|
|
});
|
|
}
|
|
function _gt(value, params) {
|
|
return new $ZodCheckGreaterThan({
|
|
check: "greater_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: false
|
|
});
|
|
}
|
|
function _gte(value, params) {
|
|
return new $ZodCheckGreaterThan({
|
|
check: "greater_than",
|
|
...normalizeParams(params),
|
|
value,
|
|
inclusive: true
|
|
});
|
|
}
|
|
function _positive(params) {
|
|
return _gt(0, params);
|
|
}
|
|
function _negative(params) {
|
|
return _lt(0, params);
|
|
}
|
|
function _nonpositive(params) {
|
|
return _lte(0, params);
|
|
}
|
|
function _nonnegative(params) {
|
|
return _gte(0, params);
|
|
}
|
|
function _multipleOf(value, params) {
|
|
return new $ZodCheckMultipleOf({
|
|
check: "multiple_of",
|
|
...normalizeParams(params),
|
|
value
|
|
});
|
|
}
|
|
function _maxSize(maximum, params) {
|
|
return new $ZodCheckMaxSize({
|
|
check: "max_size",
|
|
...normalizeParams(params),
|
|
maximum
|
|
});
|
|
}
|
|
function _minSize(minimum, params) {
|
|
return new $ZodCheckMinSize({
|
|
check: "min_size",
|
|
...normalizeParams(params),
|
|
minimum
|
|
});
|
|
}
|
|
function _size(size, params) {
|
|
return new $ZodCheckSizeEquals({
|
|
check: "size_equals",
|
|
...normalizeParams(params),
|
|
size
|
|
});
|
|
}
|
|
function _maxLength(maximum, params) {
|
|
const ch = new $ZodCheckMaxLength({
|
|
check: "max_length",
|
|
...normalizeParams(params),
|
|
maximum
|
|
});
|
|
return ch;
|
|
}
|
|
function _minLength(minimum, params) {
|
|
return new $ZodCheckMinLength({
|
|
check: "min_length",
|
|
...normalizeParams(params),
|
|
minimum
|
|
});
|
|
}
|
|
function _length(length, params) {
|
|
return new $ZodCheckLengthEquals({
|
|
check: "length_equals",
|
|
...normalizeParams(params),
|
|
length
|
|
});
|
|
}
|
|
function _regex(pattern, params) {
|
|
return new $ZodCheckRegex({
|
|
check: "string_format",
|
|
format: "regex",
|
|
...normalizeParams(params),
|
|
pattern
|
|
});
|
|
}
|
|
function _lowercase(params) {
|
|
return new $ZodCheckLowerCase({
|
|
check: "string_format",
|
|
format: "lowercase",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _uppercase(params) {
|
|
return new $ZodCheckUpperCase({
|
|
check: "string_format",
|
|
format: "uppercase",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _includes(includes, params) {
|
|
return new $ZodCheckIncludes({
|
|
check: "string_format",
|
|
format: "includes",
|
|
...normalizeParams(params),
|
|
includes
|
|
});
|
|
}
|
|
function _startsWith(prefix, params) {
|
|
return new $ZodCheckStartsWith({
|
|
check: "string_format",
|
|
format: "starts_with",
|
|
...normalizeParams(params),
|
|
prefix
|
|
});
|
|
}
|
|
function _endsWith(suffix, params) {
|
|
return new $ZodCheckEndsWith({
|
|
check: "string_format",
|
|
format: "ends_with",
|
|
...normalizeParams(params),
|
|
suffix
|
|
});
|
|
}
|
|
function _property(property, schema, params) {
|
|
return new $ZodCheckProperty({
|
|
check: "property",
|
|
property,
|
|
schema,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _mime(types, params) {
|
|
return new $ZodCheckMimeType({
|
|
check: "mime_type",
|
|
mime: types,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _overwrite(tx) {
|
|
return new $ZodCheckOverwrite({
|
|
check: "overwrite",
|
|
tx
|
|
});
|
|
}
|
|
function _normalize(form) {
|
|
return _overwrite((input) => input.normalize(form));
|
|
}
|
|
function _trim() {
|
|
return _overwrite((input) => input.trim());
|
|
}
|
|
function _toLowerCase() {
|
|
return _overwrite((input) => input.toLowerCase());
|
|
}
|
|
function _toUpperCase() {
|
|
return _overwrite((input) => input.toUpperCase());
|
|
}
|
|
function _slugify() {
|
|
return _overwrite((input) => slugify(input));
|
|
}
|
|
function _array(Class2, element, params) {
|
|
return new Class2({
|
|
type: "array",
|
|
element,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _union(Class2, options, params) {
|
|
return new Class2({
|
|
type: "union",
|
|
options,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _xor(Class2, options, params) {
|
|
return new Class2({
|
|
type: "union",
|
|
options,
|
|
inclusive: false,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _discriminatedUnion(Class2, discriminator, options, params) {
|
|
return new Class2({
|
|
type: "union",
|
|
options,
|
|
discriminator,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _intersection(Class2, left, right) {
|
|
return new Class2({
|
|
type: "intersection",
|
|
left,
|
|
right
|
|
});
|
|
}
|
|
function _tuple(Class2, items, _paramsOrRest, _params) {
|
|
const hasRest = _paramsOrRest instanceof $ZodType;
|
|
const params = hasRest ? _params : _paramsOrRest;
|
|
const rest = hasRest ? _paramsOrRest : null;
|
|
return new Class2({
|
|
type: "tuple",
|
|
items,
|
|
rest,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _record(Class2, keyType, valueType, params) {
|
|
return new Class2({
|
|
type: "record",
|
|
keyType,
|
|
valueType,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _map(Class2, keyType, valueType, params) {
|
|
return new Class2({
|
|
type: "map",
|
|
keyType,
|
|
valueType,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _set(Class2, valueType, params) {
|
|
return new Class2({
|
|
type: "set",
|
|
valueType,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _enum(Class2, values, params) {
|
|
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
|
|
return new Class2({
|
|
type: "enum",
|
|
entries,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _nativeEnum(Class2, entries, params) {
|
|
return new Class2({
|
|
type: "enum",
|
|
entries,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _literal(Class2, value, params) {
|
|
return new Class2({
|
|
type: "literal",
|
|
values: Array.isArray(value) ? value : [value],
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _file(Class2, params) {
|
|
return new Class2({
|
|
type: "file",
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _transform(Class2, fn) {
|
|
return new Class2({
|
|
type: "transform",
|
|
transform: fn
|
|
});
|
|
}
|
|
function _optional(Class2, innerType) {
|
|
return new Class2({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
function _nullable(Class2, innerType) {
|
|
return new Class2({
|
|
type: "nullable",
|
|
innerType
|
|
});
|
|
}
|
|
function _default(Class2, innerType, defaultValue) {
|
|
return new Class2({
|
|
type: "default",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
function _nonoptional(Class2, innerType, params) {
|
|
return new Class2({
|
|
type: "nonoptional",
|
|
innerType,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _success(Class2, innerType) {
|
|
return new Class2({
|
|
type: "success",
|
|
innerType
|
|
});
|
|
}
|
|
function _catch(Class2, innerType, catchValue) {
|
|
return new Class2({
|
|
type: "catch",
|
|
innerType,
|
|
catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
|
|
});
|
|
}
|
|
function _pipe(Class2, in_, out) {
|
|
return new Class2({
|
|
type: "pipe",
|
|
in: in_,
|
|
out
|
|
});
|
|
}
|
|
function _readonly(Class2, innerType) {
|
|
return new Class2({
|
|
type: "readonly",
|
|
innerType
|
|
});
|
|
}
|
|
function _templateLiteral(Class2, parts, params) {
|
|
return new Class2({
|
|
type: "template_literal",
|
|
parts,
|
|
...normalizeParams(params)
|
|
});
|
|
}
|
|
function _lazy(Class2, getter) {
|
|
return new Class2({
|
|
type: "lazy",
|
|
getter
|
|
});
|
|
}
|
|
function _promise(Class2, innerType) {
|
|
return new Class2({
|
|
type: "promise",
|
|
innerType
|
|
});
|
|
}
|
|
function _custom(Class2, fn, _params) {
|
|
const norm = normalizeParams(_params);
|
|
norm.abort ?? (norm.abort = true);
|
|
const schema = new Class2({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn,
|
|
...norm
|
|
});
|
|
return schema;
|
|
}
|
|
function _refine(Class2, fn, _params) {
|
|
const schema = new Class2({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn,
|
|
...normalizeParams(_params)
|
|
});
|
|
return schema;
|
|
}
|
|
function _superRefine(fn) {
|
|
const ch = _check((payload) => {
|
|
payload.addIssue = (issue2) => {
|
|
if (typeof issue2 === "string") {
|
|
payload.issues.push(issue(issue2, payload.value, ch._zod.def));
|
|
} else {
|
|
const _issue = issue2;
|
|
if (_issue.fatal)
|
|
_issue.continue = false;
|
|
_issue.code ?? (_issue.code = "custom");
|
|
_issue.input ?? (_issue.input = payload.value);
|
|
_issue.inst ?? (_issue.inst = ch);
|
|
_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
|
|
payload.issues.push(issue(_issue));
|
|
}
|
|
};
|
|
return fn(payload.value, payload);
|
|
});
|
|
return ch;
|
|
}
|
|
function _check(fn, params) {
|
|
const ch = new $ZodCheck({
|
|
check: "custom",
|
|
...normalizeParams(params)
|
|
});
|
|
ch._zod.check = fn;
|
|
return ch;
|
|
}
|
|
function describe(description) {
|
|
const ch = new $ZodCheck({ check: "describe" });
|
|
ch._zod.onattach = [
|
|
(inst) => {
|
|
const existing = globalRegistry.get(inst) ?? {};
|
|
globalRegistry.add(inst, { ...existing, description });
|
|
}
|
|
];
|
|
ch._zod.check = () => {};
|
|
return ch;
|
|
}
|
|
function meta(metadata) {
|
|
const ch = new $ZodCheck({ check: "meta" });
|
|
ch._zod.onattach = [
|
|
(inst) => {
|
|
const existing = globalRegistry.get(inst) ?? {};
|
|
globalRegistry.add(inst, { ...existing, ...metadata });
|
|
}
|
|
];
|
|
ch._zod.check = () => {};
|
|
return ch;
|
|
}
|
|
function _stringbool(Classes, _params) {
|
|
const params = normalizeParams(_params);
|
|
let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
|
|
let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
|
|
if (params.case !== "sensitive") {
|
|
truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
|
|
falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
|
|
}
|
|
const truthySet = new Set(truthyArray);
|
|
const falsySet = new Set(falsyArray);
|
|
const _Codec = Classes.Codec ?? $ZodCodec;
|
|
const _Boolean = Classes.Boolean ?? $ZodBoolean;
|
|
const _String = Classes.String ?? $ZodString;
|
|
const stringSchema = new _String({ type: "string", error: params.error });
|
|
const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
|
|
const codec = new _Codec({
|
|
type: "pipe",
|
|
in: stringSchema,
|
|
out: booleanSchema,
|
|
transform: (input, payload) => {
|
|
let data = input;
|
|
if (params.case !== "sensitive")
|
|
data = data.toLowerCase();
|
|
if (truthySet.has(data)) {
|
|
return true;
|
|
} else if (falsySet.has(data)) {
|
|
return false;
|
|
} else {
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
expected: "stringbool",
|
|
values: [...truthySet, ...falsySet],
|
|
input: payload.value,
|
|
inst: codec,
|
|
continue: false
|
|
});
|
|
return {};
|
|
}
|
|
},
|
|
reverseTransform: (input, _payload) => {
|
|
if (input === true) {
|
|
return truthyArray[0] || "true";
|
|
} else {
|
|
return falsyArray[0] || "false";
|
|
}
|
|
},
|
|
error: params.error
|
|
});
|
|
return codec;
|
|
}
|
|
function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
|
|
const params = normalizeParams(_params);
|
|
const def = {
|
|
...normalizeParams(_params),
|
|
check: "string_format",
|
|
type: "string",
|
|
format,
|
|
fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
|
|
...params
|
|
};
|
|
if (fnOrRegex instanceof RegExp) {
|
|
def.pattern = fnOrRegex;
|
|
}
|
|
const inst = new Class2(def);
|
|
return inst;
|
|
}
|
|
// node_modules/zod/v4/core/to-json-schema.js
|
|
function initializeContext(params) {
|
|
let target = params?.target ?? "draft-2020-12";
|
|
if (target === "draft-4")
|
|
target = "draft-04";
|
|
if (target === "draft-7")
|
|
target = "draft-07";
|
|
return {
|
|
processors: params.processors ?? {},
|
|
metadataRegistry: params?.metadata ?? globalRegistry,
|
|
target,
|
|
unrepresentable: params?.unrepresentable ?? "throw",
|
|
override: params?.override ?? (() => {}),
|
|
io: params?.io ?? "output",
|
|
counter: 0,
|
|
seen: new Map,
|
|
cycles: params?.cycles ?? "ref",
|
|
reused: params?.reused ?? "inline",
|
|
external: params?.external ?? undefined
|
|
};
|
|
}
|
|
function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
|
|
var _a2;
|
|
const def = schema._zod.def;
|
|
const seen = ctx.seen.get(schema);
|
|
if (seen) {
|
|
seen.count++;
|
|
const isCycle = _params.schemaPath.includes(schema);
|
|
if (isCycle) {
|
|
seen.cycle = _params.path;
|
|
}
|
|
return seen.schema;
|
|
}
|
|
const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
|
|
ctx.seen.set(schema, result);
|
|
const overrideSchema = schema._zod.toJSONSchema?.();
|
|
if (overrideSchema) {
|
|
result.schema = overrideSchema;
|
|
} else {
|
|
const params = {
|
|
..._params,
|
|
schemaPath: [..._params.schemaPath, schema],
|
|
path: _params.path
|
|
};
|
|
if (schema._zod.processJSONSchema) {
|
|
schema._zod.processJSONSchema(ctx, result.schema, params);
|
|
} else {
|
|
const _json = result.schema;
|
|
const processor = ctx.processors[def.type];
|
|
if (!processor) {
|
|
throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
|
|
}
|
|
processor(schema, ctx, _json, params);
|
|
}
|
|
const parent = schema._zod.parent;
|
|
if (parent) {
|
|
if (!result.ref)
|
|
result.ref = parent;
|
|
process2(parent, ctx, params);
|
|
ctx.seen.get(parent).isParent = true;
|
|
}
|
|
}
|
|
const meta2 = ctx.metadataRegistry.get(schema);
|
|
if (meta2)
|
|
Object.assign(result.schema, meta2);
|
|
if (ctx.io === "input" && isTransforming(schema)) {
|
|
delete result.schema.examples;
|
|
delete result.schema.default;
|
|
}
|
|
if (ctx.io === "input" && result.schema._prefault)
|
|
(_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
|
|
delete result.schema._prefault;
|
|
const _result = ctx.seen.get(schema);
|
|
return _result.schema;
|
|
}
|
|
function extractDefs(ctx, schema) {
|
|
const root = ctx.seen.get(schema);
|
|
if (!root)
|
|
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
|
const idToSchema = new Map;
|
|
for (const entry of ctx.seen.entries()) {
|
|
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
|
if (id) {
|
|
const existing = idToSchema.get(id);
|
|
if (existing && existing !== entry[0]) {
|
|
throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
|
|
}
|
|
idToSchema.set(id, entry[0]);
|
|
}
|
|
}
|
|
const makeURI = (entry) => {
|
|
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
|
|
if (ctx.external) {
|
|
const externalId = ctx.external.registry.get(entry[0])?.id;
|
|
const uriGenerator = ctx.external.uri ?? ((id2) => id2);
|
|
if (externalId) {
|
|
return { ref: uriGenerator(externalId) };
|
|
}
|
|
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
|
|
entry[1].defId = id;
|
|
return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
|
|
}
|
|
if (entry[1] === root) {
|
|
return { ref: "#" };
|
|
}
|
|
const uriPrefix = `#`;
|
|
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
|
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
|
|
return { defId, ref: defUriPrefix + defId };
|
|
};
|
|
const extractToDef = (entry) => {
|
|
if (entry[1].schema.$ref) {
|
|
return;
|
|
}
|
|
const seen = entry[1];
|
|
const { ref, defId } = makeURI(entry);
|
|
seen.def = { ...seen.schema };
|
|
if (defId)
|
|
seen.defId = defId;
|
|
const schema2 = seen.schema;
|
|
for (const key in schema2) {
|
|
delete schema2[key];
|
|
}
|
|
schema2.$ref = ref;
|
|
};
|
|
if (ctx.cycles === "throw") {
|
|
for (const entry of ctx.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (seen.cycle) {
|
|
throw new Error("Cycle detected: " + `#/${seen.cycle?.join("/")}/<root>` + '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
|
}
|
|
}
|
|
}
|
|
for (const entry of ctx.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (schema === entry[0]) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (ctx.external) {
|
|
const ext = ctx.external.registry.get(entry[0])?.id;
|
|
if (schema !== entry[0] && ext) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
const id = ctx.metadataRegistry.get(entry[0])?.id;
|
|
if (id) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (seen.cycle) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (seen.count > 1) {
|
|
if (ctx.reused === "ref") {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function finalize(ctx, schema) {
|
|
const root = ctx.seen.get(schema);
|
|
if (!root)
|
|
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
|
const flattenRef = (zodSchema) => {
|
|
const seen = ctx.seen.get(zodSchema);
|
|
if (seen.ref === null)
|
|
return;
|
|
const schema2 = seen.def ?? seen.schema;
|
|
const _cached = { ...schema2 };
|
|
const ref = seen.ref;
|
|
seen.ref = null;
|
|
if (ref) {
|
|
flattenRef(ref);
|
|
const refSeen = ctx.seen.get(ref);
|
|
const refSchema = refSeen.schema;
|
|
if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
|
|
schema2.allOf = schema2.allOf ?? [];
|
|
schema2.allOf.push(refSchema);
|
|
} else {
|
|
Object.assign(schema2, refSchema);
|
|
}
|
|
Object.assign(schema2, _cached);
|
|
const isParentRef = zodSchema._zod.parent === ref;
|
|
if (isParentRef) {
|
|
for (const key in schema2) {
|
|
if (key === "$ref" || key === "allOf")
|
|
continue;
|
|
if (!(key in _cached)) {
|
|
delete schema2[key];
|
|
}
|
|
}
|
|
}
|
|
if (refSchema.$ref && refSeen.def) {
|
|
for (const key in schema2) {
|
|
if (key === "$ref" || key === "allOf")
|
|
continue;
|
|
if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
|
|
delete schema2[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const parent = zodSchema._zod.parent;
|
|
if (parent && parent !== ref) {
|
|
flattenRef(parent);
|
|
const parentSeen = ctx.seen.get(parent);
|
|
if (parentSeen?.schema.$ref) {
|
|
schema2.$ref = parentSeen.schema.$ref;
|
|
if (parentSeen.def) {
|
|
for (const key in schema2) {
|
|
if (key === "$ref" || key === "allOf")
|
|
continue;
|
|
if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
|
|
delete schema2[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ctx.override({
|
|
zodSchema,
|
|
jsonSchema: schema2,
|
|
path: seen.path ?? []
|
|
});
|
|
};
|
|
for (const entry of [...ctx.seen.entries()].reverse()) {
|
|
flattenRef(entry[0]);
|
|
}
|
|
const result = {};
|
|
if (ctx.target === "draft-2020-12") {
|
|
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
|
} else if (ctx.target === "draft-07") {
|
|
result.$schema = "http://json-schema.org/draft-07/schema#";
|
|
} else if (ctx.target === "draft-04") {
|
|
result.$schema = "http://json-schema.org/draft-04/schema#";
|
|
} else if (ctx.target === "openapi-3.0") {} else {}
|
|
if (ctx.external?.uri) {
|
|
const id = ctx.external.registry.get(schema)?.id;
|
|
if (!id)
|
|
throw new Error("Schema is missing an `id` property");
|
|
result.$id = ctx.external.uri(id);
|
|
}
|
|
Object.assign(result, root.def ?? root.schema);
|
|
const defs = ctx.external?.defs ?? {};
|
|
for (const entry of ctx.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (seen.def && seen.defId) {
|
|
defs[seen.defId] = seen.def;
|
|
}
|
|
}
|
|
if (ctx.external) {} else {
|
|
if (Object.keys(defs).length > 0) {
|
|
if (ctx.target === "draft-2020-12") {
|
|
result.$defs = defs;
|
|
} else {
|
|
result.definitions = defs;
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
const finalized = JSON.parse(JSON.stringify(result));
|
|
Object.defineProperty(finalized, "~standard", {
|
|
value: {
|
|
...schema["~standard"],
|
|
jsonSchema: {
|
|
input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
|
|
output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
|
|
}
|
|
},
|
|
enumerable: false,
|
|
writable: false
|
|
});
|
|
return finalized;
|
|
} catch (_err) {
|
|
throw new Error("Error converting schema to JSON.");
|
|
}
|
|
}
|
|
function isTransforming(_schema, _ctx) {
|
|
const ctx = _ctx ?? { seen: new Set };
|
|
if (ctx.seen.has(_schema))
|
|
return false;
|
|
ctx.seen.add(_schema);
|
|
const def = _schema._zod.def;
|
|
if (def.type === "transform")
|
|
return true;
|
|
if (def.type === "array")
|
|
return isTransforming(def.element, ctx);
|
|
if (def.type === "set")
|
|
return isTransforming(def.valueType, ctx);
|
|
if (def.type === "lazy")
|
|
return isTransforming(def.getter(), ctx);
|
|
if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
|
|
return isTransforming(def.innerType, ctx);
|
|
}
|
|
if (def.type === "intersection") {
|
|
return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
|
|
}
|
|
if (def.type === "record" || def.type === "map") {
|
|
return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
|
|
}
|
|
if (def.type === "pipe") {
|
|
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
|
|
}
|
|
if (def.type === "object") {
|
|
for (const key in def.shape) {
|
|
if (isTransforming(def.shape[key], ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (def.type === "union") {
|
|
for (const option of def.options) {
|
|
if (isTransforming(option, ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (def.type === "tuple") {
|
|
for (const item of def.items) {
|
|
if (isTransforming(item, ctx))
|
|
return true;
|
|
}
|
|
if (def.rest && isTransforming(def.rest, ctx))
|
|
return true;
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
|
|
const ctx = initializeContext({ ...params, processors });
|
|
process2(schema, ctx);
|
|
extractDefs(ctx, schema);
|
|
return finalize(ctx, schema);
|
|
};
|
|
var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
|
|
const { libraryOptions, target } = params ?? {};
|
|
const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
|
|
process2(schema, ctx);
|
|
extractDefs(ctx, schema);
|
|
return finalize(ctx, schema);
|
|
};
|
|
// node_modules/zod/v4/core/json-schema-processors.js
|
|
var formatMap = {
|
|
guid: "uuid",
|
|
url: "uri",
|
|
datetime: "date-time",
|
|
json_string: "json-string",
|
|
regex: ""
|
|
};
|
|
var stringProcessor = (schema, ctx, _json, _params) => {
|
|
const json = _json;
|
|
json.type = "string";
|
|
const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json.minLength = minimum;
|
|
if (typeof maximum === "number")
|
|
json.maxLength = maximum;
|
|
if (format) {
|
|
json.format = formatMap[format] ?? format;
|
|
if (json.format === "")
|
|
delete json.format;
|
|
if (format === "time") {
|
|
delete json.format;
|
|
}
|
|
}
|
|
if (contentEncoding)
|
|
json.contentEncoding = contentEncoding;
|
|
if (patterns && patterns.size > 0) {
|
|
const regexes = [...patterns];
|
|
if (regexes.length === 1)
|
|
json.pattern = regexes[0].source;
|
|
else if (regexes.length > 1) {
|
|
json.allOf = [
|
|
...regexes.map((regex) => ({
|
|
...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
|
|
pattern: regex.source
|
|
}))
|
|
];
|
|
}
|
|
}
|
|
};
|
|
var numberProcessor = (schema, ctx, _json, _params) => {
|
|
const json = _json;
|
|
const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
|
|
if (typeof format === "string" && format.includes("int"))
|
|
json.type = "integer";
|
|
else
|
|
json.type = "number";
|
|
if (typeof exclusiveMinimum === "number") {
|
|
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
|
json.minimum = exclusiveMinimum;
|
|
json.exclusiveMinimum = true;
|
|
} else {
|
|
json.exclusiveMinimum = exclusiveMinimum;
|
|
}
|
|
}
|
|
if (typeof minimum === "number") {
|
|
json.minimum = minimum;
|
|
if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
|
|
if (exclusiveMinimum >= minimum)
|
|
delete json.minimum;
|
|
else
|
|
delete json.exclusiveMinimum;
|
|
}
|
|
}
|
|
if (typeof exclusiveMaximum === "number") {
|
|
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
|
json.maximum = exclusiveMaximum;
|
|
json.exclusiveMaximum = true;
|
|
} else {
|
|
json.exclusiveMaximum = exclusiveMaximum;
|
|
}
|
|
}
|
|
if (typeof maximum === "number") {
|
|
json.maximum = maximum;
|
|
if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
|
|
if (exclusiveMaximum <= maximum)
|
|
delete json.maximum;
|
|
else
|
|
delete json.exclusiveMaximum;
|
|
}
|
|
}
|
|
if (typeof multipleOf === "number")
|
|
json.multipleOf = multipleOf;
|
|
};
|
|
var booleanProcessor = (_schema, _ctx, json, _params) => {
|
|
json.type = "boolean";
|
|
};
|
|
var bigintProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("BigInt cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var symbolProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Symbols cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var nullProcessor = (_schema, ctx, json, _params) => {
|
|
if (ctx.target === "openapi-3.0") {
|
|
json.type = "string";
|
|
json.nullable = true;
|
|
json.enum = [null];
|
|
} else {
|
|
json.type = "null";
|
|
}
|
|
};
|
|
var undefinedProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Undefined cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var voidProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Void cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var neverProcessor = (_schema, _ctx, json, _params) => {
|
|
json.not = {};
|
|
};
|
|
var anyProcessor = (_schema, _ctx, _json, _params) => {};
|
|
var unknownProcessor = (_schema, _ctx, _json, _params) => {};
|
|
var dateProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Date cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var enumProcessor = (schema, _ctx, json, _params) => {
|
|
const def = schema._zod.def;
|
|
const values = getEnumValues(def.entries);
|
|
if (values.every((v) => typeof v === "number"))
|
|
json.type = "number";
|
|
if (values.every((v) => typeof v === "string"))
|
|
json.type = "string";
|
|
json.enum = values;
|
|
};
|
|
var literalProcessor = (schema, ctx, json, _params) => {
|
|
const def = schema._zod.def;
|
|
const vals = [];
|
|
for (const val of def.values) {
|
|
if (val === undefined) {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Literal `undefined` cannot be represented in JSON Schema");
|
|
} else {}
|
|
} else if (typeof val === "bigint") {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("BigInt literals cannot be represented in JSON Schema");
|
|
} else {
|
|
vals.push(Number(val));
|
|
}
|
|
} else {
|
|
vals.push(val);
|
|
}
|
|
}
|
|
if (vals.length === 0) {} else if (vals.length === 1) {
|
|
const val = vals[0];
|
|
json.type = val === null ? "null" : typeof val;
|
|
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
|
|
json.enum = [val];
|
|
} else {
|
|
json.const = val;
|
|
}
|
|
} else {
|
|
if (vals.every((v) => typeof v === "number"))
|
|
json.type = "number";
|
|
if (vals.every((v) => typeof v === "string"))
|
|
json.type = "string";
|
|
if (vals.every((v) => typeof v === "boolean"))
|
|
json.type = "boolean";
|
|
if (vals.every((v) => v === null))
|
|
json.type = "null";
|
|
json.enum = vals;
|
|
}
|
|
};
|
|
var nanProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("NaN cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var templateLiteralProcessor = (schema, _ctx, json, _params) => {
|
|
const _json = json;
|
|
const pattern = schema._zod.pattern;
|
|
if (!pattern)
|
|
throw new Error("Pattern not found in template literal");
|
|
_json.type = "string";
|
|
_json.pattern = pattern.source;
|
|
};
|
|
var fileProcessor = (schema, _ctx, json, _params) => {
|
|
const _json = json;
|
|
const file = {
|
|
type: "string",
|
|
format: "binary",
|
|
contentEncoding: "binary"
|
|
};
|
|
const { minimum, maximum, mime } = schema._zod.bag;
|
|
if (minimum !== undefined)
|
|
file.minLength = minimum;
|
|
if (maximum !== undefined)
|
|
file.maxLength = maximum;
|
|
if (mime) {
|
|
if (mime.length === 1) {
|
|
file.contentMediaType = mime[0];
|
|
Object.assign(_json, file);
|
|
} else {
|
|
Object.assign(_json, file);
|
|
_json.anyOf = mime.map((m) => ({ contentMediaType: m }));
|
|
}
|
|
} else {
|
|
Object.assign(_json, file);
|
|
}
|
|
};
|
|
var successProcessor = (_schema, _ctx, json, _params) => {
|
|
json.type = "boolean";
|
|
};
|
|
var customProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Custom types cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var functionProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Function types cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var transformProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Transforms cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var mapProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Map cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var setProcessor = (_schema, ctx, _json, _params) => {
|
|
if (ctx.unrepresentable === "throw") {
|
|
throw new Error("Set cannot be represented in JSON Schema");
|
|
}
|
|
};
|
|
var arrayProcessor = (schema, ctx, _json, params) => {
|
|
const json = _json;
|
|
const def = schema._zod.def;
|
|
const { minimum, maximum } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json.minItems = minimum;
|
|
if (typeof maximum === "number")
|
|
json.maxItems = maximum;
|
|
json.type = "array";
|
|
json.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
|
|
};
|
|
var objectProcessor = (schema, ctx, _json, params) => {
|
|
const json = _json;
|
|
const def = schema._zod.def;
|
|
json.type = "object";
|
|
json.properties = {};
|
|
const shape = def.shape;
|
|
for (const key in shape) {
|
|
json.properties[key] = process2(shape[key], ctx, {
|
|
...params,
|
|
path: [...params.path, "properties", key]
|
|
});
|
|
}
|
|
const allKeys = new Set(Object.keys(shape));
|
|
const requiredKeys = new Set([...allKeys].filter((key) => {
|
|
const v = def.shape[key]._zod;
|
|
if (ctx.io === "input") {
|
|
return v.optin === undefined;
|
|
} else {
|
|
return v.optout === undefined;
|
|
}
|
|
}));
|
|
if (requiredKeys.size > 0) {
|
|
json.required = Array.from(requiredKeys);
|
|
}
|
|
if (def.catchall?._zod.def.type === "never") {
|
|
json.additionalProperties = false;
|
|
} else if (!def.catchall) {
|
|
if (ctx.io === "output")
|
|
json.additionalProperties = false;
|
|
} else if (def.catchall) {
|
|
json.additionalProperties = process2(def.catchall, ctx, {
|
|
...params,
|
|
path: [...params.path, "additionalProperties"]
|
|
});
|
|
}
|
|
};
|
|
var unionProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
const isExclusive = def.inclusive === false;
|
|
const options = def.options.map((x, i) => process2(x, ctx, {
|
|
...params,
|
|
path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
|
|
}));
|
|
if (isExclusive) {
|
|
json.oneOf = options;
|
|
} else {
|
|
json.anyOf = options;
|
|
}
|
|
};
|
|
var intersectionProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
const a = process2(def.left, ctx, {
|
|
...params,
|
|
path: [...params.path, "allOf", 0]
|
|
});
|
|
const b = process2(def.right, ctx, {
|
|
...params,
|
|
path: [...params.path, "allOf", 1]
|
|
});
|
|
const isSimpleIntersection = (val) => ("allOf" in val) && Object.keys(val).length === 1;
|
|
const allOf = [
|
|
...isSimpleIntersection(a) ? a.allOf : [a],
|
|
...isSimpleIntersection(b) ? b.allOf : [b]
|
|
];
|
|
json.allOf = allOf;
|
|
};
|
|
var tupleProcessor = (schema, ctx, _json, params) => {
|
|
const json = _json;
|
|
const def = schema._zod.def;
|
|
json.type = "array";
|
|
const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
|
|
const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
|
|
const prefixItems = def.items.map((x, i) => process2(x, ctx, {
|
|
...params,
|
|
path: [...params.path, prefixPath, i]
|
|
}));
|
|
const rest = def.rest ? process2(def.rest, ctx, {
|
|
...params,
|
|
path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
|
|
}) : null;
|
|
if (ctx.target === "draft-2020-12") {
|
|
json.prefixItems = prefixItems;
|
|
if (rest) {
|
|
json.items = rest;
|
|
}
|
|
} else if (ctx.target === "openapi-3.0") {
|
|
json.items = {
|
|
anyOf: prefixItems
|
|
};
|
|
if (rest) {
|
|
json.items.anyOf.push(rest);
|
|
}
|
|
json.minItems = prefixItems.length;
|
|
if (!rest) {
|
|
json.maxItems = prefixItems.length;
|
|
}
|
|
} else {
|
|
json.items = prefixItems;
|
|
if (rest) {
|
|
json.additionalItems = rest;
|
|
}
|
|
}
|
|
const { minimum, maximum } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json.minItems = minimum;
|
|
if (typeof maximum === "number")
|
|
json.maxItems = maximum;
|
|
};
|
|
var recordProcessor = (schema, ctx, _json, params) => {
|
|
const json = _json;
|
|
const def = schema._zod.def;
|
|
json.type = "object";
|
|
const keyType = def.keyType;
|
|
const keyBag = keyType._zod.bag;
|
|
const patterns = keyBag?.patterns;
|
|
if (def.mode === "loose" && patterns && patterns.size > 0) {
|
|
const valueSchema = process2(def.valueType, ctx, {
|
|
...params,
|
|
path: [...params.path, "patternProperties", "*"]
|
|
});
|
|
json.patternProperties = {};
|
|
for (const pattern of patterns) {
|
|
json.patternProperties[pattern.source] = valueSchema;
|
|
}
|
|
} else {
|
|
if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
|
|
json.propertyNames = process2(def.keyType, ctx, {
|
|
...params,
|
|
path: [...params.path, "propertyNames"]
|
|
});
|
|
}
|
|
json.additionalProperties = process2(def.valueType, ctx, {
|
|
...params,
|
|
path: [...params.path, "additionalProperties"]
|
|
});
|
|
}
|
|
const keyValues = keyType._zod.values;
|
|
if (keyValues) {
|
|
const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
|
|
if (validKeyValues.length > 0) {
|
|
json.required = validKeyValues;
|
|
}
|
|
}
|
|
};
|
|
var nullableProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
const inner = process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
if (ctx.target === "openapi-3.0") {
|
|
seen.ref = def.innerType;
|
|
json.nullable = true;
|
|
} else {
|
|
json.anyOf = [inner, { type: "null" }];
|
|
}
|
|
};
|
|
var nonoptionalProcessor = (schema, ctx, _json, params) => {
|
|
const def = schema._zod.def;
|
|
process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
};
|
|
var defaultProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
json.default = JSON.parse(JSON.stringify(def.defaultValue));
|
|
};
|
|
var prefaultProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
if (ctx.io === "input")
|
|
json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
|
|
};
|
|
var catchProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
let catchValue;
|
|
try {
|
|
catchValue = def.catchValue(undefined);
|
|
} catch {
|
|
throw new Error("Dynamic catch values are not supported in JSON Schema");
|
|
}
|
|
json.default = catchValue;
|
|
};
|
|
var pipeProcessor = (schema, ctx, _json, params) => {
|
|
const def = schema._zod.def;
|
|
const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
|
|
process2(innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = innerType;
|
|
};
|
|
var readonlyProcessor = (schema, ctx, json, params) => {
|
|
const def = schema._zod.def;
|
|
process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
json.readOnly = true;
|
|
};
|
|
var promiseProcessor = (schema, ctx, _json, params) => {
|
|
const def = schema._zod.def;
|
|
process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
};
|
|
var optionalProcessor = (schema, ctx, _json, params) => {
|
|
const def = schema._zod.def;
|
|
process2(def.innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = def.innerType;
|
|
};
|
|
var lazyProcessor = (schema, ctx, _json, params) => {
|
|
const innerType = schema._zod.innerType;
|
|
process2(innerType, ctx, params);
|
|
const seen = ctx.seen.get(schema);
|
|
seen.ref = innerType;
|
|
};
|
|
var allProcessors = {
|
|
string: stringProcessor,
|
|
number: numberProcessor,
|
|
boolean: booleanProcessor,
|
|
bigint: bigintProcessor,
|
|
symbol: symbolProcessor,
|
|
null: nullProcessor,
|
|
undefined: undefinedProcessor,
|
|
void: voidProcessor,
|
|
never: neverProcessor,
|
|
any: anyProcessor,
|
|
unknown: unknownProcessor,
|
|
date: dateProcessor,
|
|
enum: enumProcessor,
|
|
literal: literalProcessor,
|
|
nan: nanProcessor,
|
|
template_literal: templateLiteralProcessor,
|
|
file: fileProcessor,
|
|
success: successProcessor,
|
|
custom: customProcessor,
|
|
function: functionProcessor,
|
|
transform: transformProcessor,
|
|
map: mapProcessor,
|
|
set: setProcessor,
|
|
array: arrayProcessor,
|
|
object: objectProcessor,
|
|
union: unionProcessor,
|
|
intersection: intersectionProcessor,
|
|
tuple: tupleProcessor,
|
|
record: recordProcessor,
|
|
nullable: nullableProcessor,
|
|
nonoptional: nonoptionalProcessor,
|
|
default: defaultProcessor,
|
|
prefault: prefaultProcessor,
|
|
catch: catchProcessor,
|
|
pipe: pipeProcessor,
|
|
readonly: readonlyProcessor,
|
|
promise: promiseProcessor,
|
|
optional: optionalProcessor,
|
|
lazy: lazyProcessor
|
|
};
|
|
function toJSONSchema(input, params) {
|
|
if ("_idmap" in input) {
|
|
const registry2 = input;
|
|
const ctx2 = initializeContext({ ...params, processors: allProcessors });
|
|
const defs = {};
|
|
for (const entry of registry2._idmap.entries()) {
|
|
const [_, schema] = entry;
|
|
process2(schema, ctx2);
|
|
}
|
|
const schemas = {};
|
|
const external = {
|
|
registry: registry2,
|
|
uri: params?.uri,
|
|
defs
|
|
};
|
|
ctx2.external = external;
|
|
for (const entry of registry2._idmap.entries()) {
|
|
const [key, schema] = entry;
|
|
extractDefs(ctx2, schema);
|
|
schemas[key] = finalize(ctx2, schema);
|
|
}
|
|
if (Object.keys(defs).length > 0) {
|
|
const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
|
|
schemas.__shared = {
|
|
[defsSegment]: defs
|
|
};
|
|
}
|
|
return { schemas };
|
|
}
|
|
const ctx = initializeContext({ ...params, processors: allProcessors });
|
|
process2(input, ctx);
|
|
extractDefs(ctx, input);
|
|
return finalize(ctx, input);
|
|
}
|
|
// node_modules/zod/v4/core/json-schema-generator.js
|
|
class JSONSchemaGenerator {
|
|
get metadataRegistry() {
|
|
return this.ctx.metadataRegistry;
|
|
}
|
|
get target() {
|
|
return this.ctx.target;
|
|
}
|
|
get unrepresentable() {
|
|
return this.ctx.unrepresentable;
|
|
}
|
|
get override() {
|
|
return this.ctx.override;
|
|
}
|
|
get io() {
|
|
return this.ctx.io;
|
|
}
|
|
get counter() {
|
|
return this.ctx.counter;
|
|
}
|
|
set counter(value) {
|
|
this.ctx.counter = value;
|
|
}
|
|
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(schema, _params = { path: [], schemaPath: [] }) {
|
|
return process2(schema, this.ctx, _params);
|
|
}
|
|
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 result = finalize(this.ctx, schema);
|
|
const { "~standard": _, ...plainResult } = result;
|
|
return plainResult;
|
|
}
|
|
}
|
|
// node_modules/zod/v4/core/json-schema.js
|
|
var exports_json_schema = {};
|
|
// node_modules/zod/v4/classic/schemas.js
|
|
var exports_schemas2 = {};
|
|
__export(exports_schemas2, {
|
|
xor: () => xor,
|
|
xid: () => xid2,
|
|
void: () => _void2,
|
|
uuidv7: () => uuidv7,
|
|
uuidv6: () => uuidv6,
|
|
uuidv4: () => uuidv4,
|
|
uuid: () => uuid2,
|
|
url: () => url,
|
|
unknown: () => unknown,
|
|
union: () => union,
|
|
undefined: () => _undefined3,
|
|
ulid: () => ulid2,
|
|
uint64: () => uint64,
|
|
uint32: () => uint32,
|
|
tuple: () => tuple,
|
|
transform: () => transform,
|
|
templateLiteral: () => templateLiteral,
|
|
symbol: () => symbol,
|
|
superRefine: () => superRefine,
|
|
success: () => success,
|
|
stringbool: () => stringbool,
|
|
stringFormat: () => stringFormat,
|
|
string: () => string2,
|
|
strictObject: () => strictObject,
|
|
set: () => set,
|
|
refine: () => refine,
|
|
record: () => record,
|
|
readonly: () => readonly,
|
|
promise: () => promise,
|
|
preprocess: () => preprocess,
|
|
prefault: () => prefault,
|
|
pipe: () => pipe,
|
|
partialRecord: () => partialRecord,
|
|
optional: () => optional,
|
|
object: () => object,
|
|
number: () => number2,
|
|
nullish: () => nullish2,
|
|
nullable: () => nullable,
|
|
null: () => _null3,
|
|
nonoptional: () => nonoptional,
|
|
never: () => never,
|
|
nativeEnum: () => nativeEnum,
|
|
nanoid: () => nanoid2,
|
|
nan: () => nan,
|
|
meta: () => meta2,
|
|
map: () => map,
|
|
mac: () => mac2,
|
|
looseRecord: () => looseRecord,
|
|
looseObject: () => looseObject,
|
|
literal: () => literal,
|
|
lazy: () => lazy,
|
|
ksuid: () => ksuid2,
|
|
keyof: () => keyof,
|
|
jwt: () => jwt,
|
|
json: () => json,
|
|
ipv6: () => ipv62,
|
|
ipv4: () => ipv42,
|
|
intersection: () => intersection,
|
|
int64: () => int64,
|
|
int32: () => int32,
|
|
int: () => int,
|
|
instanceof: () => _instanceof,
|
|
httpUrl: () => httpUrl,
|
|
hostname: () => hostname2,
|
|
hex: () => hex2,
|
|
hash: () => hash,
|
|
guid: () => guid2,
|
|
function: () => _function,
|
|
float64: () => float64,
|
|
float32: () => float32,
|
|
file: () => file,
|
|
exactOptional: () => exactOptional,
|
|
enum: () => _enum2,
|
|
emoji: () => emoji2,
|
|
email: () => email2,
|
|
e164: () => e1642,
|
|
discriminatedUnion: () => discriminatedUnion,
|
|
describe: () => describe2,
|
|
date: () => date3,
|
|
custom: () => custom,
|
|
cuid2: () => cuid22,
|
|
cuid: () => cuid3,
|
|
codec: () => codec,
|
|
cidrv6: () => cidrv62,
|
|
cidrv4: () => cidrv42,
|
|
check: () => check,
|
|
catch: () => _catch2,
|
|
boolean: () => boolean2,
|
|
bigint: () => bigint2,
|
|
base64url: () => base64url2,
|
|
base64: () => base642,
|
|
array: () => array,
|
|
any: () => any,
|
|
_function: () => _function,
|
|
_default: () => _default2,
|
|
_ZodString: () => _ZodString,
|
|
ZodXor: () => ZodXor,
|
|
ZodXID: () => ZodXID,
|
|
ZodVoid: () => ZodVoid,
|
|
ZodUnknown: () => ZodUnknown,
|
|
ZodUnion: () => ZodUnion,
|
|
ZodUndefined: () => ZodUndefined,
|
|
ZodUUID: () => ZodUUID,
|
|
ZodURL: () => ZodURL,
|
|
ZodULID: () => ZodULID,
|
|
ZodType: () => ZodType,
|
|
ZodTuple: () => ZodTuple,
|
|
ZodTransform: () => ZodTransform,
|
|
ZodTemplateLiteral: () => ZodTemplateLiteral,
|
|
ZodSymbol: () => ZodSymbol,
|
|
ZodSuccess: () => ZodSuccess,
|
|
ZodStringFormat: () => ZodStringFormat,
|
|
ZodString: () => ZodString,
|
|
ZodSet: () => ZodSet,
|
|
ZodRecord: () => ZodRecord,
|
|
ZodReadonly: () => ZodReadonly,
|
|
ZodPromise: () => ZodPromise,
|
|
ZodPrefault: () => ZodPrefault,
|
|
ZodPipe: () => ZodPipe,
|
|
ZodOptional: () => ZodOptional,
|
|
ZodObject: () => ZodObject,
|
|
ZodNumberFormat: () => ZodNumberFormat,
|
|
ZodNumber: () => ZodNumber,
|
|
ZodNullable: () => ZodNullable,
|
|
ZodNull: () => ZodNull,
|
|
ZodNonOptional: () => ZodNonOptional,
|
|
ZodNever: () => ZodNever,
|
|
ZodNanoID: () => ZodNanoID,
|
|
ZodNaN: () => ZodNaN,
|
|
ZodMap: () => ZodMap,
|
|
ZodMAC: () => ZodMAC,
|
|
ZodLiteral: () => ZodLiteral,
|
|
ZodLazy: () => ZodLazy,
|
|
ZodKSUID: () => ZodKSUID,
|
|
ZodJWT: () => ZodJWT,
|
|
ZodIntersection: () => ZodIntersection,
|
|
ZodIPv6: () => ZodIPv6,
|
|
ZodIPv4: () => ZodIPv4,
|
|
ZodGUID: () => ZodGUID,
|
|
ZodFunction: () => ZodFunction,
|
|
ZodFile: () => ZodFile,
|
|
ZodExactOptional: () => ZodExactOptional,
|
|
ZodEnum: () => ZodEnum,
|
|
ZodEmoji: () => ZodEmoji,
|
|
ZodEmail: () => ZodEmail,
|
|
ZodE164: () => ZodE164,
|
|
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
|
|
ZodDefault: () => ZodDefault,
|
|
ZodDate: () => ZodDate,
|
|
ZodCustomStringFormat: () => ZodCustomStringFormat,
|
|
ZodCustom: () => ZodCustom,
|
|
ZodCodec: () => ZodCodec,
|
|
ZodCatch: () => ZodCatch,
|
|
ZodCUID2: () => ZodCUID2,
|
|
ZodCUID: () => ZodCUID,
|
|
ZodCIDRv6: () => ZodCIDRv6,
|
|
ZodCIDRv4: () => ZodCIDRv4,
|
|
ZodBoolean: () => ZodBoolean,
|
|
ZodBigIntFormat: () => ZodBigIntFormat,
|
|
ZodBigInt: () => ZodBigInt,
|
|
ZodBase64URL: () => ZodBase64URL,
|
|
ZodBase64: () => ZodBase64,
|
|
ZodArray: () => ZodArray,
|
|
ZodAny: () => ZodAny
|
|
});
|
|
|
|
// node_modules/zod/v4/classic/checks.js
|
|
var exports_checks2 = {};
|
|
__export(exports_checks2, {
|
|
uppercase: () => _uppercase,
|
|
trim: () => _trim,
|
|
toUpperCase: () => _toUpperCase,
|
|
toLowerCase: () => _toLowerCase,
|
|
startsWith: () => _startsWith,
|
|
slugify: () => _slugify,
|
|
size: () => _size,
|
|
regex: () => _regex,
|
|
property: () => _property,
|
|
positive: () => _positive,
|
|
overwrite: () => _overwrite,
|
|
normalize: () => _normalize,
|
|
nonpositive: () => _nonpositive,
|
|
nonnegative: () => _nonnegative,
|
|
negative: () => _negative,
|
|
multipleOf: () => _multipleOf,
|
|
minSize: () => _minSize,
|
|
minLength: () => _minLength,
|
|
mime: () => _mime,
|
|
maxSize: () => _maxSize,
|
|
maxLength: () => _maxLength,
|
|
lte: () => _lte,
|
|
lt: () => _lt,
|
|
lowercase: () => _lowercase,
|
|
length: () => _length,
|
|
includes: () => _includes,
|
|
gte: () => _gte,
|
|
gt: () => _gt,
|
|
endsWith: () => _endsWith
|
|
});
|
|
|
|
// node_modules/zod/v4/classic/iso.js
|
|
var exports_iso = {};
|
|
__export(exports_iso, {
|
|
time: () => time2,
|
|
duration: () => duration2,
|
|
datetime: () => datetime2,
|
|
date: () => date2,
|
|
ZodISOTime: () => ZodISOTime,
|
|
ZodISODuration: () => ZodISODuration,
|
|
ZodISODateTime: () => ZodISODateTime,
|
|
ZodISODate: () => ZodISODate
|
|
});
|
|
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
|
|
$ZodISODateTime.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function datetime2(params) {
|
|
return _isoDateTime(ZodISODateTime, params);
|
|
}
|
|
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
|
|
$ZodISODate.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function date2(params) {
|
|
return _isoDate(ZodISODate, params);
|
|
}
|
|
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
|
|
$ZodISOTime.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function time2(params) {
|
|
return _isoTime(ZodISOTime, params);
|
|
}
|
|
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
|
|
$ZodISODuration.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function duration2(params) {
|
|
return _isoDuration(ZodISODuration, params);
|
|
}
|
|
|
|
// node_modules/zod/v4/classic/errors.js
|
|
var initializer2 = (inst, issues) => {
|
|
$ZodError.init(inst, issues);
|
|
inst.name = "ZodError";
|
|
Object.defineProperties(inst, {
|
|
format: {
|
|
value: (mapper) => formatError(inst, mapper)
|
|
},
|
|
flatten: {
|
|
value: (mapper) => flattenError(inst, mapper)
|
|
},
|
|
addIssue: {
|
|
value: (issue2) => {
|
|
inst.issues.push(issue2);
|
|
inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
|
|
}
|
|
},
|
|
addIssues: {
|
|
value: (issues2) => {
|
|
inst.issues.push(...issues2);
|
|
inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
|
|
}
|
|
},
|
|
isEmpty: {
|
|
get() {
|
|
return inst.issues.length === 0;
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var ZodError = $constructor("ZodError", initializer2);
|
|
var ZodRealError = $constructor("ZodError", initializer2, {
|
|
Parent: Error
|
|
});
|
|
|
|
// node_modules/zod/v4/classic/parse.js
|
|
var parse3 = /* @__PURE__ */ _parse(ZodRealError);
|
|
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
|
|
var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
|
|
var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
|
|
var encode2 = /* @__PURE__ */ _encode(ZodRealError);
|
|
var decode2 = /* @__PURE__ */ _decode(ZodRealError);
|
|
var encodeAsync2 = /* @__PURE__ */ _encodeAsync(ZodRealError);
|
|
var decodeAsync2 = /* @__PURE__ */ _decodeAsync(ZodRealError);
|
|
var safeEncode2 = /* @__PURE__ */ _safeEncode(ZodRealError);
|
|
var safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError);
|
|
var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
|
|
var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
|
|
|
|
// node_modules/zod/v4/classic/schemas.js
|
|
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
|
|
$ZodType.init(inst, def);
|
|
Object.assign(inst["~standard"], {
|
|
jsonSchema: {
|
|
input: createStandardJSONSchemaMethod(inst, "input"),
|
|
output: createStandardJSONSchemaMethod(inst, "output")
|
|
}
|
|
});
|
|
inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
|
|
inst.def = def;
|
|
inst.type = def.type;
|
|
Object.defineProperty(inst, "_def", { value: def });
|
|
inst.check = (...checks2) => {
|
|
return inst.clone(exports_util.mergeDefs(def, {
|
|
checks: [
|
|
...def.checks ?? [],
|
|
...checks2.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
|
|
]
|
|
}), {
|
|
parent: true
|
|
});
|
|
};
|
|
inst.with = inst.check;
|
|
inst.clone = (def2, params) => clone(inst, def2, params);
|
|
inst.brand = () => inst;
|
|
inst.register = (reg, meta2) => {
|
|
reg.add(inst, meta2);
|
|
return inst;
|
|
};
|
|
inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
|
|
inst.safeParse = (data, params) => safeParse2(inst, data, params);
|
|
inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
|
|
inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
|
|
inst.spa = inst.safeParseAsync;
|
|
inst.encode = (data, params) => encode2(inst, data, params);
|
|
inst.decode = (data, params) => decode2(inst, data, params);
|
|
inst.encodeAsync = async (data, params) => encodeAsync2(inst, data, params);
|
|
inst.decodeAsync = async (data, params) => decodeAsync2(inst, data, params);
|
|
inst.safeEncode = (data, params) => safeEncode2(inst, data, params);
|
|
inst.safeDecode = (data, params) => safeDecode2(inst, data, params);
|
|
inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);
|
|
inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);
|
|
inst.refine = (check, params) => inst.check(refine(check, params));
|
|
inst.superRefine = (refinement) => inst.check(superRefine(refinement));
|
|
inst.overwrite = (fn) => inst.check(_overwrite(fn));
|
|
inst.optional = () => optional(inst);
|
|
inst.exactOptional = () => exactOptional(inst);
|
|
inst.nullable = () => nullable(inst);
|
|
inst.nullish = () => optional(nullable(inst));
|
|
inst.nonoptional = (params) => nonoptional(inst, params);
|
|
inst.array = () => array(inst);
|
|
inst.or = (arg) => union([inst, arg]);
|
|
inst.and = (arg) => intersection(inst, arg);
|
|
inst.transform = (tx) => pipe(inst, transform(tx));
|
|
inst.default = (def2) => _default2(inst, def2);
|
|
inst.prefault = (def2) => prefault(inst, def2);
|
|
inst.catch = (params) => _catch2(inst, params);
|
|
inst.pipe = (target) => pipe(inst, target);
|
|
inst.readonly = () => readonly(inst);
|
|
inst.describe = (description) => {
|
|
const cl = inst.clone();
|
|
globalRegistry.add(cl, { description });
|
|
return cl;
|
|
};
|
|
Object.defineProperty(inst, "description", {
|
|
get() {
|
|
return globalRegistry.get(inst)?.description;
|
|
},
|
|
configurable: true
|
|
});
|
|
inst.meta = (...args) => {
|
|
if (args.length === 0) {
|
|
return globalRegistry.get(inst);
|
|
}
|
|
const cl = inst.clone();
|
|
globalRegistry.add(cl, args[0]);
|
|
return cl;
|
|
};
|
|
inst.isOptional = () => inst.safeParse(undefined).success;
|
|
inst.isNullable = () => inst.safeParse(null).success;
|
|
inst.apply = (fn) => fn(inst);
|
|
return inst;
|
|
});
|
|
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
|
|
$ZodString.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);
|
|
const bag = inst._zod.bag;
|
|
inst.format = bag.format ?? null;
|
|
inst.minLength = bag.minimum ?? null;
|
|
inst.maxLength = bag.maximum ?? null;
|
|
inst.regex = (...args) => inst.check(_regex(...args));
|
|
inst.includes = (...args) => inst.check(_includes(...args));
|
|
inst.startsWith = (...args) => inst.check(_startsWith(...args));
|
|
inst.endsWith = (...args) => inst.check(_endsWith(...args));
|
|
inst.min = (...args) => inst.check(_minLength(...args));
|
|
inst.max = (...args) => inst.check(_maxLength(...args));
|
|
inst.length = (...args) => inst.check(_length(...args));
|
|
inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
|
|
inst.lowercase = (params) => inst.check(_lowercase(params));
|
|
inst.uppercase = (params) => inst.check(_uppercase(params));
|
|
inst.trim = () => inst.check(_trim());
|
|
inst.normalize = (...args) => inst.check(_normalize(...args));
|
|
inst.toLowerCase = () => inst.check(_toLowerCase());
|
|
inst.toUpperCase = () => inst.check(_toUpperCase());
|
|
inst.slugify = () => inst.check(_slugify());
|
|
});
|
|
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
|
|
$ZodString.init(inst, def);
|
|
_ZodString.init(inst, def);
|
|
inst.email = (params) => inst.check(_email(ZodEmail, params));
|
|
inst.url = (params) => inst.check(_url(ZodURL, params));
|
|
inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
|
|
inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
|
|
inst.guid = (params) => inst.check(_guid(ZodGUID, params));
|
|
inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
|
|
inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
|
|
inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
|
|
inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
|
|
inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
|
|
inst.guid = (params) => inst.check(_guid(ZodGUID, params));
|
|
inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
|
|
inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
|
|
inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
|
|
inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
|
|
inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
|
|
inst.xid = (params) => inst.check(_xid(ZodXID, params));
|
|
inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
|
|
inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
|
|
inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
|
|
inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
|
|
inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
|
|
inst.e164 = (params) => inst.check(_e164(ZodE164, params));
|
|
inst.datetime = (params) => inst.check(datetime2(params));
|
|
inst.date = (params) => inst.check(date2(params));
|
|
inst.time = (params) => inst.check(time2(params));
|
|
inst.duration = (params) => inst.check(duration2(params));
|
|
});
|
|
function string2(params) {
|
|
return _string(ZodString, params);
|
|
}
|
|
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
|
|
$ZodStringFormat.init(inst, def);
|
|
_ZodString.init(inst, def);
|
|
});
|
|
var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
|
|
$ZodEmail.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function email2(params) {
|
|
return _email(ZodEmail, params);
|
|
}
|
|
var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
|
|
$ZodGUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function guid2(params) {
|
|
return _guid(ZodGUID, params);
|
|
}
|
|
var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
|
|
$ZodUUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function uuid2(params) {
|
|
return _uuid(ZodUUID, params);
|
|
}
|
|
function uuidv4(params) {
|
|
return _uuidv4(ZodUUID, params);
|
|
}
|
|
function uuidv6(params) {
|
|
return _uuidv6(ZodUUID, params);
|
|
}
|
|
function uuidv7(params) {
|
|
return _uuidv7(ZodUUID, params);
|
|
}
|
|
var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
|
|
$ZodURL.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function url(params) {
|
|
return _url(ZodURL, params);
|
|
}
|
|
function httpUrl(params) {
|
|
return _url(ZodURL, {
|
|
protocol: /^https?$/,
|
|
hostname: exports_regexes.domain,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
|
|
$ZodEmoji.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function emoji2(params) {
|
|
return _emoji2(ZodEmoji, params);
|
|
}
|
|
var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
|
|
$ZodNanoID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function nanoid2(params) {
|
|
return _nanoid(ZodNanoID, params);
|
|
}
|
|
var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
|
|
$ZodCUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function cuid3(params) {
|
|
return _cuid(ZodCUID, params);
|
|
}
|
|
var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
|
|
$ZodCUID2.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function cuid22(params) {
|
|
return _cuid2(ZodCUID2, params);
|
|
}
|
|
var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
|
|
$ZodULID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function ulid2(params) {
|
|
return _ulid(ZodULID, params);
|
|
}
|
|
var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
|
|
$ZodXID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function xid2(params) {
|
|
return _xid(ZodXID, params);
|
|
}
|
|
var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
|
|
$ZodKSUID.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function ksuid2(params) {
|
|
return _ksuid(ZodKSUID, params);
|
|
}
|
|
var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
|
|
$ZodIPv4.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function ipv42(params) {
|
|
return _ipv4(ZodIPv4, params);
|
|
}
|
|
var ZodMAC = /* @__PURE__ */ $constructor("ZodMAC", (inst, def) => {
|
|
$ZodMAC.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function mac2(params) {
|
|
return _mac(ZodMAC, params);
|
|
}
|
|
var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
|
|
$ZodIPv6.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function ipv62(params) {
|
|
return _ipv6(ZodIPv6, params);
|
|
}
|
|
var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
|
|
$ZodCIDRv4.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function cidrv42(params) {
|
|
return _cidrv4(ZodCIDRv4, params);
|
|
}
|
|
var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
|
|
$ZodCIDRv6.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function cidrv62(params) {
|
|
return _cidrv6(ZodCIDRv6, params);
|
|
}
|
|
var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
|
|
$ZodBase64.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function base642(params) {
|
|
return _base64(ZodBase64, params);
|
|
}
|
|
var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
|
|
$ZodBase64URL.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function base64url2(params) {
|
|
return _base64url(ZodBase64URL, params);
|
|
}
|
|
var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
|
|
$ZodE164.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function e1642(params) {
|
|
return _e164(ZodE164, params);
|
|
}
|
|
var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
|
|
$ZodJWT.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function jwt(params) {
|
|
return _jwt(ZodJWT, params);
|
|
}
|
|
var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat", (inst, def) => {
|
|
$ZodCustomStringFormat.init(inst, def);
|
|
ZodStringFormat.init(inst, def);
|
|
});
|
|
function stringFormat(format, fnOrRegex, _params = {}) {
|
|
return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
|
|
}
|
|
function hostname2(_params) {
|
|
return _stringFormat(ZodCustomStringFormat, "hostname", exports_regexes.hostname, _params);
|
|
}
|
|
function hex2(_params) {
|
|
return _stringFormat(ZodCustomStringFormat, "hex", exports_regexes.hex, _params);
|
|
}
|
|
function hash(alg, params) {
|
|
const enc = params?.enc ?? "hex";
|
|
const format = `${alg}_${enc}`;
|
|
const regex = exports_regexes[format];
|
|
if (!regex)
|
|
throw new Error(`Unrecognized hash format: ${format}`);
|
|
return _stringFormat(ZodCustomStringFormat, format, regex, params);
|
|
}
|
|
var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
|
|
$ZodNumber.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
|
|
inst.gt = (value, params) => inst.check(_gt(value, params));
|
|
inst.gte = (value, params) => inst.check(_gte(value, params));
|
|
inst.min = (value, params) => inst.check(_gte(value, params));
|
|
inst.lt = (value, params) => inst.check(_lt(value, params));
|
|
inst.lte = (value, params) => inst.check(_lte(value, params));
|
|
inst.max = (value, params) => inst.check(_lte(value, params));
|
|
inst.int = (params) => inst.check(int(params));
|
|
inst.safe = (params) => inst.check(int(params));
|
|
inst.positive = (params) => inst.check(_gt(0, params));
|
|
inst.nonnegative = (params) => inst.check(_gte(0, params));
|
|
inst.negative = (params) => inst.check(_lt(0, params));
|
|
inst.nonpositive = (params) => inst.check(_lte(0, params));
|
|
inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
|
|
inst.step = (value, params) => inst.check(_multipleOf(value, params));
|
|
inst.finite = () => inst;
|
|
const bag = inst._zod.bag;
|
|
inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
|
|
inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
|
|
inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
|
|
inst.isFinite = true;
|
|
inst.format = bag.format ?? null;
|
|
});
|
|
function number2(params) {
|
|
return _number(ZodNumber, params);
|
|
}
|
|
var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
|
|
$ZodNumberFormat.init(inst, def);
|
|
ZodNumber.init(inst, def);
|
|
});
|
|
function int(params) {
|
|
return _int(ZodNumberFormat, params);
|
|
}
|
|
function float32(params) {
|
|
return _float32(ZodNumberFormat, params);
|
|
}
|
|
function float64(params) {
|
|
return _float64(ZodNumberFormat, params);
|
|
}
|
|
function int32(params) {
|
|
return _int32(ZodNumberFormat, params);
|
|
}
|
|
function uint32(params) {
|
|
return _uint32(ZodNumberFormat, params);
|
|
}
|
|
var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
|
|
$ZodBoolean.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
|
|
});
|
|
function boolean2(params) {
|
|
return _boolean(ZodBoolean, params);
|
|
}
|
|
var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
|
|
$ZodBigInt.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => bigintProcessor(inst, ctx, json, params);
|
|
inst.gte = (value, params) => inst.check(_gte(value, params));
|
|
inst.min = (value, params) => inst.check(_gte(value, params));
|
|
inst.gt = (value, params) => inst.check(_gt(value, params));
|
|
inst.gte = (value, params) => inst.check(_gte(value, params));
|
|
inst.min = (value, params) => inst.check(_gte(value, params));
|
|
inst.lt = (value, params) => inst.check(_lt(value, params));
|
|
inst.lte = (value, params) => inst.check(_lte(value, params));
|
|
inst.max = (value, params) => inst.check(_lte(value, params));
|
|
inst.positive = (params) => inst.check(_gt(BigInt(0), params));
|
|
inst.negative = (params) => inst.check(_lt(BigInt(0), params));
|
|
inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
|
|
inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
|
|
inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
|
|
const bag = inst._zod.bag;
|
|
inst.minValue = bag.minimum ?? null;
|
|
inst.maxValue = bag.maximum ?? null;
|
|
inst.format = bag.format ?? null;
|
|
});
|
|
function bigint2(params) {
|
|
return _bigint(ZodBigInt, params);
|
|
}
|
|
var ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => {
|
|
$ZodBigIntFormat.init(inst, def);
|
|
ZodBigInt.init(inst, def);
|
|
});
|
|
function int64(params) {
|
|
return _int64(ZodBigIntFormat, params);
|
|
}
|
|
function uint64(params) {
|
|
return _uint64(ZodBigIntFormat, params);
|
|
}
|
|
var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
|
|
$ZodSymbol.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => symbolProcessor(inst, ctx, json, params);
|
|
});
|
|
function symbol(params) {
|
|
return _symbol(ZodSymbol, params);
|
|
}
|
|
var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
|
|
$ZodUndefined.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => undefinedProcessor(inst, ctx, json, params);
|
|
});
|
|
function _undefined3(params) {
|
|
return _undefined2(ZodUndefined, params);
|
|
}
|
|
var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
|
|
$ZodNull.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => nullProcessor(inst, ctx, json, params);
|
|
});
|
|
function _null3(params) {
|
|
return _null2(ZodNull, params);
|
|
}
|
|
var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
|
|
$ZodAny.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => anyProcessor(inst, ctx, json, params);
|
|
});
|
|
function any() {
|
|
return _any(ZodAny);
|
|
}
|
|
var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
|
|
$ZodUnknown.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);
|
|
});
|
|
function unknown() {
|
|
return _unknown(ZodUnknown);
|
|
}
|
|
var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
|
|
$ZodNever.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
|
|
});
|
|
function never(params) {
|
|
return _never(ZodNever, params);
|
|
}
|
|
var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
|
|
$ZodVoid.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => voidProcessor(inst, ctx, json, params);
|
|
});
|
|
function _void2(params) {
|
|
return _void(ZodVoid, params);
|
|
}
|
|
var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
|
|
$ZodDate.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => dateProcessor(inst, ctx, json, params);
|
|
inst.min = (value, params) => inst.check(_gte(value, params));
|
|
inst.max = (value, params) => inst.check(_lte(value, params));
|
|
const c = inst._zod.bag;
|
|
inst.minDate = c.minimum ? new Date(c.minimum) : null;
|
|
inst.maxDate = c.maximum ? new Date(c.maximum) : null;
|
|
});
|
|
function date3(params) {
|
|
return _date(ZodDate, params);
|
|
}
|
|
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
|
|
$ZodArray.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
|
|
inst.element = def.element;
|
|
inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
|
|
inst.nonempty = (params) => inst.check(_minLength(1, params));
|
|
inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
|
|
inst.length = (len, params) => inst.check(_length(len, params));
|
|
inst.unwrap = () => inst.element;
|
|
});
|
|
function array(element, params) {
|
|
return _array(ZodArray, element, params);
|
|
}
|
|
function keyof(schema) {
|
|
const shape = schema._zod.def.shape;
|
|
return _enum2(Object.keys(shape));
|
|
}
|
|
var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
|
|
$ZodObjectJIT.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
|
|
exports_util.defineLazy(inst, "shape", () => {
|
|
return def.shape;
|
|
});
|
|
inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
|
|
inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
|
|
inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
|
|
inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
|
|
inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
|
|
inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
|
|
inst.extend = (incoming) => {
|
|
return exports_util.extend(inst, incoming);
|
|
};
|
|
inst.safeExtend = (incoming) => {
|
|
return exports_util.safeExtend(inst, incoming);
|
|
};
|
|
inst.merge = (other) => exports_util.merge(inst, other);
|
|
inst.pick = (mask) => exports_util.pick(inst, mask);
|
|
inst.omit = (mask) => exports_util.omit(inst, mask);
|
|
inst.partial = (...args) => exports_util.partial(ZodOptional, inst, args[0]);
|
|
inst.required = (...args) => exports_util.required(ZodNonOptional, inst, args[0]);
|
|
});
|
|
function object(shape, params) {
|
|
const def = {
|
|
type: "object",
|
|
shape: shape ?? {},
|
|
...exports_util.normalizeParams(params)
|
|
};
|
|
return new ZodObject(def);
|
|
}
|
|
function strictObject(shape, params) {
|
|
return new ZodObject({
|
|
type: "object",
|
|
shape,
|
|
catchall: never(),
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
function looseObject(shape, params) {
|
|
return new ZodObject({
|
|
type: "object",
|
|
shape,
|
|
catchall: unknown(),
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
|
|
$ZodUnion.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
|
|
inst.options = def.options;
|
|
});
|
|
function union(options, params) {
|
|
return new ZodUnion({
|
|
type: "union",
|
|
options,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
|
|
ZodUnion.init(inst, def);
|
|
$ZodXor.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
|
|
inst.options = def.options;
|
|
});
|
|
function xor(options, params) {
|
|
return new ZodXor({
|
|
type: "union",
|
|
options,
|
|
inclusive: false,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
|
|
ZodUnion.init(inst, def);
|
|
$ZodDiscriminatedUnion.init(inst, def);
|
|
});
|
|
function discriminatedUnion(discriminator, options, params) {
|
|
return new ZodDiscriminatedUnion({
|
|
type: "union",
|
|
options,
|
|
discriminator,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
|
|
$ZodIntersection.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
|
|
});
|
|
function intersection(left, right) {
|
|
return new ZodIntersection({
|
|
type: "intersection",
|
|
left,
|
|
right
|
|
});
|
|
}
|
|
var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
|
|
$ZodTuple.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => tupleProcessor(inst, ctx, json, params);
|
|
inst.rest = (rest) => inst.clone({
|
|
...inst._zod.def,
|
|
rest
|
|
});
|
|
});
|
|
function tuple(items, _paramsOrRest, _params) {
|
|
const hasRest = _paramsOrRest instanceof $ZodType;
|
|
const params = hasRest ? _params : _paramsOrRest;
|
|
const rest = hasRest ? _paramsOrRest : null;
|
|
return new ZodTuple({
|
|
type: "tuple",
|
|
items,
|
|
rest,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
|
|
$ZodRecord.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
|
|
inst.keyType = def.keyType;
|
|
inst.valueType = def.valueType;
|
|
});
|
|
function record(keyType, valueType, params) {
|
|
return new ZodRecord({
|
|
type: "record",
|
|
keyType,
|
|
valueType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
function partialRecord(keyType, valueType, params) {
|
|
const k = clone(keyType);
|
|
k._zod.values = undefined;
|
|
return new ZodRecord({
|
|
type: "record",
|
|
keyType: k,
|
|
valueType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
function looseRecord(keyType, valueType, params) {
|
|
return new ZodRecord({
|
|
type: "record",
|
|
keyType,
|
|
valueType,
|
|
mode: "loose",
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
|
|
$ZodMap.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => mapProcessor(inst, ctx, json, params);
|
|
inst.keyType = def.keyType;
|
|
inst.valueType = def.valueType;
|
|
inst.min = (...args) => inst.check(_minSize(...args));
|
|
inst.nonempty = (params) => inst.check(_minSize(1, params));
|
|
inst.max = (...args) => inst.check(_maxSize(...args));
|
|
inst.size = (...args) => inst.check(_size(...args));
|
|
});
|
|
function map(keyType, valueType, params) {
|
|
return new ZodMap({
|
|
type: "map",
|
|
keyType,
|
|
valueType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
|
|
$ZodSet.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => setProcessor(inst, ctx, json, params);
|
|
inst.min = (...args) => inst.check(_minSize(...args));
|
|
inst.nonempty = (params) => inst.check(_minSize(1, params));
|
|
inst.max = (...args) => inst.check(_maxSize(...args));
|
|
inst.size = (...args) => inst.check(_size(...args));
|
|
});
|
|
function set(valueType, params) {
|
|
return new ZodSet({
|
|
type: "set",
|
|
valueType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
|
|
$ZodEnum.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
|
|
inst.enum = def.entries;
|
|
inst.options = Object.values(def.entries);
|
|
const keys = new Set(Object.keys(def.entries));
|
|
inst.extract = (values, params) => {
|
|
const newEntries = {};
|
|
for (const value of values) {
|
|
if (keys.has(value)) {
|
|
newEntries[value] = def.entries[value];
|
|
} else
|
|
throw new Error(`Key ${value} not found in enum`);
|
|
}
|
|
return new ZodEnum({
|
|
...def,
|
|
checks: [],
|
|
...exports_util.normalizeParams(params),
|
|
entries: newEntries
|
|
});
|
|
};
|
|
inst.exclude = (values, params) => {
|
|
const newEntries = { ...def.entries };
|
|
for (const value of values) {
|
|
if (keys.has(value)) {
|
|
delete newEntries[value];
|
|
} else
|
|
throw new Error(`Key ${value} not found in enum`);
|
|
}
|
|
return new ZodEnum({
|
|
...def,
|
|
checks: [],
|
|
...exports_util.normalizeParams(params),
|
|
entries: newEntries
|
|
});
|
|
};
|
|
});
|
|
function _enum2(values, params) {
|
|
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
|
|
return new ZodEnum({
|
|
type: "enum",
|
|
entries,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
function nativeEnum(entries, params) {
|
|
return new ZodEnum({
|
|
type: "enum",
|
|
entries,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
|
|
$ZodLiteral.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json, params);
|
|
inst.values = new Set(def.values);
|
|
Object.defineProperty(inst, "value", {
|
|
get() {
|
|
if (def.values.length > 1) {
|
|
throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
|
|
}
|
|
return def.values[0];
|
|
}
|
|
});
|
|
});
|
|
function literal(value, params) {
|
|
return new ZodLiteral({
|
|
type: "literal",
|
|
values: Array.isArray(value) ? value : [value],
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
|
|
$ZodFile.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => fileProcessor(inst, ctx, json, params);
|
|
inst.min = (size, params) => inst.check(_minSize(size, params));
|
|
inst.max = (size, params) => inst.check(_maxSize(size, params));
|
|
inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
|
|
});
|
|
function file(params) {
|
|
return _file(ZodFile, params);
|
|
}
|
|
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
|
|
$ZodTransform.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (_ctx.direction === "backward") {
|
|
throw new $ZodEncodeError(inst.constructor.name);
|
|
}
|
|
payload.addIssue = (issue2) => {
|
|
if (typeof issue2 === "string") {
|
|
payload.issues.push(exports_util.issue(issue2, payload.value, def));
|
|
} else {
|
|
const _issue = issue2;
|
|
if (_issue.fatal)
|
|
_issue.continue = false;
|
|
_issue.code ?? (_issue.code = "custom");
|
|
_issue.input ?? (_issue.input = payload.value);
|
|
_issue.inst ?? (_issue.inst = inst);
|
|
payload.issues.push(exports_util.issue(_issue));
|
|
}
|
|
};
|
|
const output = def.transform(payload.value, payload);
|
|
if (output instanceof Promise) {
|
|
return output.then((output2) => {
|
|
payload.value = output2;
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = output;
|
|
return payload;
|
|
};
|
|
});
|
|
function transform(fn) {
|
|
return new ZodTransform({
|
|
type: "transform",
|
|
transform: fn
|
|
});
|
|
}
|
|
var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
|
|
$ZodOptional.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function optional(innerType) {
|
|
return new ZodOptional({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
|
|
$ZodExactOptional.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function exactOptional(innerType) {
|
|
return new ZodExactOptional({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
|
|
$ZodNullable.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nullable(innerType) {
|
|
return new ZodNullable({
|
|
type: "nullable",
|
|
innerType
|
|
});
|
|
}
|
|
function nullish2(innerType) {
|
|
return optional(nullable(innerType));
|
|
}
|
|
var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
|
|
$ZodDefault.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeDefault = inst.unwrap;
|
|
});
|
|
function _default2(innerType, defaultValue) {
|
|
return new ZodDefault({
|
|
type: "default",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : exports_util.shallowClone(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
|
|
$ZodPrefault.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function prefault(innerType, defaultValue) {
|
|
return new ZodPrefault({
|
|
type: "prefault",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : exports_util.shallowClone(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
|
|
$ZodNonOptional.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nonoptional(innerType, params) {
|
|
return new ZodNonOptional({
|
|
type: "nonoptional",
|
|
innerType,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
|
|
$ZodSuccess.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => successProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function success(innerType) {
|
|
return new ZodSuccess({
|
|
type: "success",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
|
|
$ZodCatch.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeCatch = inst.unwrap;
|
|
});
|
|
function _catch2(innerType, catchValue) {
|
|
return new ZodCatch({
|
|
type: "catch",
|
|
innerType,
|
|
catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
|
|
});
|
|
}
|
|
var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
|
|
$ZodNaN.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => nanProcessor(inst, ctx, json, params);
|
|
});
|
|
function nan(params) {
|
|
return _nan(ZodNaN, params);
|
|
}
|
|
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
|
|
$ZodPipe.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
|
|
inst.in = def.in;
|
|
inst.out = def.out;
|
|
});
|
|
function pipe(in_, out) {
|
|
return new ZodPipe({
|
|
type: "pipe",
|
|
in: in_,
|
|
out
|
|
});
|
|
}
|
|
var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
|
|
ZodPipe.init(inst, def);
|
|
$ZodCodec.init(inst, def);
|
|
});
|
|
function codec(in_, out, params) {
|
|
return new ZodCodec({
|
|
type: "pipe",
|
|
in: in_,
|
|
out,
|
|
transform: params.decode,
|
|
reverseTransform: params.encode
|
|
});
|
|
}
|
|
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
|
|
$ZodReadonly.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function readonly(innerType) {
|
|
return new ZodReadonly({
|
|
type: "readonly",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
|
|
$ZodTemplateLiteral.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => templateLiteralProcessor(inst, ctx, json, params);
|
|
});
|
|
function templateLiteral(parts, params) {
|
|
return new ZodTemplateLiteral({
|
|
type: "template_literal",
|
|
parts,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
|
|
$ZodLazy.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => lazyProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.getter();
|
|
});
|
|
function lazy(getter) {
|
|
return new ZodLazy({
|
|
type: "lazy",
|
|
getter
|
|
});
|
|
}
|
|
var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
|
|
$ZodPromise.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => promiseProcessor(inst, ctx, json, params);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function promise(innerType) {
|
|
return new ZodPromise({
|
|
type: "promise",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
|
|
$ZodFunction.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => functionProcessor(inst, ctx, json, params);
|
|
});
|
|
function _function(params) {
|
|
return new ZodFunction({
|
|
type: "function",
|
|
input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
|
|
output: params?.output ?? unknown()
|
|
});
|
|
}
|
|
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
|
|
$ZodCustom.init(inst, def);
|
|
ZodType.init(inst, def);
|
|
inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
|
|
});
|
|
function check(fn) {
|
|
const ch = new $ZodCheck({
|
|
check: "custom"
|
|
});
|
|
ch._zod.check = fn;
|
|
return ch;
|
|
}
|
|
function custom(fn, _params) {
|
|
return _custom(ZodCustom, fn ?? (() => true), _params);
|
|
}
|
|
function refine(fn, _params = {}) {
|
|
return _refine(ZodCustom, fn, _params);
|
|
}
|
|
function superRefine(fn) {
|
|
return _superRefine(fn);
|
|
}
|
|
var describe2 = describe;
|
|
var meta2 = meta;
|
|
function _instanceof(cls, params = {}) {
|
|
const inst = new ZodCustom({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn: (data) => data instanceof cls,
|
|
abort: true,
|
|
...exports_util.normalizeParams(params)
|
|
});
|
|
inst._zod.bag.Class = cls;
|
|
inst._zod.check = (payload) => {
|
|
if (!(payload.value instanceof cls)) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: cls.name,
|
|
input: payload.value,
|
|
inst,
|
|
path: [...inst._zod.def.path ?? []]
|
|
});
|
|
}
|
|
};
|
|
return inst;
|
|
}
|
|
var stringbool = (...args) => _stringbool({
|
|
Codec: ZodCodec,
|
|
Boolean: ZodBoolean,
|
|
String: ZodString
|
|
}, ...args);
|
|
function json(params) {
|
|
const jsonSchema = lazy(() => {
|
|
return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
|
|
});
|
|
return jsonSchema;
|
|
}
|
|
function preprocess(fn, schema) {
|
|
return pipe(transform(fn), schema);
|
|
}
|
|
// node_modules/zod/v4/classic/compat.js
|
|
var ZodIssueCode = {
|
|
invalid_type: "invalid_type",
|
|
too_big: "too_big",
|
|
too_small: "too_small",
|
|
invalid_format: "invalid_format",
|
|
not_multiple_of: "not_multiple_of",
|
|
unrecognized_keys: "unrecognized_keys",
|
|
invalid_union: "invalid_union",
|
|
invalid_key: "invalid_key",
|
|
invalid_element: "invalid_element",
|
|
invalid_value: "invalid_value",
|
|
custom: "custom"
|
|
};
|
|
function setErrorMap(map2) {
|
|
config({
|
|
customError: map2
|
|
});
|
|
}
|
|
function getErrorMap() {
|
|
return config().customError;
|
|
}
|
|
var ZodFirstPartyTypeKind;
|
|
(function(ZodFirstPartyTypeKind2) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
|
|
// node_modules/zod/v4/classic/from-json-schema.js
|
|
var z = {
|
|
...exports_schemas2,
|
|
...exports_checks2,
|
|
iso: exports_iso
|
|
};
|
|
var RECOGNIZED_KEYS = 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 !== undefined) {
|
|
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 !== undefined) {
|
|
throw new Error("unevaluatedItems is not supported");
|
|
}
|
|
if (schema.unevaluatedProperties !== undefined) {
|
|
throw new Error("unevaluatedProperties is not supported");
|
|
}
|
|
if (schema.if !== undefined || schema.then !== undefined || schema.else !== undefined) {
|
|
throw new Error("Conditional schemas (if/then/else) are not supported");
|
|
}
|
|
if (schema.dependentSchemas !== undefined || schema.dependentRequired !== undefined) {
|
|
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 resolved = resolveRef(refPath, ctx);
|
|
const zodSchema2 = convertSchema(resolved, ctx);
|
|
ctx.refs.set(refPath, zodSchema2);
|
|
ctx.processing.delete(refPath);
|
|
return zodSchema2;
|
|
}
|
|
if (schema.enum !== undefined) {
|
|
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 !== undefined) {
|
|
return z.literal(schema.const);
|
|
}
|
|
const type = schema.type;
|
|
if (Array.isArray(type)) {
|
|
const typeSchemas = type.map((t) => {
|
|
const typeSchema = { ...schema, type: t };
|
|
return convertBaseSchema(typeSchema, 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 objectSchema2 = z.object(shape).passthrough();
|
|
const recordSchema = z.looseRecord(keySchema, valueSchema);
|
|
zodSchema = z.intersection(objectSchema2, 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) : undefined;
|
|
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) : undefined;
|
|
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 !== undefined) {
|
|
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}`);
|
|
}
|
|
if (schema.description) {
|
|
zodSchema = zodSchema.describe(schema.description);
|
|
}
|
|
if (schema.default !== undefined) {
|
|
zodSchema = zodSchema.default(schema.default);
|
|
}
|
|
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 !== undefined || schema.const !== undefined;
|
|
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);
|
|
}
|
|
const extraMeta = {};
|
|
const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
|
|
for (const key of coreMetadataKeys) {
|
|
if (key in schema) {
|
|
extraMeta[key] = schema[key];
|
|
}
|
|
}
|
|
const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
|
|
for (const key of contentMetadataKeys) {
|
|
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);
|
|
}
|
|
return baseSchema;
|
|
}
|
|
function fromJSONSchema(schema, params) {
|
|
if (typeof schema === "boolean") {
|
|
return schema ? z.any() : z.never();
|
|
}
|
|
const version2 = detectVersion(schema, params?.defaultTarget);
|
|
const defs = schema.$defs || schema.definitions || {};
|
|
const ctx = {
|
|
version: version2,
|
|
defs,
|
|
refs: new Map,
|
|
processing: new Set,
|
|
rootSchema: schema,
|
|
registry: params?.registry ?? globalRegistry
|
|
};
|
|
return convertSchema(schema, ctx);
|
|
}
|
|
// node_modules/zod/v4/classic/coerce.js
|
|
var exports_coerce = {};
|
|
__export(exports_coerce, {
|
|
string: () => string3,
|
|
number: () => number3,
|
|
date: () => date4,
|
|
boolean: () => boolean3,
|
|
bigint: () => bigint3
|
|
});
|
|
function string3(params) {
|
|
return _coercedString(ZodString, params);
|
|
}
|
|
function number3(params) {
|
|
return _coercedNumber(ZodNumber, params);
|
|
}
|
|
function boolean3(params) {
|
|
return _coercedBoolean(ZodBoolean, params);
|
|
}
|
|
function bigint3(params) {
|
|
return _coercedBigint(ZodBigInt, params);
|
|
}
|
|
function date4(params) {
|
|
return _coercedDate(ZodDate, params);
|
|
}
|
|
|
|
// node_modules/zod/v4/classic/external.js
|
|
config(en_default());
|
|
// src/config/schema.ts
|
|
var TmuxLayoutSchema = exports_external.enum([
|
|
"main-horizontal",
|
|
"main-vertical",
|
|
"tiled",
|
|
"even-horizontal",
|
|
"even-vertical"
|
|
]);
|
|
var TmuxConfigSchema = exports_external.object({
|
|
enabled: exports_external.boolean().default(false),
|
|
layout: TmuxLayoutSchema.default("main-vertical"),
|
|
main_pane_size: exports_external.number().min(20).max(80).default(60),
|
|
main_pane_min_width: exports_external.number().min(40).default(120),
|
|
agent_pane_min_width: exports_external.number().min(20).default(40)
|
|
});
|
|
var PluginConfigSchema = exports_external.object({
|
|
tmux: TmuxConfigSchema.partial().optional()
|
|
});
|
|
|
|
// src/shared/index.ts
|
|
init_logger();
|
|
|
|
// src/shared/normalize-sdk-response.ts
|
|
function normalizeSDKResponse(response, fallback, options) {
|
|
if (response === null || response === undefined) {
|
|
return fallback;
|
|
}
|
|
if (Array.isArray(response)) {
|
|
return response;
|
|
}
|
|
if (typeof response === "object" && response !== null && "data" in response) {
|
|
const data = response.data;
|
|
if (data !== null && data !== undefined) {
|
|
return data;
|
|
}
|
|
if (options?.preferResponseOnMissingData === true) {
|
|
return response;
|
|
}
|
|
return fallback;
|
|
}
|
|
if (options?.preferResponseOnMissingData === true) {
|
|
return response;
|
|
}
|
|
return fallback;
|
|
}
|
|
// src/shared/jsonc-parser.ts
|
|
import { existsSync, readFileSync } from "fs";
|
|
|
|
// node_modules/jsonc-parser/lib/esm/impl/scanner.js
|
|
function createScanner(text, ignoreTrivia = false) {
|
|
const len = text.length;
|
|
let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
|
|
function scanHexDigits(count, exact) {
|
|
let digits = 0;
|
|
let value2 = 0;
|
|
while (digits < count || !exact) {
|
|
let ch = text.charCodeAt(pos);
|
|
if (ch >= 48 && ch <= 57) {
|
|
value2 = value2 * 16 + ch - 48;
|
|
} else if (ch >= 65 && ch <= 70) {
|
|
value2 = value2 * 16 + ch - 65 + 10;
|
|
} else if (ch >= 97 && ch <= 102) {
|
|
value2 = value2 * 16 + ch - 97 + 10;
|
|
} else {
|
|
break;
|
|
}
|
|
pos++;
|
|
digits++;
|
|
}
|
|
if (digits < count) {
|
|
value2 = -1;
|
|
}
|
|
return value2;
|
|
}
|
|
function setPosition(newPosition) {
|
|
pos = newPosition;
|
|
value = "";
|
|
tokenOffset = 0;
|
|
token = 16;
|
|
scanError = 0;
|
|
}
|
|
function scanNumber() {
|
|
let start = pos;
|
|
if (text.charCodeAt(pos) === 48) {
|
|
pos++;
|
|
} else {
|
|
pos++;
|
|
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
}
|
|
if (pos < text.length && text.charCodeAt(pos) === 46) {
|
|
pos++;
|
|
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
} else {
|
|
scanError = 3;
|
|
return text.substring(start, pos);
|
|
}
|
|
}
|
|
let end = pos;
|
|
if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
|
|
pos++;
|
|
if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
|
|
pos++;
|
|
}
|
|
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
end = pos;
|
|
} else {
|
|
scanError = 3;
|
|
}
|
|
}
|
|
return text.substring(start, end);
|
|
}
|
|
function scanString() {
|
|
let result = "", start = pos;
|
|
while (true) {
|
|
if (pos >= len) {
|
|
result += text.substring(start, pos);
|
|
scanError = 2;
|
|
break;
|
|
}
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 34) {
|
|
result += text.substring(start, pos);
|
|
pos++;
|
|
break;
|
|
}
|
|
if (ch === 92) {
|
|
result += text.substring(start, pos);
|
|
pos++;
|
|
if (pos >= len) {
|
|
scanError = 2;
|
|
break;
|
|
}
|
|
const ch2 = text.charCodeAt(pos++);
|
|
switch (ch2) {
|
|
case 34:
|
|
result += '"';
|
|
break;
|
|
case 92:
|
|
result += "\\";
|
|
break;
|
|
case 47:
|
|
result += "/";
|
|
break;
|
|
case 98:
|
|
result += "\b";
|
|
break;
|
|
case 102:
|
|
result += "\f";
|
|
break;
|
|
case 110:
|
|
result += `
|
|
`;
|
|
break;
|
|
case 114:
|
|
result += "\r";
|
|
break;
|
|
case 116:
|
|
result += "\t";
|
|
break;
|
|
case 117:
|
|
const ch3 = scanHexDigits(4, true);
|
|
if (ch3 >= 0) {
|
|
result += String.fromCharCode(ch3);
|
|
} else {
|
|
scanError = 4;
|
|
}
|
|
break;
|
|
default:
|
|
scanError = 5;
|
|
}
|
|
start = pos;
|
|
continue;
|
|
}
|
|
if (ch >= 0 && ch <= 31) {
|
|
if (isLineBreak(ch)) {
|
|
result += text.substring(start, pos);
|
|
scanError = 2;
|
|
break;
|
|
} else {
|
|
scanError = 6;
|
|
}
|
|
}
|
|
pos++;
|
|
}
|
|
return result;
|
|
}
|
|
function scanNext() {
|
|
value = "";
|
|
scanError = 0;
|
|
tokenOffset = pos;
|
|
lineStartOffset = lineNumber;
|
|
prevTokenLineStartOffset = tokenLineStartOffset;
|
|
if (pos >= len) {
|
|
tokenOffset = len;
|
|
return token = 17;
|
|
}
|
|
let code = text.charCodeAt(pos);
|
|
if (isWhiteSpace(code)) {
|
|
do {
|
|
pos++;
|
|
value += String.fromCharCode(code);
|
|
code = text.charCodeAt(pos);
|
|
} while (isWhiteSpace(code));
|
|
return token = 15;
|
|
}
|
|
if (isLineBreak(code)) {
|
|
pos++;
|
|
value += String.fromCharCode(code);
|
|
if (code === 13 && text.charCodeAt(pos) === 10) {
|
|
pos++;
|
|
value += `
|
|
`;
|
|
}
|
|
lineNumber++;
|
|
tokenLineStartOffset = pos;
|
|
return token = 14;
|
|
}
|
|
switch (code) {
|
|
case 123:
|
|
pos++;
|
|
return token = 1;
|
|
case 125:
|
|
pos++;
|
|
return token = 2;
|
|
case 91:
|
|
pos++;
|
|
return token = 3;
|
|
case 93:
|
|
pos++;
|
|
return token = 4;
|
|
case 58:
|
|
pos++;
|
|
return token = 6;
|
|
case 44:
|
|
pos++;
|
|
return token = 5;
|
|
case 34:
|
|
pos++;
|
|
value = scanString();
|
|
return token = 10;
|
|
case 47:
|
|
const start = pos - 1;
|
|
if (text.charCodeAt(pos + 1) === 47) {
|
|
pos += 2;
|
|
while (pos < len) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
value = text.substring(start, pos);
|
|
return token = 12;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 42) {
|
|
pos += 2;
|
|
const safeLength = len - 1;
|
|
let commentClosed = false;
|
|
while (pos < safeLength) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
|
|
pos += 2;
|
|
commentClosed = true;
|
|
break;
|
|
}
|
|
pos++;
|
|
if (isLineBreak(ch)) {
|
|
if (ch === 13 && text.charCodeAt(pos) === 10) {
|
|
pos++;
|
|
}
|
|
lineNumber++;
|
|
tokenLineStartOffset = pos;
|
|
}
|
|
}
|
|
if (!commentClosed) {
|
|
pos++;
|
|
scanError = 1;
|
|
}
|
|
value = text.substring(start, pos);
|
|
return token = 13;
|
|
}
|
|
value += String.fromCharCode(code);
|
|
pos++;
|
|
return token = 16;
|
|
case 45:
|
|
value += String.fromCharCode(code);
|
|
pos++;
|
|
if (pos === len || !isDigit(text.charCodeAt(pos))) {
|
|
return token = 16;
|
|
}
|
|
case 48:
|
|
case 49:
|
|
case 50:
|
|
case 51:
|
|
case 52:
|
|
case 53:
|
|
case 54:
|
|
case 55:
|
|
case 56:
|
|
case 57:
|
|
value += scanNumber();
|
|
return token = 11;
|
|
default:
|
|
while (pos < len && isUnknownContentCharacter(code)) {
|
|
pos++;
|
|
code = text.charCodeAt(pos);
|
|
}
|
|
if (tokenOffset !== pos) {
|
|
value = text.substring(tokenOffset, pos);
|
|
switch (value) {
|
|
case "true":
|
|
return token = 8;
|
|
case "false":
|
|
return token = 9;
|
|
case "null":
|
|
return token = 7;
|
|
}
|
|
return token = 16;
|
|
}
|
|
value += String.fromCharCode(code);
|
|
pos++;
|
|
return token = 16;
|
|
}
|
|
}
|
|
function isUnknownContentCharacter(code) {
|
|
if (isWhiteSpace(code) || isLineBreak(code)) {
|
|
return false;
|
|
}
|
|
switch (code) {
|
|
case 125:
|
|
case 93:
|
|
case 123:
|
|
case 91:
|
|
case 34:
|
|
case 58:
|
|
case 44:
|
|
case 47:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function scanNextNonTrivia() {
|
|
let result;
|
|
do {
|
|
result = scanNext();
|
|
} while (result >= 12 && result <= 15);
|
|
return result;
|
|
}
|
|
return {
|
|
setPosition,
|
|
getPosition: () => pos,
|
|
scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
|
|
getToken: () => token,
|
|
getTokenValue: () => value,
|
|
getTokenOffset: () => tokenOffset,
|
|
getTokenLength: () => pos - tokenOffset,
|
|
getTokenStartLine: () => lineStartOffset,
|
|
getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
|
|
getTokenError: () => scanError
|
|
};
|
|
}
|
|
function isWhiteSpace(ch) {
|
|
return ch === 32 || ch === 9;
|
|
}
|
|
function isLineBreak(ch) {
|
|
return ch === 10 || ch === 13;
|
|
}
|
|
function isDigit(ch) {
|
|
return ch >= 48 && ch <= 57;
|
|
}
|
|
var CharacterCodes;
|
|
(function(CharacterCodes2) {
|
|
CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
|
|
CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
|
|
CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
|
|
CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
|
|
CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
|
|
CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
|
|
CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
|
|
CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
|
|
CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
|
|
CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
|
|
CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
|
|
CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
|
|
CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
|
|
CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
|
|
CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
|
|
CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
|
|
CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
|
|
CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
|
|
CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
|
|
CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
|
|
CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
|
|
CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
|
|
CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
|
|
CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
|
|
CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
|
|
CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
|
|
CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
|
|
CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
|
|
CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
|
|
CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
|
|
CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
|
|
CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
|
|
CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
|
|
CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
|
|
CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
|
|
CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
|
|
CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
|
|
CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
|
|
CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
|
|
CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
|
|
CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
|
|
CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
|
|
CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
|
|
CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
|
|
CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
|
|
CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
|
|
CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
|
|
CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
|
|
CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
|
|
CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
|
|
CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
|
|
CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
|
|
CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
|
|
CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
|
|
CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
|
|
CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
|
|
CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
|
|
CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
|
|
CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
|
|
CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
|
|
CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
|
|
CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
|
|
CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
|
|
CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
|
|
CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
|
|
CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
|
|
CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
|
|
CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
|
|
CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
|
|
CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
|
|
CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
|
|
CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
|
|
CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
|
|
CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
|
|
CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
|
|
CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
|
|
CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
|
|
CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
|
|
CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
|
|
CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
|
|
})(CharacterCodes || (CharacterCodes = {}));
|
|
|
|
// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
|
|
var cachedSpaces = new Array(20).fill(0).map((_, index) => {
|
|
return " ".repeat(index);
|
|
});
|
|
var maxCachedValues = 200;
|
|
var cachedBreakLinesWithSpaces = {
|
|
" ": {
|
|
"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
|
|
return `
|
|
` + " ".repeat(index);
|
|
}),
|
|
"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
|
|
return "\r" + " ".repeat(index);
|
|
}),
|
|
"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
|
|
return `\r
|
|
` + " ".repeat(index);
|
|
})
|
|
},
|
|
"\t": {
|
|
"\n": new Array(maxCachedValues).fill(0).map((_, index) => {
|
|
return `
|
|
` + "\t".repeat(index);
|
|
}),
|
|
"\r": new Array(maxCachedValues).fill(0).map((_, index) => {
|
|
return "\r" + "\t".repeat(index);
|
|
}),
|
|
"\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
|
|
return `\r
|
|
` + "\t".repeat(index);
|
|
})
|
|
}
|
|
};
|
|
|
|
// node_modules/jsonc-parser/lib/esm/impl/parser.js
|
|
var ParseOptions;
|
|
(function(ParseOptions2) {
|
|
ParseOptions2.DEFAULT = {
|
|
allowTrailingComma: false
|
|
};
|
|
})(ParseOptions || (ParseOptions = {}));
|
|
function parse5(text, errors3 = [], options = ParseOptions.DEFAULT) {
|
|
let currentProperty = null;
|
|
let currentParent = [];
|
|
const previousParents = [];
|
|
function onValue(value) {
|
|
if (Array.isArray(currentParent)) {
|
|
currentParent.push(value);
|
|
} else if (currentProperty !== null) {
|
|
currentParent[currentProperty] = value;
|
|
}
|
|
}
|
|
const visitor = {
|
|
onObjectBegin: () => {
|
|
const object2 = {};
|
|
onValue(object2);
|
|
previousParents.push(currentParent);
|
|
currentParent = object2;
|
|
currentProperty = null;
|
|
},
|
|
onObjectProperty: (name) => {
|
|
currentProperty = name;
|
|
},
|
|
onObjectEnd: () => {
|
|
currentParent = previousParents.pop();
|
|
},
|
|
onArrayBegin: () => {
|
|
const array2 = [];
|
|
onValue(array2);
|
|
previousParents.push(currentParent);
|
|
currentParent = array2;
|
|
currentProperty = null;
|
|
},
|
|
onArrayEnd: () => {
|
|
currentParent = previousParents.pop();
|
|
},
|
|
onLiteralValue: onValue,
|
|
onError: (error48, offset, length) => {
|
|
errors3.push({ error: error48, offset, length });
|
|
}
|
|
};
|
|
visit(text, visitor, options);
|
|
return currentParent[0];
|
|
}
|
|
function visit(text, visitor, options = ParseOptions.DEFAULT) {
|
|
const _scanner = createScanner(text, false);
|
|
const _jsonPath = [];
|
|
let suppressedCallbacks = 0;
|
|
function toNoArgVisit(visitFunction) {
|
|
return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
|
|
}
|
|
function toOneArgVisit(visitFunction) {
|
|
return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
|
|
}
|
|
function toOneArgVisitWithPath(visitFunction) {
|
|
return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
|
|
}
|
|
function toBeginVisit(visitFunction) {
|
|
return visitFunction ? () => {
|
|
if (suppressedCallbacks > 0) {
|
|
suppressedCallbacks++;
|
|
} else {
|
|
let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
|
|
if (cbReturn === false) {
|
|
suppressedCallbacks = 1;
|
|
}
|
|
}
|
|
} : () => true;
|
|
}
|
|
function toEndVisit(visitFunction) {
|
|
return visitFunction ? () => {
|
|
if (suppressedCallbacks > 0) {
|
|
suppressedCallbacks--;
|
|
}
|
|
if (suppressedCallbacks === 0) {
|
|
visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
|
|
}
|
|
} : () => true;
|
|
}
|
|
const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
|
|
const disallowComments = options && options.disallowComments;
|
|
const allowTrailingComma = options && options.allowTrailingComma;
|
|
function scanNext() {
|
|
while (true) {
|
|
const token = _scanner.scan();
|
|
switch (_scanner.getTokenError()) {
|
|
case 4:
|
|
handleError(14);
|
|
break;
|
|
case 5:
|
|
handleError(15);
|
|
break;
|
|
case 3:
|
|
handleError(13);
|
|
break;
|
|
case 1:
|
|
if (!disallowComments) {
|
|
handleError(11);
|
|
}
|
|
break;
|
|
case 2:
|
|
handleError(12);
|
|
break;
|
|
case 6:
|
|
handleError(16);
|
|
break;
|
|
}
|
|
switch (token) {
|
|
case 12:
|
|
case 13:
|
|
if (disallowComments) {
|
|
handleError(10);
|
|
} else {
|
|
onComment();
|
|
}
|
|
break;
|
|
case 16:
|
|
handleError(1);
|
|
break;
|
|
case 15:
|
|
case 14:
|
|
break;
|
|
default:
|
|
return token;
|
|
}
|
|
}
|
|
}
|
|
function handleError(error48, skipUntilAfter = [], skipUntil = []) {
|
|
onError(error48);
|
|
if (skipUntilAfter.length + skipUntil.length > 0) {
|
|
let token = _scanner.getToken();
|
|
while (token !== 17) {
|
|
if (skipUntilAfter.indexOf(token) !== -1) {
|
|
scanNext();
|
|
break;
|
|
} else if (skipUntil.indexOf(token) !== -1) {
|
|
break;
|
|
}
|
|
token = scanNext();
|
|
}
|
|
}
|
|
}
|
|
function parseString(isValue) {
|
|
const value = _scanner.getTokenValue();
|
|
if (isValue) {
|
|
onLiteralValue(value);
|
|
} else {
|
|
onObjectProperty(value);
|
|
_jsonPath.push(value);
|
|
}
|
|
scanNext();
|
|
return true;
|
|
}
|
|
function parseLiteral() {
|
|
switch (_scanner.getToken()) {
|
|
case 11:
|
|
const tokenValue = _scanner.getTokenValue();
|
|
let value = Number(tokenValue);
|
|
if (isNaN(value)) {
|
|
handleError(2);
|
|
value = 0;
|
|
}
|
|
onLiteralValue(value);
|
|
break;
|
|
case 7:
|
|
onLiteralValue(null);
|
|
break;
|
|
case 8:
|
|
onLiteralValue(true);
|
|
break;
|
|
case 9:
|
|
onLiteralValue(false);
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
scanNext();
|
|
return true;
|
|
}
|
|
function parseProperty() {
|
|
if (_scanner.getToken() !== 10) {
|
|
handleError(3, [], [2, 5]);
|
|
return false;
|
|
}
|
|
parseString(false);
|
|
if (_scanner.getToken() === 6) {
|
|
onSeparator(":");
|
|
scanNext();
|
|
if (!parseValue()) {
|
|
handleError(4, [], [2, 5]);
|
|
}
|
|
} else {
|
|
handleError(5, [], [2, 5]);
|
|
}
|
|
_jsonPath.pop();
|
|
return true;
|
|
}
|
|
function parseObject() {
|
|
onObjectBegin();
|
|
scanNext();
|
|
let needsComma = false;
|
|
while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
|
|
if (_scanner.getToken() === 5) {
|
|
if (!needsComma) {
|
|
handleError(4, [], []);
|
|
}
|
|
onSeparator(",");
|
|
scanNext();
|
|
if (_scanner.getToken() === 2 && allowTrailingComma) {
|
|
break;
|
|
}
|
|
} else if (needsComma) {
|
|
handleError(6, [], []);
|
|
}
|
|
if (!parseProperty()) {
|
|
handleError(4, [], [2, 5]);
|
|
}
|
|
needsComma = true;
|
|
}
|
|
onObjectEnd();
|
|
if (_scanner.getToken() !== 2) {
|
|
handleError(7, [2], []);
|
|
} else {
|
|
scanNext();
|
|
}
|
|
return true;
|
|
}
|
|
function parseArray() {
|
|
onArrayBegin();
|
|
scanNext();
|
|
let isFirstElement = true;
|
|
let needsComma = false;
|
|
while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
|
|
if (_scanner.getToken() === 5) {
|
|
if (!needsComma) {
|
|
handleError(4, [], []);
|
|
}
|
|
onSeparator(",");
|
|
scanNext();
|
|
if (_scanner.getToken() === 4 && allowTrailingComma) {
|
|
break;
|
|
}
|
|
} else if (needsComma) {
|
|
handleError(6, [], []);
|
|
}
|
|
if (isFirstElement) {
|
|
_jsonPath.push(0);
|
|
isFirstElement = false;
|
|
} else {
|
|
_jsonPath[_jsonPath.length - 1]++;
|
|
}
|
|
if (!parseValue()) {
|
|
handleError(4, [], [4, 5]);
|
|
}
|
|
needsComma = true;
|
|
}
|
|
onArrayEnd();
|
|
if (!isFirstElement) {
|
|
_jsonPath.pop();
|
|
}
|
|
if (_scanner.getToken() !== 4) {
|
|
handleError(8, [4], []);
|
|
} else {
|
|
scanNext();
|
|
}
|
|
return true;
|
|
}
|
|
function parseValue() {
|
|
switch (_scanner.getToken()) {
|
|
case 3:
|
|
return parseArray();
|
|
case 1:
|
|
return parseObject();
|
|
case 10:
|
|
return parseString(true);
|
|
default:
|
|
return parseLiteral();
|
|
}
|
|
}
|
|
scanNext();
|
|
if (_scanner.getToken() === 17) {
|
|
if (options.allowEmptyContent) {
|
|
return true;
|
|
}
|
|
handleError(4, [], []);
|
|
return false;
|
|
}
|
|
if (!parseValue()) {
|
|
handleError(4, [], []);
|
|
return false;
|
|
}
|
|
if (_scanner.getToken() !== 17) {
|
|
handleError(9, [], []);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// node_modules/jsonc-parser/lib/esm/main.js
|
|
var ScanError;
|
|
(function(ScanError2) {
|
|
ScanError2[ScanError2["None"] = 0] = "None";
|
|
ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
|
|
ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
|
|
ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
|
|
ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
|
|
ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
|
|
ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
|
|
})(ScanError || (ScanError = {}));
|
|
var SyntaxKind;
|
|
(function(SyntaxKind2) {
|
|
SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
|
|
SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
|
|
SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
|
|
SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
|
|
SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
|
|
SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
|
|
SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
|
|
SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
|
|
SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
|
|
SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
|
|
SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
|
|
SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
|
|
SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
|
|
SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
|
|
SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
|
|
SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
|
|
SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
|
|
})(SyntaxKind || (SyntaxKind = {}));
|
|
var parse6 = parse5;
|
|
var ParseErrorCode;
|
|
(function(ParseErrorCode2) {
|
|
ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
|
|
ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
|
|
ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
|
|
ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
|
|
ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
|
|
ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
|
|
ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
|
|
ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
|
|
ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
|
|
ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
|
|
ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
|
|
ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
|
|
ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
|
|
ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
|
|
ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
|
|
ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
|
|
})(ParseErrorCode || (ParseErrorCode = {}));
|
|
function printParseErrorCode(code) {
|
|
switch (code) {
|
|
case 1:
|
|
return "InvalidSymbol";
|
|
case 2:
|
|
return "InvalidNumberFormat";
|
|
case 3:
|
|
return "PropertyNameExpected";
|
|
case 4:
|
|
return "ValueExpected";
|
|
case 5:
|
|
return "ColonExpected";
|
|
case 6:
|
|
return "CommaExpected";
|
|
case 7:
|
|
return "CloseBraceExpected";
|
|
case 8:
|
|
return "CloseBracketExpected";
|
|
case 9:
|
|
return "EndOfFileExpected";
|
|
case 10:
|
|
return "InvalidCommentToken";
|
|
case 11:
|
|
return "UnexpectedEndOfComment";
|
|
case 12:
|
|
return "UnexpectedEndOfString";
|
|
case 13:
|
|
return "UnexpectedEndOfNumber";
|
|
case 14:
|
|
return "InvalidUnicode";
|
|
case 15:
|
|
return "InvalidEscapeCharacter";
|
|
case 16:
|
|
return "InvalidCharacter";
|
|
}
|
|
return "<unknown ParseErrorCode>";
|
|
}
|
|
|
|
// src/shared/jsonc-parser.ts
|
|
function parseJsonc(content) {
|
|
const errors3 = [];
|
|
const result = parse6(content, errors3, {
|
|
allowTrailingComma: true,
|
|
disallowComments: false
|
|
});
|
|
if (errors3.length > 0) {
|
|
const errorMessages = errors3.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join(", ");
|
|
throw new SyntaxError(`JSONC parse error: ${errorMessages}`);
|
|
}
|
|
return result;
|
|
}
|
|
function detectConfigFile(basePath) {
|
|
const jsoncPath = `${basePath}.jsonc`;
|
|
const jsonPath = `${basePath}.json`;
|
|
if (existsSync(jsoncPath)) {
|
|
return { format: "jsonc", path: jsoncPath };
|
|
}
|
|
if (existsSync(jsonPath)) {
|
|
return { format: "json", path: jsonPath };
|
|
}
|
|
return { format: "none", path: jsonPath };
|
|
}
|
|
// src/shared/opencode-config-dir.ts
|
|
import { existsSync as existsSync2 } from "fs";
|
|
import { homedir } from "os";
|
|
import { join as join2, resolve } from "path";
|
|
var TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
|
|
var TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
|
|
function isDevBuild(version2) {
|
|
if (!version2)
|
|
return false;
|
|
return version2.includes("-dev") || version2.includes(".dev");
|
|
}
|
|
function getTauriConfigDir(identifier) {
|
|
const platform = process.platform;
|
|
switch (platform) {
|
|
case "darwin":
|
|
return join2(homedir(), "Library", "Application Support", identifier);
|
|
case "win32": {
|
|
const appData = process.env.APPDATA || join2(homedir(), "AppData", "Roaming");
|
|
return join2(appData, identifier);
|
|
}
|
|
default: {
|
|
const xdgConfig = process.env.XDG_CONFIG_HOME || join2(homedir(), ".config");
|
|
return join2(xdgConfig, identifier);
|
|
}
|
|
}
|
|
}
|
|
function getCliConfigDir() {
|
|
const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
|
|
if (envConfigDir) {
|
|
return resolve(envConfigDir);
|
|
}
|
|
const xdgConfig = process.env.XDG_CONFIG_HOME || join2(homedir(), ".config");
|
|
return join2(xdgConfig, "opencode");
|
|
}
|
|
function getOpenCodeConfigDir(options) {
|
|
const { binary, version: version2, checkExisting = true } = options;
|
|
if (binary === "opencode") {
|
|
return getCliConfigDir();
|
|
}
|
|
const identifier = isDevBuild(version2) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER;
|
|
const tauriDir = getTauriConfigDir(identifier);
|
|
if (checkExisting) {
|
|
const legacyDir = getCliConfigDir();
|
|
const legacyConfig = join2(legacyDir, "opencode.json");
|
|
const legacyConfigC = join2(legacyDir, "opencode.jsonc");
|
|
if (existsSync2(legacyConfig) || existsSync2(legacyConfigC)) {
|
|
return legacyDir;
|
|
}
|
|
}
|
|
return tauriDir;
|
|
}
|
|
// src/shared/tmux/tmux-utils/environment.ts
|
|
function isInsideTmuxEnvironment(environment) {
|
|
return Boolean(environment.TMUX);
|
|
}
|
|
function isInsideTmux() {
|
|
return isInsideTmuxEnvironment(process.env);
|
|
}
|
|
function getCurrentPaneId() {
|
|
return process.env.TMUX_PANE;
|
|
}
|
|
// src/shared/tmux/tmux-utils/server-health.ts
|
|
var serverAvailable = null;
|
|
var serverCheckUrl = null;
|
|
function delay(milliseconds) {
|
|
return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
|
|
}
|
|
async function isServerRunning(serverUrl) {
|
|
if (serverCheckUrl === serverUrl && serverAvailable === true) {
|
|
return true;
|
|
}
|
|
const healthUrl = new URL("/global/health", serverUrl).toString();
|
|
const timeoutMs = 3000;
|
|
const maxAttempts = 2;
|
|
for (let attempt = 1;attempt <= maxAttempts; attempt++) {
|
|
const controller = new AbortController;
|
|
const timeout = setTimeout(() => controller.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetch(healthUrl, {
|
|
signal: controller.signal
|
|
}).catch(() => null);
|
|
clearTimeout(timeout);
|
|
if (response?.ok) {
|
|
serverCheckUrl = serverUrl;
|
|
serverAvailable = true;
|
|
return true;
|
|
}
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
if (attempt < maxAttempts) {
|
|
await delay(250);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
// src/tools/interactive-bash/tmux-path-resolver.ts
|
|
var {spawn } = globalThis.Bun;
|
|
var tmuxPath = null;
|
|
var initPromise = null;
|
|
async function findTmuxPath() {
|
|
const isWindows = process.platform === "win32";
|
|
const cmd = isWindows ? "where" : "which";
|
|
try {
|
|
const proc = spawn([cmd, "tmux"], {
|
|
stdout: "pipe",
|
|
stderr: "pipe"
|
|
});
|
|
const exitCode = await proc.exited;
|
|
if (exitCode !== 0) {
|
|
return null;
|
|
}
|
|
const stdout = await new Response(proc.stdout).text();
|
|
const path2 = stdout.trim().split(`
|
|
`)[0];
|
|
if (!path2) {
|
|
return null;
|
|
}
|
|
const verifyProc = spawn([path2, "-V"], {
|
|
stdout: "pipe",
|
|
stderr: "pipe"
|
|
});
|
|
const verifyExitCode = await verifyProc.exited;
|
|
if (verifyExitCode !== 0) {
|
|
return null;
|
|
}
|
|
return path2;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
async function getTmuxPath() {
|
|
if (tmuxPath !== null) {
|
|
return tmuxPath;
|
|
}
|
|
if (initPromise) {
|
|
return initPromise;
|
|
}
|
|
initPromise = (async () => {
|
|
const path2 = await findTmuxPath();
|
|
tmuxPath = path2;
|
|
return path2;
|
|
})();
|
|
return initPromise;
|
|
}
|
|
function getCachedTmuxPath() {
|
|
return tmuxPath;
|
|
}
|
|
function startBackgroundCheck() {
|
|
if (!initPromise) {
|
|
initPromise = getTmuxPath();
|
|
initPromise.catch(() => {});
|
|
}
|
|
}
|
|
// src/shared/tmux/tmux-utils/pane-spawn.ts
|
|
var {spawn: spawn2 } = globalThis.Bun;
|
|
|
|
// src/shared/shell-env.ts
|
|
function shellEscapeForDoubleQuotedCommand(value) {
|
|
return value.replace(/\\/g, "\\\\").replace(/\$/g, "\\$").replace(/`/g, "\\`").replace(/"/g, "\\\"").replace(/;/g, "\\;").replace(/\|/g, "\\|").replace(/&/g, "\\&").replace(/#/g, "\\#").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
|
|
}
|
|
|
|
// src/shared/tmux/tmux-utils/pane-spawn.ts
|
|
async function spawnTmuxPane(sessionId, description, config2, serverUrl, targetPaneId, splitDirection = "-h") {
|
|
const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
|
|
log2("[spawnTmuxPane] called", {
|
|
sessionId,
|
|
description,
|
|
serverUrl,
|
|
configEnabled: config2.enabled,
|
|
targetPaneId,
|
|
splitDirection
|
|
});
|
|
if (!config2.enabled) {
|
|
log2("[spawnTmuxPane] SKIP: config.enabled is false");
|
|
return { success: false };
|
|
}
|
|
if (!isInsideTmux()) {
|
|
log2("[spawnTmuxPane] SKIP: not inside tmux", { TMUX: process.env.TMUX });
|
|
return { success: false };
|
|
}
|
|
const serverRunning = await isServerRunning(serverUrl);
|
|
if (!serverRunning) {
|
|
log2("[spawnTmuxPane] SKIP: server not running", { serverUrl });
|
|
return { success: false };
|
|
}
|
|
const tmux = await getTmuxPath();
|
|
if (!tmux) {
|
|
log2("[spawnTmuxPane] SKIP: tmux not found");
|
|
return { success: false };
|
|
}
|
|
log2("[spawnTmuxPane] all checks passed, spawning...");
|
|
const shell = process.env.SHELL || "/bin/sh";
|
|
const escapedUrl = shellEscapeForDoubleQuotedCommand(serverUrl);
|
|
const opencodeCmd = `${shell} -c "opencode attach ${escapedUrl} --session ${sessionId}"`;
|
|
const args = [
|
|
"split-window",
|
|
splitDirection,
|
|
"-d",
|
|
"-P",
|
|
"-F",
|
|
"#{pane_id}",
|
|
...targetPaneId ? ["-t", targetPaneId] : [],
|
|
opencodeCmd
|
|
];
|
|
const proc = spawn2([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
|
|
const exitCode = await proc.exited;
|
|
const stdout = await new Response(proc.stdout).text();
|
|
const paneId = stdout.trim();
|
|
if (exitCode !== 0 || !paneId) {
|
|
return { success: false };
|
|
}
|
|
const title = `omo-subagent-${description.slice(0, 20)}`;
|
|
const titleProc = spawn2([tmux, "select-pane", "-t", paneId, "-T", title], {
|
|
stdout: "ignore",
|
|
stderr: "pipe"
|
|
});
|
|
const stderrPromise = new Response(titleProc.stderr).text().catch(() => "");
|
|
const titleExitCode = await titleProc.exited;
|
|
if (titleExitCode !== 0) {
|
|
const titleStderr = await stderrPromise;
|
|
log2("[spawnTmuxPane] WARNING: failed to set pane title", {
|
|
paneId,
|
|
title,
|
|
exitCode: titleExitCode,
|
|
stderr: titleStderr.trim()
|
|
});
|
|
}
|
|
return { success: true, paneId };
|
|
}
|
|
// src/shared/tmux/tmux-utils/pane-close.ts
|
|
var {spawn: spawn3 } = globalThis.Bun;
|
|
function delay2(milliseconds) {
|
|
return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
|
|
}
|
|
async function closeTmuxPane(paneId) {
|
|
const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
|
|
if (!isInsideTmux()) {
|
|
log2("[closeTmuxPane] SKIP: not inside tmux");
|
|
return false;
|
|
}
|
|
const tmux = await getTmuxPath();
|
|
if (!tmux) {
|
|
log2("[closeTmuxPane] SKIP: tmux not found");
|
|
return false;
|
|
}
|
|
log2("[closeTmuxPane] sending Ctrl+C for graceful shutdown", { paneId });
|
|
const ctrlCProc = spawn3([tmux, "send-keys", "-t", paneId, "C-c"], {
|
|
stdout: "pipe",
|
|
stderr: "pipe"
|
|
});
|
|
await ctrlCProc.exited;
|
|
await delay2(250);
|
|
log2("[closeTmuxPane] killing pane", { paneId });
|
|
const proc = spawn3([tmux, "kill-pane", "-t", paneId], {
|
|
stdout: "pipe",
|
|
stderr: "pipe"
|
|
});
|
|
const exitCode = await proc.exited;
|
|
const stderr = await new Response(proc.stderr).text();
|
|
if (exitCode !== 0) {
|
|
log2("[closeTmuxPane] FAILED", { paneId, exitCode, stderr: stderr.trim() });
|
|
} else {
|
|
log2("[closeTmuxPane] SUCCESS", { paneId });
|
|
}
|
|
return exitCode === 0;
|
|
}
|
|
// src/shared/tmux/tmux-utils/pane-replace.ts
|
|
var {spawn: spawn4 } = globalThis.Bun;
|
|
async function replaceTmuxPane(paneId, sessionId, description, config2, serverUrl) {
|
|
const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
|
|
log2("[replaceTmuxPane] called", { paneId, sessionId, description });
|
|
if (!config2.enabled) {
|
|
return { success: false };
|
|
}
|
|
if (!isInsideTmux()) {
|
|
return { success: false };
|
|
}
|
|
const tmux = await getTmuxPath();
|
|
if (!tmux) {
|
|
return { success: false };
|
|
}
|
|
log2("[replaceTmuxPane] sending Ctrl+C for graceful shutdown", { paneId });
|
|
const ctrlCProc = spawn4([tmux, "send-keys", "-t", paneId, "C-c"], {
|
|
stdout: "pipe",
|
|
stderr: "pipe"
|
|
});
|
|
await ctrlCProc.exited;
|
|
const shell = process.env.SHELL || "/bin/sh";
|
|
const escapedUrl = shellEscapeForDoubleQuotedCommand(serverUrl);
|
|
const opencodeCmd = `${shell} -c "opencode attach ${escapedUrl} --session ${sessionId}"`;
|
|
const proc = spawn4([tmux, "respawn-pane", "-k", "-t", paneId, opencodeCmd], {
|
|
stdout: "pipe",
|
|
stderr: "pipe"
|
|
});
|
|
const exitCode = await proc.exited;
|
|
if (exitCode !== 0) {
|
|
const stderr = await new Response(proc.stderr).text();
|
|
log2("[replaceTmuxPane] FAILED", { paneId, exitCode, stderr: stderr.trim() });
|
|
return { success: false };
|
|
}
|
|
const title = `omo-subagent-${description.slice(0, 20)}`;
|
|
const titleProc = spawn4([tmux, "select-pane", "-t", paneId, "-T", title], {
|
|
stdout: "ignore",
|
|
stderr: "pipe"
|
|
});
|
|
const stderrPromise = new Response(titleProc.stderr).text().catch(() => "");
|
|
const titleExitCode = await titleProc.exited;
|
|
if (titleExitCode !== 0) {
|
|
const titleStderr = await stderrPromise;
|
|
log2("[replaceTmuxPane] WARNING: failed to set pane title", {
|
|
paneId,
|
|
title,
|
|
exitCode: titleExitCode,
|
|
stderr: titleStderr.trim()
|
|
});
|
|
}
|
|
log2("[replaceTmuxPane] SUCCESS", { paneId, sessionId });
|
|
return { success: true, paneId };
|
|
}
|
|
// src/shared/tmux/tmux-utils/layout.ts
|
|
var {spawn: spawn5 } = globalThis.Bun;
|
|
function clamp(value, min, max) {
|
|
return Math.max(min, Math.min(max, value));
|
|
}
|
|
function calculateMainPaneWidth(windowWidth, options) {
|
|
const dividerWidth = 1;
|
|
const sizePercent = clamp(options?.mainPaneSize ?? 50, 20, 80);
|
|
const minMainPaneWidth = options?.mainPaneMinWidth ?? 0;
|
|
const minAgentPaneWidth = options?.agentPaneMinWidth ?? 0;
|
|
const desiredMainPaneWidth = Math.floor((windowWidth - dividerWidth) * (sizePercent / 100));
|
|
const maxMainPaneWidth = Math.max(0, windowWidth - dividerWidth - minAgentPaneWidth);
|
|
return clamp(Math.max(desiredMainPaneWidth, minMainPaneWidth), 0, maxMainPaneWidth);
|
|
}
|
|
async function applyLayout(tmux, layout, mainPaneSize, deps) {
|
|
const spawnCommand = deps?.spawnCommand ?? spawn5;
|
|
const layoutProc = spawnCommand([tmux, "select-layout", layout], {
|
|
stdout: "ignore",
|
|
stderr: "ignore"
|
|
});
|
|
await layoutProc.exited;
|
|
if (layout.startsWith("main-")) {
|
|
const dimension = layout === "main-horizontal" ? "main-pane-height" : "main-pane-width";
|
|
const sizeProc = spawnCommand([tmux, "set-window-option", dimension, `${mainPaneSize}%`], { stdout: "ignore", stderr: "ignore" });
|
|
await sizeProc.exited;
|
|
}
|
|
}
|
|
async function enforceMainPaneWidth(mainPaneId, windowWidth, mainPaneSizeOrOptions) {
|
|
const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
|
|
const tmux = await getTmuxPath();
|
|
if (!tmux)
|
|
return;
|
|
const options = typeof mainPaneSizeOrOptions === "number" ? { mainPaneSize: mainPaneSizeOrOptions } : mainPaneSizeOrOptions ?? {};
|
|
const mainWidth = calculateMainPaneWidth(windowWidth, options);
|
|
const proc = spawn5([tmux, "resize-pane", "-t", mainPaneId, "-x", String(mainWidth)], {
|
|
stdout: "ignore",
|
|
stderr: "ignore"
|
|
});
|
|
await proc.exited;
|
|
log2("[enforceMainPaneWidth] main pane resized", {
|
|
mainPaneId,
|
|
mainWidth,
|
|
windowWidth,
|
|
mainPaneSize: options?.mainPaneSize,
|
|
mainPaneMinWidth: options?.mainPaneMinWidth,
|
|
agentPaneMinWidth: options?.agentPaneMinWidth
|
|
});
|
|
}
|
|
// src/shared/tmux/constants.ts
|
|
var POLL_INTERVAL_BACKGROUND_MS = 2000;
|
|
var SESSION_TIMEOUT_MS = 10 * 60 * 1000;
|
|
var SESSION_MISSING_GRACE_MS = 6000;
|
|
var SESSION_READY_POLL_INTERVAL_MS = 500;
|
|
var SESSION_READY_TIMEOUT_MS = 1e4;
|
|
// src/features/tmux-subagent/pane-state-querier.ts
|
|
var {spawn: spawn6 } = globalThis.Bun;
|
|
|
|
// src/features/tmux-subagent/pane-state-parser.ts
|
|
var MANDATORY_PANE_FIELD_COUNT = 8;
|
|
function parsePaneStateOutput(stdout) {
|
|
const lines = stdout.split(`
|
|
`).map((line) => line.replace(/\r$/, "")).filter((line) => line.length > 0);
|
|
if (lines.length === 0)
|
|
return null;
|
|
const parsedPaneLines = lines.map(parsePaneLine).filter((parsedPaneLine) => parsedPaneLine !== null);
|
|
if (parsedPaneLines.length === 0)
|
|
return null;
|
|
const latestPaneLine = parsedPaneLines[parsedPaneLines.length - 1];
|
|
if (!latestPaneLine)
|
|
return null;
|
|
return {
|
|
windowWidth: latestPaneLine.windowWidth,
|
|
windowHeight: latestPaneLine.windowHeight,
|
|
panes: parsedPaneLines.map(({ pane }) => pane)
|
|
};
|
|
}
|
|
function parsePaneLine(line) {
|
|
const fields = line.split("\t");
|
|
const mandatoryFields = getMandatoryPaneFields(fields);
|
|
if (!mandatoryFields)
|
|
return null;
|
|
const [paneId, widthString, heightString, leftString, topString, activeString, windowWidthString, windowHeightString] = mandatoryFields;
|
|
const width = parseInteger(widthString);
|
|
const height = parseInteger(heightString);
|
|
const left = parseInteger(leftString);
|
|
const top = parseInteger(topString);
|
|
const isActive = parseActiveValue(activeString);
|
|
const windowWidth = parseInteger(windowWidthString);
|
|
const windowHeight = parseInteger(windowHeightString);
|
|
if (width === null || height === null || left === null || top === null || isActive === null || windowWidth === null || windowHeight === null) {
|
|
return null;
|
|
}
|
|
return {
|
|
pane: {
|
|
paneId,
|
|
width,
|
|
height,
|
|
left,
|
|
top,
|
|
title: fields.slice(MANDATORY_PANE_FIELD_COUNT).join("\t"),
|
|
isActive
|
|
},
|
|
windowWidth,
|
|
windowHeight
|
|
};
|
|
}
|
|
function getMandatoryPaneFields(fields) {
|
|
if (fields.length < MANDATORY_PANE_FIELD_COUNT)
|
|
return null;
|
|
const [paneId, widthString, heightString, leftString, topString, activeString, windowWidthString, windowHeightString] = fields;
|
|
if (paneId === undefined || widthString === undefined || heightString === undefined || leftString === undefined || topString === undefined || activeString === undefined || windowWidthString === undefined || windowHeightString === undefined) {
|
|
return null;
|
|
}
|
|
return [
|
|
paneId,
|
|
widthString,
|
|
heightString,
|
|
leftString,
|
|
topString,
|
|
activeString,
|
|
windowWidthString,
|
|
windowHeightString
|
|
];
|
|
}
|
|
function parseInteger(value) {
|
|
if (!/^\d+$/.test(value))
|
|
return null;
|
|
const parsedValue = Number.parseInt(value, 10);
|
|
return Number.isNaN(parsedValue) ? null : parsedValue;
|
|
}
|
|
function parseActiveValue(value) {
|
|
if (value === "1")
|
|
return true;
|
|
if (value === "0")
|
|
return false;
|
|
return null;
|
|
}
|
|
|
|
// src/features/tmux-subagent/pane-state-querier.ts
|
|
async function queryWindowState(sourcePaneId) {
|
|
const tmux2 = await getTmuxPath();
|
|
if (!tmux2)
|
|
return null;
|
|
const proc = spawn6([
|
|
tmux2,
|
|
"list-panes",
|
|
"-t",
|
|
sourcePaneId,
|
|
"-F",
|
|
"#{pane_id}\t#{pane_width}\t#{pane_height}\t#{pane_left}\t#{pane_top}\t#{pane_active}\t#{window_width}\t#{window_height}\t#{pane_title}"
|
|
], { stdout: "pipe", stderr: "pipe" });
|
|
const exitCode = await proc.exited;
|
|
const stdout = await new Response(proc.stdout).text();
|
|
if (exitCode !== 0) {
|
|
log("[pane-state-querier] list-panes failed", { exitCode });
|
|
return null;
|
|
}
|
|
const parsedPaneState = parsePaneStateOutput(stdout);
|
|
if (!parsedPaneState) {
|
|
log("[pane-state-querier] failed to parse pane state output", {
|
|
sourcePaneId
|
|
});
|
|
return null;
|
|
}
|
|
const { panes } = parsedPaneState;
|
|
const windowWidth = parsedPaneState.windowWidth;
|
|
const windowHeight = parsedPaneState.windowHeight;
|
|
panes.sort((a, b) => a.left - b.left || a.top - b.top);
|
|
const mainPane = panes.reduce((selected, pane) => {
|
|
if (!selected)
|
|
return pane;
|
|
if (pane.left !== selected.left) {
|
|
return pane.left < selected.left ? pane : selected;
|
|
}
|
|
if (pane.width !== selected.width) {
|
|
return pane.width > selected.width ? pane : selected;
|
|
}
|
|
if (pane.top !== selected.top) {
|
|
return pane.top < selected.top ? pane : selected;
|
|
}
|
|
return pane.paneId === sourcePaneId ? pane : selected;
|
|
}, null);
|
|
if (!mainPane) {
|
|
log("[pane-state-querier] CRITICAL: failed to determine main pane", {
|
|
sourcePaneId,
|
|
availablePanes: panes.map((p) => p.paneId)
|
|
});
|
|
return null;
|
|
}
|
|
const agentPanes = panes.filter((p) => p.paneId !== mainPane.paneId);
|
|
log("[pane-state-querier] window state", {
|
|
windowWidth,
|
|
windowHeight,
|
|
mainPane: mainPane.paneId,
|
|
agentPaneCount: agentPanes.length
|
|
});
|
|
return { windowWidth, windowHeight, mainPane, agentPanes };
|
|
}
|
|
|
|
// src/features/tmux-subagent/types.ts
|
|
var MIN_PANE_WIDTH = 52;
|
|
var MIN_PANE_HEIGHT = 11;
|
|
|
|
// src/features/tmux-subagent/tmux-grid-constants.ts
|
|
var MAIN_PANE_RATIO = 0.5;
|
|
var DEFAULT_MAIN_PANE_SIZE = MAIN_PANE_RATIO * 100;
|
|
var MAX_COLS = 2;
|
|
var MAX_ROWS = 3;
|
|
var MAX_GRID_SIZE = 4;
|
|
var DIVIDER_SIZE = 1;
|
|
var MIN_SPLIT_WIDTH = 2 * MIN_PANE_WIDTH + DIVIDER_SIZE;
|
|
var MIN_SPLIT_HEIGHT = 2 * MIN_PANE_HEIGHT + DIVIDER_SIZE;
|
|
function clamp2(value, min, max) {
|
|
return Math.max(min, Math.min(max, value));
|
|
}
|
|
function getMainPaneSizePercent(config2) {
|
|
return clamp2(config2?.mainPaneSize ?? DEFAULT_MAIN_PANE_SIZE, 20, 80);
|
|
}
|
|
function computeMainPaneWidth(windowWidth, config2) {
|
|
const safeWindowWidth = Math.max(0, windowWidth);
|
|
if (!config2) {
|
|
return Math.floor(safeWindowWidth * MAIN_PANE_RATIO);
|
|
}
|
|
const dividerWidth = DIVIDER_SIZE;
|
|
const minMainPaneWidth = config2?.mainPaneMinWidth ?? Math.floor(safeWindowWidth * MAIN_PANE_RATIO);
|
|
const minAgentPaneWidth = config2?.agentPaneWidth ?? MIN_PANE_WIDTH;
|
|
const percentageMainPaneWidth = Math.floor((safeWindowWidth - dividerWidth) * (getMainPaneSizePercent(config2) / 100));
|
|
const maxMainPaneWidth = Math.max(0, safeWindowWidth - dividerWidth - minAgentPaneWidth);
|
|
return clamp2(Math.max(percentageMainPaneWidth, minMainPaneWidth), 0, maxMainPaneWidth);
|
|
}
|
|
function computeAgentAreaWidth(windowWidth, config2) {
|
|
const safeWindowWidth = Math.max(0, windowWidth);
|
|
if (!config2) {
|
|
return Math.floor(safeWindowWidth * (1 - MAIN_PANE_RATIO));
|
|
}
|
|
const mainPaneWidth = computeMainPaneWidth(safeWindowWidth, config2);
|
|
return Math.max(0, safeWindowWidth - DIVIDER_SIZE - mainPaneWidth);
|
|
}
|
|
|
|
// src/features/tmux-subagent/grid-planning.ts
|
|
function resolveMinPaneWidth(options) {
|
|
if (typeof options === "number") {
|
|
return Math.max(1, options);
|
|
}
|
|
if (options && typeof options.agentPaneWidth === "number") {
|
|
return Math.max(1, options.agentPaneWidth);
|
|
}
|
|
return MIN_PANE_WIDTH;
|
|
}
|
|
function resolveAgentAreaWidth(windowWidth, options) {
|
|
if (typeof options === "number") {
|
|
return computeAgentAreaWidth(windowWidth);
|
|
}
|
|
return computeAgentAreaWidth(windowWidth, options);
|
|
}
|
|
function calculateCapacity(windowWidth, windowHeight, options, mainPaneWidth) {
|
|
const availableWidth = typeof mainPaneWidth === "number" ? Math.max(0, windowWidth - mainPaneWidth - DIVIDER_SIZE) : resolveAgentAreaWidth(windowWidth, options);
|
|
const minPaneWidth = resolveMinPaneWidth(options);
|
|
const cols = Math.min(MAX_GRID_SIZE, Math.max(0, Math.floor((availableWidth + DIVIDER_SIZE) / (minPaneWidth + DIVIDER_SIZE))));
|
|
const rows = Math.min(MAX_GRID_SIZE, Math.max(0, Math.floor((windowHeight + DIVIDER_SIZE) / (MIN_PANE_HEIGHT + DIVIDER_SIZE))));
|
|
return { cols, rows, total: cols * rows };
|
|
}
|
|
function computeGridPlan(windowWidth, windowHeight, paneCount, options, mainPaneWidth) {
|
|
const capacity = calculateCapacity(windowWidth, windowHeight, options, mainPaneWidth);
|
|
const { cols: maxCols, rows: maxRows } = capacity;
|
|
if (maxCols === 0 || maxRows === 0 || paneCount === 0) {
|
|
return { cols: 1, rows: 1, slotWidth: 0, slotHeight: 0 };
|
|
}
|
|
let bestCols = 1;
|
|
let bestRows = 1;
|
|
let bestArea = Number.POSITIVE_INFINITY;
|
|
for (let rows = 1;rows <= maxRows; rows++) {
|
|
for (let cols = 1;cols <= maxCols; cols++) {
|
|
if (cols * rows < paneCount)
|
|
continue;
|
|
const area = cols * rows;
|
|
if (area < bestArea || area === bestArea && rows < bestRows) {
|
|
bestCols = cols;
|
|
bestRows = rows;
|
|
bestArea = area;
|
|
}
|
|
}
|
|
}
|
|
const availableWidth = typeof mainPaneWidth === "number" ? Math.max(0, windowWidth - mainPaneWidth - DIVIDER_SIZE) : resolveAgentAreaWidth(windowWidth, options);
|
|
const slotWidth = Math.floor(availableWidth / bestCols);
|
|
const slotHeight = Math.floor(windowHeight / bestRows);
|
|
return { cols: bestCols, rows: bestRows, slotWidth, slotHeight };
|
|
}
|
|
function mapPaneToSlot(pane, plan, mainPaneWidth) {
|
|
const rightAreaX = mainPaneWidth;
|
|
const relativeX = Math.max(0, pane.left - rightAreaX);
|
|
const relativeY = pane.top;
|
|
const col = plan.slotWidth > 0 ? Math.min(plan.cols - 1, Math.floor(relativeX / plan.slotWidth)) : 0;
|
|
const row = plan.slotHeight > 0 ? Math.min(plan.rows - 1, Math.floor(relativeY / plan.slotHeight)) : 0;
|
|
return { row, col };
|
|
}
|
|
// src/features/tmux-subagent/pane-split-availability.ts
|
|
function getMinSplitWidth(minPaneWidth) {
|
|
const width = Math.max(1, minPaneWidth ?? MIN_PANE_WIDTH);
|
|
return 2 * width + DIVIDER_SIZE;
|
|
}
|
|
function getColumnCount(paneCount) {
|
|
if (paneCount <= 0)
|
|
return 1;
|
|
return Math.min(MAX_COLS, Math.max(1, Math.ceil(paneCount / MAX_ROWS)));
|
|
}
|
|
function getColumnWidth(agentAreaWidth, paneCount) {
|
|
const cols = getColumnCount(paneCount);
|
|
const dividersWidth = (cols - 1) * DIVIDER_SIZE;
|
|
return Math.floor((agentAreaWidth - dividersWidth) / cols);
|
|
}
|
|
function isSplittableAtCount(agentAreaWidth, paneCount, minPaneWidth) {
|
|
const columnWidth = getColumnWidth(agentAreaWidth, paneCount);
|
|
return columnWidth >= getMinSplitWidth(minPaneWidth);
|
|
}
|
|
function findMinimalEvictions(agentAreaWidth, currentCount, minPaneWidth) {
|
|
for (let k = 1;k <= currentCount; k++) {
|
|
if (isSplittableAtCount(agentAreaWidth, currentCount - k, minPaneWidth)) {
|
|
return k;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function canSplitPane(pane, direction, minPaneWidth) {
|
|
if (direction === "-h") {
|
|
return pane.width >= getMinSplitWidth(minPaneWidth);
|
|
}
|
|
return pane.height >= MIN_SPLIT_HEIGHT;
|
|
}
|
|
// src/features/tmux-subagent/spawn-target-finder.ts
|
|
function isStrictMainVertical(config2) {
|
|
return config2.layout === "main-vertical";
|
|
}
|
|
function isStrictMainHorizontal(config2) {
|
|
return config2.layout === "main-horizontal";
|
|
}
|
|
function isStrictMainLayout(config2) {
|
|
return isStrictMainVertical(config2) || isStrictMainHorizontal(config2);
|
|
}
|
|
function getInitialSplitDirection(config2) {
|
|
return isStrictMainHorizontal(config2) ? "-v" : "-h";
|
|
}
|
|
function getStrictFollowupSplitDirection(config2) {
|
|
return isStrictMainHorizontal(config2) ? "-h" : "-v";
|
|
}
|
|
function sortPanesForStrictLayout(panes, config2) {
|
|
if (isStrictMainHorizontal(config2)) {
|
|
return [...panes].sort((a, b) => a.left - b.left || a.top - b.top);
|
|
}
|
|
return [...panes].sort((a, b) => a.top - b.top || a.left - b.left);
|
|
}
|
|
function buildOccupancy(agentPanes, plan, mainPaneWidth) {
|
|
const occupancy = new Map;
|
|
for (const pane of agentPanes) {
|
|
const slot = mapPaneToSlot(pane, plan, mainPaneWidth);
|
|
occupancy.set(`${slot.row}:${slot.col}`, pane);
|
|
}
|
|
return occupancy;
|
|
}
|
|
function findFirstEmptySlot(occupancy, plan) {
|
|
for (let row = 0;row < plan.rows; row++) {
|
|
for (let col = 0;col < plan.cols; col++) {
|
|
if (!occupancy.has(`${row}:${col}`)) {
|
|
return { row, col };
|
|
}
|
|
}
|
|
}
|
|
return { row: plan.rows - 1, col: plan.cols - 1 };
|
|
}
|
|
function findSplittableTarget(state, config2, _preferredDirection) {
|
|
if (!state.mainPane)
|
|
return null;
|
|
const existingCount = state.agentPanes.length;
|
|
const minAgentPaneWidth = config2.agentPaneWidth;
|
|
const initialDirection = getInitialSplitDirection(config2);
|
|
if (existingCount === 0) {
|
|
const virtualMainPane = { ...state.mainPane, width: state.windowWidth };
|
|
if (canSplitPane(virtualMainPane, initialDirection, minAgentPaneWidth)) {
|
|
return { targetPaneId: state.mainPane.paneId, splitDirection: initialDirection };
|
|
}
|
|
return null;
|
|
}
|
|
if (isStrictMainLayout(config2)) {
|
|
const followupDirection = getStrictFollowupSplitDirection(config2);
|
|
const panesByPriority = sortPanesForStrictLayout(state.agentPanes, config2);
|
|
for (const pane of panesByPriority) {
|
|
if (canSplitPane(pane, followupDirection, minAgentPaneWidth)) {
|
|
return { targetPaneId: pane.paneId, splitDirection: followupDirection };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
const plan = computeGridPlan(state.windowWidth, state.windowHeight, existingCount + 1, config2);
|
|
const mainPaneWidth = computeMainPaneWidth(state.windowWidth, config2);
|
|
const occupancy = buildOccupancy(state.agentPanes, plan, mainPaneWidth);
|
|
const targetSlot = findFirstEmptySlot(occupancy, plan);
|
|
const leftPane = occupancy.get(`${targetSlot.row}:${targetSlot.col - 1}`);
|
|
if (!isStrictMainVertical(config2) && leftPane && canSplitPane(leftPane, "-h", minAgentPaneWidth)) {
|
|
return { targetPaneId: leftPane.paneId, splitDirection: "-h" };
|
|
}
|
|
const abovePane = occupancy.get(`${targetSlot.row - 1}:${targetSlot.col}`);
|
|
if (abovePane && canSplitPane(abovePane, "-v", minAgentPaneWidth)) {
|
|
return { targetPaneId: abovePane.paneId, splitDirection: "-v" };
|
|
}
|
|
const panesByPosition = [...state.agentPanes].sort((a, b) => a.left - b.left || a.top - b.top);
|
|
for (const pane of panesByPosition) {
|
|
if (canSplitPane(pane, "-v", minAgentPaneWidth)) {
|
|
return { targetPaneId: pane.paneId, splitDirection: "-v" };
|
|
}
|
|
}
|
|
if (isStrictMainVertical(config2)) {
|
|
return null;
|
|
}
|
|
for (const pane of panesByPosition) {
|
|
if (canSplitPane(pane, "-h", minAgentPaneWidth)) {
|
|
return { targetPaneId: pane.paneId, splitDirection: "-h" };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function findSpawnTarget(state, config2) {
|
|
return findSplittableTarget(state, config2);
|
|
}
|
|
// src/features/tmux-subagent/oldest-agent-pane.ts
|
|
function findOldestAgentPane(agentPanes, sessionMappings) {
|
|
if (agentPanes.length === 0)
|
|
return null;
|
|
const paneIdToAge = new Map;
|
|
for (const mapping of sessionMappings) {
|
|
paneIdToAge.set(mapping.paneId, mapping.createdAt);
|
|
}
|
|
const panesWithAge = agentPanes.map((pane) => ({ pane, age: paneIdToAge.get(pane.paneId) })).filter((item) => item.age !== undefined).sort((a, b) => a.age.getTime() - b.age.getTime());
|
|
if (panesWithAge.length > 0) {
|
|
return panesWithAge[0].pane;
|
|
}
|
|
return agentPanes.reduce((oldest, pane) => {
|
|
if (pane.top < oldest.top || pane.top === oldest.top && pane.left < oldest.left) {
|
|
return pane;
|
|
}
|
|
return oldest;
|
|
});
|
|
}
|
|
|
|
// src/features/tmux-subagent/spawn-action-decider.ts
|
|
function getInitialSplitDirection2(layout) {
|
|
return layout === "main-horizontal" ? "-v" : "-h";
|
|
}
|
|
function isStrictMainLayout2(layout) {
|
|
return layout === "main-vertical" || layout === "main-horizontal";
|
|
}
|
|
function decideSpawnActions(state, sessionId, description, config2, sessionMappings) {
|
|
if (!state.mainPane) {
|
|
return { canSpawn: false, actions: [], reason: "no main pane found" };
|
|
}
|
|
const agentAreaWidth = computeAgentAreaWidth(state.windowWidth, config2);
|
|
const minAgentPaneWidth = config2.agentPaneWidth;
|
|
const currentCount = state.agentPanes.length;
|
|
const strictLayout = isStrictMainLayout2(config2.layout);
|
|
const initialSplitDirection = getInitialSplitDirection2(config2.layout);
|
|
if (agentAreaWidth < minAgentPaneWidth && currentCount > 0) {
|
|
return {
|
|
canSpawn: false,
|
|
actions: [],
|
|
reason: `window too small for agent panes: ${state.windowWidth}x${state.windowHeight}`
|
|
};
|
|
}
|
|
const oldestPane = findOldestAgentPane(state.agentPanes, sessionMappings);
|
|
const oldestMapping = oldestPane ? sessionMappings.find((m) => m.paneId === oldestPane.paneId) ?? null : null;
|
|
if (currentCount === 0) {
|
|
const virtualMainPane = { ...state.mainPane, width: state.windowWidth };
|
|
if (canSplitPane(virtualMainPane, initialSplitDirection, minAgentPaneWidth)) {
|
|
return {
|
|
canSpawn: true,
|
|
actions: [
|
|
{
|
|
type: "spawn",
|
|
sessionId,
|
|
description,
|
|
targetPaneId: state.mainPane.paneId,
|
|
splitDirection: initialSplitDirection
|
|
}
|
|
]
|
|
};
|
|
}
|
|
return { canSpawn: false, actions: [], reason: "mainPane too small to split" };
|
|
}
|
|
const canEvaluateSpawnTarget = strictLayout || isSplittableAtCount(agentAreaWidth, currentCount, minAgentPaneWidth);
|
|
if (canEvaluateSpawnTarget) {
|
|
const spawnTarget = findSpawnTarget(state, config2);
|
|
if (spawnTarget) {
|
|
return {
|
|
canSpawn: true,
|
|
actions: [
|
|
{
|
|
type: "spawn",
|
|
sessionId,
|
|
description,
|
|
targetPaneId: spawnTarget.targetPaneId,
|
|
splitDirection: spawnTarget.splitDirection
|
|
}
|
|
]
|
|
};
|
|
}
|
|
}
|
|
if (!strictLayout) {
|
|
const minEvictions = findMinimalEvictions(agentAreaWidth, currentCount, minAgentPaneWidth);
|
|
if (minEvictions === 1 && oldestPane) {
|
|
return {
|
|
canSpawn: true,
|
|
actions: [
|
|
{
|
|
type: "close",
|
|
paneId: oldestPane.paneId,
|
|
sessionId: oldestMapping?.sessionId || ""
|
|
},
|
|
{
|
|
type: "spawn",
|
|
sessionId,
|
|
description,
|
|
targetPaneId: state.mainPane.paneId,
|
|
splitDirection: initialSplitDirection
|
|
}
|
|
],
|
|
reason: "closed 1 pane to make room for split"
|
|
};
|
|
}
|
|
}
|
|
if (oldestPane) {
|
|
return {
|
|
canSpawn: false,
|
|
actions: [],
|
|
reason: "no split target available (defer attach)"
|
|
};
|
|
}
|
|
return { canSpawn: false, actions: [], reason: "no split target available (defer attach)" };
|
|
}
|
|
function decideCloseAction(state, sessionId, sessionMappings) {
|
|
const mapping = sessionMappings.find((m) => m.sessionId === sessionId);
|
|
if (!mapping)
|
|
return null;
|
|
const paneExists = state.agentPanes.some((pane) => pane.paneId === mapping.paneId);
|
|
if (!paneExists)
|
|
return null;
|
|
return { type: "close", paneId: mapping.paneId, sessionId };
|
|
}
|
|
// src/features/tmux-subagent/action-executor.ts
|
|
async function enforceMainPane(windowState, config2) {
|
|
if (!windowState.mainPane)
|
|
return;
|
|
await enforceMainPaneWidth(windowState.mainPane.paneId, windowState.windowWidth, {
|
|
mainPaneSize: config2.main_pane_size,
|
|
mainPaneMinWidth: config2.main_pane_min_width,
|
|
agentPaneMinWidth: config2.agent_pane_min_width
|
|
});
|
|
}
|
|
async function enforceLayoutAndMainPane(ctx) {
|
|
const sourcePaneId = ctx.sourcePaneId;
|
|
if (!sourcePaneId) {
|
|
await enforceMainPane(ctx.windowState, ctx.config);
|
|
return;
|
|
}
|
|
const latestState = await queryWindowState(sourcePaneId);
|
|
if (!latestState?.mainPane) {
|
|
await enforceMainPane(ctx.windowState, ctx.config);
|
|
return;
|
|
}
|
|
const tmux2 = await getTmuxPath();
|
|
if (tmux2) {
|
|
await applyLayout(tmux2, ctx.config.layout, ctx.config.main_pane_size);
|
|
}
|
|
await enforceMainPane(latestState, ctx.config);
|
|
}
|
|
async function executeAction(action, ctx) {
|
|
if (action.type === "close") {
|
|
const success2 = await closeTmuxPane(action.paneId);
|
|
if (success2) {
|
|
await enforceLayoutAndMainPane(ctx);
|
|
}
|
|
return { success: success2 };
|
|
}
|
|
if (action.type === "replace") {
|
|
const result2 = await replaceTmuxPane(action.paneId, action.newSessionId, action.description, ctx.config, ctx.serverUrl);
|
|
if (result2.success) {
|
|
await enforceLayoutAndMainPane(ctx);
|
|
}
|
|
return {
|
|
success: result2.success,
|
|
paneId: result2.paneId
|
|
};
|
|
}
|
|
const result = await spawnTmuxPane(action.sessionId, action.description, ctx.config, ctx.serverUrl, action.targetPaneId, action.splitDirection);
|
|
if (result.success) {
|
|
await enforceLayoutAndMainPane(ctx);
|
|
}
|
|
return {
|
|
success: result.success,
|
|
paneId: result.paneId
|
|
};
|
|
}
|
|
async function executeActions(actions, ctx) {
|
|
const results = [];
|
|
let spawnedPaneId;
|
|
for (const action of actions) {
|
|
log("[action-executor] executing", { type: action.type });
|
|
const result = await executeAction(action, ctx);
|
|
results.push({ action, result });
|
|
if (!result.success) {
|
|
log("[action-executor] action failed", { type: action.type, error: result.error });
|
|
return { success: false, results };
|
|
}
|
|
if ((action.type === "spawn" || action.type === "replace") && result.paneId) {
|
|
spawnedPaneId = result.paneId;
|
|
}
|
|
}
|
|
return { success: true, spawnedPaneId, results };
|
|
}
|
|
|
|
// src/features/tmux-subagent/polling-manager.ts
|
|
var SESSION_TIMEOUT_MS2 = 10 * 60 * 1000;
|
|
var MIN_STABILITY_TIME_MS = 10 * 1000;
|
|
var STABLE_POLLS_REQUIRED = 3;
|
|
|
|
class TmuxPollingManager {
|
|
client;
|
|
sessions;
|
|
closeSessionById;
|
|
pollInterval;
|
|
pollingInFlight = false;
|
|
constructor(client, sessions, closeSessionById) {
|
|
this.client = client;
|
|
this.sessions = sessions;
|
|
this.closeSessionById = closeSessionById;
|
|
}
|
|
startPolling() {
|
|
if (this.pollInterval)
|
|
return;
|
|
this.pollInterval = setInterval(() => this.pollSessions(), POLL_INTERVAL_BACKGROUND_MS);
|
|
log("[tmux-session-manager] polling started");
|
|
}
|
|
stopPolling() {
|
|
if (this.pollInterval) {
|
|
clearInterval(this.pollInterval);
|
|
this.pollInterval = undefined;
|
|
log("[tmux-session-manager] polling stopped");
|
|
}
|
|
}
|
|
async pollSessions() {
|
|
if (this.pollingInFlight)
|
|
return;
|
|
this.pollingInFlight = true;
|
|
try {
|
|
if (this.sessions.size === 0) {
|
|
this.stopPolling();
|
|
return;
|
|
}
|
|
const statusResult = await this.client.session.status({ path: undefined });
|
|
const allStatuses = normalizeSDKResponse(statusResult, {});
|
|
log("[tmux-session-manager] pollSessions", {
|
|
trackedSessions: Array.from(this.sessions.keys()),
|
|
allStatusKeys: Object.keys(allStatuses)
|
|
});
|
|
const now = Date.now();
|
|
const sessionsToClose = [];
|
|
for (const [sessionId, tracked] of this.sessions.entries()) {
|
|
const status = allStatuses[sessionId];
|
|
const isIdle = status?.type === "idle";
|
|
if (status) {
|
|
tracked.lastSeenAt = new Date(now);
|
|
}
|
|
const missingSince = !status ? now - tracked.lastSeenAt.getTime() : 0;
|
|
const missingTooLong = missingSince >= SESSION_MISSING_GRACE_MS;
|
|
const isTimedOut = now - tracked.createdAt.getTime() > SESSION_TIMEOUT_MS2;
|
|
const elapsedMs = now - tracked.createdAt.getTime();
|
|
let shouldCloseViaStability = false;
|
|
if (isIdle && elapsedMs >= MIN_STABILITY_TIME_MS) {
|
|
try {
|
|
const messagesResult = await this.client.session.messages({
|
|
path: { id: sessionId }
|
|
});
|
|
const currentMsgCount = Array.isArray(messagesResult.data) ? messagesResult.data.length : 0;
|
|
if (tracked.lastMessageCount === currentMsgCount) {
|
|
tracked.stableIdlePolls = (tracked.stableIdlePolls ?? 0) + 1;
|
|
if (tracked.stableIdlePolls >= STABLE_POLLS_REQUIRED) {
|
|
const recheckResult = await this.client.session.status({ path: undefined });
|
|
const recheckStatuses = normalizeSDKResponse(recheckResult, {});
|
|
const recheckStatus = recheckStatuses[sessionId];
|
|
if (recheckStatus?.type === "idle") {
|
|
shouldCloseViaStability = true;
|
|
} else {
|
|
tracked.stableIdlePolls = 0;
|
|
log("[tmux-session-manager] stability reached but session not idle on recheck, resetting", {
|
|
sessionId,
|
|
recheckStatus: recheckStatus?.type
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
tracked.stableIdlePolls = 0;
|
|
}
|
|
tracked.lastMessageCount = currentMsgCount;
|
|
} catch (msgErr) {
|
|
log("[tmux-session-manager] failed to fetch messages for stability check", {
|
|
sessionId,
|
|
error: String(msgErr)
|
|
});
|
|
}
|
|
} else if (!isIdle) {
|
|
tracked.stableIdlePolls = 0;
|
|
}
|
|
log("[tmux-session-manager] session check", {
|
|
sessionId,
|
|
statusType: status?.type,
|
|
isIdle,
|
|
elapsedMs,
|
|
stableIdlePolls: tracked.stableIdlePolls,
|
|
lastMessageCount: tracked.lastMessageCount,
|
|
missingSince,
|
|
missingTooLong,
|
|
isTimedOut,
|
|
shouldCloseViaStability
|
|
});
|
|
if (shouldCloseViaStability || missingTooLong || isTimedOut) {
|
|
sessionsToClose.push(sessionId);
|
|
}
|
|
}
|
|
for (const sessionId of sessionsToClose) {
|
|
log("[tmux-session-manager] closing session due to poll", { sessionId });
|
|
await this.closeSessionById(sessionId);
|
|
}
|
|
} catch (err) {
|
|
log("[tmux-session-manager] poll error", { error: String(err) });
|
|
} finally {
|
|
this.pollingInFlight = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/features/tmux-subagent/tracked-session-state.ts
|
|
function createTrackedSession(params) {
|
|
const now = params.now ?? new Date;
|
|
return {
|
|
sessionId: params.sessionId,
|
|
paneId: params.paneId,
|
|
description: params.description,
|
|
createdAt: now,
|
|
lastSeenAt: now,
|
|
closePending: false,
|
|
closeRetryCount: 0
|
|
};
|
|
}
|
|
function markTrackedSessionClosePending(tracked) {
|
|
return {
|
|
...tracked,
|
|
closePending: true,
|
|
closeRetryCount: tracked.closePending ? tracked.closeRetryCount + 1 : tracked.closeRetryCount
|
|
};
|
|
}
|
|
|
|
// src/features/tmux-subagent/manager.ts
|
|
var defaultTmuxDeps = {
|
|
isInsideTmux,
|
|
getCurrentPaneId
|
|
};
|
|
var DEFERRED_SESSION_TTL_MS = 5 * 60 * 1000;
|
|
var MAX_DEFERRED_QUEUE_SIZE = 20;
|
|
var MAX_CLOSE_RETRY_COUNT = 3;
|
|
|
|
class TmuxSessionManager {
|
|
client;
|
|
tmuxConfig;
|
|
serverUrl;
|
|
sourcePaneId;
|
|
sessions = new Map;
|
|
pendingSessions = new Set;
|
|
spawnQueue = Promise.resolve();
|
|
deferredSessions = new Map;
|
|
deferredQueue = [];
|
|
deferredAttachInterval;
|
|
deferredAttachTickScheduled = false;
|
|
nullStateCount = 0;
|
|
deps;
|
|
pollingManager;
|
|
constructor(ctx, tmuxConfig, deps = defaultTmuxDeps) {
|
|
this.client = ctx.client;
|
|
this.tmuxConfig = tmuxConfig;
|
|
this.deps = deps;
|
|
const defaultPort = process.env.OPENCODE_PORT ?? "4096";
|
|
try {
|
|
this.serverUrl = ctx.serverUrl?.toString() ?? `http://localhost:${defaultPort}`;
|
|
} catch {
|
|
this.serverUrl = `http://localhost:${defaultPort}`;
|
|
}
|
|
this.sourcePaneId = deps.getCurrentPaneId();
|
|
this.pollingManager = new TmuxPollingManager(this.client, this.sessions, this.closeSessionById.bind(this));
|
|
log("[tmux-session-manager] initialized", {
|
|
configEnabled: this.tmuxConfig.enabled,
|
|
tmuxConfig: this.tmuxConfig,
|
|
serverUrl: this.serverUrl,
|
|
sourcePaneId: this.sourcePaneId
|
|
});
|
|
}
|
|
isEnabled() {
|
|
return this.tmuxConfig.enabled && this.deps.isInsideTmux();
|
|
}
|
|
getCapacityConfig() {
|
|
return {
|
|
layout: this.tmuxConfig.layout,
|
|
mainPaneSize: this.tmuxConfig.main_pane_size,
|
|
mainPaneMinWidth: this.tmuxConfig.main_pane_min_width,
|
|
agentPaneWidth: this.tmuxConfig.agent_pane_min_width
|
|
};
|
|
}
|
|
getSessionMappings() {
|
|
return Array.from(this.sessions.values()).map((s) => ({
|
|
sessionId: s.sessionId,
|
|
paneId: s.paneId,
|
|
createdAt: s.createdAt
|
|
}));
|
|
}
|
|
removeTrackedSession(sessionId) {
|
|
this.sessions.delete(sessionId);
|
|
if (this.sessions.size === 0) {
|
|
this.pollingManager.stopPolling();
|
|
}
|
|
}
|
|
markSessionClosePending(sessionId) {
|
|
const tracked = this.sessions.get(sessionId);
|
|
if (!tracked)
|
|
return;
|
|
this.sessions.set(sessionId, markTrackedSessionClosePending(tracked));
|
|
log("[tmux-session-manager] marked session close pending", {
|
|
sessionId,
|
|
paneId: tracked.paneId,
|
|
closeRetryCount: tracked.closeRetryCount
|
|
});
|
|
}
|
|
async queryWindowStateSafely() {
|
|
if (!this.sourcePaneId)
|
|
return null;
|
|
try {
|
|
return await queryWindowState(this.sourcePaneId);
|
|
} catch (error48) {
|
|
log("[tmux-session-manager] failed to query window state for close", {
|
|
error: String(error48)
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
async tryCloseTrackedSession(tracked) {
|
|
const state = await this.queryWindowStateSafely();
|
|
if (!state)
|
|
return false;
|
|
try {
|
|
const result = await executeAction({ type: "close", paneId: tracked.paneId, sessionId: tracked.sessionId }, {
|
|
config: this.tmuxConfig,
|
|
serverUrl: this.serverUrl,
|
|
windowState: state,
|
|
sourcePaneId: this.sourcePaneId
|
|
});
|
|
return result.success;
|
|
} catch (error48) {
|
|
log("[tmux-session-manager] close session pane failed", {
|
|
sessionId: tracked.sessionId,
|
|
paneId: tracked.paneId,
|
|
error: String(error48)
|
|
});
|
|
return false;
|
|
}
|
|
}
|
|
async retryPendingCloses() {
|
|
const pendingSessions = Array.from(this.sessions.values()).filter((tracked) => tracked.closePending);
|
|
for (const tracked of pendingSessions) {
|
|
if (!this.sessions.has(tracked.sessionId))
|
|
continue;
|
|
if (tracked.closeRetryCount >= MAX_CLOSE_RETRY_COUNT) {
|
|
log("[tmux-session-manager] force removing close-pending session after max retries", {
|
|
sessionId: tracked.sessionId,
|
|
paneId: tracked.paneId,
|
|
closeRetryCount: tracked.closeRetryCount
|
|
});
|
|
this.removeTrackedSession(tracked.sessionId);
|
|
continue;
|
|
}
|
|
const closed = await this.tryCloseTrackedSession(tracked);
|
|
if (closed) {
|
|
log("[tmux-session-manager] retried close succeeded", {
|
|
sessionId: tracked.sessionId,
|
|
paneId: tracked.paneId,
|
|
closeRetryCount: tracked.closeRetryCount
|
|
});
|
|
this.removeTrackedSession(tracked.sessionId);
|
|
continue;
|
|
}
|
|
const currentTracked = this.sessions.get(tracked.sessionId);
|
|
if (!currentTracked || !currentTracked.closePending) {
|
|
continue;
|
|
}
|
|
const nextRetryCount = currentTracked.closeRetryCount + 1;
|
|
if (nextRetryCount >= MAX_CLOSE_RETRY_COUNT) {
|
|
log("[tmux-session-manager] force removing close-pending session after failed retry", {
|
|
sessionId: currentTracked.sessionId,
|
|
paneId: currentTracked.paneId,
|
|
closeRetryCount: nextRetryCount
|
|
});
|
|
this.removeTrackedSession(currentTracked.sessionId);
|
|
continue;
|
|
}
|
|
this.sessions.set(currentTracked.sessionId, {
|
|
...currentTracked,
|
|
closePending: true,
|
|
closeRetryCount: nextRetryCount
|
|
});
|
|
log("[tmux-session-manager] retried close failed", {
|
|
sessionId: currentTracked.sessionId,
|
|
paneId: currentTracked.paneId,
|
|
closeRetryCount: nextRetryCount
|
|
});
|
|
}
|
|
}
|
|
enqueueDeferredSession(sessionId, title) {
|
|
if (this.deferredSessions.has(sessionId))
|
|
return;
|
|
if (this.deferredQueue.length >= MAX_DEFERRED_QUEUE_SIZE) {
|
|
log("[tmux-session-manager] deferred queue full, dropping session", {
|
|
sessionId,
|
|
queueLength: this.deferredQueue.length,
|
|
maxQueueSize: MAX_DEFERRED_QUEUE_SIZE
|
|
});
|
|
return;
|
|
}
|
|
this.deferredSessions.set(sessionId, {
|
|
sessionId,
|
|
title,
|
|
queuedAt: new Date
|
|
});
|
|
this.deferredQueue.push(sessionId);
|
|
log("[tmux-session-manager] deferred session queued", {
|
|
sessionId,
|
|
queueLength: this.deferredQueue.length
|
|
});
|
|
this.startDeferredAttachLoop();
|
|
}
|
|
removeDeferredSession(sessionId) {
|
|
if (!this.deferredSessions.delete(sessionId))
|
|
return;
|
|
this.deferredQueue = this.deferredQueue.filter((id) => id !== sessionId);
|
|
log("[tmux-session-manager] deferred session removed", {
|
|
sessionId,
|
|
queueLength: this.deferredQueue.length
|
|
});
|
|
if (this.deferredQueue.length === 0) {
|
|
this.stopDeferredAttachLoop();
|
|
}
|
|
}
|
|
startDeferredAttachLoop() {
|
|
if (this.deferredAttachInterval)
|
|
return;
|
|
this.nullStateCount = 0;
|
|
this.deferredAttachInterval = setInterval(() => {
|
|
if (this.deferredAttachTickScheduled)
|
|
return;
|
|
this.deferredAttachTickScheduled = true;
|
|
this.enqueueSpawn(async () => {
|
|
try {
|
|
await this.tryAttachDeferredSession();
|
|
} finally {
|
|
this.deferredAttachTickScheduled = false;
|
|
}
|
|
});
|
|
}, POLL_INTERVAL_BACKGROUND_MS);
|
|
log("[tmux-session-manager] deferred attach polling started", {
|
|
intervalMs: POLL_INTERVAL_BACKGROUND_MS
|
|
});
|
|
}
|
|
stopDeferredAttachLoop() {
|
|
if (!this.deferredAttachInterval)
|
|
return;
|
|
clearInterval(this.deferredAttachInterval);
|
|
this.deferredAttachInterval = undefined;
|
|
this.deferredAttachTickScheduled = false;
|
|
this.nullStateCount = 0;
|
|
log("[tmux-session-manager] deferred attach polling stopped");
|
|
}
|
|
async tryAttachDeferredSession() {
|
|
if (!this.sourcePaneId)
|
|
return;
|
|
const sessionId = this.deferredQueue[0];
|
|
if (!sessionId) {
|
|
this.stopDeferredAttachLoop();
|
|
return;
|
|
}
|
|
const deferred = this.deferredSessions.get(sessionId);
|
|
if (!deferred) {
|
|
this.deferredQueue.shift();
|
|
return;
|
|
}
|
|
if (Date.now() - deferred.queuedAt.getTime() > DEFERRED_SESSION_TTL_MS) {
|
|
this.deferredQueue.shift();
|
|
this.deferredSessions.delete(sessionId);
|
|
log("[tmux-session-manager] deferred session expired", {
|
|
sessionId,
|
|
queuedAt: deferred.queuedAt.toISOString(),
|
|
ttlMs: DEFERRED_SESSION_TTL_MS,
|
|
queueLength: this.deferredQueue.length
|
|
});
|
|
if (this.deferredQueue.length === 0) {
|
|
this.stopDeferredAttachLoop();
|
|
}
|
|
return;
|
|
}
|
|
const state = await queryWindowState(this.sourcePaneId);
|
|
if (!state) {
|
|
this.nullStateCount += 1;
|
|
log("[tmux-session-manager] deferred attach window state is null", {
|
|
nullStateCount: this.nullStateCount
|
|
});
|
|
if (this.nullStateCount >= 3) {
|
|
log("[tmux-session-manager] stopping deferred attach loop after consecutive null states", {
|
|
nullStateCount: this.nullStateCount
|
|
});
|
|
this.stopDeferredAttachLoop();
|
|
}
|
|
return;
|
|
}
|
|
this.nullStateCount = 0;
|
|
const decision = decideSpawnActions(state, sessionId, deferred.title, this.getCapacityConfig(), this.getSessionMappings());
|
|
if (!decision.canSpawn || decision.actions.length === 0) {
|
|
log("[tmux-session-manager] deferred session still waiting for capacity", {
|
|
sessionId,
|
|
reason: decision.reason
|
|
});
|
|
return;
|
|
}
|
|
const result = await executeActions(decision.actions, {
|
|
config: this.tmuxConfig,
|
|
serverUrl: this.serverUrl,
|
|
windowState: state,
|
|
sourcePaneId: this.sourcePaneId
|
|
});
|
|
if (!result.success || !result.spawnedPaneId) {
|
|
log("[tmux-session-manager] deferred session attach failed", {
|
|
sessionId,
|
|
results: result.results.map((r) => ({
|
|
type: r.action.type,
|
|
success: r.result.success,
|
|
error: r.result.error
|
|
}))
|
|
});
|
|
return;
|
|
}
|
|
const sessionReady = await this.waitForSessionReady(sessionId);
|
|
if (!sessionReady) {
|
|
log("[tmux-session-manager] deferred session not ready after timeout", {
|
|
sessionId,
|
|
paneId: result.spawnedPaneId
|
|
});
|
|
}
|
|
this.sessions.set(sessionId, createTrackedSession({
|
|
sessionId,
|
|
paneId: result.spawnedPaneId,
|
|
description: deferred.title
|
|
}));
|
|
this.removeDeferredSession(sessionId);
|
|
this.pollingManager.startPolling();
|
|
log("[tmux-session-manager] deferred session attached", {
|
|
sessionId,
|
|
paneId: result.spawnedPaneId,
|
|
sessionReady
|
|
});
|
|
}
|
|
async waitForSessionReady(sessionId) {
|
|
const startTime = Date.now();
|
|
while (Date.now() - startTime < SESSION_READY_TIMEOUT_MS) {
|
|
try {
|
|
const statusResult = await this.client.session.status({ path: undefined });
|
|
const allStatuses = normalizeSDKResponse(statusResult, {});
|
|
if (allStatuses[sessionId]) {
|
|
log("[tmux-session-manager] session ready", {
|
|
sessionId,
|
|
status: allStatuses[sessionId].type,
|
|
waitedMs: Date.now() - startTime
|
|
});
|
|
return true;
|
|
}
|
|
} catch (err) {
|
|
log("[tmux-session-manager] session status check error", { error: String(err) });
|
|
}
|
|
await new Promise((resolve2) => setTimeout(resolve2, SESSION_READY_POLL_INTERVAL_MS));
|
|
}
|
|
log("[tmux-session-manager] session ready timeout", {
|
|
sessionId,
|
|
timeoutMs: SESSION_READY_TIMEOUT_MS
|
|
});
|
|
return false;
|
|
}
|
|
async onSessionCreated(event) {
|
|
const enabled = this.isEnabled();
|
|
log("[tmux-session-manager] onSessionCreated called", {
|
|
enabled,
|
|
tmuxConfigEnabled: this.tmuxConfig.enabled,
|
|
isInsideTmux: this.deps.isInsideTmux(),
|
|
eventType: event.type,
|
|
infoId: event.properties?.info?.id,
|
|
infoParentID: event.properties?.info?.parentID
|
|
});
|
|
if (!enabled)
|
|
return;
|
|
if (event.type !== "session.created")
|
|
return;
|
|
const info = event.properties?.info;
|
|
if (!info?.id || !info?.parentID)
|
|
return;
|
|
const sessionId = info.id;
|
|
const title = info.title ?? "Subagent";
|
|
if (!this.sourcePaneId) {
|
|
log("[tmux-session-manager] no source pane id");
|
|
return;
|
|
}
|
|
await this.retryPendingCloses();
|
|
if (this.sessions.has(sessionId) || this.pendingSessions.has(sessionId) || this.deferredSessions.has(sessionId)) {
|
|
log("[tmux-session-manager] session already tracked or pending", { sessionId });
|
|
return;
|
|
}
|
|
const sourcePaneId = this.sourcePaneId;
|
|
this.pendingSessions.add(sessionId);
|
|
await this.enqueueSpawn(async () => {
|
|
try {
|
|
const state = await queryWindowState(sourcePaneId);
|
|
if (!state) {
|
|
log("[tmux-session-manager] failed to query window state, deferring session");
|
|
this.enqueueDeferredSession(sessionId, title);
|
|
return;
|
|
}
|
|
log("[tmux-session-manager] window state queried", {
|
|
windowWidth: state.windowWidth,
|
|
mainPane: state.mainPane?.paneId,
|
|
agentPaneCount: state.agentPanes.length,
|
|
agentPanes: state.agentPanes.map((p) => p.paneId)
|
|
});
|
|
const decision = decideSpawnActions(state, sessionId, title, this.getCapacityConfig(), this.getSessionMappings());
|
|
log("[tmux-session-manager] spawn decision", {
|
|
canSpawn: decision.canSpawn,
|
|
reason: decision.reason,
|
|
actionCount: decision.actions.length,
|
|
actions: decision.actions.map((a) => {
|
|
if (a.type === "close")
|
|
return { type: "close", paneId: a.paneId };
|
|
if (a.type === "replace")
|
|
return { type: "replace", paneId: a.paneId, newSessionId: a.newSessionId };
|
|
return { type: "spawn", sessionId: a.sessionId };
|
|
})
|
|
});
|
|
if (!decision.canSpawn) {
|
|
log("[tmux-session-manager] cannot spawn", { reason: decision.reason });
|
|
this.enqueueDeferredSession(sessionId, title);
|
|
return;
|
|
}
|
|
const result = await executeActions(decision.actions, {
|
|
config: this.tmuxConfig,
|
|
serverUrl: this.serverUrl,
|
|
windowState: state,
|
|
sourcePaneId
|
|
});
|
|
for (const { action, result: actionResult } of result.results) {
|
|
if (action.type === "close" && actionResult.success) {
|
|
this.sessions.delete(action.sessionId);
|
|
log("[tmux-session-manager] removed closed session from cache", {
|
|
sessionId: action.sessionId
|
|
});
|
|
}
|
|
if (action.type === "replace" && actionResult.success) {
|
|
this.sessions.delete(action.oldSessionId);
|
|
log("[tmux-session-manager] removed replaced session from cache", {
|
|
oldSessionId: action.oldSessionId,
|
|
newSessionId: action.newSessionId
|
|
});
|
|
}
|
|
}
|
|
if (result.success && result.spawnedPaneId) {
|
|
const sessionReady = await this.waitForSessionReady(sessionId);
|
|
if (!sessionReady) {
|
|
log("[tmux-session-manager] session not ready after timeout, tracking anyway", {
|
|
sessionId,
|
|
paneId: result.spawnedPaneId
|
|
});
|
|
}
|
|
this.sessions.set(sessionId, createTrackedSession({
|
|
sessionId,
|
|
paneId: result.spawnedPaneId,
|
|
description: title
|
|
}));
|
|
log("[tmux-session-manager] pane spawned and tracked", {
|
|
sessionId,
|
|
paneId: result.spawnedPaneId,
|
|
sessionReady
|
|
});
|
|
this.pollingManager.startPolling();
|
|
} else {
|
|
log("[tmux-session-manager] spawn failed", {
|
|
success: result.success,
|
|
results: result.results.map((r) => ({
|
|
type: r.action.type,
|
|
success: r.result.success,
|
|
error: r.result.error
|
|
}))
|
|
});
|
|
log("[tmux-session-manager] re-queueing deferred session after spawn failure", {
|
|
sessionId
|
|
});
|
|
this.enqueueDeferredSession(sessionId, title);
|
|
if (result.spawnedPaneId) {
|
|
await executeAction({ type: "close", paneId: result.spawnedPaneId, sessionId }, { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state });
|
|
}
|
|
return;
|
|
}
|
|
} finally {
|
|
this.pendingSessions.delete(sessionId);
|
|
}
|
|
});
|
|
}
|
|
async enqueueSpawn(run) {
|
|
this.spawnQueue = this.spawnQueue.catch(() => {
|
|
return;
|
|
}).then(run).catch((err) => {
|
|
log("[tmux-session-manager] spawn queue task failed", {
|
|
error: String(err)
|
|
});
|
|
});
|
|
await this.spawnQueue;
|
|
}
|
|
async onSessionDeleted(event) {
|
|
if (!this.isEnabled())
|
|
return;
|
|
if (!this.sourcePaneId)
|
|
return;
|
|
this.removeDeferredSession(event.sessionID);
|
|
const tracked = this.sessions.get(event.sessionID);
|
|
if (!tracked)
|
|
return;
|
|
log("[tmux-session-manager] onSessionDeleted", { sessionId: event.sessionID });
|
|
const state = await this.queryWindowStateSafely();
|
|
if (!state) {
|
|
this.markSessionClosePending(event.sessionID);
|
|
return;
|
|
}
|
|
const closeAction = decideCloseAction(state, event.sessionID, this.getSessionMappings());
|
|
if (!closeAction) {
|
|
this.removeTrackedSession(event.sessionID);
|
|
return;
|
|
}
|
|
try {
|
|
const result = await executeAction(closeAction, {
|
|
config: this.tmuxConfig,
|
|
serverUrl: this.serverUrl,
|
|
windowState: state,
|
|
sourcePaneId: this.sourcePaneId
|
|
});
|
|
if (!result.success) {
|
|
this.markSessionClosePending(event.sessionID);
|
|
return;
|
|
}
|
|
} catch (error48) {
|
|
log("[tmux-session-manager] failed to close pane for deleted session", {
|
|
sessionId: event.sessionID,
|
|
error: String(error48)
|
|
});
|
|
this.markSessionClosePending(event.sessionID);
|
|
return;
|
|
}
|
|
this.removeTrackedSession(event.sessionID);
|
|
}
|
|
async closeSessionById(sessionId) {
|
|
const tracked = this.sessions.get(sessionId);
|
|
if (!tracked)
|
|
return;
|
|
if (tracked.closePending && tracked.closeRetryCount >= MAX_CLOSE_RETRY_COUNT) {
|
|
log("[tmux-session-manager] force removing close-pending session after max retries", {
|
|
sessionId,
|
|
paneId: tracked.paneId,
|
|
closeRetryCount: tracked.closeRetryCount
|
|
});
|
|
this.removeTrackedSession(sessionId);
|
|
return;
|
|
}
|
|
log("[tmux-session-manager] closing session pane", {
|
|
sessionId,
|
|
paneId: tracked.paneId
|
|
});
|
|
const closed = await this.tryCloseTrackedSession(tracked);
|
|
if (!closed) {
|
|
this.markSessionClosePending(sessionId);
|
|
return;
|
|
}
|
|
this.removeTrackedSession(sessionId);
|
|
}
|
|
createEventHandler() {
|
|
return async (input) => {
|
|
await this.onSessionCreated(input.event);
|
|
};
|
|
}
|
|
async cleanup() {
|
|
this.stopDeferredAttachLoop();
|
|
this.deferredQueue = [];
|
|
this.deferredSessions.clear();
|
|
this.pollingManager.stopPolling();
|
|
if (this.sessions.size > 0) {
|
|
log("[tmux-session-manager] closing all panes", { count: this.sessions.size });
|
|
const sessionIds = Array.from(this.sessions.keys());
|
|
for (const sessionId of sessionIds) {
|
|
try {
|
|
await this.closeSessionById(sessionId);
|
|
} catch (error48) {
|
|
log("[tmux-session-manager] cleanup error for pane", {
|
|
sessionId,
|
|
error: String(error48)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
await this.retryPendingCloses();
|
|
log("[tmux-session-manager] cleanup complete");
|
|
}
|
|
}
|
|
// src/features/tmux-subagent/polling-constants.ts
|
|
var SESSION_TIMEOUT_MS3 = 10 * 60 * 1000;
|
|
var MIN_STABILITY_TIME_MS2 = 10 * 1000;
|
|
// src/plugin-config.ts
|
|
import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
|
|
import { join as join3 } from "path";
|
|
function loadConfigFromPath(configPath) {
|
|
try {
|
|
if (!existsSync3(configPath))
|
|
return null;
|
|
const content = readFileSync2(configPath, "utf-8");
|
|
const rawConfig = parseJsonc(content);
|
|
const result = PluginConfigSchema.safeParse(rawConfig);
|
|
if (result.success) {
|
|
log(`Config loaded from ${configPath}`);
|
|
return result.data;
|
|
}
|
|
log(`Config validation error in ${configPath}:`, result.error.issues);
|
|
return null;
|
|
} catch (error48) {
|
|
log(`Error loading config from ${configPath}:`, error48);
|
|
return null;
|
|
}
|
|
}
|
|
function mergeConfigs(base, override) {
|
|
return {
|
|
...base,
|
|
...override,
|
|
tmux: {
|
|
...base.tmux ?? {},
|
|
...override.tmux ?? {}
|
|
}
|
|
};
|
|
}
|
|
function loadPluginConfig(directory) {
|
|
const configDir = getOpenCodeConfigDir({ binary: "opencode" });
|
|
const userBasePath = join3(configDir, "tmux-utils");
|
|
const userDetected = detectConfigFile(userBasePath);
|
|
const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
|
|
const projectBasePath = join3(directory, ".opencode", "tmux-utils");
|
|
const projectDetected = detectConfigFile(projectBasePath);
|
|
const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : `${projectBasePath}.json`;
|
|
let config2 = loadConfigFromPath(userConfigPath) ?? {};
|
|
const projectConfig = loadConfigFromPath(projectConfigPath);
|
|
if (projectConfig) {
|
|
config2 = mergeConfigs(config2, projectConfig);
|
|
}
|
|
return config2;
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
|
|
var exports_external2 = {};
|
|
__export(exports_external2, {
|
|
xid: () => xid4,
|
|
void: () => _void4,
|
|
uuidv7: () => uuidv72,
|
|
uuidv6: () => uuidv62,
|
|
uuidv4: () => uuidv42,
|
|
uuid: () => uuid5,
|
|
util: () => exports_util2,
|
|
url: () => url2,
|
|
uppercase: () => _uppercase2,
|
|
unknown: () => unknown2,
|
|
union: () => union2,
|
|
undefined: () => _undefined6,
|
|
ulid: () => ulid4,
|
|
uint64: () => uint642,
|
|
uint32: () => uint322,
|
|
tuple: () => tuple2,
|
|
trim: () => _trim2,
|
|
treeifyError: () => treeifyError2,
|
|
transform: () => transform2,
|
|
toUpperCase: () => _toUpperCase2,
|
|
toLowerCase: () => _toLowerCase2,
|
|
toJSONSchema: () => toJSONSchema2,
|
|
templateLiteral: () => templateLiteral2,
|
|
symbol: () => symbol2,
|
|
superRefine: () => superRefine2,
|
|
success: () => success2,
|
|
stringbool: () => stringbool2,
|
|
stringFormat: () => stringFormat2,
|
|
string: () => string5,
|
|
strictObject: () => strictObject2,
|
|
startsWith: () => _startsWith2,
|
|
size: () => _size2,
|
|
setErrorMap: () => setErrorMap2,
|
|
set: () => set2,
|
|
safeParseAsync: () => safeParseAsync4,
|
|
safeParse: () => safeParse4,
|
|
safeEncodeAsync: () => safeEncodeAsync4,
|
|
safeEncode: () => safeEncode4,
|
|
safeDecodeAsync: () => safeDecodeAsync4,
|
|
safeDecode: () => safeDecode4,
|
|
registry: () => registry2,
|
|
regexes: () => exports_regexes2,
|
|
regex: () => _regex2,
|
|
refine: () => refine2,
|
|
record: () => record2,
|
|
readonly: () => readonly2,
|
|
property: () => _property2,
|
|
promise: () => promise2,
|
|
prettifyError: () => prettifyError2,
|
|
preprocess: () => preprocess2,
|
|
prefault: () => prefault2,
|
|
positive: () => _positive2,
|
|
pipe: () => pipe2,
|
|
partialRecord: () => partialRecord2,
|
|
parseAsync: () => parseAsync4,
|
|
parse: () => parse9,
|
|
overwrite: () => _overwrite2,
|
|
optional: () => optional2,
|
|
object: () => object2,
|
|
number: () => number5,
|
|
nullish: () => nullish4,
|
|
nullable: () => nullable2,
|
|
null: () => _null6,
|
|
normalize: () => _normalize2,
|
|
nonpositive: () => _nonpositive2,
|
|
nonoptional: () => nonoptional2,
|
|
nonnegative: () => _nonnegative2,
|
|
never: () => never2,
|
|
negative: () => _negative2,
|
|
nativeEnum: () => nativeEnum2,
|
|
nanoid: () => nanoid4,
|
|
nan: () => nan2,
|
|
multipleOf: () => _multipleOf2,
|
|
minSize: () => _minSize2,
|
|
minLength: () => _minLength2,
|
|
mime: () => _mime2,
|
|
maxSize: () => _maxSize2,
|
|
maxLength: () => _maxLength2,
|
|
map: () => map2,
|
|
lte: () => _lte2,
|
|
lt: () => _lt2,
|
|
lowercase: () => _lowercase2,
|
|
looseObject: () => looseObject2,
|
|
locales: () => exports_locales2,
|
|
literal: () => literal2,
|
|
length: () => _length2,
|
|
lazy: () => lazy2,
|
|
ksuid: () => ksuid4,
|
|
keyof: () => keyof2,
|
|
jwt: () => jwt2,
|
|
json: () => json2,
|
|
iso: () => exports_iso2,
|
|
ipv6: () => ipv64,
|
|
ipv4: () => ipv44,
|
|
intersection: () => intersection2,
|
|
int64: () => int642,
|
|
int32: () => int322,
|
|
int: () => int2,
|
|
instanceof: () => _instanceof2,
|
|
includes: () => _includes2,
|
|
httpUrl: () => httpUrl2,
|
|
hostname: () => hostname4,
|
|
hex: () => hex4,
|
|
hash: () => hash2,
|
|
guid: () => guid4,
|
|
gte: () => _gte2,
|
|
gt: () => _gt2,
|
|
globalRegistry: () => globalRegistry2,
|
|
getErrorMap: () => getErrorMap2,
|
|
function: () => _function2,
|
|
formatError: () => formatError2,
|
|
float64: () => float642,
|
|
float32: () => float322,
|
|
flattenError: () => flattenError2,
|
|
file: () => file2,
|
|
enum: () => _enum4,
|
|
endsWith: () => _endsWith2,
|
|
encodeAsync: () => encodeAsync4,
|
|
encode: () => encode4,
|
|
emoji: () => emoji4,
|
|
email: () => email4,
|
|
e164: () => e1644,
|
|
discriminatedUnion: () => discriminatedUnion2,
|
|
decodeAsync: () => decodeAsync4,
|
|
decode: () => decode4,
|
|
date: () => date7,
|
|
custom: () => custom2,
|
|
cuid2: () => cuid24,
|
|
cuid: () => cuid6,
|
|
core: () => exports_core4,
|
|
config: () => config2,
|
|
coerce: () => exports_coerce2,
|
|
codec: () => codec2,
|
|
clone: () => clone2,
|
|
cidrv6: () => cidrv64,
|
|
cidrv4: () => cidrv44,
|
|
check: () => check2,
|
|
catch: () => _catch4,
|
|
boolean: () => boolean5,
|
|
bigint: () => bigint5,
|
|
base64url: () => base64url4,
|
|
base64: () => base644,
|
|
array: () => array2,
|
|
any: () => any2,
|
|
_function: () => _function2,
|
|
_default: () => _default4,
|
|
_ZodString: () => _ZodString2,
|
|
ZodXID: () => ZodXID2,
|
|
ZodVoid: () => ZodVoid2,
|
|
ZodUnknown: () => ZodUnknown2,
|
|
ZodUnion: () => ZodUnion2,
|
|
ZodUndefined: () => ZodUndefined2,
|
|
ZodUUID: () => ZodUUID2,
|
|
ZodURL: () => ZodURL2,
|
|
ZodULID: () => ZodULID2,
|
|
ZodType: () => ZodType2,
|
|
ZodTuple: () => ZodTuple2,
|
|
ZodTransform: () => ZodTransform2,
|
|
ZodTemplateLiteral: () => ZodTemplateLiteral2,
|
|
ZodSymbol: () => ZodSymbol2,
|
|
ZodSuccess: () => ZodSuccess2,
|
|
ZodStringFormat: () => ZodStringFormat2,
|
|
ZodString: () => ZodString2,
|
|
ZodSet: () => ZodSet2,
|
|
ZodRecord: () => ZodRecord2,
|
|
ZodRealError: () => ZodRealError2,
|
|
ZodReadonly: () => ZodReadonly2,
|
|
ZodPromise: () => ZodPromise2,
|
|
ZodPrefault: () => ZodPrefault2,
|
|
ZodPipe: () => ZodPipe2,
|
|
ZodOptional: () => ZodOptional2,
|
|
ZodObject: () => ZodObject2,
|
|
ZodNumberFormat: () => ZodNumberFormat2,
|
|
ZodNumber: () => ZodNumber2,
|
|
ZodNullable: () => ZodNullable2,
|
|
ZodNull: () => ZodNull2,
|
|
ZodNonOptional: () => ZodNonOptional2,
|
|
ZodNever: () => ZodNever2,
|
|
ZodNanoID: () => ZodNanoID2,
|
|
ZodNaN: () => ZodNaN2,
|
|
ZodMap: () => ZodMap2,
|
|
ZodLiteral: () => ZodLiteral2,
|
|
ZodLazy: () => ZodLazy2,
|
|
ZodKSUID: () => ZodKSUID2,
|
|
ZodJWT: () => ZodJWT2,
|
|
ZodIssueCode: () => ZodIssueCode2,
|
|
ZodIntersection: () => ZodIntersection2,
|
|
ZodISOTime: () => ZodISOTime2,
|
|
ZodISODuration: () => ZodISODuration2,
|
|
ZodISODateTime: () => ZodISODateTime2,
|
|
ZodISODate: () => ZodISODate2,
|
|
ZodIPv6: () => ZodIPv62,
|
|
ZodIPv4: () => ZodIPv42,
|
|
ZodGUID: () => ZodGUID2,
|
|
ZodFunction: () => ZodFunction2,
|
|
ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind2,
|
|
ZodFile: () => ZodFile2,
|
|
ZodError: () => ZodError2,
|
|
ZodEnum: () => ZodEnum2,
|
|
ZodEmoji: () => ZodEmoji2,
|
|
ZodEmail: () => ZodEmail2,
|
|
ZodE164: () => ZodE1642,
|
|
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion2,
|
|
ZodDefault: () => ZodDefault2,
|
|
ZodDate: () => ZodDate2,
|
|
ZodCustomStringFormat: () => ZodCustomStringFormat2,
|
|
ZodCustom: () => ZodCustom2,
|
|
ZodCodec: () => ZodCodec2,
|
|
ZodCatch: () => ZodCatch2,
|
|
ZodCUID2: () => ZodCUID22,
|
|
ZodCUID: () => ZodCUID3,
|
|
ZodCIDRv6: () => ZodCIDRv62,
|
|
ZodCIDRv4: () => ZodCIDRv42,
|
|
ZodBoolean: () => ZodBoolean2,
|
|
ZodBigIntFormat: () => ZodBigIntFormat2,
|
|
ZodBigInt: () => ZodBigInt2,
|
|
ZodBase64URL: () => ZodBase64URL2,
|
|
ZodBase64: () => ZodBase642,
|
|
ZodArray: () => ZodArray2,
|
|
ZodAny: () => ZodAny2,
|
|
TimePrecision: () => TimePrecision2,
|
|
NEVER: () => NEVER2,
|
|
$output: () => $output2,
|
|
$input: () => $input2,
|
|
$brand: () => $brand2
|
|
});
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/index.js
|
|
var exports_core4 = {};
|
|
__export(exports_core4, {
|
|
version: () => version2,
|
|
util: () => exports_util2,
|
|
treeifyError: () => treeifyError2,
|
|
toJSONSchema: () => toJSONSchema2,
|
|
toDotPath: () => toDotPath2,
|
|
safeParseAsync: () => safeParseAsync3,
|
|
safeParse: () => safeParse3,
|
|
safeEncodeAsync: () => safeEncodeAsync3,
|
|
safeEncode: () => safeEncode3,
|
|
safeDecodeAsync: () => safeDecodeAsync3,
|
|
safeDecode: () => safeDecode3,
|
|
registry: () => registry2,
|
|
regexes: () => exports_regexes2,
|
|
prettifyError: () => prettifyError2,
|
|
parseAsync: () => parseAsync3,
|
|
parse: () => parse7,
|
|
locales: () => exports_locales2,
|
|
isValidJWT: () => isValidJWT2,
|
|
isValidBase64URL: () => isValidBase64URL2,
|
|
isValidBase64: () => isValidBase642,
|
|
globalRegistry: () => globalRegistry2,
|
|
globalConfig: () => globalConfig2,
|
|
formatError: () => formatError2,
|
|
flattenError: () => flattenError2,
|
|
encodeAsync: () => encodeAsync3,
|
|
encode: () => encode3,
|
|
decodeAsync: () => decodeAsync3,
|
|
decode: () => decode3,
|
|
config: () => config2,
|
|
clone: () => clone2,
|
|
_xid: () => _xid2,
|
|
_void: () => _void3,
|
|
_uuidv7: () => _uuidv72,
|
|
_uuidv6: () => _uuidv62,
|
|
_uuidv4: () => _uuidv42,
|
|
_uuid: () => _uuid2,
|
|
_url: () => _url2,
|
|
_uppercase: () => _uppercase2,
|
|
_unknown: () => _unknown2,
|
|
_union: () => _union2,
|
|
_undefined: () => _undefined5,
|
|
_ulid: () => _ulid2,
|
|
_uint64: () => _uint642,
|
|
_uint32: () => _uint322,
|
|
_tuple: () => _tuple2,
|
|
_trim: () => _trim2,
|
|
_transform: () => _transform2,
|
|
_toUpperCase: () => _toUpperCase2,
|
|
_toLowerCase: () => _toLowerCase2,
|
|
_templateLiteral: () => _templateLiteral2,
|
|
_symbol: () => _symbol2,
|
|
_superRefine: () => _superRefine2,
|
|
_success: () => _success2,
|
|
_stringbool: () => _stringbool2,
|
|
_stringFormat: () => _stringFormat2,
|
|
_string: () => _string2,
|
|
_startsWith: () => _startsWith2,
|
|
_size: () => _size2,
|
|
_set: () => _set2,
|
|
_safeParseAsync: () => _safeParseAsync2,
|
|
_safeParse: () => _safeParse2,
|
|
_safeEncodeAsync: () => _safeEncodeAsync2,
|
|
_safeEncode: () => _safeEncode2,
|
|
_safeDecodeAsync: () => _safeDecodeAsync2,
|
|
_safeDecode: () => _safeDecode2,
|
|
_regex: () => _regex2,
|
|
_refine: () => _refine2,
|
|
_record: () => _record2,
|
|
_readonly: () => _readonly2,
|
|
_property: () => _property2,
|
|
_promise: () => _promise2,
|
|
_positive: () => _positive2,
|
|
_pipe: () => _pipe2,
|
|
_parseAsync: () => _parseAsync2,
|
|
_parse: () => _parse2,
|
|
_overwrite: () => _overwrite2,
|
|
_optional: () => _optional2,
|
|
_number: () => _number2,
|
|
_nullable: () => _nullable2,
|
|
_null: () => _null5,
|
|
_normalize: () => _normalize2,
|
|
_nonpositive: () => _nonpositive2,
|
|
_nonoptional: () => _nonoptional2,
|
|
_nonnegative: () => _nonnegative2,
|
|
_never: () => _never2,
|
|
_negative: () => _negative2,
|
|
_nativeEnum: () => _nativeEnum2,
|
|
_nanoid: () => _nanoid2,
|
|
_nan: () => _nan2,
|
|
_multipleOf: () => _multipleOf2,
|
|
_minSize: () => _minSize2,
|
|
_minLength: () => _minLength2,
|
|
_min: () => _gte2,
|
|
_mime: () => _mime2,
|
|
_maxSize: () => _maxSize2,
|
|
_maxLength: () => _maxLength2,
|
|
_max: () => _lte2,
|
|
_map: () => _map2,
|
|
_lte: () => _lte2,
|
|
_lt: () => _lt2,
|
|
_lowercase: () => _lowercase2,
|
|
_literal: () => _literal2,
|
|
_length: () => _length2,
|
|
_lazy: () => _lazy2,
|
|
_ksuid: () => _ksuid2,
|
|
_jwt: () => _jwt2,
|
|
_isoTime: () => _isoTime2,
|
|
_isoDuration: () => _isoDuration2,
|
|
_isoDateTime: () => _isoDateTime2,
|
|
_isoDate: () => _isoDate2,
|
|
_ipv6: () => _ipv62,
|
|
_ipv4: () => _ipv42,
|
|
_intersection: () => _intersection2,
|
|
_int64: () => _int642,
|
|
_int32: () => _int322,
|
|
_int: () => _int2,
|
|
_includes: () => _includes2,
|
|
_guid: () => _guid2,
|
|
_gte: () => _gte2,
|
|
_gt: () => _gt2,
|
|
_float64: () => _float642,
|
|
_float32: () => _float322,
|
|
_file: () => _file2,
|
|
_enum: () => _enum3,
|
|
_endsWith: () => _endsWith2,
|
|
_encodeAsync: () => _encodeAsync2,
|
|
_encode: () => _encode2,
|
|
_emoji: () => _emoji4,
|
|
_email: () => _email2,
|
|
_e164: () => _e1642,
|
|
_discriminatedUnion: () => _discriminatedUnion2,
|
|
_default: () => _default3,
|
|
_decodeAsync: () => _decodeAsync2,
|
|
_decode: () => _decode2,
|
|
_date: () => _date2,
|
|
_custom: () => _custom2,
|
|
_cuid2: () => _cuid22,
|
|
_cuid: () => _cuid3,
|
|
_coercedString: () => _coercedString2,
|
|
_coercedNumber: () => _coercedNumber2,
|
|
_coercedDate: () => _coercedDate2,
|
|
_coercedBoolean: () => _coercedBoolean2,
|
|
_coercedBigint: () => _coercedBigint2,
|
|
_cidrv6: () => _cidrv62,
|
|
_cidrv4: () => _cidrv42,
|
|
_check: () => _check2,
|
|
_catch: () => _catch3,
|
|
_boolean: () => _boolean2,
|
|
_bigint: () => _bigint2,
|
|
_base64url: () => _base64url2,
|
|
_base64: () => _base642,
|
|
_array: () => _array2,
|
|
_any: () => _any2,
|
|
TimePrecision: () => TimePrecision2,
|
|
NEVER: () => NEVER2,
|
|
JSONSchemaGenerator: () => JSONSchemaGenerator2,
|
|
JSONSchema: () => exports_json_schema2,
|
|
Doc: () => Doc2,
|
|
$output: () => $output2,
|
|
$input: () => $input2,
|
|
$constructor: () => $constructor2,
|
|
$brand: () => $brand2,
|
|
$ZodXID: () => $ZodXID2,
|
|
$ZodVoid: () => $ZodVoid2,
|
|
$ZodUnknown: () => $ZodUnknown2,
|
|
$ZodUnion: () => $ZodUnion2,
|
|
$ZodUndefined: () => $ZodUndefined2,
|
|
$ZodUUID: () => $ZodUUID2,
|
|
$ZodURL: () => $ZodURL2,
|
|
$ZodULID: () => $ZodULID2,
|
|
$ZodType: () => $ZodType2,
|
|
$ZodTuple: () => $ZodTuple2,
|
|
$ZodTransform: () => $ZodTransform2,
|
|
$ZodTemplateLiteral: () => $ZodTemplateLiteral2,
|
|
$ZodSymbol: () => $ZodSymbol2,
|
|
$ZodSuccess: () => $ZodSuccess2,
|
|
$ZodStringFormat: () => $ZodStringFormat2,
|
|
$ZodString: () => $ZodString2,
|
|
$ZodSet: () => $ZodSet2,
|
|
$ZodRegistry: () => $ZodRegistry2,
|
|
$ZodRecord: () => $ZodRecord2,
|
|
$ZodRealError: () => $ZodRealError2,
|
|
$ZodReadonly: () => $ZodReadonly2,
|
|
$ZodPromise: () => $ZodPromise2,
|
|
$ZodPrefault: () => $ZodPrefault2,
|
|
$ZodPipe: () => $ZodPipe2,
|
|
$ZodOptional: () => $ZodOptional2,
|
|
$ZodObjectJIT: () => $ZodObjectJIT2,
|
|
$ZodObject: () => $ZodObject2,
|
|
$ZodNumberFormat: () => $ZodNumberFormat2,
|
|
$ZodNumber: () => $ZodNumber2,
|
|
$ZodNullable: () => $ZodNullable2,
|
|
$ZodNull: () => $ZodNull2,
|
|
$ZodNonOptional: () => $ZodNonOptional2,
|
|
$ZodNever: () => $ZodNever2,
|
|
$ZodNanoID: () => $ZodNanoID2,
|
|
$ZodNaN: () => $ZodNaN2,
|
|
$ZodMap: () => $ZodMap2,
|
|
$ZodLiteral: () => $ZodLiteral2,
|
|
$ZodLazy: () => $ZodLazy2,
|
|
$ZodKSUID: () => $ZodKSUID2,
|
|
$ZodJWT: () => $ZodJWT2,
|
|
$ZodIntersection: () => $ZodIntersection2,
|
|
$ZodISOTime: () => $ZodISOTime2,
|
|
$ZodISODuration: () => $ZodISODuration2,
|
|
$ZodISODateTime: () => $ZodISODateTime2,
|
|
$ZodISODate: () => $ZodISODate2,
|
|
$ZodIPv6: () => $ZodIPv62,
|
|
$ZodIPv4: () => $ZodIPv42,
|
|
$ZodGUID: () => $ZodGUID2,
|
|
$ZodFunction: () => $ZodFunction2,
|
|
$ZodFile: () => $ZodFile2,
|
|
$ZodError: () => $ZodError2,
|
|
$ZodEnum: () => $ZodEnum2,
|
|
$ZodEncodeError: () => $ZodEncodeError2,
|
|
$ZodEmoji: () => $ZodEmoji2,
|
|
$ZodEmail: () => $ZodEmail2,
|
|
$ZodE164: () => $ZodE1642,
|
|
$ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion2,
|
|
$ZodDefault: () => $ZodDefault2,
|
|
$ZodDate: () => $ZodDate2,
|
|
$ZodCustomStringFormat: () => $ZodCustomStringFormat2,
|
|
$ZodCustom: () => $ZodCustom2,
|
|
$ZodCodec: () => $ZodCodec2,
|
|
$ZodCheckUpperCase: () => $ZodCheckUpperCase2,
|
|
$ZodCheckStringFormat: () => $ZodCheckStringFormat2,
|
|
$ZodCheckStartsWith: () => $ZodCheckStartsWith2,
|
|
$ZodCheckSizeEquals: () => $ZodCheckSizeEquals2,
|
|
$ZodCheckRegex: () => $ZodCheckRegex2,
|
|
$ZodCheckProperty: () => $ZodCheckProperty2,
|
|
$ZodCheckOverwrite: () => $ZodCheckOverwrite2,
|
|
$ZodCheckNumberFormat: () => $ZodCheckNumberFormat2,
|
|
$ZodCheckMultipleOf: () => $ZodCheckMultipleOf2,
|
|
$ZodCheckMinSize: () => $ZodCheckMinSize2,
|
|
$ZodCheckMinLength: () => $ZodCheckMinLength2,
|
|
$ZodCheckMimeType: () => $ZodCheckMimeType2,
|
|
$ZodCheckMaxSize: () => $ZodCheckMaxSize2,
|
|
$ZodCheckMaxLength: () => $ZodCheckMaxLength2,
|
|
$ZodCheckLowerCase: () => $ZodCheckLowerCase2,
|
|
$ZodCheckLessThan: () => $ZodCheckLessThan2,
|
|
$ZodCheckLengthEquals: () => $ZodCheckLengthEquals2,
|
|
$ZodCheckIncludes: () => $ZodCheckIncludes2,
|
|
$ZodCheckGreaterThan: () => $ZodCheckGreaterThan2,
|
|
$ZodCheckEndsWith: () => $ZodCheckEndsWith2,
|
|
$ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat2,
|
|
$ZodCheck: () => $ZodCheck2,
|
|
$ZodCatch: () => $ZodCatch2,
|
|
$ZodCUID2: () => $ZodCUID22,
|
|
$ZodCUID: () => $ZodCUID3,
|
|
$ZodCIDRv6: () => $ZodCIDRv62,
|
|
$ZodCIDRv4: () => $ZodCIDRv42,
|
|
$ZodBoolean: () => $ZodBoolean2,
|
|
$ZodBigIntFormat: () => $ZodBigIntFormat2,
|
|
$ZodBigInt: () => $ZodBigInt2,
|
|
$ZodBase64URL: () => $ZodBase64URL2,
|
|
$ZodBase64: () => $ZodBase642,
|
|
$ZodAsyncError: () => $ZodAsyncError2,
|
|
$ZodArray: () => $ZodArray2,
|
|
$ZodAny: () => $ZodAny2
|
|
});
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/core.js
|
|
var NEVER2 = Object.freeze({
|
|
status: "aborted"
|
|
});
|
|
function $constructor2(name, initializer3, params) {
|
|
function init(inst, def) {
|
|
var _a2;
|
|
Object.defineProperty(inst, "_zod", {
|
|
value: inst._zod ?? {},
|
|
enumerable: false
|
|
});
|
|
(_a2 = inst._zod).traits ?? (_a2.traits = new Set);
|
|
inst._zod.traits.add(name);
|
|
initializer3(inst, def);
|
|
for (const k in _.prototype) {
|
|
if (!(k in inst))
|
|
Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
|
|
}
|
|
inst._zod.constr = _;
|
|
inst._zod.def = def;
|
|
}
|
|
const Parent = params?.Parent ?? Object;
|
|
|
|
class Definition extends Parent {
|
|
}
|
|
Object.defineProperty(Definition, "name", { value: name });
|
|
function _(def) {
|
|
var _a2;
|
|
const inst = params?.Parent ? new Definition : this;
|
|
init(inst, def);
|
|
(_a2 = inst._zod).deferred ?? (_a2.deferred = []);
|
|
for (const fn of inst._zod.deferred) {
|
|
fn();
|
|
}
|
|
return inst;
|
|
}
|
|
Object.defineProperty(_, "init", { value: init });
|
|
Object.defineProperty(_, Symbol.hasInstance, {
|
|
value: (inst) => {
|
|
if (params?.Parent && inst instanceof params.Parent)
|
|
return true;
|
|
return inst?._zod?.traits?.has(name);
|
|
}
|
|
});
|
|
Object.defineProperty(_, "name", { value: name });
|
|
return _;
|
|
}
|
|
var $brand2 = Symbol("zod_brand");
|
|
|
|
class $ZodAsyncError2 extends Error {
|
|
constructor() {
|
|
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
|
|
}
|
|
}
|
|
|
|
class $ZodEncodeError2 extends Error {
|
|
constructor(name) {
|
|
super(`Encountered unidirectional transform during encode: ${name}`);
|
|
this.name = "ZodEncodeError";
|
|
}
|
|
}
|
|
var globalConfig2 = {};
|
|
function config2(newConfig) {
|
|
if (newConfig)
|
|
Object.assign(globalConfig2, newConfig);
|
|
return globalConfig2;
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/util.js
|
|
var exports_util2 = {};
|
|
__export(exports_util2, {
|
|
unwrapMessage: () => unwrapMessage2,
|
|
uint8ArrayToHex: () => uint8ArrayToHex2,
|
|
uint8ArrayToBase64url: () => uint8ArrayToBase64url2,
|
|
uint8ArrayToBase64: () => uint8ArrayToBase642,
|
|
stringifyPrimitive: () => stringifyPrimitive2,
|
|
shallowClone: () => shallowClone2,
|
|
safeExtend: () => safeExtend2,
|
|
required: () => required2,
|
|
randomString: () => randomString2,
|
|
propertyKeyTypes: () => propertyKeyTypes2,
|
|
promiseAllObject: () => promiseAllObject2,
|
|
primitiveTypes: () => primitiveTypes2,
|
|
prefixIssues: () => prefixIssues2,
|
|
pick: () => pick2,
|
|
partial: () => partial2,
|
|
optionalKeys: () => optionalKeys2,
|
|
omit: () => omit2,
|
|
objectClone: () => objectClone2,
|
|
numKeys: () => numKeys2,
|
|
nullish: () => nullish3,
|
|
normalizeParams: () => normalizeParams2,
|
|
mergeDefs: () => mergeDefs2,
|
|
merge: () => merge2,
|
|
jsonStringifyReplacer: () => jsonStringifyReplacer2,
|
|
joinValues: () => joinValues2,
|
|
issue: () => issue2,
|
|
isPlainObject: () => isPlainObject2,
|
|
isObject: () => isObject2,
|
|
hexToUint8Array: () => hexToUint8Array2,
|
|
getSizableOrigin: () => getSizableOrigin2,
|
|
getParsedType: () => getParsedType2,
|
|
getLengthableOrigin: () => getLengthableOrigin2,
|
|
getEnumValues: () => getEnumValues2,
|
|
getElementAtPath: () => getElementAtPath2,
|
|
floatSafeRemainder: () => floatSafeRemainder2,
|
|
finalizeIssue: () => finalizeIssue2,
|
|
extend: () => extend2,
|
|
escapeRegex: () => escapeRegex2,
|
|
esc: () => esc2,
|
|
defineLazy: () => defineLazy2,
|
|
createTransparentProxy: () => createTransparentProxy2,
|
|
cloneDef: () => cloneDef2,
|
|
clone: () => clone2,
|
|
cleanRegex: () => cleanRegex2,
|
|
cleanEnum: () => cleanEnum2,
|
|
captureStackTrace: () => captureStackTrace2,
|
|
cached: () => cached2,
|
|
base64urlToUint8Array: () => base64urlToUint8Array2,
|
|
base64ToUint8Array: () => base64ToUint8Array2,
|
|
assignProp: () => assignProp2,
|
|
assertNotEqual: () => assertNotEqual2,
|
|
assertNever: () => assertNever2,
|
|
assertIs: () => assertIs2,
|
|
assertEqual: () => assertEqual2,
|
|
assert: () => assert2,
|
|
allowsEval: () => allowsEval2,
|
|
aborted: () => aborted2,
|
|
NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES2,
|
|
Class: () => Class2,
|
|
BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES2
|
|
});
|
|
function assertEqual2(val) {
|
|
return val;
|
|
}
|
|
function assertNotEqual2(val) {
|
|
return val;
|
|
}
|
|
function assertIs2(_arg) {}
|
|
function assertNever2(_x) {
|
|
throw new Error;
|
|
}
|
|
function assert2(_) {}
|
|
function getEnumValues2(entries) {
|
|
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
|
|
const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
|
|
return values;
|
|
}
|
|
function joinValues2(array2, separator = "|") {
|
|
return array2.map((val) => stringifyPrimitive2(val)).join(separator);
|
|
}
|
|
function jsonStringifyReplacer2(_, value) {
|
|
if (typeof value === "bigint")
|
|
return value.toString();
|
|
return value;
|
|
}
|
|
function cached2(getter) {
|
|
const set2 = false;
|
|
return {
|
|
get value() {
|
|
if (!set2) {
|
|
const value = getter();
|
|
Object.defineProperty(this, "value", { value });
|
|
return value;
|
|
}
|
|
throw new Error("cached value already set");
|
|
}
|
|
};
|
|
}
|
|
function nullish3(input) {
|
|
return input === null || input === undefined;
|
|
}
|
|
function cleanRegex2(source) {
|
|
const start = source.startsWith("^") ? 1 : 0;
|
|
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
|
return source.slice(start, end);
|
|
}
|
|
function floatSafeRemainder2(val, step) {
|
|
const valDecCount = (val.toString().split(".")[1] || "").length;
|
|
const stepString = step.toString();
|
|
let stepDecCount = (stepString.split(".")[1] || "").length;
|
|
if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
|
|
const match = stepString.match(/\d?e-(\d?)/);
|
|
if (match?.[1]) {
|
|
stepDecCount = Number.parseInt(match[1]);
|
|
}
|
|
}
|
|
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
|
|
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
|
|
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
|
|
return valInt % stepInt / 10 ** decCount;
|
|
}
|
|
var EVALUATING2 = Symbol("evaluating");
|
|
function defineLazy2(object2, key, getter) {
|
|
let value = undefined;
|
|
Object.defineProperty(object2, key, {
|
|
get() {
|
|
if (value === EVALUATING2) {
|
|
return;
|
|
}
|
|
if (value === undefined) {
|
|
value = EVALUATING2;
|
|
value = getter();
|
|
}
|
|
return value;
|
|
},
|
|
set(v) {
|
|
Object.defineProperty(object2, key, {
|
|
value: v
|
|
});
|
|
},
|
|
configurable: true
|
|
});
|
|
}
|
|
function objectClone2(obj) {
|
|
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
|
|
}
|
|
function assignProp2(target, prop, value) {
|
|
Object.defineProperty(target, prop, {
|
|
value,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
function mergeDefs2(...defs) {
|
|
const mergedDescriptors = {};
|
|
for (const def of defs) {
|
|
const descriptors = Object.getOwnPropertyDescriptors(def);
|
|
Object.assign(mergedDescriptors, descriptors);
|
|
}
|
|
return Object.defineProperties({}, mergedDescriptors);
|
|
}
|
|
function cloneDef2(schema) {
|
|
return mergeDefs2(schema._zod.def);
|
|
}
|
|
function getElementAtPath2(obj, path2) {
|
|
if (!path2)
|
|
return obj;
|
|
return path2.reduce((acc, key) => acc?.[key], obj);
|
|
}
|
|
function promiseAllObject2(promisesObj) {
|
|
const keys = Object.keys(promisesObj);
|
|
const promises = keys.map((key) => promisesObj[key]);
|
|
return Promise.all(promises).then((results) => {
|
|
const resolvedObj = {};
|
|
for (let i = 0;i < keys.length; i++) {
|
|
resolvedObj[keys[i]] = results[i];
|
|
}
|
|
return resolvedObj;
|
|
});
|
|
}
|
|
function randomString2(length = 10) {
|
|
const chars = "abcdefghijklmnopqrstuvwxyz";
|
|
let str = "";
|
|
for (let i = 0;i < length; i++) {
|
|
str += chars[Math.floor(Math.random() * chars.length)];
|
|
}
|
|
return str;
|
|
}
|
|
function esc2(str) {
|
|
return JSON.stringify(str);
|
|
}
|
|
var captureStackTrace2 = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
|
|
function isObject2(data) {
|
|
return typeof data === "object" && data !== null && !Array.isArray(data);
|
|
}
|
|
var allowsEval2 = cached2(() => {
|
|
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
|
|
return false;
|
|
}
|
|
try {
|
|
const F = Function;
|
|
new F("");
|
|
return true;
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
});
|
|
function isPlainObject2(o) {
|
|
if (isObject2(o) === false)
|
|
return false;
|
|
const ctor = o.constructor;
|
|
if (ctor === undefined)
|
|
return true;
|
|
const prot = ctor.prototype;
|
|
if (isObject2(prot) === false)
|
|
return false;
|
|
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function shallowClone2(o) {
|
|
if (isPlainObject2(o))
|
|
return { ...o };
|
|
if (Array.isArray(o))
|
|
return [...o];
|
|
return o;
|
|
}
|
|
function numKeys2(data) {
|
|
let keyCount = 0;
|
|
for (const key in data) {
|
|
if (Object.prototype.hasOwnProperty.call(data, key)) {
|
|
keyCount++;
|
|
}
|
|
}
|
|
return keyCount;
|
|
}
|
|
var getParsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "undefined":
|
|
return "undefined";
|
|
case "string":
|
|
return "string";
|
|
case "number":
|
|
return Number.isNaN(data) ? "nan" : "number";
|
|
case "boolean":
|
|
return "boolean";
|
|
case "function":
|
|
return "function";
|
|
case "bigint":
|
|
return "bigint";
|
|
case "symbol":
|
|
return "symbol";
|
|
case "object":
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
|
|
return "promise";
|
|
}
|
|
if (typeof Map !== "undefined" && data instanceof Map) {
|
|
return "map";
|
|
}
|
|
if (typeof Set !== "undefined" && data instanceof Set) {
|
|
return "set";
|
|
}
|
|
if (typeof Date !== "undefined" && data instanceof Date) {
|
|
return "date";
|
|
}
|
|
if (typeof File !== "undefined" && data instanceof File) {
|
|
return "file";
|
|
}
|
|
return "object";
|
|
default:
|
|
throw new Error(`Unknown data type: ${t}`);
|
|
}
|
|
};
|
|
var propertyKeyTypes2 = new Set(["string", "number", "symbol"]);
|
|
var primitiveTypes2 = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
|
|
function escapeRegex2(str) {
|
|
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
}
|
|
function clone2(inst, def, params) {
|
|
const cl = new inst._zod.constr(def ?? inst._zod.def);
|
|
if (!def || params?.parent)
|
|
cl._zod.parent = inst;
|
|
return cl;
|
|
}
|
|
function normalizeParams2(_params) {
|
|
const params = _params;
|
|
if (!params)
|
|
return {};
|
|
if (typeof params === "string")
|
|
return { error: () => params };
|
|
if (params?.message !== undefined) {
|
|
if (params?.error !== undefined)
|
|
throw new Error("Cannot specify both `message` and `error` params");
|
|
params.error = params.message;
|
|
}
|
|
delete params.message;
|
|
if (typeof params.error === "string")
|
|
return { ...params, error: () => params.error };
|
|
return params;
|
|
}
|
|
function createTransparentProxy2(getter) {
|
|
let target;
|
|
return new Proxy({}, {
|
|
get(_, prop, receiver) {
|
|
target ?? (target = getter());
|
|
return Reflect.get(target, prop, receiver);
|
|
},
|
|
set(_, prop, value, receiver) {
|
|
target ?? (target = getter());
|
|
return Reflect.set(target, prop, value, receiver);
|
|
},
|
|
has(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.has(target, prop);
|
|
},
|
|
deleteProperty(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.deleteProperty(target, prop);
|
|
},
|
|
ownKeys(_) {
|
|
target ?? (target = getter());
|
|
return Reflect.ownKeys(target);
|
|
},
|
|
getOwnPropertyDescriptor(_, prop) {
|
|
target ?? (target = getter());
|
|
return Reflect.getOwnPropertyDescriptor(target, prop);
|
|
},
|
|
defineProperty(_, prop, descriptor) {
|
|
target ?? (target = getter());
|
|
return Reflect.defineProperty(target, prop, descriptor);
|
|
}
|
|
});
|
|
}
|
|
function stringifyPrimitive2(value) {
|
|
if (typeof value === "bigint")
|
|
return value.toString() + "n";
|
|
if (typeof value === "string")
|
|
return `"${value}"`;
|
|
return `${value}`;
|
|
}
|
|
function optionalKeys2(shape) {
|
|
return Object.keys(shape).filter((k) => {
|
|
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
|
|
});
|
|
}
|
|
var NUMBER_FORMAT_RANGES2 = {
|
|
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
|
|
int32: [-2147483648, 2147483647],
|
|
uint32: [0, 4294967295],
|
|
float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
|
|
float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
|
|
};
|
|
var BIGINT_FORMAT_RANGES2 = {
|
|
int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
|
|
uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
|
|
};
|
|
function pick2(schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const def = mergeDefs2(schema._zod.def, {
|
|
get shape() {
|
|
const newShape = {};
|
|
for (const key in mask) {
|
|
if (!(key in currDef.shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
newShape[key] = currDef.shape[key];
|
|
}
|
|
assignProp2(this, "shape", newShape);
|
|
return newShape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone2(schema, def);
|
|
}
|
|
function omit2(schema, mask) {
|
|
const currDef = schema._zod.def;
|
|
const def = mergeDefs2(schema._zod.def, {
|
|
get shape() {
|
|
const newShape = { ...schema._zod.def.shape };
|
|
for (const key in mask) {
|
|
if (!(key in currDef.shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
delete newShape[key];
|
|
}
|
|
assignProp2(this, "shape", newShape);
|
|
return newShape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone2(schema, def);
|
|
}
|
|
function extend2(schema, shape) {
|
|
if (!isPlainObject2(shape)) {
|
|
throw new Error("Invalid input to extend: expected a plain object");
|
|
}
|
|
const checks3 = schema._zod.def.checks;
|
|
const hasChecks = checks3 && checks3.length > 0;
|
|
if (hasChecks) {
|
|
throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
|
|
}
|
|
const def = mergeDefs2(schema._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...schema._zod.def.shape, ...shape };
|
|
assignProp2(this, "shape", _shape);
|
|
return _shape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone2(schema, def);
|
|
}
|
|
function safeExtend2(schema, shape) {
|
|
if (!isPlainObject2(shape)) {
|
|
throw new Error("Invalid input to safeExtend: expected a plain object");
|
|
}
|
|
const def = {
|
|
...schema._zod.def,
|
|
get shape() {
|
|
const _shape = { ...schema._zod.def.shape, ...shape };
|
|
assignProp2(this, "shape", _shape);
|
|
return _shape;
|
|
},
|
|
checks: schema._zod.def.checks
|
|
};
|
|
return clone2(schema, def);
|
|
}
|
|
function merge2(a, b) {
|
|
const def = mergeDefs2(a._zod.def, {
|
|
get shape() {
|
|
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
|
|
assignProp2(this, "shape", _shape);
|
|
return _shape;
|
|
},
|
|
get catchall() {
|
|
return b._zod.def.catchall;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone2(a, def);
|
|
}
|
|
function partial2(Class2, schema, mask) {
|
|
const def = mergeDefs2(schema._zod.def, {
|
|
get shape() {
|
|
const oldShape = schema._zod.def.shape;
|
|
const shape = { ...oldShape };
|
|
if (mask) {
|
|
for (const key in mask) {
|
|
if (!(key in oldShape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
shape[key] = Class2 ? new Class2({
|
|
type: "optional",
|
|
innerType: oldShape[key]
|
|
}) : oldShape[key];
|
|
}
|
|
} else {
|
|
for (const key in oldShape) {
|
|
shape[key] = Class2 ? new Class2({
|
|
type: "optional",
|
|
innerType: oldShape[key]
|
|
}) : oldShape[key];
|
|
}
|
|
}
|
|
assignProp2(this, "shape", shape);
|
|
return shape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone2(schema, def);
|
|
}
|
|
function required2(Class2, schema, mask) {
|
|
const def = mergeDefs2(schema._zod.def, {
|
|
get shape() {
|
|
const oldShape = schema._zod.def.shape;
|
|
const shape = { ...oldShape };
|
|
if (mask) {
|
|
for (const key in mask) {
|
|
if (!(key in shape)) {
|
|
throw new Error(`Unrecognized key: "${key}"`);
|
|
}
|
|
if (!mask[key])
|
|
continue;
|
|
shape[key] = new Class2({
|
|
type: "nonoptional",
|
|
innerType: oldShape[key]
|
|
});
|
|
}
|
|
} else {
|
|
for (const key in oldShape) {
|
|
shape[key] = new Class2({
|
|
type: "nonoptional",
|
|
innerType: oldShape[key]
|
|
});
|
|
}
|
|
}
|
|
assignProp2(this, "shape", shape);
|
|
return shape;
|
|
},
|
|
checks: []
|
|
});
|
|
return clone2(schema, def);
|
|
}
|
|
function aborted2(x, startIndex = 0) {
|
|
if (x.aborted === true)
|
|
return true;
|
|
for (let i = startIndex;i < x.issues.length; i++) {
|
|
if (x.issues[i]?.continue !== true) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function prefixIssues2(path2, issues) {
|
|
return issues.map((iss) => {
|
|
var _a2;
|
|
(_a2 = iss).path ?? (_a2.path = []);
|
|
iss.path.unshift(path2);
|
|
return iss;
|
|
});
|
|
}
|
|
function unwrapMessage2(message) {
|
|
return typeof message === "string" ? message : message?.message;
|
|
}
|
|
function finalizeIssue2(iss, ctx, config3) {
|
|
const full = { ...iss, path: iss.path ?? [] };
|
|
if (!iss.message) {
|
|
const message = unwrapMessage2(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage2(ctx?.error?.(iss)) ?? unwrapMessage2(config3.customError?.(iss)) ?? unwrapMessage2(config3.localeError?.(iss)) ?? "Invalid input";
|
|
full.message = message;
|
|
}
|
|
delete full.inst;
|
|
delete full.continue;
|
|
if (!ctx?.reportInput) {
|
|
delete full.input;
|
|
}
|
|
return full;
|
|
}
|
|
function getSizableOrigin2(input) {
|
|
if (input instanceof Set)
|
|
return "set";
|
|
if (input instanceof Map)
|
|
return "map";
|
|
if (input instanceof File)
|
|
return "file";
|
|
return "unknown";
|
|
}
|
|
function getLengthableOrigin2(input) {
|
|
if (Array.isArray(input))
|
|
return "array";
|
|
if (typeof input === "string")
|
|
return "string";
|
|
return "unknown";
|
|
}
|
|
function issue2(...args) {
|
|
const [iss, input, inst] = args;
|
|
if (typeof iss === "string") {
|
|
return {
|
|
message: iss,
|
|
code: "custom",
|
|
input,
|
|
inst
|
|
};
|
|
}
|
|
return { ...iss };
|
|
}
|
|
function cleanEnum2(obj) {
|
|
return Object.entries(obj).filter(([k, _]) => {
|
|
return Number.isNaN(Number.parseInt(k, 10));
|
|
}).map((el) => el[1]);
|
|
}
|
|
function base64ToUint8Array2(base643) {
|
|
const binaryString = atob(base643);
|
|
const bytes = new Uint8Array(binaryString.length);
|
|
for (let i = 0;i < binaryString.length; i++) {
|
|
bytes[i] = binaryString.charCodeAt(i);
|
|
}
|
|
return bytes;
|
|
}
|
|
function uint8ArrayToBase642(bytes) {
|
|
let binaryString = "";
|
|
for (let i = 0;i < bytes.length; i++) {
|
|
binaryString += String.fromCharCode(bytes[i]);
|
|
}
|
|
return btoa(binaryString);
|
|
}
|
|
function base64urlToUint8Array2(base64url3) {
|
|
const base643 = base64url3.replace(/-/g, "+").replace(/_/g, "/");
|
|
const padding = "=".repeat((4 - base643.length % 4) % 4);
|
|
return base64ToUint8Array2(base643 + padding);
|
|
}
|
|
function uint8ArrayToBase64url2(bytes) {
|
|
return uint8ArrayToBase642(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
|
|
}
|
|
function hexToUint8Array2(hex3) {
|
|
const cleanHex = hex3.replace(/^0x/, "");
|
|
if (cleanHex.length % 2 !== 0) {
|
|
throw new Error("Invalid hex string length");
|
|
}
|
|
const bytes = new Uint8Array(cleanHex.length / 2);
|
|
for (let i = 0;i < cleanHex.length; i += 2) {
|
|
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
|
|
}
|
|
return bytes;
|
|
}
|
|
function uint8ArrayToHex2(bytes) {
|
|
return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
|
|
}
|
|
|
|
class Class2 {
|
|
constructor(..._args) {}
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/errors.js
|
|
var initializer3 = (inst, def) => {
|
|
inst.name = "$ZodError";
|
|
Object.defineProperty(inst, "_zod", {
|
|
value: inst._zod,
|
|
enumerable: false
|
|
});
|
|
Object.defineProperty(inst, "issues", {
|
|
value: def,
|
|
enumerable: false
|
|
});
|
|
inst.message = JSON.stringify(def, jsonStringifyReplacer2, 2);
|
|
Object.defineProperty(inst, "toString", {
|
|
value: () => inst.message,
|
|
enumerable: false
|
|
});
|
|
};
|
|
var $ZodError2 = $constructor2("$ZodError", initializer3);
|
|
var $ZodRealError2 = $constructor2("$ZodError", initializer3, { Parent: Error });
|
|
function flattenError2(error48, mapper = (issue3) => issue3.message) {
|
|
const fieldErrors = {};
|
|
const formErrors = [];
|
|
for (const sub of error48.issues) {
|
|
if (sub.path.length > 0) {
|
|
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
|
|
fieldErrors[sub.path[0]].push(mapper(sub));
|
|
} else {
|
|
formErrors.push(mapper(sub));
|
|
}
|
|
}
|
|
return { formErrors, fieldErrors };
|
|
}
|
|
function formatError2(error48, _mapper) {
|
|
const mapper = _mapper || function(issue3) {
|
|
return issue3.message;
|
|
};
|
|
const fieldErrors = { _errors: [] };
|
|
const processError = (error49) => {
|
|
for (const issue3 of error49.issues) {
|
|
if (issue3.code === "invalid_union" && issue3.errors.length) {
|
|
issue3.errors.map((issues) => processError({ issues }));
|
|
} else if (issue3.code === "invalid_key") {
|
|
processError({ issues: issue3.issues });
|
|
} else if (issue3.code === "invalid_element") {
|
|
processError({ issues: issue3.issues });
|
|
} else if (issue3.path.length === 0) {
|
|
fieldErrors._errors.push(mapper(issue3));
|
|
} else {
|
|
let curr = fieldErrors;
|
|
let i = 0;
|
|
while (i < issue3.path.length) {
|
|
const el = issue3.path[i];
|
|
const terminal = i === issue3.path.length - 1;
|
|
if (!terminal) {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
} else {
|
|
curr[el] = curr[el] || { _errors: [] };
|
|
curr[el]._errors.push(mapper(issue3));
|
|
}
|
|
curr = curr[el];
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
processError(error48);
|
|
return fieldErrors;
|
|
}
|
|
function treeifyError2(error48, _mapper) {
|
|
const mapper = _mapper || function(issue3) {
|
|
return issue3.message;
|
|
};
|
|
const result = { errors: [] };
|
|
const processError = (error49, path2 = []) => {
|
|
var _a2, _b;
|
|
for (const issue3 of error49.issues) {
|
|
if (issue3.code === "invalid_union" && issue3.errors.length) {
|
|
issue3.errors.map((issues) => processError({ issues }, issue3.path));
|
|
} else if (issue3.code === "invalid_key") {
|
|
processError({ issues: issue3.issues }, issue3.path);
|
|
} else if (issue3.code === "invalid_element") {
|
|
processError({ issues: issue3.issues }, issue3.path);
|
|
} else {
|
|
const fullpath = [...path2, ...issue3.path];
|
|
if (fullpath.length === 0) {
|
|
result.errors.push(mapper(issue3));
|
|
continue;
|
|
}
|
|
let curr = result;
|
|
let i = 0;
|
|
while (i < fullpath.length) {
|
|
const el = fullpath[i];
|
|
const terminal = i === fullpath.length - 1;
|
|
if (typeof el === "string") {
|
|
curr.properties ?? (curr.properties = {});
|
|
(_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
|
|
curr = curr.properties[el];
|
|
} else {
|
|
curr.items ?? (curr.items = []);
|
|
(_b = curr.items)[el] ?? (_b[el] = { errors: [] });
|
|
curr = curr.items[el];
|
|
}
|
|
if (terminal) {
|
|
curr.errors.push(mapper(issue3));
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
processError(error48);
|
|
return result;
|
|
}
|
|
function toDotPath2(_path) {
|
|
const segs = [];
|
|
const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
|
|
for (const seg of path2) {
|
|
if (typeof seg === "number")
|
|
segs.push(`[${seg}]`);
|
|
else if (typeof seg === "symbol")
|
|
segs.push(`[${JSON.stringify(String(seg))}]`);
|
|
else if (/[^\w$]/.test(seg))
|
|
segs.push(`[${JSON.stringify(seg)}]`);
|
|
else {
|
|
if (segs.length)
|
|
segs.push(".");
|
|
segs.push(seg);
|
|
}
|
|
}
|
|
return segs.join("");
|
|
}
|
|
function prettifyError2(error48) {
|
|
const lines = [];
|
|
const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
|
|
for (const issue3 of issues) {
|
|
lines.push(`\u2716 ${issue3.message}`);
|
|
if (issue3.path?.length)
|
|
lines.push(` \u2192 at ${toDotPath2(issue3.path)}`);
|
|
}
|
|
return lines.join(`
|
|
`);
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/parse.js
|
|
var _parse2 = (_Err) => (schema, value, _ctx, _params) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
|
|
const result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
throw new $ZodAsyncError2;
|
|
}
|
|
if (result.issues.length) {
|
|
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())));
|
|
captureStackTrace2(e, _params?.callee);
|
|
throw e;
|
|
}
|
|
return result.value;
|
|
};
|
|
var parse7 = /* @__PURE__ */ _parse2($ZodRealError2);
|
|
var _parseAsync2 = (_Err) => async (schema, value, _ctx, params) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
|
let result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise)
|
|
result = await result;
|
|
if (result.issues.length) {
|
|
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())));
|
|
captureStackTrace2(e, params?.callee);
|
|
throw e;
|
|
}
|
|
return result.value;
|
|
};
|
|
var parseAsync3 = /* @__PURE__ */ _parseAsync2($ZodRealError2);
|
|
var _safeParse2 = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
|
|
const result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
throw new $ZodAsyncError2;
|
|
}
|
|
return result.issues.length ? {
|
|
success: false,
|
|
error: new (_Err ?? $ZodError2)(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())))
|
|
} : { success: true, data: result.value };
|
|
};
|
|
var safeParse3 = /* @__PURE__ */ _safeParse2($ZodRealError2);
|
|
var _safeParseAsync2 = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
|
|
let result = schema._zod.run({ value, issues: [] }, ctx);
|
|
if (result instanceof Promise)
|
|
result = await result;
|
|
return result.issues.length ? {
|
|
success: false,
|
|
error: new _Err(result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())))
|
|
} : { success: true, data: result.value };
|
|
};
|
|
var safeParseAsync3 = /* @__PURE__ */ _safeParseAsync2($ZodRealError2);
|
|
var _encode2 = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _parse2(_Err)(schema, value, ctx);
|
|
};
|
|
var encode3 = /* @__PURE__ */ _encode2($ZodRealError2);
|
|
var _decode2 = (_Err) => (schema, value, _ctx) => {
|
|
return _parse2(_Err)(schema, value, _ctx);
|
|
};
|
|
var decode3 = /* @__PURE__ */ _decode2($ZodRealError2);
|
|
var _encodeAsync2 = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _parseAsync2(_Err)(schema, value, ctx);
|
|
};
|
|
var encodeAsync3 = /* @__PURE__ */ _encodeAsync2($ZodRealError2);
|
|
var _decodeAsync2 = (_Err) => async (schema, value, _ctx) => {
|
|
return _parseAsync2(_Err)(schema, value, _ctx);
|
|
};
|
|
var decodeAsync3 = /* @__PURE__ */ _decodeAsync2($ZodRealError2);
|
|
var _safeEncode2 = (_Err) => (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _safeParse2(_Err)(schema, value, ctx);
|
|
};
|
|
var safeEncode3 = /* @__PURE__ */ _safeEncode2($ZodRealError2);
|
|
var _safeDecode2 = (_Err) => (schema, value, _ctx) => {
|
|
return _safeParse2(_Err)(schema, value, _ctx);
|
|
};
|
|
var safeDecode3 = /* @__PURE__ */ _safeDecode2($ZodRealError2);
|
|
var _safeEncodeAsync2 = (_Err) => async (schema, value, _ctx) => {
|
|
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
|
|
return _safeParseAsync2(_Err)(schema, value, ctx);
|
|
};
|
|
var safeEncodeAsync3 = /* @__PURE__ */ _safeEncodeAsync2($ZodRealError2);
|
|
var _safeDecodeAsync2 = (_Err) => async (schema, value, _ctx) => {
|
|
return _safeParseAsync2(_Err)(schema, value, _ctx);
|
|
};
|
|
var safeDecodeAsync3 = /* @__PURE__ */ _safeDecodeAsync2($ZodRealError2);
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/regexes.js
|
|
var exports_regexes2 = {};
|
|
__export(exports_regexes2, {
|
|
xid: () => xid3,
|
|
uuid7: () => uuid72,
|
|
uuid6: () => uuid62,
|
|
uuid4: () => uuid42,
|
|
uuid: () => uuid3,
|
|
uppercase: () => uppercase2,
|
|
unicodeEmail: () => unicodeEmail2,
|
|
undefined: () => _undefined4,
|
|
ulid: () => ulid3,
|
|
time: () => time3,
|
|
string: () => string4,
|
|
sha512_hex: () => sha512_hex2,
|
|
sha512_base64url: () => sha512_base64url2,
|
|
sha512_base64: () => sha512_base642,
|
|
sha384_hex: () => sha384_hex2,
|
|
sha384_base64url: () => sha384_base64url2,
|
|
sha384_base64: () => sha384_base642,
|
|
sha256_hex: () => sha256_hex2,
|
|
sha256_base64url: () => sha256_base64url2,
|
|
sha256_base64: () => sha256_base642,
|
|
sha1_hex: () => sha1_hex2,
|
|
sha1_base64url: () => sha1_base64url2,
|
|
sha1_base64: () => sha1_base642,
|
|
rfc5322Email: () => rfc5322Email2,
|
|
number: () => number4,
|
|
null: () => _null4,
|
|
nanoid: () => nanoid3,
|
|
md5_hex: () => md5_hex2,
|
|
md5_base64url: () => md5_base64url2,
|
|
md5_base64: () => md5_base642,
|
|
lowercase: () => lowercase2,
|
|
ksuid: () => ksuid3,
|
|
ipv6: () => ipv63,
|
|
ipv4: () => ipv43,
|
|
integer: () => integer2,
|
|
idnEmail: () => idnEmail2,
|
|
html5Email: () => html5Email2,
|
|
hostname: () => hostname3,
|
|
hex: () => hex3,
|
|
guid: () => guid3,
|
|
extendedDuration: () => extendedDuration2,
|
|
emoji: () => emoji3,
|
|
email: () => email3,
|
|
e164: () => e1643,
|
|
duration: () => duration3,
|
|
domain: () => domain2,
|
|
datetime: () => datetime3,
|
|
date: () => date5,
|
|
cuid2: () => cuid23,
|
|
cuid: () => cuid5,
|
|
cidrv6: () => cidrv63,
|
|
cidrv4: () => cidrv43,
|
|
browserEmail: () => browserEmail2,
|
|
boolean: () => boolean4,
|
|
bigint: () => bigint4,
|
|
base64url: () => base64url3,
|
|
base64: () => base643
|
|
});
|
|
var cuid5 = /^[cC][^\s-]{8,}$/;
|
|
var cuid23 = /^[0-9a-z]+$/;
|
|
var ulid3 = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
|
|
var xid3 = /^[0-9a-vA-V]{20}$/;
|
|
var ksuid3 = /^[A-Za-z0-9]{27}$/;
|
|
var nanoid3 = /^[a-zA-Z0-9_-]{21}$/;
|
|
var duration3 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
|
|
var extendedDuration2 = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
|
|
var guid3 = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
|
|
var uuid3 = (version2) => {
|
|
if (!version2)
|
|
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
|
|
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
|
|
};
|
|
var uuid42 = /* @__PURE__ */ uuid3(4);
|
|
var uuid62 = /* @__PURE__ */ uuid3(6);
|
|
var uuid72 = /* @__PURE__ */ uuid3(7);
|
|
var email3 = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
|
|
var html5Email2 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
|
var rfc5322Email2 = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
|
|
var unicodeEmail2 = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
|
|
var idnEmail2 = unicodeEmail2;
|
|
var browserEmail2 = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
|
|
var _emoji3 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
|
|
function emoji3() {
|
|
return new RegExp(_emoji3, "u");
|
|
}
|
|
var ipv43 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
|
var ipv63 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
|
|
var cidrv43 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
|
|
var cidrv63 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
|
|
var base643 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
|
|
var base64url3 = /^[A-Za-z0-9_-]*$/;
|
|
var hostname3 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
|
|
var domain2 = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
|
|
var e1643 = /^\+(?:[0-9]){6,14}[0-9]$/;
|
|
var dateSource2 = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
|
|
var date5 = /* @__PURE__ */ new RegExp(`^${dateSource2}$`);
|
|
function timeSource2(args) {
|
|
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
|
|
const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
|
|
return regex;
|
|
}
|
|
function time3(args) {
|
|
return new RegExp(`^${timeSource2(args)}$`);
|
|
}
|
|
function datetime3(args) {
|
|
const time4 = timeSource2({ precision: args.precision });
|
|
const opts = ["Z"];
|
|
if (args.local)
|
|
opts.push("");
|
|
if (args.offset)
|
|
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
|
|
const timeRegex = `${time4}(?:${opts.join("|")})`;
|
|
return new RegExp(`^${dateSource2}T(?:${timeRegex})$`);
|
|
}
|
|
var string4 = (params) => {
|
|
const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
|
|
return new RegExp(`^${regex}$`);
|
|
};
|
|
var bigint4 = /^-?\d+n?$/;
|
|
var integer2 = /^-?\d+$/;
|
|
var number4 = /^-?\d+(?:\.\d+)?/;
|
|
var boolean4 = /^(?:true|false)$/i;
|
|
var _null4 = /^null$/i;
|
|
var _undefined4 = /^undefined$/i;
|
|
var lowercase2 = /^[^A-Z]*$/;
|
|
var uppercase2 = /^[^a-z]*$/;
|
|
var hex3 = /^[0-9a-fA-F]*$/;
|
|
function fixedBase642(bodyLength, padding) {
|
|
return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
|
|
}
|
|
function fixedBase64url2(length) {
|
|
return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
|
|
}
|
|
var md5_hex2 = /^[0-9a-fA-F]{32}$/;
|
|
var md5_base642 = /* @__PURE__ */ fixedBase642(22, "==");
|
|
var md5_base64url2 = /* @__PURE__ */ fixedBase64url2(22);
|
|
var sha1_hex2 = /^[0-9a-fA-F]{40}$/;
|
|
var sha1_base642 = /* @__PURE__ */ fixedBase642(27, "=");
|
|
var sha1_base64url2 = /* @__PURE__ */ fixedBase64url2(27);
|
|
var sha256_hex2 = /^[0-9a-fA-F]{64}$/;
|
|
var sha256_base642 = /* @__PURE__ */ fixedBase642(43, "=");
|
|
var sha256_base64url2 = /* @__PURE__ */ fixedBase64url2(43);
|
|
var sha384_hex2 = /^[0-9a-fA-F]{96}$/;
|
|
var sha384_base642 = /* @__PURE__ */ fixedBase642(64, "");
|
|
var sha384_base64url2 = /* @__PURE__ */ fixedBase64url2(64);
|
|
var sha512_hex2 = /^[0-9a-fA-F]{128}$/;
|
|
var sha512_base642 = /* @__PURE__ */ fixedBase642(86, "==");
|
|
var sha512_base64url2 = /* @__PURE__ */ fixedBase64url2(86);
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/checks.js
|
|
var $ZodCheck2 = /* @__PURE__ */ $constructor2("$ZodCheck", (inst, def) => {
|
|
var _a2;
|
|
inst._zod ?? (inst._zod = {});
|
|
inst._zod.def = def;
|
|
(_a2 = inst._zod).onattach ?? (_a2.onattach = []);
|
|
});
|
|
var numericOriginMap2 = {
|
|
number: "number",
|
|
bigint: "bigint",
|
|
object: "date"
|
|
};
|
|
var $ZodCheckLessThan2 = /* @__PURE__ */ $constructor2("$ZodCheckLessThan", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
const origin = numericOriginMap2[typeof def.value];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
|
|
if (def.value < curr) {
|
|
if (def.inclusive)
|
|
bag.maximum = def.value;
|
|
else
|
|
bag.exclusiveMaximum = def.value;
|
|
}
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_big",
|
|
maximum: def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckGreaterThan2 = /* @__PURE__ */ $constructor2("$ZodCheckGreaterThan", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
const origin = numericOriginMap2[typeof def.value];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
|
|
if (def.value > curr) {
|
|
if (def.inclusive)
|
|
bag.minimum = def.value;
|
|
else
|
|
bag.exclusiveMinimum = def.value;
|
|
}
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
|
|
return;
|
|
}
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_small",
|
|
minimum: def.value,
|
|
input: payload.value,
|
|
inclusive: def.inclusive,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMultipleOf2 = /* @__PURE__ */ $constructor2("$ZodCheckMultipleOf", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
var _a2;
|
|
(_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (typeof payload.value !== typeof def.value)
|
|
throw new Error("Cannot mix number and bigint in multiple_of check.");
|
|
const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder2(payload.value, def.value) === 0;
|
|
if (isMultiple)
|
|
return;
|
|
payload.issues.push({
|
|
origin: typeof payload.value,
|
|
code: "not_multiple_of",
|
|
divisor: def.value,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckNumberFormat2 = /* @__PURE__ */ $constructor2("$ZodCheckNumberFormat", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
def.format = def.format || "float64";
|
|
const isInt = def.format?.includes("int");
|
|
const origin = isInt ? "int" : "number";
|
|
const [minimum, maximum] = NUMBER_FORMAT_RANGES2[def.format];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
bag.minimum = minimum;
|
|
bag.maximum = maximum;
|
|
if (isInt)
|
|
bag.pattern = integer2;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
if (isInt) {
|
|
if (!Number.isInteger(input)) {
|
|
payload.issues.push({
|
|
expected: origin,
|
|
format: def.format,
|
|
code: "invalid_type",
|
|
continue: false,
|
|
input,
|
|
inst
|
|
});
|
|
return;
|
|
}
|
|
if (!Number.isSafeInteger(input)) {
|
|
if (input > 0) {
|
|
payload.issues.push({
|
|
input,
|
|
code: "too_big",
|
|
maximum: Number.MAX_SAFE_INTEGER,
|
|
note: "Integers must be within the safe integer range.",
|
|
inst,
|
|
origin,
|
|
continue: !def.abort
|
|
});
|
|
} else {
|
|
payload.issues.push({
|
|
input,
|
|
code: "too_small",
|
|
minimum: Number.MIN_SAFE_INTEGER,
|
|
note: "Integers must be within the safe integer range.",
|
|
inst,
|
|
origin,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (input < minimum) {
|
|
payload.issues.push({
|
|
origin: "number",
|
|
input,
|
|
code: "too_small",
|
|
minimum,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
if (input > maximum) {
|
|
payload.issues.push({
|
|
origin: "number",
|
|
input,
|
|
code: "too_big",
|
|
maximum,
|
|
inst
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodCheckBigIntFormat2 = /* @__PURE__ */ $constructor2("$ZodCheckBigIntFormat", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
const [minimum, maximum] = BIGINT_FORMAT_RANGES2[def.format];
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
bag.minimum = minimum;
|
|
bag.maximum = maximum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
if (input < minimum) {
|
|
payload.issues.push({
|
|
origin: "bigint",
|
|
input,
|
|
code: "too_small",
|
|
minimum,
|
|
inclusive: true,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
if (input > maximum) {
|
|
payload.issues.push({
|
|
origin: "bigint",
|
|
input,
|
|
code: "too_big",
|
|
maximum,
|
|
inst
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodCheckMaxSize2 = /* @__PURE__ */ $constructor2("$ZodCheckMaxSize", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck2.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish3(val) && val.size !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
|
|
if (def.maximum < curr)
|
|
inst2._zod.bag.maximum = def.maximum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const size = input.size;
|
|
if (size <= def.maximum)
|
|
return;
|
|
payload.issues.push({
|
|
origin: getSizableOrigin2(input),
|
|
code: "too_big",
|
|
maximum: def.maximum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMinSize2 = /* @__PURE__ */ $constructor2("$ZodCheckMinSize", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck2.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish3(val) && val.size !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
|
|
if (def.minimum > curr)
|
|
inst2._zod.bag.minimum = def.minimum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const size = input.size;
|
|
if (size >= def.minimum)
|
|
return;
|
|
payload.issues.push({
|
|
origin: getSizableOrigin2(input),
|
|
code: "too_small",
|
|
minimum: def.minimum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckSizeEquals2 = /* @__PURE__ */ $constructor2("$ZodCheckSizeEquals", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck2.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish3(val) && val.size !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.minimum = def.size;
|
|
bag.maximum = def.size;
|
|
bag.size = def.size;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const size = input.size;
|
|
if (size === def.size)
|
|
return;
|
|
const tooBig = size > def.size;
|
|
payload.issues.push({
|
|
origin: getSizableOrigin2(input),
|
|
...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
|
|
inclusive: true,
|
|
exact: true,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMaxLength2 = /* @__PURE__ */ $constructor2("$ZodCheckMaxLength", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck2.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish3(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
|
|
if (def.maximum < curr)
|
|
inst2._zod.bag.maximum = def.maximum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length <= def.maximum)
|
|
return;
|
|
const origin = getLengthableOrigin2(input);
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_big",
|
|
maximum: def.maximum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckMinLength2 = /* @__PURE__ */ $constructor2("$ZodCheckMinLength", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck2.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish3(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
|
|
if (def.minimum > curr)
|
|
inst2._zod.bag.minimum = def.minimum;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length >= def.minimum)
|
|
return;
|
|
const origin = getLengthableOrigin2(input);
|
|
payload.issues.push({
|
|
origin,
|
|
code: "too_small",
|
|
minimum: def.minimum,
|
|
inclusive: true,
|
|
input,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckLengthEquals2 = /* @__PURE__ */ $constructor2("$ZodCheckLengthEquals", (inst, def) => {
|
|
var _a2;
|
|
$ZodCheck2.init(inst, def);
|
|
(_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
|
|
const val = payload.value;
|
|
return !nullish3(val) && val.length !== undefined;
|
|
});
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.minimum = def.length;
|
|
bag.maximum = def.length;
|
|
bag.length = def.length;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const length = input.length;
|
|
if (length === def.length)
|
|
return;
|
|
const origin = getLengthableOrigin2(input);
|
|
const tooBig = length > def.length;
|
|
payload.issues.push({
|
|
origin,
|
|
...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
|
|
inclusive: true,
|
|
exact: true,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckStringFormat2 = /* @__PURE__ */ $constructor2("$ZodCheckStringFormat", (inst, def) => {
|
|
var _a2, _b;
|
|
$ZodCheck2.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = def.format;
|
|
if (def.pattern) {
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(def.pattern);
|
|
}
|
|
});
|
|
if (def.pattern)
|
|
(_a2 = inst._zod).check ?? (_a2.check = (payload) => {
|
|
def.pattern.lastIndex = 0;
|
|
if (def.pattern.test(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: def.format,
|
|
input: payload.value,
|
|
...def.pattern ? { pattern: def.pattern.toString() } : {},
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
});
|
|
else
|
|
(_b = inst._zod).check ?? (_b.check = () => {});
|
|
});
|
|
var $ZodCheckRegex2 = /* @__PURE__ */ $constructor2("$ZodCheckRegex", (inst, def) => {
|
|
$ZodCheckStringFormat2.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
def.pattern.lastIndex = 0;
|
|
if (def.pattern.test(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "regex",
|
|
input: payload.value,
|
|
pattern: def.pattern.toString(),
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckLowerCase2 = /* @__PURE__ */ $constructor2("$ZodCheckLowerCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = lowercase2);
|
|
$ZodCheckStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodCheckUpperCase2 = /* @__PURE__ */ $constructor2("$ZodCheckUpperCase", (inst, def) => {
|
|
def.pattern ?? (def.pattern = uppercase2);
|
|
$ZodCheckStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodCheckIncludes2 = /* @__PURE__ */ $constructor2("$ZodCheckIncludes", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
const escapedRegex = escapeRegex2(def.includes);
|
|
const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
|
|
def.pattern = pattern;
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.includes(def.includes, def.position))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "includes",
|
|
includes: def.includes,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckStartsWith2 = /* @__PURE__ */ $constructor2("$ZodCheckStartsWith", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
const pattern = new RegExp(`^${escapeRegex2(def.prefix)}.*`);
|
|
def.pattern ?? (def.pattern = pattern);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.startsWith(def.prefix))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "starts_with",
|
|
prefix: def.prefix,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckEndsWith2 = /* @__PURE__ */ $constructor2("$ZodCheckEndsWith", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
const pattern = new RegExp(`.*${escapeRegex2(def.suffix)}$`);
|
|
def.pattern ?? (def.pattern = pattern);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.patterns ?? (bag.patterns = new Set);
|
|
bag.patterns.add(pattern);
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (payload.value.endsWith(def.suffix))
|
|
return;
|
|
payload.issues.push({
|
|
origin: "string",
|
|
code: "invalid_format",
|
|
format: "ends_with",
|
|
suffix: def.suffix,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
function handleCheckPropertyResult2(result, payload, property) {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues2(property, result.issues));
|
|
}
|
|
}
|
|
var $ZodCheckProperty2 = /* @__PURE__ */ $constructor2("$ZodCheckProperty", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
const result = def.schema._zod.run({
|
|
value: payload.value[def.property],
|
|
issues: []
|
|
}, {});
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleCheckPropertyResult2(result2, payload, def.property));
|
|
}
|
|
handleCheckPropertyResult2(result, payload, def.property);
|
|
return;
|
|
};
|
|
});
|
|
var $ZodCheckMimeType2 = /* @__PURE__ */ $constructor2("$ZodCheckMimeType", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
const mimeSet = new Set(def.mime);
|
|
inst._zod.onattach.push((inst2) => {
|
|
inst2._zod.bag.mime = def.mime;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (mimeSet.has(payload.value.type))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values: def.mime,
|
|
input: payload.value.type,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCheckOverwrite2 = /* @__PURE__ */ $constructor2("$ZodCheckOverwrite", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
payload.value = def.tx(payload.value);
|
|
};
|
|
});
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/doc.js
|
|
class Doc2 {
|
|
constructor(args = []) {
|
|
this.content = [];
|
|
this.indent = 0;
|
|
if (this)
|
|
this.args = args;
|
|
}
|
|
indented(fn) {
|
|
this.indent += 1;
|
|
fn(this);
|
|
this.indent -= 1;
|
|
}
|
|
write(arg) {
|
|
if (typeof arg === "function") {
|
|
arg(this, { execution: "sync" });
|
|
arg(this, { execution: "async" });
|
|
return;
|
|
}
|
|
const content = arg;
|
|
const lines = content.split(`
|
|
`).filter((x) => x);
|
|
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
|
|
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
|
|
for (const line of dedented) {
|
|
this.content.push(line);
|
|
}
|
|
}
|
|
compile() {
|
|
const F = Function;
|
|
const args = this?.args;
|
|
const content = this?.content ?? [``];
|
|
const lines = [...content.map((x) => ` ${x}`)];
|
|
return new F(...args, lines.join(`
|
|
`));
|
|
}
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/versions.js
|
|
var version2 = {
|
|
major: 4,
|
|
minor: 1,
|
|
patch: 8
|
|
};
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/schemas.js
|
|
var $ZodType2 = /* @__PURE__ */ $constructor2("$ZodType", (inst, def) => {
|
|
var _a2;
|
|
inst ?? (inst = {});
|
|
inst._zod.def = def;
|
|
inst._zod.bag = inst._zod.bag || {};
|
|
inst._zod.version = version2;
|
|
const checks3 = [...inst._zod.def.checks ?? []];
|
|
if (inst._zod.traits.has("$ZodCheck")) {
|
|
checks3.unshift(inst);
|
|
}
|
|
for (const ch of checks3) {
|
|
for (const fn of ch._zod.onattach) {
|
|
fn(inst);
|
|
}
|
|
}
|
|
if (checks3.length === 0) {
|
|
(_a2 = inst._zod).deferred ?? (_a2.deferred = []);
|
|
inst._zod.deferred?.push(() => {
|
|
inst._zod.run = inst._zod.parse;
|
|
});
|
|
} else {
|
|
const runChecks = (payload, checks4, ctx) => {
|
|
let isAborted = aborted2(payload);
|
|
let asyncResult;
|
|
for (const ch of checks4) {
|
|
if (ch._zod.def.when) {
|
|
const shouldRun = ch._zod.def.when(payload);
|
|
if (!shouldRun)
|
|
continue;
|
|
} else if (isAborted) {
|
|
continue;
|
|
}
|
|
const currLen = payload.issues.length;
|
|
const _ = ch._zod.check(payload);
|
|
if (_ instanceof Promise && ctx?.async === false) {
|
|
throw new $ZodAsyncError2;
|
|
}
|
|
if (asyncResult || _ instanceof Promise) {
|
|
asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
|
|
await _;
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
return;
|
|
if (!isAborted)
|
|
isAborted = aborted2(payload, currLen);
|
|
});
|
|
} else {
|
|
const nextLen = payload.issues.length;
|
|
if (nextLen === currLen)
|
|
continue;
|
|
if (!isAborted)
|
|
isAborted = aborted2(payload, currLen);
|
|
}
|
|
}
|
|
if (asyncResult) {
|
|
return asyncResult.then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
return payload;
|
|
};
|
|
const handleCanaryResult = (canary, payload, ctx) => {
|
|
if (aborted2(canary)) {
|
|
canary.aborted = true;
|
|
return canary;
|
|
}
|
|
const checkResult = runChecks(payload, checks3, ctx);
|
|
if (checkResult instanceof Promise) {
|
|
if (ctx.async === false)
|
|
throw new $ZodAsyncError2;
|
|
return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
|
|
}
|
|
return inst._zod.parse(checkResult, ctx);
|
|
};
|
|
inst._zod.run = (payload, ctx) => {
|
|
if (ctx.skipChecks) {
|
|
return inst._zod.parse(payload, ctx);
|
|
}
|
|
if (ctx.direction === "backward") {
|
|
const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
|
|
if (canary instanceof Promise) {
|
|
return canary.then((canary2) => {
|
|
return handleCanaryResult(canary2, payload, ctx);
|
|
});
|
|
}
|
|
return handleCanaryResult(canary, payload, ctx);
|
|
}
|
|
const result = inst._zod.parse(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
if (ctx.async === false)
|
|
throw new $ZodAsyncError2;
|
|
return result.then((result2) => runChecks(result2, checks3, ctx));
|
|
}
|
|
return runChecks(result, checks3, ctx);
|
|
};
|
|
}
|
|
inst["~standard"] = {
|
|
validate: (value) => {
|
|
try {
|
|
const r = safeParse3(inst, value);
|
|
return r.success ? { value: r.data } : { issues: r.error?.issues };
|
|
} catch (_) {
|
|
return safeParseAsync3(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
|
|
}
|
|
},
|
|
vendor: "zod",
|
|
version: 1
|
|
};
|
|
});
|
|
var $ZodString2 = /* @__PURE__ */ $constructor2("$ZodString", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string4(inst._zod.bag);
|
|
inst._zod.parse = (payload, _) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = String(payload.value);
|
|
} catch (_2) {}
|
|
if (typeof payload.value === "string")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "string",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodStringFormat2 = /* @__PURE__ */ $constructor2("$ZodStringFormat", (inst, def) => {
|
|
$ZodCheckStringFormat2.init(inst, def);
|
|
$ZodString2.init(inst, def);
|
|
});
|
|
var $ZodGUID2 = /* @__PURE__ */ $constructor2("$ZodGUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = guid3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodUUID2 = /* @__PURE__ */ $constructor2("$ZodUUID", (inst, def) => {
|
|
if (def.version) {
|
|
const versionMap = {
|
|
v1: 1,
|
|
v2: 2,
|
|
v3: 3,
|
|
v4: 4,
|
|
v5: 5,
|
|
v6: 6,
|
|
v7: 7,
|
|
v8: 8
|
|
};
|
|
const v = versionMap[def.version];
|
|
if (v === undefined)
|
|
throw new Error(`Invalid UUID version: "${def.version}"`);
|
|
def.pattern ?? (def.pattern = uuid3(v));
|
|
} else
|
|
def.pattern ?? (def.pattern = uuid3());
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodEmail2 = /* @__PURE__ */ $constructor2("$ZodEmail", (inst, def) => {
|
|
def.pattern ?? (def.pattern = email3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodURL2 = /* @__PURE__ */ $constructor2("$ZodURL", (inst, def) => {
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
const trimmed = payload.value.trim();
|
|
const url2 = new URL(trimmed);
|
|
if (def.hostname) {
|
|
def.hostname.lastIndex = 0;
|
|
if (!def.hostname.test(url2.hostname)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid hostname",
|
|
pattern: hostname3.source,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
}
|
|
if (def.protocol) {
|
|
def.protocol.lastIndex = 0;
|
|
if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
note: "Invalid protocol",
|
|
pattern: def.protocol.source,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
}
|
|
if (def.normalize) {
|
|
payload.value = url2.href;
|
|
} else {
|
|
payload.value = trimmed;
|
|
}
|
|
return;
|
|
} catch (_) {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodEmoji2 = /* @__PURE__ */ $constructor2("$ZodEmoji", (inst, def) => {
|
|
def.pattern ?? (def.pattern = emoji3());
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodNanoID2 = /* @__PURE__ */ $constructor2("$ZodNanoID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = nanoid3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodCUID3 = /* @__PURE__ */ $constructor2("$ZodCUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cuid5);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodCUID22 = /* @__PURE__ */ $constructor2("$ZodCUID2", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cuid23);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodULID2 = /* @__PURE__ */ $constructor2("$ZodULID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ulid3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodXID2 = /* @__PURE__ */ $constructor2("$ZodXID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = xid3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodKSUID2 = /* @__PURE__ */ $constructor2("$ZodKSUID", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ksuid3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodISODateTime2 = /* @__PURE__ */ $constructor2("$ZodISODateTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = datetime3(def));
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodISODate2 = /* @__PURE__ */ $constructor2("$ZodISODate", (inst, def) => {
|
|
def.pattern ?? (def.pattern = date5);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodISOTime2 = /* @__PURE__ */ $constructor2("$ZodISOTime", (inst, def) => {
|
|
def.pattern ?? (def.pattern = time3(def));
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodISODuration2 = /* @__PURE__ */ $constructor2("$ZodISODuration", (inst, def) => {
|
|
def.pattern ?? (def.pattern = duration3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodIPv42 = /* @__PURE__ */ $constructor2("$ZodIPv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ipv43);
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = `ipv4`;
|
|
});
|
|
});
|
|
var $ZodIPv62 = /* @__PURE__ */ $constructor2("$ZodIPv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = ipv63);
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
const bag = inst2._zod.bag;
|
|
bag.format = `ipv6`;
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
try {
|
|
new URL(`http://[${payload.value}]`);
|
|
} catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "ipv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
var $ZodCIDRv42 = /* @__PURE__ */ $constructor2("$ZodCIDRv4", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cidrv43);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
var $ZodCIDRv62 = /* @__PURE__ */ $constructor2("$ZodCIDRv6", (inst, def) => {
|
|
def.pattern ?? (def.pattern = cidrv63);
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
const parts = payload.value.split("/");
|
|
try {
|
|
if (parts.length !== 2)
|
|
throw new Error;
|
|
const [address, prefix] = parts;
|
|
if (!prefix)
|
|
throw new Error;
|
|
const prefixNum = Number(prefix);
|
|
if (`${prefixNum}` !== prefix)
|
|
throw new Error;
|
|
if (prefixNum < 0 || prefixNum > 128)
|
|
throw new Error;
|
|
new URL(`http://[${address}]`);
|
|
} catch {
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "cidrv6",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
}
|
|
};
|
|
});
|
|
function isValidBase642(data) {
|
|
if (data === "")
|
|
return true;
|
|
if (data.length % 4 !== 0)
|
|
return false;
|
|
try {
|
|
atob(data);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
var $ZodBase642 = /* @__PURE__ */ $constructor2("$ZodBase64", (inst, def) => {
|
|
def.pattern ?? (def.pattern = base643);
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
inst2._zod.bag.contentEncoding = "base64";
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase642(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
function isValidBase64URL2(data) {
|
|
if (!base64url3.test(data))
|
|
return false;
|
|
const base644 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
|
|
const padded = base644.padEnd(Math.ceil(base644.length / 4) * 4, "=");
|
|
return isValidBase642(padded);
|
|
}
|
|
var $ZodBase64URL2 = /* @__PURE__ */ $constructor2("$ZodBase64URL", (inst, def) => {
|
|
def.pattern ?? (def.pattern = base64url3);
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.onattach.push((inst2) => {
|
|
inst2._zod.bag.contentEncoding = "base64url";
|
|
});
|
|
inst._zod.check = (payload) => {
|
|
if (isValidBase64URL2(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "base64url",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodE1642 = /* @__PURE__ */ $constructor2("$ZodE164", (inst, def) => {
|
|
def.pattern ?? (def.pattern = e1643);
|
|
$ZodStringFormat2.init(inst, def);
|
|
});
|
|
function isValidJWT2(token, algorithm = null) {
|
|
try {
|
|
const tokensParts = token.split(".");
|
|
if (tokensParts.length !== 3)
|
|
return false;
|
|
const [header] = tokensParts;
|
|
if (!header)
|
|
return false;
|
|
const parsedHeader = JSON.parse(atob(header));
|
|
if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
|
|
return false;
|
|
if (!parsedHeader.alg)
|
|
return false;
|
|
if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
|
|
return false;
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
var $ZodJWT2 = /* @__PURE__ */ $constructor2("$ZodJWT", (inst, def) => {
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
if (isValidJWT2(payload.value, def.alg))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: "jwt",
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodCustomStringFormat2 = /* @__PURE__ */ $constructor2("$ZodCustomStringFormat", (inst, def) => {
|
|
$ZodStringFormat2.init(inst, def);
|
|
inst._zod.check = (payload) => {
|
|
if (def.fn(payload.value))
|
|
return;
|
|
payload.issues.push({
|
|
code: "invalid_format",
|
|
format: def.format,
|
|
input: payload.value,
|
|
inst,
|
|
continue: !def.abort
|
|
});
|
|
};
|
|
});
|
|
var $ZodNumber2 = /* @__PURE__ */ $constructor2("$ZodNumber", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.pattern = inst._zod.bag.pattern ?? number4;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Number(payload.value);
|
|
} catch (_) {}
|
|
const input = payload.value;
|
|
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
|
|
return payload;
|
|
}
|
|
const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : undefined : undefined;
|
|
payload.issues.push({
|
|
expected: "number",
|
|
code: "invalid_type",
|
|
input,
|
|
inst,
|
|
...received ? { received } : {}
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodNumberFormat2 = /* @__PURE__ */ $constructor2("$ZodNumber", (inst, def) => {
|
|
$ZodCheckNumberFormat2.init(inst, def);
|
|
$ZodNumber2.init(inst, def);
|
|
});
|
|
var $ZodBoolean2 = /* @__PURE__ */ $constructor2("$ZodBoolean", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.pattern = boolean4;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = Boolean(payload.value);
|
|
} catch (_) {}
|
|
const input = payload.value;
|
|
if (typeof input === "boolean")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "boolean",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodBigInt2 = /* @__PURE__ */ $constructor2("$ZodBigInt", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.pattern = bigint4;
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce)
|
|
try {
|
|
payload.value = BigInt(payload.value);
|
|
} catch (_) {}
|
|
if (typeof payload.value === "bigint")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "bigint",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodBigIntFormat2 = /* @__PURE__ */ $constructor2("$ZodBigInt", (inst, def) => {
|
|
$ZodCheckBigIntFormat2.init(inst, def);
|
|
$ZodBigInt2.init(inst, def);
|
|
});
|
|
var $ZodSymbol2 = /* @__PURE__ */ $constructor2("$ZodSymbol", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "symbol")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "symbol",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodUndefined2 = /* @__PURE__ */ $constructor2("$ZodUndefined", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.pattern = _undefined4;
|
|
inst._zod.values = new Set([undefined]);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.optout = "optional";
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "undefined")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "undefined",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodNull2 = /* @__PURE__ */ $constructor2("$ZodNull", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.pattern = _null4;
|
|
inst._zod.values = new Set([null]);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (input === null)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "null",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodAny2 = /* @__PURE__ */ $constructor2("$ZodAny", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload) => payload;
|
|
});
|
|
var $ZodUnknown2 = /* @__PURE__ */ $constructor2("$ZodUnknown", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload) => payload;
|
|
});
|
|
var $ZodNever2 = /* @__PURE__ */ $constructor2("$ZodNever", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
payload.issues.push({
|
|
expected: "never",
|
|
code: "invalid_type",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodVoid2 = /* @__PURE__ */ $constructor2("$ZodVoid", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (typeof input === "undefined")
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "void",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodDate2 = /* @__PURE__ */ $constructor2("$ZodDate", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (def.coerce) {
|
|
try {
|
|
payload.value = new Date(payload.value);
|
|
} catch (_err) {}
|
|
}
|
|
const input = payload.value;
|
|
const isDate = input instanceof Date;
|
|
const isValidDate = isDate && !Number.isNaN(input.getTime());
|
|
if (isValidDate)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "date",
|
|
code: "invalid_type",
|
|
input,
|
|
...isDate ? { received: "Invalid Date" } : {},
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
function handleArrayResult2(result, final, index) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...prefixIssues2(index, result.issues));
|
|
}
|
|
final.value[index] = result.value;
|
|
}
|
|
var $ZodArray2 = /* @__PURE__ */ $constructor2("$ZodArray", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!Array.isArray(input)) {
|
|
payload.issues.push({
|
|
expected: "array",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = Array(input.length);
|
|
const proms = [];
|
|
for (let i = 0;i < input.length; i++) {
|
|
const item = input[i];
|
|
const result = def.element._zod.run({
|
|
value: item,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleArrayResult2(result2, payload, i)));
|
|
} else {
|
|
handleArrayResult2(result, payload, i);
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
function handlePropertyResult2(result, final, key, input) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...prefixIssues2(key, result.issues));
|
|
}
|
|
if (result.value === undefined) {
|
|
if (key in input) {
|
|
final.value[key] = undefined;
|
|
}
|
|
} else {
|
|
final.value[key] = result.value;
|
|
}
|
|
}
|
|
function normalizeDef2(def) {
|
|
const keys = Object.keys(def.shape);
|
|
for (const k of keys) {
|
|
if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
|
|
throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
|
|
}
|
|
}
|
|
const okeys = optionalKeys2(def.shape);
|
|
return {
|
|
...def,
|
|
keys,
|
|
keySet: new Set(keys),
|
|
numKeys: keys.length,
|
|
optionalKeys: new Set(okeys)
|
|
};
|
|
}
|
|
function handleCatchall2(proms, input, payload, ctx, def, inst) {
|
|
const unrecognized = [];
|
|
const keySet = def.keySet;
|
|
const _catchall = def.catchall._zod;
|
|
const t = _catchall.def.type;
|
|
for (const key of Object.keys(input)) {
|
|
if (keySet.has(key))
|
|
continue;
|
|
if (t === "never") {
|
|
unrecognized.push(key);
|
|
continue;
|
|
}
|
|
const r = _catchall.run({ value: input[key], issues: [] }, ctx);
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r2) => handlePropertyResult2(r2, payload, key, input)));
|
|
} else {
|
|
handlePropertyResult2(r, payload, key, input);
|
|
}
|
|
}
|
|
if (unrecognized.length) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
keys: unrecognized,
|
|
input,
|
|
inst
|
|
});
|
|
}
|
|
if (!proms.length)
|
|
return payload;
|
|
return Promise.all(proms).then(() => {
|
|
return payload;
|
|
});
|
|
}
|
|
var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
const _normalized = cached2(() => normalizeDef2(def));
|
|
defineLazy2(inst._zod, "propValues", () => {
|
|
const shape = def.shape;
|
|
const propValues = {};
|
|
for (const key in shape) {
|
|
const field = shape[key]._zod;
|
|
if (field.values) {
|
|
propValues[key] ?? (propValues[key] = new Set);
|
|
for (const v of field.values)
|
|
propValues[key].add(v);
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const isObject3 = isObject2;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject3(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = {};
|
|
const proms = [];
|
|
const shape = value.shape;
|
|
for (const key of value.keys) {
|
|
const el = shape[key];
|
|
const r = el._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (r instanceof Promise) {
|
|
proms.push(r.then((r2) => handlePropertyResult2(r2, payload, key, input)));
|
|
} else {
|
|
handlePropertyResult2(r, payload, key, input);
|
|
}
|
|
}
|
|
if (!catchall) {
|
|
return proms.length ? Promise.all(proms).then(() => payload) : payload;
|
|
}
|
|
return handleCatchall2(proms, input, payload, ctx, _normalized.value, inst);
|
|
};
|
|
});
|
|
var $ZodObjectJIT2 = /* @__PURE__ */ $constructor2("$ZodObjectJIT", (inst, def) => {
|
|
$ZodObject2.init(inst, def);
|
|
const superParse = inst._zod.parse;
|
|
const _normalized = cached2(() => normalizeDef2(def));
|
|
const generateFastpass = (shape) => {
|
|
const doc2 = new Doc2(["shape", "payload", "ctx"]);
|
|
const normalized = _normalized.value;
|
|
const parseStr = (key) => {
|
|
const k = esc2(key);
|
|
return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
|
|
};
|
|
doc2.write(`const input = payload.value;`);
|
|
const ids = Object.create(null);
|
|
let counter = 0;
|
|
for (const key of normalized.keys) {
|
|
ids[key] = `key_${counter++}`;
|
|
}
|
|
doc2.write(`const newResult = {};`);
|
|
for (const key of normalized.keys) {
|
|
const id = ids[key];
|
|
const k = esc2(key);
|
|
doc2.write(`const ${id} = ${parseStr(key)};`);
|
|
doc2.write(`
|
|
if (${id}.issues.length) {
|
|
payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
|
|
...iss,
|
|
path: iss.path ? [${k}, ...iss.path] : [${k}]
|
|
})));
|
|
}
|
|
|
|
|
|
if (${id}.value === undefined) {
|
|
if (${k} in input) {
|
|
newResult[${k}] = undefined;
|
|
}
|
|
} else {
|
|
newResult[${k}] = ${id}.value;
|
|
}
|
|
|
|
`);
|
|
}
|
|
doc2.write(`payload.value = newResult;`);
|
|
doc2.write(`return payload;`);
|
|
const fn = doc2.compile();
|
|
return (payload, ctx) => fn(shape, payload, ctx);
|
|
};
|
|
let fastpass;
|
|
const isObject3 = isObject2;
|
|
const jit = !globalConfig2.jitless;
|
|
const allowsEval3 = allowsEval2;
|
|
const fastEnabled = jit && allowsEval3.value;
|
|
const catchall = def.catchall;
|
|
let value;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
value ?? (value = _normalized.value);
|
|
const input = payload.value;
|
|
if (!isObject3(input)) {
|
|
payload.issues.push({
|
|
expected: "object",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
|
|
if (!fastpass)
|
|
fastpass = generateFastpass(def.shape);
|
|
payload = fastpass(payload, ctx);
|
|
if (!catchall)
|
|
return payload;
|
|
return handleCatchall2([], input, payload, ctx, value, inst);
|
|
}
|
|
return superParse(payload, ctx);
|
|
};
|
|
});
|
|
function handleUnionResults2(results, final, inst, ctx) {
|
|
for (const result of results) {
|
|
if (result.issues.length === 0) {
|
|
final.value = result.value;
|
|
return final;
|
|
}
|
|
}
|
|
const nonaborted = results.filter((r) => !aborted2(r));
|
|
if (nonaborted.length === 1) {
|
|
final.value = nonaborted[0].value;
|
|
return nonaborted[0];
|
|
}
|
|
final.issues.push({
|
|
code: "invalid_union",
|
|
input: final.value,
|
|
inst,
|
|
errors: results.map((result) => result.issues.map((iss) => finalizeIssue2(iss, ctx, config2())))
|
|
});
|
|
return final;
|
|
}
|
|
var $ZodUnion2 = /* @__PURE__ */ $constructor2("$ZodUnion", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
|
|
defineLazy2(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
|
|
defineLazy2(inst._zod, "values", () => {
|
|
if (def.options.every((o) => o._zod.values)) {
|
|
return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
|
|
}
|
|
return;
|
|
});
|
|
defineLazy2(inst._zod, "pattern", () => {
|
|
if (def.options.every((o) => o._zod.pattern)) {
|
|
const patterns = def.options.map((o) => o._zod.pattern);
|
|
return new RegExp(`^(${patterns.map((p) => cleanRegex2(p.source)).join("|")})$`);
|
|
}
|
|
return;
|
|
});
|
|
const single = def.options.length === 1;
|
|
const first = def.options[0]._zod.run;
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (single) {
|
|
return first(payload, ctx);
|
|
}
|
|
let async = false;
|
|
const results = [];
|
|
for (const option of def.options) {
|
|
const result = option._zod.run({
|
|
value: payload.value,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
results.push(result);
|
|
async = true;
|
|
} else {
|
|
if (result.issues.length === 0)
|
|
return result;
|
|
results.push(result);
|
|
}
|
|
}
|
|
if (!async)
|
|
return handleUnionResults2(results, payload, inst, ctx);
|
|
return Promise.all(results).then((results2) => {
|
|
return handleUnionResults2(results2, payload, inst, ctx);
|
|
});
|
|
};
|
|
});
|
|
var $ZodDiscriminatedUnion2 = /* @__PURE__ */ $constructor2("$ZodDiscriminatedUnion", (inst, def) => {
|
|
$ZodUnion2.init(inst, def);
|
|
const _super = inst._zod.parse;
|
|
defineLazy2(inst._zod, "propValues", () => {
|
|
const propValues = {};
|
|
for (const option of def.options) {
|
|
const pv = option._zod.propValues;
|
|
if (!pv || Object.keys(pv).length === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
|
|
for (const [k, v] of Object.entries(pv)) {
|
|
if (!propValues[k])
|
|
propValues[k] = new Set;
|
|
for (const val of v) {
|
|
propValues[k].add(val);
|
|
}
|
|
}
|
|
}
|
|
return propValues;
|
|
});
|
|
const disc = cached2(() => {
|
|
const opts = def.options;
|
|
const map2 = new Map;
|
|
for (const o of opts) {
|
|
const values = o._zod.propValues?.[def.discriminator];
|
|
if (!values || values.size === 0)
|
|
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
|
|
for (const v of values) {
|
|
if (map2.has(v)) {
|
|
throw new Error(`Duplicate discriminator value "${String(v)}"`);
|
|
}
|
|
map2.set(v, o);
|
|
}
|
|
}
|
|
return map2;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!isObject2(input)) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "object",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const opt = disc.value.get(input?.[def.discriminator]);
|
|
if (opt) {
|
|
return opt._zod.run(payload, ctx);
|
|
}
|
|
if (def.unionFallback) {
|
|
return _super(payload, ctx);
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_union",
|
|
errors: [],
|
|
note: "No matching discriminator",
|
|
discriminator: def.discriminator,
|
|
input,
|
|
path: [def.discriminator],
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodIntersection2 = /* @__PURE__ */ $constructor2("$ZodIntersection", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
const left = def.left._zod.run({ value: input, issues: [] }, ctx);
|
|
const right = def.right._zod.run({ value: input, issues: [] }, ctx);
|
|
const async = left instanceof Promise || right instanceof Promise;
|
|
if (async) {
|
|
return Promise.all([left, right]).then(([left2, right2]) => {
|
|
return handleIntersectionResults2(payload, left2, right2);
|
|
});
|
|
}
|
|
return handleIntersectionResults2(payload, left, right);
|
|
};
|
|
});
|
|
function mergeValues2(a, b) {
|
|
if (a === b) {
|
|
return { valid: true, data: a };
|
|
}
|
|
if (a instanceof Date && b instanceof Date && +a === +b) {
|
|
return { valid: true, data: a };
|
|
}
|
|
if (isPlainObject2(a) && isPlainObject2(b)) {
|
|
const bKeys = Object.keys(b);
|
|
const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
|
|
const newObj = { ...a, ...b };
|
|
for (const key of sharedKeys) {
|
|
const sharedValue = mergeValues2(a[key], b[key]);
|
|
if (!sharedValue.valid) {
|
|
return {
|
|
valid: false,
|
|
mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
|
|
};
|
|
}
|
|
newObj[key] = sharedValue.data;
|
|
}
|
|
return { valid: true, data: newObj };
|
|
}
|
|
if (Array.isArray(a) && Array.isArray(b)) {
|
|
if (a.length !== b.length) {
|
|
return { valid: false, mergeErrorPath: [] };
|
|
}
|
|
const newArray = [];
|
|
for (let index = 0;index < a.length; index++) {
|
|
const itemA = a[index];
|
|
const itemB = b[index];
|
|
const sharedValue = mergeValues2(itemA, itemB);
|
|
if (!sharedValue.valid) {
|
|
return {
|
|
valid: false,
|
|
mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
|
|
};
|
|
}
|
|
newArray.push(sharedValue.data);
|
|
}
|
|
return { valid: true, data: newArray };
|
|
}
|
|
return { valid: false, mergeErrorPath: [] };
|
|
}
|
|
function handleIntersectionResults2(result, left, right) {
|
|
if (left.issues.length) {
|
|
result.issues.push(...left.issues);
|
|
}
|
|
if (right.issues.length) {
|
|
result.issues.push(...right.issues);
|
|
}
|
|
if (aborted2(result))
|
|
return result;
|
|
const merged = mergeValues2(left.value, right.value);
|
|
if (!merged.valid) {
|
|
throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);
|
|
}
|
|
result.value = merged.data;
|
|
return result;
|
|
}
|
|
var $ZodTuple2 = /* @__PURE__ */ $constructor2("$ZodTuple", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
const items = def.items;
|
|
const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!Array.isArray(input)) {
|
|
payload.issues.push({
|
|
input,
|
|
inst,
|
|
expected: "tuple",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
payload.value = [];
|
|
const proms = [];
|
|
if (!def.rest) {
|
|
const tooBig = input.length > items.length;
|
|
const tooSmall = input.length < optStart - 1;
|
|
if (tooBig || tooSmall) {
|
|
payload.issues.push({
|
|
...tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length },
|
|
input,
|
|
inst,
|
|
origin: "array"
|
|
});
|
|
return payload;
|
|
}
|
|
}
|
|
let i = -1;
|
|
for (const item of items) {
|
|
i++;
|
|
if (i >= input.length) {
|
|
if (i >= optStart)
|
|
continue;
|
|
}
|
|
const result = item._zod.run({
|
|
value: input[i],
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleTupleResult2(result2, payload, i)));
|
|
} else {
|
|
handleTupleResult2(result, payload, i);
|
|
}
|
|
}
|
|
if (def.rest) {
|
|
const rest = input.slice(items.length);
|
|
for (const el of rest) {
|
|
i++;
|
|
const result = def.rest._zod.run({
|
|
value: el,
|
|
issues: []
|
|
}, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleTupleResult2(result2, payload, i)));
|
|
} else {
|
|
handleTupleResult2(result, payload, i);
|
|
}
|
|
}
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleTupleResult2(result, final, index) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...prefixIssues2(index, result.issues));
|
|
}
|
|
final.value[index] = result.value;
|
|
}
|
|
var $ZodRecord2 = /* @__PURE__ */ $constructor2("$ZodRecord", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!isPlainObject2(input)) {
|
|
payload.issues.push({
|
|
expected: "record",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
if (def.keyType._zod.values) {
|
|
const values = def.keyType._zod.values;
|
|
payload.value = {};
|
|
for (const key of values) {
|
|
if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => {
|
|
if (result2.issues.length) {
|
|
payload.issues.push(...prefixIssues2(key, result2.issues));
|
|
}
|
|
payload.value[key] = result2.value;
|
|
}));
|
|
} else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues2(key, result.issues));
|
|
}
|
|
payload.value[key] = result.value;
|
|
}
|
|
}
|
|
}
|
|
let unrecognized;
|
|
for (const key in input) {
|
|
if (!values.has(key)) {
|
|
unrecognized = unrecognized ?? [];
|
|
unrecognized.push(key);
|
|
}
|
|
}
|
|
if (unrecognized && unrecognized.length > 0) {
|
|
payload.issues.push({
|
|
code: "unrecognized_keys",
|
|
input,
|
|
inst,
|
|
keys: unrecognized
|
|
});
|
|
}
|
|
} else {
|
|
payload.value = {};
|
|
for (const key of Reflect.ownKeys(input)) {
|
|
if (key === "__proto__")
|
|
continue;
|
|
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
if (keyResult instanceof Promise) {
|
|
throw new Error("Async schemas not supported in object keys currently");
|
|
}
|
|
if (keyResult.issues.length) {
|
|
payload.issues.push({
|
|
code: "invalid_key",
|
|
origin: "record",
|
|
issues: keyResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2())),
|
|
input: key,
|
|
path: [key],
|
|
inst
|
|
});
|
|
payload.value[keyResult.value] = keyResult.value;
|
|
continue;
|
|
}
|
|
const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => {
|
|
if (result2.issues.length) {
|
|
payload.issues.push(...prefixIssues2(key, result2.issues));
|
|
}
|
|
payload.value[keyResult.value] = result2.value;
|
|
}));
|
|
} else {
|
|
if (result.issues.length) {
|
|
payload.issues.push(...prefixIssues2(key, result.issues));
|
|
}
|
|
payload.value[keyResult.value] = result.value;
|
|
}
|
|
}
|
|
}
|
|
if (proms.length) {
|
|
return Promise.all(proms).then(() => payload);
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodMap2 = /* @__PURE__ */ $constructor2("$ZodMap", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!(input instanceof Map)) {
|
|
payload.issues.push({
|
|
expected: "map",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
payload.value = new Map;
|
|
for (const [key, value] of input) {
|
|
const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
|
|
const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
|
|
if (keyResult instanceof Promise || valueResult instanceof Promise) {
|
|
proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
|
|
handleMapResult2(keyResult2, valueResult2, payload, key, input, inst, ctx);
|
|
}));
|
|
} else {
|
|
handleMapResult2(keyResult, valueResult, payload, key, input, inst, ctx);
|
|
}
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleMapResult2(keyResult, valueResult, final, key, input, inst, ctx) {
|
|
if (keyResult.issues.length) {
|
|
if (propertyKeyTypes2.has(typeof key)) {
|
|
final.issues.push(...prefixIssues2(key, keyResult.issues));
|
|
} else {
|
|
final.issues.push({
|
|
code: "invalid_key",
|
|
origin: "map",
|
|
input,
|
|
inst,
|
|
issues: keyResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
|
|
});
|
|
}
|
|
}
|
|
if (valueResult.issues.length) {
|
|
if (propertyKeyTypes2.has(typeof key)) {
|
|
final.issues.push(...prefixIssues2(key, valueResult.issues));
|
|
} else {
|
|
final.issues.push({
|
|
origin: "map",
|
|
code: "invalid_element",
|
|
input,
|
|
inst,
|
|
key,
|
|
issues: valueResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
|
|
});
|
|
}
|
|
}
|
|
final.value.set(keyResult.value, valueResult.value);
|
|
}
|
|
var $ZodSet2 = /* @__PURE__ */ $constructor2("$ZodSet", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const input = payload.value;
|
|
if (!(input instanceof Set)) {
|
|
payload.issues.push({
|
|
input,
|
|
inst,
|
|
expected: "set",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
const proms = [];
|
|
payload.value = new Set;
|
|
for (const item of input) {
|
|
const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
|
|
if (result instanceof Promise) {
|
|
proms.push(result.then((result2) => handleSetResult2(result2, payload)));
|
|
} else
|
|
handleSetResult2(result, payload);
|
|
}
|
|
if (proms.length)
|
|
return Promise.all(proms).then(() => payload);
|
|
return payload;
|
|
};
|
|
});
|
|
function handleSetResult2(result, final) {
|
|
if (result.issues.length) {
|
|
final.issues.push(...result.issues);
|
|
}
|
|
final.value.add(result.value);
|
|
}
|
|
var $ZodEnum2 = /* @__PURE__ */ $constructor2("$ZodEnum", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
const values = getEnumValues2(def.entries);
|
|
const valuesSet = new Set(values);
|
|
inst._zod.values = valuesSet;
|
|
inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes2.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex2(o) : o.toString()).join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (valuesSet.has(input)) {
|
|
return payload;
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values,
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodLiteral2 = /* @__PURE__ */ $constructor2("$ZodLiteral", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
if (def.values.length === 0) {
|
|
throw new Error("Cannot create literal schema with no valid values");
|
|
}
|
|
inst._zod.values = new Set(def.values);
|
|
inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex2(o) : o ? escapeRegex2(o.toString()) : String(o)).join("|")})$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (inst._zod.values.has(input)) {
|
|
return payload;
|
|
}
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
values: def.values,
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodFile2 = /* @__PURE__ */ $constructor2("$ZodFile", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
const input = payload.value;
|
|
if (input instanceof File)
|
|
return payload;
|
|
payload.issues.push({
|
|
expected: "file",
|
|
code: "invalid_type",
|
|
input,
|
|
inst
|
|
});
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodTransform2 = /* @__PURE__ */ $constructor2("$ZodTransform", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
throw new $ZodEncodeError2(inst.constructor.name);
|
|
}
|
|
const _out = def.transform(payload.value, payload);
|
|
if (ctx.async) {
|
|
const output = _out instanceof Promise ? _out : Promise.resolve(_out);
|
|
return output.then((output2) => {
|
|
payload.value = output2;
|
|
return payload;
|
|
});
|
|
}
|
|
if (_out instanceof Promise) {
|
|
throw new $ZodAsyncError2;
|
|
}
|
|
payload.value = _out;
|
|
return payload;
|
|
};
|
|
});
|
|
function handleOptionalResult2(result, input) {
|
|
if (result.issues.length && input === undefined) {
|
|
return { issues: [], value: undefined };
|
|
}
|
|
return result;
|
|
}
|
|
var $ZodOptional2 = /* @__PURE__ */ $constructor2("$ZodOptional", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
inst._zod.optout = "optional";
|
|
defineLazy2(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;
|
|
});
|
|
defineLazy2(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${cleanRegex2(pattern.source)})?$`) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (def.innerType._zod.optin === "optional") {
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise)
|
|
return result.then((r) => handleOptionalResult2(r, payload.value));
|
|
return handleOptionalResult2(result, payload.value);
|
|
}
|
|
if (payload.value === undefined) {
|
|
return payload;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodNullable2 = /* @__PURE__ */ $constructor2("$ZodNullable", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
defineLazy2(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
defineLazy2(inst._zod, "pattern", () => {
|
|
const pattern = def.innerType._zod.pattern;
|
|
return pattern ? new RegExp(`^(${cleanRegex2(pattern.source)}|null)$`) : undefined;
|
|
});
|
|
defineLazy2(inst._zod, "values", () => {
|
|
return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (payload.value === null)
|
|
return payload;
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodDefault2 = /* @__PURE__ */ $constructor2("$ZodDefault", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
return payload;
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleDefaultResult2(result2, def));
|
|
}
|
|
return handleDefaultResult2(result, def);
|
|
};
|
|
});
|
|
function handleDefaultResult2(payload, def) {
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return payload;
|
|
}
|
|
var $ZodPrefault2 = /* @__PURE__ */ $constructor2("$ZodPrefault", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.optin = "optional";
|
|
defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
if (payload.value === undefined) {
|
|
payload.value = def.defaultValue;
|
|
}
|
|
return def.innerType._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodNonOptional2 = /* @__PURE__ */ $constructor2("$ZodNonOptional", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "values", () => {
|
|
const v = def.innerType._zod.values;
|
|
return v ? new Set([...v].filter((x) => x !== undefined)) : undefined;
|
|
});
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => handleNonOptionalResult2(result2, inst));
|
|
}
|
|
return handleNonOptionalResult2(result, inst);
|
|
};
|
|
});
|
|
function handleNonOptionalResult2(payload, inst) {
|
|
if (!payload.issues.length && payload.value === undefined) {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "nonoptional",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
}
|
|
return payload;
|
|
}
|
|
var $ZodSuccess2 = /* @__PURE__ */ $constructor2("$ZodSuccess", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
throw new $ZodEncodeError2("ZodSuccess");
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => {
|
|
payload.value = result2.issues.length === 0;
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = result.issues.length === 0;
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodCatch2 = /* @__PURE__ */ $constructor2("$ZodCatch", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
defineLazy2(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then((result2) => {
|
|
payload.value = result2.value;
|
|
if (result2.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result2.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
|
|
},
|
|
input: payload.value
|
|
});
|
|
payload.issues = [];
|
|
}
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = result.value;
|
|
if (result.issues.length) {
|
|
payload.value = def.catchValue({
|
|
...payload,
|
|
error: {
|
|
issues: result.issues.map((iss) => finalizeIssue2(iss, ctx, config2()))
|
|
},
|
|
input: payload.value
|
|
});
|
|
payload.issues = [];
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodNaN2 = /* @__PURE__ */ $constructor2("$ZodNaN", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
expected: "nan",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodPipe2 = /* @__PURE__ */ $constructor2("$ZodPipe", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "values", () => def.in._zod.values);
|
|
defineLazy2(inst._zod, "optin", () => def.in._zod.optin);
|
|
defineLazy2(inst._zod, "optout", () => def.out._zod.optout);
|
|
defineLazy2(inst._zod, "propValues", () => def.in._zod.propValues);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
const right = def.out._zod.run(payload, ctx);
|
|
if (right instanceof Promise) {
|
|
return right.then((right2) => handlePipeResult2(right2, def.in, ctx));
|
|
}
|
|
return handlePipeResult2(right, def.in, ctx);
|
|
}
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left2) => handlePipeResult2(left2, def.out, ctx));
|
|
}
|
|
return handlePipeResult2(left, def.out, ctx);
|
|
};
|
|
});
|
|
function handlePipeResult2(left, next, ctx) {
|
|
if (left.issues.length) {
|
|
left.aborted = true;
|
|
return left;
|
|
}
|
|
return next._zod.run({ value: left.value, issues: left.issues }, ctx);
|
|
}
|
|
var $ZodCodec2 = /* @__PURE__ */ $constructor2("$ZodCodec", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "values", () => def.in._zod.values);
|
|
defineLazy2(inst._zod, "optin", () => def.in._zod.optin);
|
|
defineLazy2(inst._zod, "optout", () => def.out._zod.optout);
|
|
defineLazy2(inst._zod, "propValues", () => def.in._zod.propValues);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const direction = ctx.direction || "forward";
|
|
if (direction === "forward") {
|
|
const left = def.in._zod.run(payload, ctx);
|
|
if (left instanceof Promise) {
|
|
return left.then((left2) => handleCodecAResult2(left2, def, ctx));
|
|
}
|
|
return handleCodecAResult2(left, def, ctx);
|
|
} else {
|
|
const right = def.out._zod.run(payload, ctx);
|
|
if (right instanceof Promise) {
|
|
return right.then((right2) => handleCodecAResult2(right2, def, ctx));
|
|
}
|
|
return handleCodecAResult2(right, def, ctx);
|
|
}
|
|
};
|
|
});
|
|
function handleCodecAResult2(result, def, ctx) {
|
|
if (result.issues.length) {
|
|
result.aborted = true;
|
|
return result;
|
|
}
|
|
const direction = ctx.direction || "forward";
|
|
if (direction === "forward") {
|
|
const transformed = def.transform(result.value, result);
|
|
if (transformed instanceof Promise) {
|
|
return transformed.then((value) => handleCodecTxResult2(result, value, def.out, ctx));
|
|
}
|
|
return handleCodecTxResult2(result, transformed, def.out, ctx);
|
|
} else {
|
|
const transformed = def.reverseTransform(result.value, result);
|
|
if (transformed instanceof Promise) {
|
|
return transformed.then((value) => handleCodecTxResult2(result, value, def.in, ctx));
|
|
}
|
|
return handleCodecTxResult2(result, transformed, def.in, ctx);
|
|
}
|
|
}
|
|
function handleCodecTxResult2(left, value, nextSchema, ctx) {
|
|
if (left.issues.length) {
|
|
left.aborted = true;
|
|
return left;
|
|
}
|
|
return nextSchema._zod.run({ value, issues: left.issues }, ctx);
|
|
}
|
|
var $ZodReadonly2 = /* @__PURE__ */ $constructor2("$ZodReadonly", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "propValues", () => def.innerType._zod.propValues);
|
|
defineLazy2(inst._zod, "values", () => def.innerType._zod.values);
|
|
defineLazy2(inst._zod, "optin", () => def.innerType._zod.optin);
|
|
defineLazy2(inst._zod, "optout", () => def.innerType._zod.optout);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
if (ctx.direction === "backward") {
|
|
return def.innerType._zod.run(payload, ctx);
|
|
}
|
|
const result = def.innerType._zod.run(payload, ctx);
|
|
if (result instanceof Promise) {
|
|
return result.then(handleReadonlyResult2);
|
|
}
|
|
return handleReadonlyResult2(result);
|
|
};
|
|
});
|
|
function handleReadonlyResult2(payload) {
|
|
payload.value = Object.freeze(payload.value);
|
|
return payload;
|
|
}
|
|
var $ZodTemplateLiteral2 = /* @__PURE__ */ $constructor2("$ZodTemplateLiteral", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
const regexParts = [];
|
|
for (const part of def.parts) {
|
|
if (typeof part === "object" && part !== null) {
|
|
if (!part._zod.pattern) {
|
|
throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
|
|
}
|
|
const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
|
|
if (!source)
|
|
throw new Error(`Invalid template literal part: ${part._zod.traits}`);
|
|
const start = source.startsWith("^") ? 1 : 0;
|
|
const end = source.endsWith("$") ? source.length - 1 : source.length;
|
|
regexParts.push(source.slice(start, end));
|
|
} else if (part === null || primitiveTypes2.has(typeof part)) {
|
|
regexParts.push(escapeRegex2(`${part}`));
|
|
} else {
|
|
throw new Error(`Invalid template literal part: ${part}`);
|
|
}
|
|
}
|
|
inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "string") {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
expected: "template_literal",
|
|
code: "invalid_type"
|
|
});
|
|
return payload;
|
|
}
|
|
inst._zod.pattern.lastIndex = 0;
|
|
if (!inst._zod.pattern.test(payload.value)) {
|
|
payload.issues.push({
|
|
input: payload.value,
|
|
inst,
|
|
code: "invalid_format",
|
|
format: def.format ?? "template_literal",
|
|
pattern: inst._zod.pattern.source
|
|
});
|
|
return payload;
|
|
}
|
|
return payload;
|
|
};
|
|
});
|
|
var $ZodFunction2 = /* @__PURE__ */ $constructor2("$ZodFunction", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._def = def;
|
|
inst._zod.def = def;
|
|
inst.implement = (func) => {
|
|
if (typeof func !== "function") {
|
|
throw new Error("implement() must be called with a function");
|
|
}
|
|
return function(...args) {
|
|
const parsedArgs = inst._def.input ? parse7(inst._def.input, args) : args;
|
|
const result = Reflect.apply(func, this, parsedArgs);
|
|
if (inst._def.output) {
|
|
return parse7(inst._def.output, result);
|
|
}
|
|
return result;
|
|
};
|
|
};
|
|
inst.implementAsync = (func) => {
|
|
if (typeof func !== "function") {
|
|
throw new Error("implementAsync() must be called with a function");
|
|
}
|
|
return async function(...args) {
|
|
const parsedArgs = inst._def.input ? await parseAsync3(inst._def.input, args) : args;
|
|
const result = await Reflect.apply(func, this, parsedArgs);
|
|
if (inst._def.output) {
|
|
return await parseAsync3(inst._def.output, result);
|
|
}
|
|
return result;
|
|
};
|
|
};
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (typeof payload.value !== "function") {
|
|
payload.issues.push({
|
|
code: "invalid_type",
|
|
expected: "function",
|
|
input: payload.value,
|
|
inst
|
|
});
|
|
return payload;
|
|
}
|
|
const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
|
|
if (hasPromiseOutput) {
|
|
payload.value = inst.implementAsync(payload.value);
|
|
} else {
|
|
payload.value = inst.implement(payload.value);
|
|
}
|
|
return payload;
|
|
};
|
|
inst.input = (...args) => {
|
|
const F = inst.constructor;
|
|
if (Array.isArray(args[0])) {
|
|
return new F({
|
|
type: "function",
|
|
input: new $ZodTuple2({
|
|
type: "tuple",
|
|
items: args[0],
|
|
rest: args[1]
|
|
}),
|
|
output: inst._def.output
|
|
});
|
|
}
|
|
return new F({
|
|
type: "function",
|
|
input: args[0],
|
|
output: inst._def.output
|
|
});
|
|
};
|
|
inst.output = (output) => {
|
|
const F = inst.constructor;
|
|
return new F({
|
|
type: "function",
|
|
input: inst._def.input,
|
|
output
|
|
});
|
|
};
|
|
return inst;
|
|
});
|
|
var $ZodPromise2 = /* @__PURE__ */ $constructor2("$ZodPromise", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
|
|
};
|
|
});
|
|
var $ZodLazy2 = /* @__PURE__ */ $constructor2("$ZodLazy", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
defineLazy2(inst._zod, "innerType", () => def.getter());
|
|
defineLazy2(inst._zod, "pattern", () => inst._zod.innerType._zod.pattern);
|
|
defineLazy2(inst._zod, "propValues", () => inst._zod.innerType._zod.propValues);
|
|
defineLazy2(inst._zod, "optin", () => inst._zod.innerType._zod.optin ?? undefined);
|
|
defineLazy2(inst._zod, "optout", () => inst._zod.innerType._zod.optout ?? undefined);
|
|
inst._zod.parse = (payload, ctx) => {
|
|
const inner = inst._zod.innerType;
|
|
return inner._zod.run(payload, ctx);
|
|
};
|
|
});
|
|
var $ZodCustom2 = /* @__PURE__ */ $constructor2("$ZodCustom", (inst, def) => {
|
|
$ZodCheck2.init(inst, def);
|
|
$ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _) => {
|
|
return payload;
|
|
};
|
|
inst._zod.check = (payload) => {
|
|
const input = payload.value;
|
|
const r = def.fn(input);
|
|
if (r instanceof Promise) {
|
|
return r.then((r2) => handleRefineResult2(r2, payload, input, inst));
|
|
}
|
|
handleRefineResult2(r, payload, input, inst);
|
|
return;
|
|
};
|
|
});
|
|
function handleRefineResult2(result, payload, input, inst) {
|
|
if (!result) {
|
|
const _iss = {
|
|
code: "custom",
|
|
input,
|
|
inst,
|
|
path: [...inst._zod.def.path ?? []],
|
|
continue: !inst._zod.def.abort
|
|
};
|
|
if (inst._zod.def.params)
|
|
_iss.params = inst._zod.def.params;
|
|
payload.issues.push(issue2(_iss));
|
|
}
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/index.js
|
|
var exports_locales2 = {};
|
|
__export(exports_locales2, {
|
|
zhTW: () => zh_TW_default2,
|
|
zhCN: () => zh_CN_default2,
|
|
yo: () => yo_default2,
|
|
vi: () => vi_default2,
|
|
ur: () => ur_default2,
|
|
uk: () => uk_default2,
|
|
ua: () => ua_default2,
|
|
tr: () => tr_default2,
|
|
th: () => th_default2,
|
|
ta: () => ta_default2,
|
|
sv: () => sv_default2,
|
|
sl: () => sl_default2,
|
|
ru: () => ru_default2,
|
|
pt: () => pt_default2,
|
|
ps: () => ps_default2,
|
|
pl: () => pl_default2,
|
|
ota: () => ota_default2,
|
|
no: () => no_default2,
|
|
nl: () => nl_default2,
|
|
ms: () => ms_default2,
|
|
mk: () => mk_default2,
|
|
lt: () => lt_default2,
|
|
ko: () => ko_default2,
|
|
km: () => km_default2,
|
|
kh: () => kh_default2,
|
|
ka: () => ka_default2,
|
|
ja: () => ja_default2,
|
|
it: () => it_default2,
|
|
is: () => is_default2,
|
|
id: () => id_default2,
|
|
hu: () => hu_default2,
|
|
he: () => he_default2,
|
|
frCA: () => fr_CA_default2,
|
|
fr: () => fr_default2,
|
|
fi: () => fi_default2,
|
|
fa: () => fa_default2,
|
|
es: () => es_default2,
|
|
eo: () => eo_default2,
|
|
en: () => en_default2,
|
|
de: () => de_default2,
|
|
da: () => da_default2,
|
|
cs: () => cs_default2,
|
|
ca: () => ca_default2,
|
|
be: () => be_default2,
|
|
az: () => az_default2,
|
|
ar: () => ar_default2
|
|
});
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ar.js
|
|
var error48 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
|
|
file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
|
|
array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
|
|
set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0645\u062F\u062E\u0644",
|
|
email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A",
|
|
url: "\u0631\u0627\u0628\u0637",
|
|
emoji: "\u0625\u064A\u0645\u0648\u062C\u064A",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
|
|
ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4",
|
|
ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6",
|
|
cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4",
|
|
cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6",
|
|
base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded",
|
|
base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded",
|
|
json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON",
|
|
e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0645\u062F\u062E\u0644"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${issue3.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${parsedType2(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue3.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"}`;
|
|
return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue3.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue3.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue3.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${issue3.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`;
|
|
return `${Nouns[_issue.format] ?? issue3.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u0645\u0639\u0631\u0641${issue3.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${issue3.keys.length > 1 ? "\u0629" : ""}: ${joinValues2(issue3.keys, "\u060C ")}`;
|
|
case "invalid_key":
|
|
return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
|
|
case "invalid_element":
|
|
return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue3.origin}`;
|
|
default:
|
|
return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
|
|
}
|
|
};
|
|
};
|
|
function ar_default2() {
|
|
return {
|
|
localeError: error48()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/az.js
|
|
var error49 = () => {
|
|
const Sizable = {
|
|
string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
|
|
file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
|
|
array: { unit: "element", verb: "olmal\u0131d\u0131r" },
|
|
set: { unit: "element", verb: "olmal\u0131d\u0131r" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${issue3.expected}, daxil olan ${parsedType2(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue3.origin ?? "d\u0259y\u0259r"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element"}`;
|
|
return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue3.origin ?? "d\u0259y\u0259r"} ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Yanl\u0131\u015F m\u0259tn: "${_issue.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`;
|
|
if (_issue.format === "ends_with")
|
|
return `Yanl\u0131\u015F m\u0259tn: "${_issue.suffix}" il\u0259 bitm\u0259lidir`;
|
|
if (_issue.format === "includes")
|
|
return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`;
|
|
if (_issue.format === "regex")
|
|
return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`;
|
|
return `Yanl\u0131\u015F ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Yanl\u0131\u015F \u0259d\u0259d: ${issue3.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`;
|
|
case "unrecognized_keys":
|
|
return `Tan\u0131nmayan a\xE7ar${issue3.keys.length > 1 ? "lar" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`;
|
|
case "invalid_union":
|
|
return "Yanl\u0131\u015F d\u0259y\u0259r";
|
|
case "invalid_element":
|
|
return `${issue3.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`;
|
|
default:
|
|
return `Yanl\u0131\u015F d\u0259y\u0259r`;
|
|
}
|
|
};
|
|
};
|
|
function az_default2() {
|
|
return {
|
|
localeError: error49()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/be.js
|
|
function getBelarusianPlural2(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;
|
|
}
|
|
var error50 = () => {
|
|
const Sizable = {
|
|
string: {
|
|
unit: {
|
|
one: "\u0441\u0456\u043C\u0432\u0430\u043B",
|
|
few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B",
|
|
many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
},
|
|
array: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
},
|
|
set: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
},
|
|
file: {
|
|
unit: {
|
|
one: "\u0431\u0430\u0439\u0442",
|
|
few: "\u0431\u0430\u0439\u0442\u044B",
|
|
many: "\u0431\u0430\u0439\u0442\u0430\u045E"
|
|
},
|
|
verb: "\u043C\u0435\u0446\u044C"
|
|
}
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u043B\u0456\u043A";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u043C\u0430\u0441\u0456\u045E";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0443\u0432\u043E\u0434",
|
|
email: "email \u0430\u0434\u0440\u0430\u0441",
|
|
url: "URL",
|
|
emoji: "\u044D\u043C\u043E\u0434\u0437\u0456",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441",
|
|
date: "ISO \u0434\u0430\u0442\u0430",
|
|
time: "ISO \u0447\u0430\u0441",
|
|
duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C",
|
|
ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441",
|
|
ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441",
|
|
cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
|
|
cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
|
|
base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64",
|
|
base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url",
|
|
json_string: "JSON \u0440\u0430\u0434\u043E\u043A",
|
|
e164: "\u043D\u0443\u043C\u0430\u0440 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0443\u0432\u043E\u0434"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${issue3.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${parsedType2(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
const maxValue = Number(issue3.maximum);
|
|
const unit = getBelarusianPlural2(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue3.maximum.toString()} ${unit}`;
|
|
}
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
const minValue = Number(issue3.minimum);
|
|
const unit = getBelarusianPlural2(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue3.minimum.toString()} ${unit}`;
|
|
}
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue3.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${issue3.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434";
|
|
case "invalid_element":
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${issue3.origin}`;
|
|
default:
|
|
return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434`;
|
|
}
|
|
};
|
|
};
|
|
function be_default2() {
|
|
return {
|
|
localeError: error50()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ca.js
|
|
var error51 = () => {
|
|
const Sizable = {
|
|
string: { unit: "car\xE0cters", 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 parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "entrada",
|
|
email: "adre\xE7a electr\xF2nica",
|
|
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\xE7a IPv4",
|
|
ipv6: "adre\xE7a IPv6",
|
|
cidrv4: "rang IPv4",
|
|
cidrv6: "rang IPv6",
|
|
base64: "cadena codificada en base64",
|
|
base64url: "cadena codificada en base64url",
|
|
json_string: "cadena JSON",
|
|
e164: "n\xFAmero E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entrada"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Tipus inv\xE0lid: s'esperava ${issue3.expected}, s'ha rebut ${parsedType2(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Valor inv\xE0lid: s'esperava ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Opci\xF3 inv\xE0lida: s'esperava una de ${joinValues2(issue3.values, " o ")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "com a m\xE0xim" : "menys de";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Massa gran: s'esperava que ${issue3.origin ?? "el valor"} contingu\xE9s ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "elements"}`;
|
|
return `Massa gran: s'esperava que ${issue3.origin ?? "el valor"} fos ${adj} ${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? "com a m\xEDnim" : "m\xE9s de";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Massa petit: s'esperava que ${issue3.origin} contingu\xE9s ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Massa petit: s'esperava que ${issue3.origin} fos ${adj} ${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `Format inv\xE0lid: ha de comen\xE7ar amb "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Format inv\xE0lid: ha d'acabar amb "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`;
|
|
return `Format inv\xE0lid per a ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Clau${issue3.keys.length > 1 ? "s" : ""} no reconeguda${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Clau inv\xE0lida a ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Entrada inv\xE0lida";
|
|
case "invalid_element":
|
|
return `Element inv\xE0lid a ${issue3.origin}`;
|
|
default:
|
|
return `Entrada inv\xE0lida`;
|
|
}
|
|
};
|
|
};
|
|
function ca_default2() {
|
|
return {
|
|
localeError: error51()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/cs.js
|
|
var error52 = () => {
|
|
const Sizable = {
|
|
string: { unit: "znak\u016F", verb: "m\xEDt" },
|
|
file: { unit: "bajt\u016F", verb: "m\xEDt" },
|
|
array: { unit: "prvk\u016F", verb: "m\xEDt" },
|
|
set: { unit: "prvk\u016F", verb: "m\xEDt" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u010D\xEDslo";
|
|
}
|
|
case "string": {
|
|
return "\u0159et\u011Bzec";
|
|
}
|
|
case "boolean": {
|
|
return "boolean";
|
|
}
|
|
case "bigint": {
|
|
return "bigint";
|
|
}
|
|
case "function": {
|
|
return "funkce";
|
|
}
|
|
case "symbol": {
|
|
return "symbol";
|
|
}
|
|
case "undefined": {
|
|
return "undefined";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "pole";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "regul\xE1rn\xED v\xFDraz",
|
|
email: "e-mailov\xE1 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 \u010Das ve form\xE1tu ISO",
|
|
date: "datum ve form\xE1tu ISO",
|
|
time: "\u010Das ve form\xE1tu ISO",
|
|
duration: "doba trv\xE1n\xED ISO",
|
|
ipv4: "IPv4 adresa",
|
|
ipv6: "IPv6 adresa",
|
|
cidrv4: "rozsah IPv4",
|
|
cidrv6: "rozsah IPv6",
|
|
base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64",
|
|
base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url",
|
|
json_string: "\u0159et\u011Bzec ve form\xE1tu JSON",
|
|
e164: "\u010D\xEDslo E.164",
|
|
jwt: "JWT",
|
|
template_literal: "vstup"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${issue3.expected}, obdr\u017Eeno ${parsedType2(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue3.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
|
|
}
|
|
return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue3.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue3.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue3.minimum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
|
|
}
|
|
return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue3.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`;
|
|
return `Neplatn\xFD form\xE1t ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Nezn\xE1m\xE9 kl\xED\u010De: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Neplatn\xFD kl\xED\u010D v ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Neplatn\xFD vstup";
|
|
case "invalid_element":
|
|
return `Neplatn\xE1 hodnota v ${issue3.origin}`;
|
|
default:
|
|
return `Neplatn\xFD vstup`;
|
|
}
|
|
};
|
|
};
|
|
function cs_default2() {
|
|
return {
|
|
localeError: error52()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/da.js
|
|
var error53 = () => {
|
|
const Sizable = {
|
|
string: { unit: "tegn", verb: "havde" },
|
|
file: { unit: "bytes", verb: "havde" },
|
|
array: { unit: "elementer", verb: "indeholdt" },
|
|
set: { unit: "elementer", verb: "indeholdt" }
|
|
};
|
|
const TypeNames = {
|
|
string: "streng",
|
|
number: "tal",
|
|
boolean: "boolean",
|
|
array: "liste",
|
|
object: "objekt",
|
|
set: "s\xE6t",
|
|
file: "fil"
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
function getTypeName(type) {
|
|
return TypeNames[type] ?? type;
|
|
}
|
|
const parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "tal";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "liste";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
return "objekt";
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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\xE6t",
|
|
date: "ISO-dato",
|
|
time: "ISO-klokkesl\xE6t",
|
|
duration: "ISO-varighed",
|
|
ipv4: "IPv4-omr\xE5de",
|
|
ipv6: "IPv6-omr\xE5de",
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Ugyldigt input: forventede ${getTypeName(issue3.expected)}, fik ${getTypeName(parsedType2(issue3.input))}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Ugyldig v\xE6rdi: forventede ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Ugyldigt valg: forventede en af f\xF8lgende ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
const origin = getTypeName(issue3.origin);
|
|
if (sizing)
|
|
return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "elementer"}`;
|
|
return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
const origin = getTypeName(issue3.origin);
|
|
if (sizing) {
|
|
return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `For lille: forventede ${origin} havde ${adj} ${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
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\xF8nsteret ${_issue.pattern}`;
|
|
return `Ugyldig ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ugyldigt tal: skal v\xE6re deleligt med ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue3.keys.length > 1 ? "Ukendte n\xF8gler" : "Ukendt n\xF8gle"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ugyldig n\xF8gle i ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Ugyldigt input: matcher ingen af de tilladte typer";
|
|
case "invalid_element":
|
|
return `Ugyldig v\xE6rdi i ${issue3.origin}`;
|
|
default:
|
|
return `Ugyldigt input`;
|
|
}
|
|
};
|
|
};
|
|
function da_default2() {
|
|
return {
|
|
localeError: error53()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/de.js
|
|
var error54 = () => {
|
|
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 parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "Zahl";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "Array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Ung\xFCltige Eingabe: erwartet ${issue3.expected}, erhalten ${parsedType2(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Ung\xFCltige Eingabe: erwartet ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Ung\xFCltige Option: erwartet eine von ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Zu gro\xDF: erwartet, dass ${issue3.origin ?? "Wert"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "Elemente"} hat`;
|
|
return `Zu gro\xDF: erwartet, dass ${issue3.origin ?? "Wert"} ${adj}${issue3.maximum.toString()} ist`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Zu klein: erwartet, dass ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} hat`;
|
|
}
|
|
return `Zu klein: erwartet, dass ${issue3.origin} ${adj}${issue3.minimum.toString()} ist`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Ung\xFCltiger String: muss mit "${_issue.prefix}" beginnen`;
|
|
if (_issue.format === "ends_with")
|
|
return `Ung\xFCltiger String: muss mit "${_issue.suffix}" enden`;
|
|
if (_issue.format === "includes")
|
|
return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`;
|
|
if (_issue.format === "regex")
|
|
return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;
|
|
return `Ung\xFCltig: ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue3.divisor} sein`;
|
|
case "unrecognized_keys":
|
|
return `${issue3.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ung\xFCltiger Schl\xFCssel in ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Ung\xFCltige Eingabe";
|
|
case "invalid_element":
|
|
return `Ung\xFCltiger Wert in ${issue3.origin}`;
|
|
default:
|
|
return `Ung\xFCltige Eingabe`;
|
|
}
|
|
};
|
|
};
|
|
function de_default2() {
|
|
return {
|
|
localeError: error54()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/en.js
|
|
var parsedType2 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
var error55 = () => {
|
|
const Sizable = {
|
|
string: { unit: "characters", verb: "to have" },
|
|
file: { unit: "bytes", verb: "to have" },
|
|
array: { unit: "items", verb: "to have" },
|
|
set: { unit: "items", verb: "to have" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const Nouns = {
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Invalid input: expected ${issue3.expected}, received ${parsedType2(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Invalid input: expected ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Invalid option: expected one of ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Too big: expected ${issue3.origin ?? "value"} to have ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elements"}`;
|
|
return `Too big: expected ${issue3.origin ?? "value"} to be ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Too small: expected ${issue3.origin} to have ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Too small: expected ${issue3.origin} to be ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `Invalid string: must start with "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Invalid string: must end with "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Invalid string: must include "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Invalid string: must match pattern ${_issue.pattern}`;
|
|
return `Invalid ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Invalid number: must be a multiple of ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Unrecognized key${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Invalid key in ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Invalid input";
|
|
case "invalid_element":
|
|
return `Invalid value in ${issue3.origin}`;
|
|
default:
|
|
return `Invalid input`;
|
|
}
|
|
};
|
|
};
|
|
function en_default2() {
|
|
return {
|
|
localeError: error55()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/eo.js
|
|
var parsedType3 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "nombro";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "tabelo";
|
|
}
|
|
if (data === null) {
|
|
return "senvalora";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
var error56 = () => {
|
|
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 Nouns = {
|
|
regex: "enigo",
|
|
email: "retadreso",
|
|
url: "URL",
|
|
emoji: "emo\u011Dio",
|
|
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\u016Dro",
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Nevalida enigo: atendi\u011Dis ${issue3.expected}, ricevi\u011Dis ${parsedType3(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Nevalida opcio: atendi\u011Dis unu el ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Tro granda: atendi\u011Dis ke ${issue3.origin ?? "valoro"} havu ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementojn"}`;
|
|
return `Tro granda: atendi\u011Dis ke ${issue3.origin ?? "valoro"} havu ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Tro malgranda: atendi\u011Dis ke ${issue3.origin} havu ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Tro malgranda: atendi\u011Dis ke ${issue3.origin} estu ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Nevalida karaktraro: devas komenci\u011Di per "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Nevalida karaktraro: devas fini\u011Di 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 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nevalida nombro: devas esti oblo de ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Nekonata${issue3.keys.length > 1 ? "j" : ""} \u015Dlosilo${issue3.keys.length > 1 ? "j" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Nevalida \u015Dlosilo en ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Nevalida enigo";
|
|
case "invalid_element":
|
|
return `Nevalida valoro en ${issue3.origin}`;
|
|
default:
|
|
return `Nevalida enigo`;
|
|
}
|
|
};
|
|
};
|
|
function eo_default2() {
|
|
return {
|
|
localeError: error56()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/es.js
|
|
var error57 = () => {
|
|
const Sizable = {
|
|
string: { unit: "caracteres", verb: "tener" },
|
|
file: { unit: "bytes", verb: "tener" },
|
|
array: { unit: "elementos", verb: "tener" },
|
|
set: { unit: "elementos", verb: "tener" }
|
|
};
|
|
const TypeNames = {
|
|
string: "texto",
|
|
number: "n\xFAmero",
|
|
boolean: "booleano",
|
|
array: "arreglo",
|
|
object: "objeto",
|
|
set: "conjunto",
|
|
file: "archivo",
|
|
date: "fecha",
|
|
bigint: "n\xFAmero grande",
|
|
symbol: "s\xEDmbolo",
|
|
undefined: "indefinido",
|
|
null: "nulo",
|
|
function: "funci\xF3n",
|
|
map: "mapa",
|
|
record: "registro",
|
|
tuple: "tupla",
|
|
enum: "enumeraci\xF3n",
|
|
union: "uni\xF3n",
|
|
literal: "literal",
|
|
promise: "promesa",
|
|
void: "vac\xEDo",
|
|
never: "nunca",
|
|
unknown: "desconocido",
|
|
any: "cualquiera"
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
function getTypeName(type) {
|
|
return TypeNames[type] ?? type;
|
|
}
|
|
const parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype) {
|
|
return data.constructor.name;
|
|
}
|
|
return "object";
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "entrada",
|
|
email: "direcci\xF3n de correo electr\xF3nico",
|
|
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\xF3n ISO",
|
|
ipv4: "direcci\xF3n IPv4",
|
|
ipv6: "direcci\xF3n IPv6",
|
|
cidrv4: "rango IPv4",
|
|
cidrv6: "rango IPv6",
|
|
base64: "cadena codificada en base64",
|
|
base64url: "URL codificada en base64",
|
|
json_string: "cadena JSON",
|
|
e164: "n\xFAmero E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entrada"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Entrada inv\xE1lida: se esperaba ${getTypeName(issue3.expected)}, recibido ${getTypeName(parsedType4(issue3.input))}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
const origin = getTypeName(issue3.origin);
|
|
if (sizing)
|
|
return `Demasiado grande: se esperaba que ${origin ?? "valor"} tuviera ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementos"}`;
|
|
return `Demasiado grande: se esperaba que ${origin ?? "valor"} fuera ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
const origin = getTypeName(issue3.origin);
|
|
if (sizing) {
|
|
return `Demasiado peque\xF1o: se esperaba que ${origin} tuviera ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Demasiado peque\xF1o: se esperaba que ${origin} fuera ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Cadena inv\xE1lida: debe comenzar con "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Cadena inv\xE1lida: debe terminar en "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`;
|
|
return `Inv\xE1lido ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Llave${issue3.keys.length > 1 ? "s" : ""} desconocida${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Llave inv\xE1lida en ${getTypeName(issue3.origin)}`;
|
|
case "invalid_union":
|
|
return "Entrada inv\xE1lida";
|
|
case "invalid_element":
|
|
return `Valor inv\xE1lido en ${getTypeName(issue3.origin)}`;
|
|
default:
|
|
return `Entrada inv\xE1lida`;
|
|
}
|
|
};
|
|
};
|
|
function es_default2() {
|
|
return {
|
|
localeError: error57()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/fa.js
|
|
var error58 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
|
|
set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u0639\u062F\u062F";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u0622\u0631\u0627\u06CC\u0647";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0648\u0631\u0648\u062F\u06CC",
|
|
email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644",
|
|
url: "URL",
|
|
emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
|
|
date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648",
|
|
time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
|
|
duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
|
|
ipv4: "IPv4 \u0622\u062F\u0631\u0633",
|
|
ipv6: "IPv6 \u0622\u062F\u0631\u0633",
|
|
cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647",
|
|
cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647",
|
|
base64: "base64-encoded \u0631\u0634\u062A\u0647",
|
|
base64url: "base64url-encoded \u0631\u0634\u062A\u0647",
|
|
json_string: "JSON \u0631\u0634\u062A\u0647",
|
|
e164: "E.164 \u0639\u062F\u062F",
|
|
jwt: "JWT",
|
|
template_literal: "\u0648\u0631\u0648\u062F\u06CC"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${issue3.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${parsedType4(issue3.input)} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1) {
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${stringifyPrimitive2(issue3.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`;
|
|
}
|
|
return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${joinValues2(issue3.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue3.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue3.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} \u0628\u0627\u0634\u062F`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`;
|
|
}
|
|
if (_issue.format === "ends_with") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`;
|
|
}
|
|
if (_issue.format === "includes") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${_issue.includes}" \u0628\u0627\u0634\u062F`;
|
|
}
|
|
if (_issue.format === "regex") {
|
|
return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`;
|
|
}
|
|
return `${Nouns[_issue.format] ?? issue3.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue3.divisor} \u0628\u0627\u0634\u062F`;
|
|
case "unrecognized_keys":
|
|
return `\u06A9\u0644\u06CC\u062F${issue3.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
|
|
case "invalid_element":
|
|
return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${issue3.origin}`;
|
|
default:
|
|
return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
|
|
}
|
|
};
|
|
};
|
|
function fa_default2() {
|
|
return {
|
|
localeError: error58()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/fi.js
|
|
var error59 = () => {
|
|
const Sizable = {
|
|
string: { unit: "merkki\xE4", 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\xE4iv\xE4m\xE4\xE4r\xE4n" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "s\xE4\xE4nn\xF6llinen lauseke",
|
|
email: "s\xE4hk\xF6postiosoite",
|
|
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\xE4iv\xE4m\xE4\xE4r\xE4",
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Virheellinen tyyppi: odotettiin ${issue3.expected}, oli ${parsedType4(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy olla ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Liian suuri: ${sizing.subject} t\xE4ytyy olla ${adj}${issue3.maximum.toString()} ${sizing.unit}`.trim();
|
|
}
|
|
return `Liian suuri: arvon t\xE4ytyy olla ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Liian pieni: ${sizing.subject} t\xE4ytyy olla ${adj}${issue3.minimum.toString()} ${sizing.unit}`.trim();
|
|
}
|
|
return `Liian pieni: arvon t\xE4ytyy olla ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${_issue.includes}"`;
|
|
if (_issue.format === "regex") {
|
|
return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`;
|
|
}
|
|
return `Virheellinen ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Virheellinen luku: t\xE4ytyy olla luvun ${issue3.divisor} monikerta`;
|
|
case "unrecognized_keys":
|
|
return `${issue3.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${joinValues2(issue3.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\xF6te`;
|
|
}
|
|
};
|
|
};
|
|
function fi_default2() {
|
|
return {
|
|
localeError: error59()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/fr.js
|
|
var error60 = () => {
|
|
const Sizable = {
|
|
string: { unit: "caract\xE8res", verb: "avoir" },
|
|
file: { unit: "octets", verb: "avoir" },
|
|
array: { unit: "\xE9l\xE9ments", verb: "avoir" },
|
|
set: { unit: "\xE9l\xE9ments", verb: "avoir" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "nombre";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "tableau";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "entr\xE9e",
|
|
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\xE9e ISO",
|
|
ipv4: "adresse IPv4",
|
|
ipv6: "adresse IPv6",
|
|
cidrv4: "plage IPv4",
|
|
cidrv6: "plage IPv6",
|
|
base64: "cha\xEEne encod\xE9e en base64",
|
|
base64url: "cha\xEEne encod\xE9e en base64url",
|
|
json_string: "cha\xEEne JSON",
|
|
e164: "num\xE9ro E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entr\xE9e"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Entr\xE9e invalide : ${issue3.expected} attendu, ${parsedType4(issue3.input)} re\xE7u`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Entr\xE9e invalide : ${stringifyPrimitive2(issue3.values[0])} attendu`;
|
|
return `Option invalide : une valeur parmi ${joinValues2(issue3.values, "|")} attendue`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Trop grand : ${issue3.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
|
|
return `Trop grand : ${issue3.origin ?? "valeur"} doit \xEAtre ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Trop petit : ${issue3.origin} doit ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Trop petit : ${issue3.origin} doit \xEAtre ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`;
|
|
return `${Nouns[_issue.format] ?? issue3.format} invalide`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nombre invalide : doit \xEAtre un multiple de ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Cl\xE9${issue3.keys.length > 1 ? "s" : ""} non reconnue${issue3.keys.length > 1 ? "s" : ""} : ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Cl\xE9 invalide dans ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Entr\xE9e invalide";
|
|
case "invalid_element":
|
|
return `Valeur invalide dans ${issue3.origin}`;
|
|
default:
|
|
return `Entr\xE9e invalide`;
|
|
}
|
|
};
|
|
};
|
|
function fr_default2() {
|
|
return {
|
|
localeError: error60()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/fr-CA.js
|
|
var error61 = () => {
|
|
const Sizable = {
|
|
string: { unit: "caract\xE8res", verb: "avoir" },
|
|
file: { unit: "octets", verb: "avoir" },
|
|
array: { unit: "\xE9l\xE9ments", verb: "avoir" },
|
|
set: { unit: "\xE9l\xE9ments", verb: "avoir" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "entr\xE9e",
|
|
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\xE9e ISO",
|
|
ipv4: "adresse IPv4",
|
|
ipv6: "adresse IPv6",
|
|
cidrv4: "plage IPv4",
|
|
cidrv6: "plage IPv6",
|
|
base64: "cha\xEEne encod\xE9e en base64",
|
|
base64url: "cha\xEEne encod\xE9e en base64url",
|
|
json_string: "cha\xEEne JSON",
|
|
e164: "num\xE9ro E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entr\xE9e"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Entr\xE9e invalide : attendu ${issue3.expected}, re\xE7u ${parsedType4(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Entr\xE9e invalide : attendu ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Option invalide : attendu l'une des valeurs suivantes ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "\u2264" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Trop grand : attendu que ${issue3.origin ?? "la valeur"} ait ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
|
|
return `Trop grand : attendu que ${issue3.origin ?? "la valeur"} soit ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? "\u2265" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Trop petit : attendu que ${issue3.origin} ait ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Trop petit : attendu que ${issue3.origin} soit ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;
|
|
return `${Nouns[_issue.format] ?? issue3.format} invalide`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nombre invalide : doit \xEAtre un multiple de ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Cl\xE9${issue3.keys.length > 1 ? "s" : ""} non reconnue${issue3.keys.length > 1 ? "s" : ""} : ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Cl\xE9 invalide dans ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Entr\xE9e invalide";
|
|
case "invalid_element":
|
|
return `Valeur invalide dans ${issue3.origin}`;
|
|
default:
|
|
return `Entr\xE9e invalide`;
|
|
}
|
|
};
|
|
};
|
|
function fr_CA_default2() {
|
|
return {
|
|
localeError: error61()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/he.js
|
|
var error62 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u05D0\u05D5\u05EA\u05D9\u05D5\u05EA", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" },
|
|
file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" },
|
|
array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" },
|
|
set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", verb: "\u05DC\u05DB\u05DC\u05D5\u05DC" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u05E7\u05DC\u05D8",
|
|
email: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC",
|
|
url: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA",
|
|
emoji: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO",
|
|
date: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO",
|
|
time: "\u05D6\u05DE\u05DF ISO",
|
|
duration: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO",
|
|
ipv4: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4",
|
|
ipv6: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6",
|
|
cidrv4: "\u05D8\u05D5\u05D5\u05D7 IPv4",
|
|
cidrv6: "\u05D8\u05D5\u05D5\u05D7 IPv6",
|
|
base64: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64",
|
|
base64url: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA",
|
|
json_string: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON",
|
|
e164: "\u05DE\u05E1\u05E4\u05E8 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u05E7\u05DC\u05D8"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA ${issue3.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${parsedType4(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05D0\u05D7\u05EA \u05DE\u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${issue3.origin ?? "value"} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elements"}`;
|
|
return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${issue3.origin ?? "value"} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${issue3.origin} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${issue3.origin} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1"${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05E0\u05D4: \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
|
|
return `${Nouns[_issue.format] ?? issue3.format} \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u05DE\u05E4\u05EA\u05D7${issue3.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${issue3.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u05DE\u05E4\u05EA\u05D7 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF";
|
|
case "invalid_element":
|
|
return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${issue3.origin}`;
|
|
default:
|
|
return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`;
|
|
}
|
|
};
|
|
};
|
|
function he_default2() {
|
|
return {
|
|
localeError: error62()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/hu.js
|
|
var error63 = () => {
|
|
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 parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "sz\xE1m";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "t\xF6mb";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "bemenet",
|
|
email: "email c\xEDm",
|
|
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\u0151b\xE9lyeg",
|
|
date: "ISO d\xE1tum",
|
|
time: "ISO id\u0151",
|
|
duration: "ISO id\u0151intervallum",
|
|
ipv4: "IPv4 c\xEDm",
|
|
ipv6: "IPv6 c\xEDm",
|
|
cidrv4: "IPv4 tartom\xE1ny",
|
|
cidrv6: "IPv6 tartom\xE1ny",
|
|
base64: "base64-k\xF3dolt string",
|
|
base64url: "base64url-k\xF3dolt string",
|
|
json_string: "JSON string",
|
|
e164: "E.164 sz\xE1m",
|
|
jwt: "JWT",
|
|
template_literal: "bemenet"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${issue3.expected}, a kapott \xE9rt\xE9k ${parsedType4(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `T\xFAl nagy: ${issue3.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elem"}`;
|
|
return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue3.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue3.origin} m\xE9rete t\xFAl kicsi ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue3.origin} t\xFAl kicsi ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
|
|
if (_issue.format === "ends_with")
|
|
return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
|
|
if (_issue.format === "includes")
|
|
return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
|
|
if (_issue.format === "regex")
|
|
return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`;
|
|
return `\xC9rv\xE9nytelen ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\xC9rv\xE9nytelen sz\xE1m: ${issue3.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`;
|
|
case "unrecognized_keys":
|
|
return `Ismeretlen kulcs${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\xC9rv\xE9nytelen kulcs ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\xC9rv\xE9nytelen bemenet";
|
|
case "invalid_element":
|
|
return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${issue3.origin}`;
|
|
default:
|
|
return `\xC9rv\xE9nytelen bemenet`;
|
|
}
|
|
};
|
|
};
|
|
function hu_default2() {
|
|
return {
|
|
localeError: error63()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/id.js
|
|
var error64 = () => {
|
|
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 parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Input tidak valid: diharapkan ${issue3.expected}, diterima ${parsedType4(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Input tidak valid: diharapkan ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Terlalu besar: diharapkan ${issue3.origin ?? "value"} memiliki ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elemen"}`;
|
|
return `Terlalu besar: diharapkan ${issue3.origin ?? "value"} menjadi ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Terlalu kecil: diharapkan ${issue3.origin} memiliki ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Terlalu kecil: diharapkan ${issue3.origin} menjadi ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
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 `${Nouns[_issue.format] ?? issue3.format} tidak valid`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Angka tidak valid: harus kelipatan dari ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Kunci tidak dikenali ${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Kunci tidak valid di ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Input tidak valid";
|
|
case "invalid_element":
|
|
return `Nilai tidak valid di ${issue3.origin}`;
|
|
default:
|
|
return `Input tidak valid`;
|
|
}
|
|
};
|
|
};
|
|
function id_default2() {
|
|
return {
|
|
localeError: error64()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/is.js
|
|
var parsedType4 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "n\xFAmer";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "fylki";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
var error65 = () => {
|
|
const Sizable = {
|
|
string: { unit: "stafi", verb: "a\xF0 hafa" },
|
|
file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
|
|
array: { unit: "hluti", verb: "a\xF0 hafa" },
|
|
set: { unit: "hluti", verb: "a\xF0 hafa" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const Nouns = {
|
|
regex: "gildi",
|
|
email: "netfang",
|
|
url: "vefsl\xF3\xF0",
|
|
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\xEDmi",
|
|
date: "ISO dagsetning",
|
|
time: "ISO t\xEDmi",
|
|
duration: "ISO t\xEDmalengd",
|
|
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\xF6lugildi",
|
|
jwt: "JWT",
|
|
template_literal: "gildi"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Rangt gildi: \xDE\xFA sl\xF3st inn ${parsedType4(issue3.input)} \xFEar sem \xE1 a\xF0 vera ${issue3.expected}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\xD3gilt val: m\xE1 vera eitt af eftirfarandi ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin ?? "gildi"} hafi ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "hluti"}`;
|
|
return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin ?? "gildi"} s\xE9 ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin} hafi ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue3.origin} s\xE9 ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 byrja \xE1 "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 enda \xE1 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`;
|
|
return `Rangt ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\xD3\xFEekkt ${issue3.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Rangur lykill \xED ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Rangt gildi";
|
|
case "invalid_element":
|
|
return `Rangt gildi \xED ${issue3.origin}`;
|
|
default:
|
|
return `Rangt gildi`;
|
|
}
|
|
};
|
|
};
|
|
function is_default2() {
|
|
return {
|
|
localeError: error65()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/it.js
|
|
var error66 = () => {
|
|
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 parsedType5 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "numero";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "vettore";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Input non valido: atteso ${issue3.expected}, ricevuto ${parsedType5(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Input non valido: atteso ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Opzione non valida: atteso uno tra ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Troppo grande: ${issue3.origin ?? "valore"} deve avere ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementi"}`;
|
|
return `Troppo grande: ${issue3.origin ?? "valore"} deve essere ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Troppo piccolo: ${issue3.origin} deve avere ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Troppo piccolo: ${issue3.origin} deve essere ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
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 `Invalid ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Numero non valido: deve essere un multiplo di ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Chiav${issue3.keys.length > 1 ? "i" : "e"} non riconosciut${issue3.keys.length > 1 ? "e" : "a"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Chiave non valida in ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Input non valido";
|
|
case "invalid_element":
|
|
return `Valore non valido in ${issue3.origin}`;
|
|
default:
|
|
return `Input non valido`;
|
|
}
|
|
};
|
|
};
|
|
function it_default2() {
|
|
return {
|
|
localeError: error66()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ja.js
|
|
var error67 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
|
|
file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
|
|
array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" },
|
|
set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType5 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u6570\u5024";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u914D\u5217";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u5165\u529B\u5024",
|
|
email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9",
|
|
url: "URL",
|
|
emoji: "\u7D75\u6587\u5B57",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO\u65E5\u6642",
|
|
date: "ISO\u65E5\u4ED8",
|
|
time: "ISO\u6642\u523B",
|
|
duration: "ISO\u671F\u9593",
|
|
ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9",
|
|
ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9",
|
|
cidrv4: "IPv4\u7BC4\u56F2",
|
|
cidrv6: "IPv6\u7BC4\u56F2",
|
|
base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
|
|
base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
|
|
json_string: "JSON\u6587\u5B57\u5217",
|
|
e164: "E.164\u756A\u53F7",
|
|
jwt: "JWT",
|
|
template_literal: "\u5165\u529B\u5024"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u7121\u52B9\u306A\u5165\u529B: ${issue3.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${parsedType5(issue3.input)}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u7121\u52B9\u306A\u5165\u529B: ${stringifyPrimitive2(issue3.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`;
|
|
return `\u7121\u52B9\u306A\u9078\u629E: ${joinValues2(issue3.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue3.origin ?? "\u5024"}\u306F${issue3.maximum.toString()}${sizing.unit ?? "\u8981\u7D20"}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue3.origin ?? "\u5024"}\u306F${issue3.maximum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue3.origin}\u306F${issue3.minimum.toString()}${sizing.unit}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue3.origin}\u306F${issue3.minimum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
if (_issue.format === "includes")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
if (_issue.format === "regex")
|
|
return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
return `\u7121\u52B9\u306A${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u7121\u52B9\u306A\u6570\u5024: ${issue3.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
|
|
case "unrecognized_keys":
|
|
return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${issue3.keys.length > 1 ? "\u7FA4" : ""}: ${joinValues2(issue3.keys, "\u3001")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`;
|
|
case "invalid_union":
|
|
return "\u7121\u52B9\u306A\u5165\u529B";
|
|
case "invalid_element":
|
|
return `${issue3.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`;
|
|
default:
|
|
return `\u7121\u52B9\u306A\u5165\u529B`;
|
|
}
|
|
};
|
|
};
|
|
function ja_default2() {
|
|
return {
|
|
localeError: error67()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ka.js
|
|
var parsedType5 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
const typeMap = {
|
|
string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
|
|
undefined: "undefined",
|
|
bigint: "bigint",
|
|
symbol: "symbol",
|
|
function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0"
|
|
};
|
|
return typeMap[t] ?? t;
|
|
};
|
|
var error68 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
|
|
set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const Nouns = {
|
|
regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
|
|
email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
|
|
url: "URL",
|
|
emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD",
|
|
date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8",
|
|
time: "\u10D3\u10E0\u10DD",
|
|
duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0",
|
|
ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
|
|
ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
|
|
cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
|
|
cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
|
|
base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
|
|
e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
|
|
jwt: "JWT",
|
|
template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${parsedType5(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${joinValues2(issue3.values, "|")}-\u10D3\u10D0\u10DC`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit}`;
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue3.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
|
|
if (_issue.format === "includes")
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
|
|
if (_issue.format === "regex")
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue3.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
|
|
case "unrecognized_keys":
|
|
return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue3.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue3.origin}-\u10E8\u10D8`;
|
|
case "invalid_union":
|
|
return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0";
|
|
case "invalid_element":
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue3.origin}-\u10E8\u10D8`;
|
|
default:
|
|
return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`;
|
|
}
|
|
};
|
|
};
|
|
function ka_default2() {
|
|
return {
|
|
localeError: error68()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/km.js
|
|
var error69 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
|
|
set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType6 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "\u1798\u17B7\u1793\u1798\u17C2\u1793\u1787\u17B6\u179B\u17C1\u1781 (NaN)" : "\u179B\u17C1\u1781";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u17A2\u17B6\u179A\u17C1 (Array)";
|
|
}
|
|
if (data === null) {
|
|
return "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
|
|
email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
|
|
url: "URL",
|
|
emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO",
|
|
date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO",
|
|
time: "\u1798\u17C9\u17C4\u1784 ISO",
|
|
duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO",
|
|
ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
|
|
ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
|
|
cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
|
|
cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
|
|
base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64",
|
|
base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url",
|
|
json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON",
|
|
e164: "\u179B\u17C1\u1781 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${parsedType6(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u1792\u17B6\u178F\u17BB"}`;
|
|
return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin} ${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue3.origin} ${adj} ${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
|
|
return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
|
|
case "invalid_element":
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue3.origin}`;
|
|
default:
|
|
return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
|
|
}
|
|
};
|
|
};
|
|
function km_default2() {
|
|
return {
|
|
localeError: error69()
|
|
};
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/kh.js
|
|
function kh_default2() {
|
|
return km_default2();
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ko.js
|
|
var error70 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\uBB38\uC790", verb: "to have" },
|
|
file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
|
|
array: { unit: "\uAC1C", verb: "to have" },
|
|
set: { unit: "\uAC1C", verb: "to have" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType6 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\uC785\uB825",
|
|
email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
|
|
url: "URL",
|
|
emoji: "\uC774\uBAA8\uC9C0",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04",
|
|
date: "ISO \uB0A0\uC9DC",
|
|
time: "ISO \uC2DC\uAC04",
|
|
duration: "ISO \uAE30\uAC04",
|
|
ipv4: "IPv4 \uC8FC\uC18C",
|
|
ipv6: "IPv6 \uC8FC\uC18C",
|
|
cidrv4: "IPv4 \uBC94\uC704",
|
|
cidrv6: "IPv6 \uBC94\uC704",
|
|
base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
|
|
base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
|
|
json_string: "JSON \uBB38\uC790\uC5F4",
|
|
e164: "E.164 \uBC88\uD638",
|
|
jwt: "JWT",
|
|
template_literal: "\uC785\uB825"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${issue3.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${parsedType6(issue3.input)}\uC785\uB2C8\uB2E4`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive2(issue3.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
|
|
return `\uC798\uBABB\uB41C \uC635\uC158: ${joinValues2(issue3.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
|
|
const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
|
|
const sizing = getSizing(issue3.origin);
|
|
const unit = sizing?.unit ?? "\uC694\uC18C";
|
|
if (sizing)
|
|
return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue3.maximum.toString()}${unit} ${adj}${suffix}`;
|
|
return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue3.maximum.toString()} ${adj}${suffix}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
|
|
const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
|
|
const sizing = getSizing(issue3.origin);
|
|
const unit = sizing?.unit ?? "\uC694\uC18C";
|
|
if (sizing) {
|
|
return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue3.minimum.toString()}${unit} ${adj}${suffix}`;
|
|
}
|
|
return `${issue3.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue3.minimum.toString()} ${adj}${suffix}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`;
|
|
if (_issue.format === "includes")
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
|
|
if (_issue.format === "regex")
|
|
return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
|
|
return `\uC798\uBABB\uB41C ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue3.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
|
|
case "unrecognized_keys":
|
|
return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\uC798\uBABB\uB41C \uD0A4: ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return `\uC798\uBABB\uB41C \uC785\uB825`;
|
|
case "invalid_element":
|
|
return `\uC798\uBABB\uB41C \uAC12: ${issue3.origin}`;
|
|
default:
|
|
return `\uC798\uBABB\uB41C \uC785\uB825`;
|
|
}
|
|
};
|
|
};
|
|
function ko_default2() {
|
|
return {
|
|
localeError: error70()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/lt.js
|
|
var parsedType6 = (data) => {
|
|
const t = typeof data;
|
|
return parsedTypeFromType(t, data);
|
|
};
|
|
var parsedTypeFromType = (t, data = undefined) => {
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "skai\u010Dius";
|
|
}
|
|
case "bigint": {
|
|
return "sveikasis skai\u010Dius";
|
|
}
|
|
case "string": {
|
|
return "eilut\u0117";
|
|
}
|
|
case "boolean": {
|
|
return "login\u0117 reik\u0161m\u0117";
|
|
}
|
|
case "undefined":
|
|
case "void": {
|
|
return "neapibr\u0117\u017Eta reik\u0161m\u0117";
|
|
}
|
|
case "function": {
|
|
return "funkcija";
|
|
}
|
|
case "symbol": {
|
|
return "simbolis";
|
|
}
|
|
case "object": {
|
|
if (data === undefined)
|
|
return "ne\u017Einomas objektas";
|
|
if (data === null)
|
|
return "nulin\u0117 reik\u0161m\u0117";
|
|
if (Array.isArray(data))
|
|
return "masyvas";
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
return "objektas";
|
|
}
|
|
case "null": {
|
|
return "nulin\u0117 reik\u0161m\u0117";
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
var capitalizeFirstCharacter2 = (text) => {
|
|
return text.charAt(0).toUpperCase() + text.slice(1);
|
|
};
|
|
function getUnitTypeFromNumber2(number5) {
|
|
const abs = Math.abs(number5);
|
|
const last = abs % 10;
|
|
const last2 = abs % 100;
|
|
if (last2 >= 11 && last2 <= 19 || last === 0)
|
|
return "many";
|
|
if (last === 1)
|
|
return "one";
|
|
return "few";
|
|
}
|
|
var error71 = () => {
|
|
const Sizable = {
|
|
string: {
|
|
unit: {
|
|
one: "simbolis",
|
|
few: "simboliai",
|
|
many: "simboli\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip",
|
|
notInclusive: "turi b\u016Bti trumpesn\u0117 kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip",
|
|
notInclusive: "turi b\u016Bti ilgesn\u0117 kaip"
|
|
}
|
|
}
|
|
},
|
|
file: {
|
|
unit: {
|
|
one: "baitas",
|
|
few: "baitai",
|
|
many: "bait\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi b\u016Bti ne didesnis kaip",
|
|
notInclusive: "turi b\u016Bti ma\u017Eesnis kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip",
|
|
notInclusive: "turi b\u016Bti didesnis kaip"
|
|
}
|
|
}
|
|
},
|
|
array: {
|
|
unit: {
|
|
one: "element\u0105",
|
|
few: "elementus",
|
|
many: "element\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi tur\u0117ti ne daugiau kaip",
|
|
notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
|
|
notInclusive: "turi tur\u0117ti daugiau kaip"
|
|
}
|
|
}
|
|
},
|
|
set: {
|
|
unit: {
|
|
one: "element\u0105",
|
|
few: "elementus",
|
|
many: "element\u0173"
|
|
},
|
|
verb: {
|
|
smaller: {
|
|
inclusive: "turi tur\u0117ti ne daugiau kaip",
|
|
notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
|
|
},
|
|
bigger: {
|
|
inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
|
|
notInclusive: "turi tur\u0117ti 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 Nouns = {
|
|
regex: "\u012Fvestis",
|
|
email: "el. pa\u0161to 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\u0117",
|
|
ipv4: "IPv4 adresas",
|
|
ipv6: "IPv6 adresas",
|
|
cidrv4: "IPv4 tinklo prefiksas (CIDR)",
|
|
cidrv6: "IPv6 tinklo prefiksas (CIDR)",
|
|
base64: "base64 u\u017Ekoduota eilut\u0117",
|
|
base64url: "base64url u\u017Ekoduota eilut\u0117",
|
|
json_string: "JSON eilut\u0117",
|
|
e164: "E.164 numeris",
|
|
jwt: "JWT",
|
|
template_literal: "\u012Fvestis"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Gautas tipas ${parsedType6(issue3.input)}, o tik\u0117tasi - ${parsedTypeFromType(issue3.expected)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Privalo b\u016Bti ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Privalo b\u016Bti vienas i\u0161 ${joinValues2(issue3.values, "|")} pasirinkim\u0173`;
|
|
case "too_big": {
|
|
const origin = parsedTypeFromType(issue3.origin);
|
|
const sizing = getSizing(issue3.origin, getUnitTypeFromNumber2(Number(issue3.maximum)), issue3.inclusive ?? false, "smaller");
|
|
if (sizing?.verb)
|
|
return `${capitalizeFirstCharacter2(origin ?? issue3.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue3.maximum.toString()} ${sizing.unit ?? "element\u0173"}`;
|
|
const adj = issue3.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
|
|
return `${capitalizeFirstCharacter2(origin ?? issue3.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue3.maximum.toString()} ${sizing?.unit}`;
|
|
}
|
|
case "too_small": {
|
|
const origin = parsedTypeFromType(issue3.origin);
|
|
const sizing = getSizing(issue3.origin, getUnitTypeFromNumber2(Number(issue3.minimum)), issue3.inclusive ?? false, "bigger");
|
|
if (sizing?.verb)
|
|
return `${capitalizeFirstCharacter2(origin ?? issue3.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue3.minimum.toString()} ${sizing.unit ?? "element\u0173"}`;
|
|
const adj = issue3.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
|
|
return `${capitalizeFirstCharacter2(origin ?? issue3.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue3.minimum.toString()} ${sizing?.unit}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
|
|
return `Neteisingas ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Skai\u010Dius privalo b\u016Bti ${issue3.divisor} kartotinis.`;
|
|
case "unrecognized_keys":
|
|
return `Neatpa\u017Eint${issue3.keys.length > 1 ? "i" : "as"} rakt${issue3.keys.length > 1 ? "ai" : "as"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return "Rastas klaidingas raktas";
|
|
case "invalid_union":
|
|
return "Klaidinga \u012Fvestis";
|
|
case "invalid_element": {
|
|
const origin = parsedTypeFromType(issue3.origin);
|
|
return `${capitalizeFirstCharacter2(origin ?? issue3.origin ?? "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
|
|
}
|
|
default:
|
|
return "Klaidinga \u012Fvestis";
|
|
}
|
|
};
|
|
};
|
|
function lt_default2() {
|
|
return {
|
|
localeError: error71()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/mk.js
|
|
var error72 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
|
|
set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u0431\u0440\u043E\u0458";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u043D\u0438\u0437\u0430";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0432\u043D\u0435\u0441",
|
|
email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
|
|
url: "URL",
|
|
emoji: "\u0435\u043C\u043E\u045F\u0438",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435",
|
|
date: "ISO \u0434\u0430\u0442\u0443\u043C",
|
|
time: "ISO \u0432\u0440\u0435\u043C\u0435",
|
|
duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435",
|
|
ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430",
|
|
ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430",
|
|
cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433",
|
|
cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433",
|
|
base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
|
|
base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
|
|
json_string: "JSON \u043D\u0438\u0437\u0430",
|
|
e164: "E.164 \u0431\u0440\u043E\u0458",
|
|
jwt: "JWT",
|
|
template_literal: "\u0432\u043D\u0435\u0441"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Invalid input: expected ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`;
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue3.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
|
|
return `Invalid ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue3.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441";
|
|
case "invalid_element":
|
|
return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${issue3.origin}`;
|
|
default:
|
|
return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441`;
|
|
}
|
|
};
|
|
};
|
|
function mk_default2() {
|
|
return {
|
|
localeError: error72()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ms.js
|
|
var error73 = () => {
|
|
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 parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "nombor";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Input tidak sah: dijangka ${issue3.expected}, diterima ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Input tidak sah: dijangka ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Terlalu besar: dijangka ${issue3.origin ?? "nilai"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elemen"}`;
|
|
return `Terlalu besar: dijangka ${issue3.origin ?? "nilai"} adalah ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Terlalu kecil: dijangka ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Terlalu kecil: dijangka ${issue3.origin} adalah ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
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 `${Nouns[_issue.format] ?? issue3.format} tidak sah`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nombor tidak sah: perlu gandaan ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Kunci tidak dikenali: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Kunci tidak sah dalam ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Input tidak sah";
|
|
case "invalid_element":
|
|
return `Nilai tidak sah dalam ${issue3.origin}`;
|
|
default:
|
|
return `Input tidak sah`;
|
|
}
|
|
};
|
|
};
|
|
function ms_default2() {
|
|
return {
|
|
localeError: error73()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/nl.js
|
|
var error74 = () => {
|
|
const Sizable = {
|
|
string: { unit: "tekens" },
|
|
file: { unit: "bytes" },
|
|
array: { unit: "elementen" },
|
|
set: { unit: "elementen" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "getal";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Ongeldige invoer: verwacht ${issue3.expected}, ontving ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Ongeldige invoer: verwacht ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Ongeldige optie: verwacht \xE9\xE9n van ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Te lang: verwacht dat ${issue3.origin ?? "waarde"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementen"} bevat`;
|
|
return `Te lang: verwacht dat ${issue3.origin ?? "waarde"} ${adj}${issue3.maximum.toString()} is`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Te kort: verwacht dat ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} bevat`;
|
|
}
|
|
return `Te kort: verwacht dat ${issue3.origin} ${adj}${issue3.minimum.toString()} is`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
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: ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ongeldig getal: moet een veelvoud van ${issue3.divisor} zijn`;
|
|
case "unrecognized_keys":
|
|
return `Onbekende key${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ongeldige key in ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Ongeldige invoer";
|
|
case "invalid_element":
|
|
return `Ongeldige waarde in ${issue3.origin}`;
|
|
default:
|
|
return `Ongeldige invoer`;
|
|
}
|
|
};
|
|
};
|
|
function nl_default2() {
|
|
return {
|
|
localeError: error74()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/no.js
|
|
var error75 = () => {
|
|
const Sizable = {
|
|
string: { unit: "tegn", verb: "\xE5 ha" },
|
|
file: { unit: "bytes", verb: "\xE5 ha" },
|
|
array: { unit: "elementer", verb: "\xE5 inneholde" },
|
|
set: { unit: "elementer", verb: "\xE5 inneholde" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "tall";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "liste";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
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\xE5de",
|
|
ipv6: "IPv6-omr\xE5de",
|
|
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"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Ugyldig input: forventet ${issue3.expected}, fikk ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Ugyldig verdi: forventet ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Ugyldig valg: forventet en av ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `For stor(t): forventet ${issue3.origin ?? "value"} til \xE5 ha ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementer"}`;
|
|
return `For stor(t): forventet ${issue3.origin ?? "value"} til \xE5 ha ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `For lite(n): forventet ${issue3.origin} til \xE5 ha ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `For lite(n): forventet ${issue3.origin} til \xE5 ha ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Ugyldig streng: m\xE5 starte med "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Ugyldig streng: m\xE5 ende med "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
|
|
return `Ugyldig ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue3.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ugyldig n\xF8kkel i ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Ugyldig input";
|
|
case "invalid_element":
|
|
return `Ugyldig verdi i ${issue3.origin}`;
|
|
default:
|
|
return `Ugyldig input`;
|
|
}
|
|
};
|
|
};
|
|
function no_default2() {
|
|
return {
|
|
localeError: error75()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ota.js
|
|
var error76 = () => {
|
|
const Sizable = {
|
|
string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
|
|
file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
|
|
array: { unit: "unsur", verb: "olmal\u0131d\u0131r" },
|
|
set: { unit: "unsur", verb: "olmal\u0131d\u0131r" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "numara";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "saf";
|
|
}
|
|
if (data === null) {
|
|
return "gayb";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "giren",
|
|
email: "epostag\xE2h",
|
|
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\xE2m\u0131",
|
|
date: "ISO tarihi",
|
|
time: "ISO zaman\u0131",
|
|
duration: "ISO m\xFCddeti",
|
|
ipv4: "IPv4 ni\u015F\xE2n\u0131",
|
|
ipv6: "IPv6 ni\u015F\xE2n\u0131",
|
|
cidrv4: "IPv4 menzili",
|
|
cidrv6: "IPv6 menzili",
|
|
base64: "base64-\u015Fifreli metin",
|
|
base64url: "base64url-\u015Fifreli metin",
|
|
json_string: "JSON metin",
|
|
e164: "E.164 say\u0131s\u0131",
|
|
jwt: "JWT",
|
|
template_literal: "giren"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `F\xE2sit giren: umulan ${issue3.expected}, al\u0131nan ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `F\xE2sit giren: umulan ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `F\xE2sit tercih: m\xFBteberler ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Fazla b\xFCy\xFCk: ${issue3.origin ?? "value"}, ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elements"} sahip olmal\u0131yd\u0131.`;
|
|
return `Fazla b\xFCy\xFCk: ${issue3.origin ?? "value"}, ${adj}${issue3.maximum.toString()} olmal\u0131yd\u0131.`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Fazla k\xFC\xE7\xFCk: ${issue3.origin}, ${adj}${issue3.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`;
|
|
}
|
|
return `Fazla k\xFC\xE7\xFCk: ${issue3.origin}, ${adj}${issue3.minimum.toString()} olmal\u0131yd\u0131.`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `F\xE2sit metin: "${_issue.prefix}" ile ba\u015Flamal\u0131.`;
|
|
if (_issue.format === "ends_with")
|
|
return `F\xE2sit metin: "${_issue.suffix}" ile bitmeli.`;
|
|
if (_issue.format === "includes")
|
|
return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
|
|
if (_issue.format === "regex")
|
|
return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
|
|
return `F\xE2sit ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `F\xE2sit say\u0131: ${issue3.divisor} kat\u0131 olmal\u0131yd\u0131.`;
|
|
case "unrecognized_keys":
|
|
return `Tan\u0131nmayan anahtar ${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin} i\xE7in tan\u0131nmayan anahtar var.`;
|
|
case "invalid_union":
|
|
return "Giren tan\u0131namad\u0131.";
|
|
case "invalid_element":
|
|
return `${issue3.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`;
|
|
default:
|
|
return `K\u0131ymet tan\u0131namad\u0131.`;
|
|
}
|
|
};
|
|
};
|
|
function ota_default2() {
|
|
return {
|
|
localeError: error76()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ps.js
|
|
var error77 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
|
|
file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
|
|
array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
|
|
set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u0639\u062F\u062F";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u0627\u0631\u06D0";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0648\u0631\u0648\u062F\u064A",
|
|
email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9",
|
|
url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644",
|
|
emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A",
|
|
date: "\u0646\u06D0\u067C\u0647",
|
|
time: "\u0648\u062E\u062A",
|
|
duration: "\u0645\u0648\u062F\u0647",
|
|
ipv4: "\u062F IPv4 \u067E\u062A\u0647",
|
|
ipv6: "\u062F IPv6 \u067E\u062A\u0647",
|
|
cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647",
|
|
cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647",
|
|
base64: "base64-encoded \u0645\u062A\u0646",
|
|
base64url: "base64url-encoded \u0645\u062A\u0646",
|
|
json_string: "JSON \u0645\u062A\u0646",
|
|
e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647",
|
|
jwt: "JWT",
|
|
template_literal: "\u0648\u0631\u0648\u062F\u064A"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${issue3.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${parsedType7(issue3.input)} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1) {
|
|
return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${stringifyPrimitive2(issue3.values[0])} \u0648\u0627\u06CC`;
|
|
}
|
|
return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${joinValues2(issue3.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue3.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`;
|
|
}
|
|
return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue3.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue3.maximum.toString()} \u0648\u064A`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0648\u0644\u0631\u064A`;
|
|
}
|
|
return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue3.origin} \u0628\u0627\u06CC\u062F ${adj}${issue3.minimum.toString()} \u0648\u064A`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`;
|
|
}
|
|
if (_issue.format === "ends_with") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`;
|
|
}
|
|
if (_issue.format === "includes") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${_issue.includes}" \u0648\u0644\u0631\u064A`;
|
|
}
|
|
if (_issue.format === "regex") {
|
|
return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`;
|
|
}
|
|
return `${Nouns[_issue.format] ?? issue3.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue3.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`;
|
|
case "unrecognized_keys":
|
|
return `\u0646\u0627\u0633\u0645 ${issue3.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${issue3.origin} \u06A9\u06D0`;
|
|
case "invalid_union":
|
|
return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
|
|
case "invalid_element":
|
|
return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${issue3.origin} \u06A9\u06D0`;
|
|
default:
|
|
return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
|
|
}
|
|
};
|
|
};
|
|
function ps_default2() {
|
|
return {
|
|
localeError: error77()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/pl.js
|
|
var error78 = () => {
|
|
const Sizable = {
|
|
string: { unit: "znak\xF3w", verb: "mie\u0107" },
|
|
file: { unit: "bajt\xF3w", verb: "mie\u0107" },
|
|
array: { unit: "element\xF3w", verb: "mie\u0107" },
|
|
set: { unit: "element\xF3w", verb: "mie\u0107" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "liczba";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "tablica";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "wyra\u017Cenie",
|
|
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\u0105g znak\xF3w zakodowany w formacie base64",
|
|
base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url",
|
|
json_string: "ci\u0105g znak\xF3w w formacie JSON",
|
|
e164: "liczba E.164",
|
|
jwt: "JWT",
|
|
template_literal: "wej\u015Bcie"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${issue3.expected}, otrzymano ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element\xF3w"}`;
|
|
}
|
|
return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue3.minimum.toString()} ${sizing.unit ?? "element\xF3w"}`;
|
|
}
|
|
return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${issue3.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
|
|
return `Nieprawid\u0142ow(y/a/e) ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Nierozpoznane klucze${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Nieprawid\u0142owy klucz w ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Nieprawid\u0142owe dane wej\u015Bciowe";
|
|
case "invalid_element":
|
|
return `Nieprawid\u0142owa warto\u015B\u0107 w ${issue3.origin}`;
|
|
default:
|
|
return `Nieprawid\u0142owe dane wej\u015Bciowe`;
|
|
}
|
|
};
|
|
};
|
|
function pl_default2() {
|
|
return {
|
|
localeError: error78()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/pt.js
|
|
var error79 = () => {
|
|
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 parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "n\xFAmero";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "nulo";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "padr\xE3o",
|
|
email: "endere\xE7o 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\xE7\xE3o ISO",
|
|
ipv4: "endere\xE7o IPv4",
|
|
ipv6: "endere\xE7o 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\xFAmero E.164",
|
|
jwt: "JWT",
|
|
template_literal: "entrada"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Tipo inv\xE1lido: esperado ${issue3.expected}, recebido ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Entrada inv\xE1lida: esperado ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Muito grande: esperado que ${issue3.origin ?? "valor"} tivesse ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementos"}`;
|
|
return `Muito grande: esperado que ${issue3.origin ?? "valor"} fosse ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Muito pequeno: esperado que ${issue3.origin} tivesse ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Muito pequeno: esperado que ${issue3.origin} fosse ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Texto inv\xE1lido: deve come\xE7ar com "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Texto inv\xE1lido: deve terminar com "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
|
|
return `${Nouns[_issue.format] ?? issue3.format} inv\xE1lido`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Chave${issue3.keys.length > 1 ? "s" : ""} desconhecida${issue3.keys.length > 1 ? "s" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Chave inv\xE1lida em ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Entrada inv\xE1lida";
|
|
case "invalid_element":
|
|
return `Valor inv\xE1lido em ${issue3.origin}`;
|
|
default:
|
|
return `Campo inv\xE1lido`;
|
|
}
|
|
};
|
|
};
|
|
function pt_default2() {
|
|
return {
|
|
localeError: error79()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ru.js
|
|
function getRussianPlural2(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;
|
|
}
|
|
var error80 = () => {
|
|
const Sizable = {
|
|
string: {
|
|
unit: {
|
|
one: "\u0441\u0438\u043C\u0432\u043E\u043B",
|
|
few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430",
|
|
many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
},
|
|
file: {
|
|
unit: {
|
|
one: "\u0431\u0430\u0439\u0442",
|
|
few: "\u0431\u0430\u0439\u0442\u0430",
|
|
many: "\u0431\u0430\u0439\u0442"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
},
|
|
array: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
},
|
|
set: {
|
|
unit: {
|
|
one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
|
|
few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
|
|
many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
|
|
},
|
|
verb: "\u0438\u043C\u0435\u0442\u044C"
|
|
}
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u0447\u0438\u0441\u043B\u043E";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u043C\u0430\u0441\u0441\u0438\u0432";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0432\u0432\u043E\u0434",
|
|
email: "email \u0430\u0434\u0440\u0435\u0441",
|
|
url: "URL",
|
|
emoji: "\u044D\u043C\u043E\u0434\u0437\u0438",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F",
|
|
date: "ISO \u0434\u0430\u0442\u0430",
|
|
time: "ISO \u0432\u0440\u0435\u043C\u044F",
|
|
duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
|
|
ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
|
|
ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
|
|
cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
|
|
cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
|
|
base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64",
|
|
base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url",
|
|
json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430",
|
|
e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0432\u0432\u043E\u0434"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${issue3.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
const maxValue = Number(issue3.maximum);
|
|
const unit = getRussianPlural2(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue3.maximum.toString()} ${unit}`;
|
|
}
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
const minValue = Number(issue3.minimum);
|
|
const unit = getRussianPlural2(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue3.minimum.toString()} ${unit}`;
|
|
}
|
|
return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue3.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${issue3.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u0438" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435";
|
|
case "invalid_element":
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${issue3.origin}`;
|
|
default:
|
|
return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435`;
|
|
}
|
|
};
|
|
};
|
|
function ru_default2() {
|
|
return {
|
|
localeError: error80()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/sl.js
|
|
var error81 = () => {
|
|
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 parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u0161tevilo";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "tabela";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "vnos",
|
|
email: "e-po\u0161tni 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 \u010Das",
|
|
date: "ISO datum",
|
|
time: "ISO \u010Das",
|
|
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 \u0161tevilka",
|
|
jwt: "JWT",
|
|
template_literal: "vnos"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Neveljaven vnos: pri\u010Dakovano ${issue3.expected}, prejeto ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Preveliko: pri\u010Dakovano, da bo ${issue3.origin ?? "vrednost"} imelo ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "elementov"}`;
|
|
return `Preveliko: pri\u010Dakovano, da bo ${issue3.origin ?? "vrednost"} ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Premajhno: pri\u010Dakovano, da bo ${issue3.origin} imelo ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Premajhno: pri\u010Dakovano, da bo ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `Neveljaven niz: mora se za\u010Deti z "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Neveljaven niz: mora se kon\u010Dati 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 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Neprepoznan${issue3.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Neveljaven klju\u010D v ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "Neveljaven vnos";
|
|
case "invalid_element":
|
|
return `Neveljavna vrednost v ${issue3.origin}`;
|
|
default:
|
|
return "Neveljaven vnos";
|
|
}
|
|
};
|
|
};
|
|
function sl_default2() {
|
|
return {
|
|
localeError: error81()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/sv.js
|
|
var error82 = () => {
|
|
const Sizable = {
|
|
string: { unit: "tecken", verb: "att ha" },
|
|
file: { unit: "bytes", verb: "att ha" },
|
|
array: { unit: "objekt", verb: "att inneh\xE5lla" },
|
|
set: { unit: "objekt", verb: "att inneh\xE5lla" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "antal";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "lista";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "regulj\xE4rt 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\xE4ng",
|
|
base64url: "base64url-kodad str\xE4ng",
|
|
json_string: "JSON-str\xE4ng",
|
|
e164: "E.164-nummer",
|
|
jwt: "JWT",
|
|
template_literal: "mall-literal"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Ogiltig inmatning: f\xF6rv\xE4ntat ${issue3.expected}, fick ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Ogiltigt val: f\xF6rv\xE4ntade en av ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `F\xF6r stor(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "element"}`;
|
|
}
|
|
return `F\xF6r stor(t): f\xF6rv\xE4ntat ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue3.origin ?? "v\xE4rdet"} att ha ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
|
|
return `Ogiltig(t) ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `${issue3.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Ogiltig nyckel i ${issue3.origin ?? "v\xE4rdet"}`;
|
|
case "invalid_union":
|
|
return "Ogiltig input";
|
|
case "invalid_element":
|
|
return `Ogiltigt v\xE4rde i ${issue3.origin ?? "v\xE4rdet"}`;
|
|
default:
|
|
return `Ogiltig input`;
|
|
}
|
|
};
|
|
};
|
|
function sv_default2() {
|
|
return {
|
|
localeError: error82()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ta.js
|
|
var error83 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
|
|
file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
|
|
array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
|
|
set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "\u0B8E\u0BA3\u0BCD \u0B85\u0BB2\u0BCD\u0BB2\u0BBE\u0BA4\u0BA4\u0BC1" : "\u0B8E\u0BA3\u0BCD";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u0B85\u0BA3\u0BBF";
|
|
}
|
|
if (data === null) {
|
|
return "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
|
|
email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
|
|
url: "URL",
|
|
emoji: "emoji",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
|
|
date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF",
|
|
time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
|
|
duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1",
|
|
ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
|
|
ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
|
|
cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
|
|
cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
|
|
base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
|
|
base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
|
|
json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD",
|
|
e164: "E.164 \u0B8E\u0BA3\u0BCD",
|
|
jwt: "JWT",
|
|
template_literal: "input"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${joinValues2(issue3.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue3.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue3.origin} ${adj}${issue3.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
if (_issue.format === "includes")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
if (_issue.format === "regex")
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue3.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
|
|
case "unrecognized_keys":
|
|
return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${issue3.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`;
|
|
case "invalid_union":
|
|
return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1";
|
|
case "invalid_element":
|
|
return `${issue3.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`;
|
|
default:
|
|
return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1`;
|
|
}
|
|
};
|
|
};
|
|
function ta_default2() {
|
|
return {
|
|
localeError: error83()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/th.js
|
|
var error84 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
|
|
set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "\u0E44\u0E21\u0E48\u0E43\u0E0A\u0E48\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02 (NaN)" : "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)";
|
|
}
|
|
if (data === null) {
|
|
return "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
|
|
email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
|
|
url: "URL",
|
|
emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
|
|
date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO",
|
|
time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
|
|
duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
|
|
ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4",
|
|
ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6",
|
|
cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4",
|
|
cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6",
|
|
base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64",
|
|
base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL",
|
|
json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON",
|
|
e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)",
|
|
jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
|
|
template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${issue3.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.maximum.toString()} ${sizing.unit ?? "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`;
|
|
return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue3.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${_issue.prefix}"`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
|
|
if (_issue.format === "regex")
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
|
|
return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue3.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
|
|
case "unrecognized_keys":
|
|
return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49";
|
|
case "invalid_element":
|
|
return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue3.origin}`;
|
|
default:
|
|
return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07`;
|
|
}
|
|
};
|
|
};
|
|
function th_default2() {
|
|
return {
|
|
localeError: error84()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/tr.js
|
|
var parsedType7 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
var error85 = () => {
|
|
const Sizable = {
|
|
string: { unit: "karakter", verb: "olmal\u0131" },
|
|
file: { unit: "bayt", verb: "olmal\u0131" },
|
|
array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" },
|
|
set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const Nouns = {
|
|
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\xFCre",
|
|
ipv4: "IPv4 adresi",
|
|
ipv6: "IPv6 adresi",
|
|
cidrv4: "IPv4 aral\u0131\u011F\u0131",
|
|
cidrv6: "IPv6 aral\u0131\u011F\u0131",
|
|
base64: "base64 ile \u015Fifrelenmi\u015F metin",
|
|
base64url: "base64url ile \u015Fifrelenmi\u015F metin",
|
|
json_string: "JSON dizesi",
|
|
e164: "E.164 say\u0131s\u0131",
|
|
jwt: "JWT",
|
|
template_literal: "\u015Eablon dizesi"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `Ge\xE7ersiz de\u011Fer: beklenen ${issue3.expected}, al\u0131nan ${parsedType7(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\xC7ok b\xFCy\xFCk: beklenen ${issue3.origin ?? "de\u011Fer"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\xF6\u011Fe"}`;
|
|
return `\xC7ok b\xFCy\xFCk: beklenen ${issue3.origin ?? "de\u011Fer"} ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Ge\xE7ersiz metin: "${_issue.prefix}" ile ba\u015Flamal\u0131`;
|
|
if (_issue.format === "ends_with")
|
|
return `Ge\xE7ersiz metin: "${_issue.suffix}" ile bitmeli`;
|
|
if (_issue.format === "includes")
|
|
return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
|
|
if (_issue.format === "regex")
|
|
return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
|
|
return `Ge\xE7ersiz ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `Ge\xE7ersiz say\u0131: ${issue3.divisor} ile tam b\xF6l\xFCnebilmeli`;
|
|
case "unrecognized_keys":
|
|
return `Tan\u0131nmayan anahtar${issue3.keys.length > 1 ? "lar" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin} i\xE7inde ge\xE7ersiz anahtar`;
|
|
case "invalid_union":
|
|
return "Ge\xE7ersiz de\u011Fer";
|
|
case "invalid_element":
|
|
return `${issue3.origin} i\xE7inde ge\xE7ersiz de\u011Fer`;
|
|
default:
|
|
return `Ge\xE7ersiz de\u011Fer`;
|
|
}
|
|
};
|
|
};
|
|
function tr_default2() {
|
|
return {
|
|
localeError: error85()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/uk.js
|
|
var error86 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
|
|
set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType8 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u0447\u0438\u0441\u043B\u043E";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u043C\u0430\u0441\u0438\u0432";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
|
|
email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
|
|
url: "URL",
|
|
emoji: "\u0435\u043C\u043E\u0434\u0437\u0456",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO",
|
|
date: "\u0434\u0430\u0442\u0430 ISO",
|
|
time: "\u0447\u0430\u0441 ISO",
|
|
duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO",
|
|
ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4",
|
|
ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6",
|
|
cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4",
|
|
cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6",
|
|
base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64",
|
|
base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url",
|
|
json_string: "\u0440\u044F\u0434\u043E\u043A JSON",
|
|
e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${issue3.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${parsedType8(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`;
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue3.origin} \u0431\u0443\u0434\u0435 ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${issue3.keys.length > 1 ? "\u0456" : ""}: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456";
|
|
case "invalid_element":
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${issue3.origin}`;
|
|
default:
|
|
return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456`;
|
|
}
|
|
};
|
|
};
|
|
function uk_default2() {
|
|
return {
|
|
localeError: error86()
|
|
};
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ua.js
|
|
function ua_default2() {
|
|
return uk_default2();
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/ur.js
|
|
var error87 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
|
|
file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
|
|
array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" },
|
|
set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType8 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "\u0646\u0645\u0628\u0631";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u0622\u0631\u06D2";
|
|
}
|
|
if (data === null) {
|
|
return "\u0646\u0644";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0627\u0646 \u067E\u0679",
|
|
email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
|
|
url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
|
|
emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
|
|
uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4",
|
|
uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6",
|
|
nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2",
|
|
ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC",
|
|
xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC",
|
|
ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
|
|
datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645",
|
|
date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E",
|
|
time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A",
|
|
duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A",
|
|
ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633",
|
|
ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633",
|
|
cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C",
|
|
cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C",
|
|
base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
|
|
base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
|
|
json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF",
|
|
e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631",
|
|
jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
|
|
template_literal: "\u0627\u0646 \u067E\u0679"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${issue3.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${parsedType8(issue3.input)} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive2(issue3.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${joinValues2(issue3.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue3.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
|
|
return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue3.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue3.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue3.origin} \u06A9\u06D2 ${adj}${issue3.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
|
|
}
|
|
return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue3.origin} \u06A9\u0627 ${adj}${issue3.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
if (_issue.format === "includes")
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
if (_issue.format === "regex")
|
|
return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
return `\u063A\u0644\u0637 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue3.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
|
|
case "unrecognized_keys":
|
|
return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${issue3.keys.length > 1 ? "\u0632" : ""}: ${joinValues2(issue3.keys, "\u060C ")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`;
|
|
case "invalid_union":
|
|
return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679";
|
|
case "invalid_element":
|
|
return `${issue3.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`;
|
|
default:
|
|
return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679`;
|
|
}
|
|
};
|
|
};
|
|
function ur_default2() {
|
|
return {
|
|
localeError: error87()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/vi.js
|
|
var error88 = () => {
|
|
const Sizable = {
|
|
string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
|
|
file: { unit: "byte", verb: "c\xF3" },
|
|
array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
|
|
set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType8 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "s\u1ED1";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "m\u1EA3ng";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u0111\u1EA7u v\xE0o",
|
|
email: "\u0111\u1ECBa ch\u1EC9 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\xE0y gi\u1EDD ISO",
|
|
date: "ng\xE0y ISO",
|
|
time: "gi\u1EDD ISO",
|
|
duration: "kho\u1EA3ng th\u1EDDi gian ISO",
|
|
ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4",
|
|
ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6",
|
|
cidrv4: "d\u1EA3i IPv4",
|
|
cidrv6: "d\u1EA3i IPv6",
|
|
base64: "chu\u1ED7i m\xE3 h\xF3a base64",
|
|
base64url: "chu\u1ED7i m\xE3 h\xF3a base64url",
|
|
json_string: "chu\u1ED7i JSON",
|
|
e164: "s\u1ED1 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u0111\u1EA7u v\xE0o"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${issue3.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${parsedType8(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue3.origin ?? "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "ph\u1EA7n t\u1EED"}`;
|
|
return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue3.origin ?? "gi\xE1 tr\u1ECB"} ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
|
|
return `${Nouns[_issue.format] ?? issue3.format} kh\xF4ng h\u1EE3p l\u1EC7`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7";
|
|
case "invalid_element":
|
|
return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue3.origin}`;
|
|
default:
|
|
return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7`;
|
|
}
|
|
};
|
|
};
|
|
function vi_default2() {
|
|
return {
|
|
localeError: error88()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/zh-CN.js
|
|
var error89 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
|
|
file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
|
|
array: { unit: "\u9879", verb: "\u5305\u542B" },
|
|
set: { unit: "\u9879", verb: "\u5305\u542B" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType8 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "\u975E\u6570\u5B57(NaN)" : "\u6570\u5B57";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "\u6570\u7EC4";
|
|
}
|
|
if (data === null) {
|
|
return "\u7A7A\u503C(null)";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u8F93\u5165",
|
|
email: "\u7535\u5B50\u90AE\u4EF6",
|
|
url: "URL",
|
|
emoji: "\u8868\u60C5\u7B26\u53F7",
|
|
uuid: "UUID",
|
|
uuidv4: "UUIDv4",
|
|
uuidv6: "UUIDv6",
|
|
nanoid: "nanoid",
|
|
guid: "GUID",
|
|
cuid: "cuid",
|
|
cuid2: "cuid2",
|
|
ulid: "ULID",
|
|
xid: "XID",
|
|
ksuid: "KSUID",
|
|
datetime: "ISO\u65E5\u671F\u65F6\u95F4",
|
|
date: "ISO\u65E5\u671F",
|
|
time: "ISO\u65F6\u95F4",
|
|
duration: "ISO\u65F6\u957F",
|
|
ipv4: "IPv4\u5730\u5740",
|
|
ipv6: "IPv6\u5730\u5740",
|
|
cidrv4: "IPv4\u7F51\u6BB5",
|
|
cidrv6: "IPv6\u7F51\u6BB5",
|
|
base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32",
|
|
base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32",
|
|
json_string: "JSON\u5B57\u7B26\u4E32",
|
|
e164: "E.164\u53F7\u7801",
|
|
jwt: "JWT",
|
|
template_literal: "\u8F93\u5165"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${issue3.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${parsedType8(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue3.origin ?? "\u503C"} ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u4E2A\u5143\u7D20"}`;
|
|
return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue3.origin ?? "\u503C"} ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue3.origin} ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue3.origin} ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.prefix}" \u5F00\u5934`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.suffix}" \u7ED3\u5C3E`;
|
|
if (_issue.format === "includes")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
|
|
return `\u65E0\u6548${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue3.divisor} \u7684\u500D\u6570`;
|
|
case "unrecognized_keys":
|
|
return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`;
|
|
case "invalid_union":
|
|
return "\u65E0\u6548\u8F93\u5165";
|
|
case "invalid_element":
|
|
return `${issue3.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`;
|
|
default:
|
|
return `\u65E0\u6548\u8F93\u5165`;
|
|
}
|
|
};
|
|
};
|
|
function zh_CN_default2() {
|
|
return {
|
|
localeError: error89()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/zh-TW.js
|
|
var error90 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
|
|
file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
|
|
array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" },
|
|
set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType8 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "number";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "array";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u8F38\u5165",
|
|
email: "\u90F5\u4EF6\u5730\u5740",
|
|
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 \u65E5\u671F\u6642\u9593",
|
|
date: "ISO \u65E5\u671F",
|
|
time: "ISO \u6642\u9593",
|
|
duration: "ISO \u671F\u9593",
|
|
ipv4: "IPv4 \u4F4D\u5740",
|
|
ipv6: "IPv6 \u4F4D\u5740",
|
|
cidrv4: "IPv4 \u7BC4\u570D",
|
|
cidrv6: "IPv6 \u7BC4\u570D",
|
|
base64: "base64 \u7DE8\u78BC\u5B57\u4E32",
|
|
base64url: "base64url \u7DE8\u78BC\u5B57\u4E32",
|
|
json_string: "JSON \u5B57\u4E32",
|
|
e164: "E.164 \u6578\u503C",
|
|
jwt: "JWT",
|
|
template_literal: "\u8F38\u5165"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${issue3.expected}\uFF0C\u4F46\u6536\u5230 ${parsedType8(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue3.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue3.maximum.toString()} ${sizing.unit ?? "\u500B\u5143\u7D20"}`;
|
|
return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue3.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue3.maximum.toString()}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing) {
|
|
return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue3.origin} \u61C9\u70BA ${adj}${issue3.minimum.toString()} ${sizing.unit}`;
|
|
}
|
|
return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue3.origin} \u61C9\u70BA ${adj}${issue3.minimum.toString()}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with") {
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.prefix}" \u958B\u982D`;
|
|
}
|
|
if (_issue.format === "ends_with")
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.suffix}" \u7D50\u5C3E`;
|
|
if (_issue.format === "includes")
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
|
|
return `\u7121\u6548\u7684 ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue3.divisor} \u7684\u500D\u6578`;
|
|
case "unrecognized_keys":
|
|
return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${issue3.keys.length > 1 ? "\u5011" : ""}\uFF1A${joinValues2(issue3.keys, "\u3001")}`;
|
|
case "invalid_key":
|
|
return `${issue3.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`;
|
|
case "invalid_union":
|
|
return "\u7121\u6548\u7684\u8F38\u5165\u503C";
|
|
case "invalid_element":
|
|
return `${issue3.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`;
|
|
default:
|
|
return `\u7121\u6548\u7684\u8F38\u5165\u503C`;
|
|
}
|
|
};
|
|
};
|
|
function zh_TW_default2() {
|
|
return {
|
|
localeError: error90()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/locales/yo.js
|
|
var error91 = () => {
|
|
const Sizable = {
|
|
string: { unit: "\xE0mi", verb: "n\xED" },
|
|
file: { unit: "bytes", verb: "n\xED" },
|
|
array: { unit: "nkan", verb: "n\xED" },
|
|
set: { unit: "nkan", verb: "n\xED" }
|
|
};
|
|
function getSizing(origin) {
|
|
return Sizable[origin] ?? null;
|
|
}
|
|
const parsedType8 = (data) => {
|
|
const t = typeof data;
|
|
switch (t) {
|
|
case "number": {
|
|
return Number.isNaN(data) ? "NaN" : "n\u1ECD\u0301mb\xE0";
|
|
}
|
|
case "object": {
|
|
if (Array.isArray(data)) {
|
|
return "akop\u1ECD";
|
|
}
|
|
if (data === null) {
|
|
return "null";
|
|
}
|
|
if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
|
|
return data.constructor.name;
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
const Nouns = {
|
|
regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9",
|
|
email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC",
|
|
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: "\xE0k\xF3k\xF2 ISO",
|
|
date: "\u1ECDj\u1ECD\u0301 ISO",
|
|
time: "\xE0k\xF3k\xF2 ISO",
|
|
duration: "\xE0k\xF3k\xF2 t\xF3 p\xE9 ISO",
|
|
ipv4: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv4",
|
|
ipv6: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv6",
|
|
cidrv4: "\xE0gb\xE8gb\xE8 IPv4",
|
|
cidrv6: "\xE0gb\xE8gb\xE8 IPv6",
|
|
base64: "\u1ECD\u0300r\u1ECD\u0300 t\xED a k\u1ECD\u0301 n\xED base64",
|
|
base64url: "\u1ECD\u0300r\u1ECD\u0300 base64url",
|
|
json_string: "\u1ECD\u0300r\u1ECD\u0300 JSON",
|
|
e164: "n\u1ECD\u0301mb\xE0 E.164",
|
|
jwt: "JWT",
|
|
template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9"
|
|
};
|
|
return (issue3) => {
|
|
switch (issue3.code) {
|
|
case "invalid_type":
|
|
return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${issue3.expected}, \xE0m\u1ECD\u0300 a r\xED ${parsedType8(issue3.input)}`;
|
|
case "invalid_value":
|
|
if (issue3.values.length === 1)
|
|
return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${stringifyPrimitive2(issue3.values[0])}`;
|
|
return `\xC0\u1E63\xE0y\xE0n a\u1E63\xEC\u1E63e: yan \u1ECD\u0300kan l\xE1ra ${joinValues2(issue3.values, "|")}`;
|
|
case "too_big": {
|
|
const adj = issue3.inclusive ? "<=" : "<";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue3.origin ?? "iye"} ${sizing.verb} ${adj}${issue3.maximum} ${sizing.unit}`;
|
|
return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue3.maximum}`;
|
|
}
|
|
case "too_small": {
|
|
const adj = issue3.inclusive ? ">=" : ">";
|
|
const sizing = getSizing(issue3.origin);
|
|
if (sizing)
|
|
return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue3.origin} ${sizing.verb} ${adj}${issue3.minimum} ${sizing.unit}`;
|
|
return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue3.minimum}`;
|
|
}
|
|
case "invalid_format": {
|
|
const _issue = issue3;
|
|
if (_issue.format === "starts_with")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\u1EB9\u0300r\u1EB9\u0300 p\u1EB9\u0300l\xFA "${_issue.prefix}"`;
|
|
if (_issue.format === "ends_with")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 par\xED p\u1EB9\u0300l\xFA "${_issue.suffix}"`;
|
|
if (_issue.format === "includes")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`;
|
|
if (_issue.format === "regex")
|
|
return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`;
|
|
return `A\u1E63\xEC\u1E63e: ${Nouns[_issue.format] ?? issue3.format}`;
|
|
}
|
|
case "not_multiple_of":
|
|
return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue3.divisor}`;
|
|
case "unrecognized_keys":
|
|
return `B\u1ECDt\xECn\xEC \xE0\xECm\u1ECD\u0300: ${joinValues2(issue3.keys, ", ")}`;
|
|
case "invalid_key":
|
|
return `B\u1ECDt\xECn\xEC a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue3.origin}`;
|
|
case "invalid_union":
|
|
return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
|
|
case "invalid_element":
|
|
return `Iye a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue3.origin}`;
|
|
default:
|
|
return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
|
|
}
|
|
};
|
|
};
|
|
function yo_default2() {
|
|
return {
|
|
localeError: error91()
|
|
};
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/registries.js
|
|
var $output2 = Symbol("ZodOutput");
|
|
var $input2 = Symbol("ZodInput");
|
|
|
|
class $ZodRegistry2 {
|
|
constructor() {
|
|
this._map = new WeakMap;
|
|
this._idmap = new Map;
|
|
}
|
|
add(schema, ..._meta) {
|
|
const meta3 = _meta[0];
|
|
this._map.set(schema, meta3);
|
|
if (meta3 && typeof meta3 === "object" && "id" in meta3) {
|
|
if (this._idmap.has(meta3.id)) {
|
|
throw new Error(`ID ${meta3.id} already exists in the registry`);
|
|
}
|
|
this._idmap.set(meta3.id, schema);
|
|
}
|
|
return this;
|
|
}
|
|
clear() {
|
|
this._map = new WeakMap;
|
|
this._idmap = new Map;
|
|
return this;
|
|
}
|
|
remove(schema) {
|
|
const meta3 = this._map.get(schema);
|
|
if (meta3 && typeof meta3 === "object" && "id" in meta3) {
|
|
this._idmap.delete(meta3.id);
|
|
}
|
|
this._map.delete(schema);
|
|
return this;
|
|
}
|
|
get(schema) {
|
|
const p = schema._zod.parent;
|
|
if (p) {
|
|
const pm = { ...this.get(p) ?? {} };
|
|
delete pm.id;
|
|
const f = { ...pm, ...this._map.get(schema) };
|
|
return Object.keys(f).length ? f : undefined;
|
|
}
|
|
return this._map.get(schema);
|
|
}
|
|
has(schema) {
|
|
return this._map.has(schema);
|
|
}
|
|
}
|
|
function registry2() {
|
|
return new $ZodRegistry2;
|
|
}
|
|
var globalRegistry2 = /* @__PURE__ */ registry2();
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/api.js
|
|
function _string2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _coercedString2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
coerce: true,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _email2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "email",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _guid2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "guid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _uuid2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _uuidv42(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v4",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _uuidv62(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v6",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _uuidv72(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "uuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
version: "v7",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _url2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _emoji4(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "emoji",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _nanoid2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "nanoid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _cuid3(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "cuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _cuid22(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "cuid2",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _ulid2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "ulid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _xid2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "xid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _ksuid2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "ksuid",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _ipv42(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "ipv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _ipv62(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "ipv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _cidrv42(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "cidrv4",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _cidrv62(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "cidrv6",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _base642(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "base64",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _base64url2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "base64url",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _e1642(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "e164",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _jwt2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "jwt",
|
|
check: "string_format",
|
|
abort: false,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
var TimePrecision2 = {
|
|
Any: null,
|
|
Minute: -1,
|
|
Second: 0,
|
|
Millisecond: 3,
|
|
Microsecond: 6
|
|
};
|
|
function _isoDateTime2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "datetime",
|
|
check: "string_format",
|
|
offset: false,
|
|
local: false,
|
|
precision: null,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _isoDate2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "date",
|
|
check: "string_format",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _isoTime2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "time",
|
|
check: "string_format",
|
|
precision: null,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _isoDuration2(Class3, params) {
|
|
return new Class3({
|
|
type: "string",
|
|
format: "duration",
|
|
check: "string_format",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _number2(Class3, params) {
|
|
return new Class3({
|
|
type: "number",
|
|
checks: [],
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _coercedNumber2(Class3, params) {
|
|
return new Class3({
|
|
type: "number",
|
|
coerce: true,
|
|
checks: [],
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _int2(Class3, params) {
|
|
return new Class3({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "safeint",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _float322(Class3, params) {
|
|
return new Class3({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "float32",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _float642(Class3, params) {
|
|
return new Class3({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "float64",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _int322(Class3, params) {
|
|
return new Class3({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "int32",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _uint322(Class3, params) {
|
|
return new Class3({
|
|
type: "number",
|
|
check: "number_format",
|
|
abort: false,
|
|
format: "uint32",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _boolean2(Class3, params) {
|
|
return new Class3({
|
|
type: "boolean",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _coercedBoolean2(Class3, params) {
|
|
return new Class3({
|
|
type: "boolean",
|
|
coerce: true,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _bigint2(Class3, params) {
|
|
return new Class3({
|
|
type: "bigint",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _coercedBigint2(Class3, params) {
|
|
return new Class3({
|
|
type: "bigint",
|
|
coerce: true,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _int642(Class3, params) {
|
|
return new Class3({
|
|
type: "bigint",
|
|
check: "bigint_format",
|
|
abort: false,
|
|
format: "int64",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _uint642(Class3, params) {
|
|
return new Class3({
|
|
type: "bigint",
|
|
check: "bigint_format",
|
|
abort: false,
|
|
format: "uint64",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _symbol2(Class3, params) {
|
|
return new Class3({
|
|
type: "symbol",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _undefined5(Class3, params) {
|
|
return new Class3({
|
|
type: "undefined",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _null5(Class3, params) {
|
|
return new Class3({
|
|
type: "null",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _any2(Class3) {
|
|
return new Class3({
|
|
type: "any"
|
|
});
|
|
}
|
|
function _unknown2(Class3) {
|
|
return new Class3({
|
|
type: "unknown"
|
|
});
|
|
}
|
|
function _never2(Class3, params) {
|
|
return new Class3({
|
|
type: "never",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _void3(Class3, params) {
|
|
return new Class3({
|
|
type: "void",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _date2(Class3, params) {
|
|
return new Class3({
|
|
type: "date",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _coercedDate2(Class3, params) {
|
|
return new Class3({
|
|
type: "date",
|
|
coerce: true,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _nan2(Class3, params) {
|
|
return new Class3({
|
|
type: "nan",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _lt2(value, params) {
|
|
return new $ZodCheckLessThan2({
|
|
check: "less_than",
|
|
...normalizeParams2(params),
|
|
value,
|
|
inclusive: false
|
|
});
|
|
}
|
|
function _lte2(value, params) {
|
|
return new $ZodCheckLessThan2({
|
|
check: "less_than",
|
|
...normalizeParams2(params),
|
|
value,
|
|
inclusive: true
|
|
});
|
|
}
|
|
function _gt2(value, params) {
|
|
return new $ZodCheckGreaterThan2({
|
|
check: "greater_than",
|
|
...normalizeParams2(params),
|
|
value,
|
|
inclusive: false
|
|
});
|
|
}
|
|
function _gte2(value, params) {
|
|
return new $ZodCheckGreaterThan2({
|
|
check: "greater_than",
|
|
...normalizeParams2(params),
|
|
value,
|
|
inclusive: true
|
|
});
|
|
}
|
|
function _positive2(params) {
|
|
return _gt2(0, params);
|
|
}
|
|
function _negative2(params) {
|
|
return _lt2(0, params);
|
|
}
|
|
function _nonpositive2(params) {
|
|
return _lte2(0, params);
|
|
}
|
|
function _nonnegative2(params) {
|
|
return _gte2(0, params);
|
|
}
|
|
function _multipleOf2(value, params) {
|
|
return new $ZodCheckMultipleOf2({
|
|
check: "multiple_of",
|
|
...normalizeParams2(params),
|
|
value
|
|
});
|
|
}
|
|
function _maxSize2(maximum, params) {
|
|
return new $ZodCheckMaxSize2({
|
|
check: "max_size",
|
|
...normalizeParams2(params),
|
|
maximum
|
|
});
|
|
}
|
|
function _minSize2(minimum, params) {
|
|
return new $ZodCheckMinSize2({
|
|
check: "min_size",
|
|
...normalizeParams2(params),
|
|
minimum
|
|
});
|
|
}
|
|
function _size2(size, params) {
|
|
return new $ZodCheckSizeEquals2({
|
|
check: "size_equals",
|
|
...normalizeParams2(params),
|
|
size
|
|
});
|
|
}
|
|
function _maxLength2(maximum, params) {
|
|
const ch = new $ZodCheckMaxLength2({
|
|
check: "max_length",
|
|
...normalizeParams2(params),
|
|
maximum
|
|
});
|
|
return ch;
|
|
}
|
|
function _minLength2(minimum, params) {
|
|
return new $ZodCheckMinLength2({
|
|
check: "min_length",
|
|
...normalizeParams2(params),
|
|
minimum
|
|
});
|
|
}
|
|
function _length2(length, params) {
|
|
return new $ZodCheckLengthEquals2({
|
|
check: "length_equals",
|
|
...normalizeParams2(params),
|
|
length
|
|
});
|
|
}
|
|
function _regex2(pattern, params) {
|
|
return new $ZodCheckRegex2({
|
|
check: "string_format",
|
|
format: "regex",
|
|
...normalizeParams2(params),
|
|
pattern
|
|
});
|
|
}
|
|
function _lowercase2(params) {
|
|
return new $ZodCheckLowerCase2({
|
|
check: "string_format",
|
|
format: "lowercase",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _uppercase2(params) {
|
|
return new $ZodCheckUpperCase2({
|
|
check: "string_format",
|
|
format: "uppercase",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _includes2(includes, params) {
|
|
return new $ZodCheckIncludes2({
|
|
check: "string_format",
|
|
format: "includes",
|
|
...normalizeParams2(params),
|
|
includes
|
|
});
|
|
}
|
|
function _startsWith2(prefix, params) {
|
|
return new $ZodCheckStartsWith2({
|
|
check: "string_format",
|
|
format: "starts_with",
|
|
...normalizeParams2(params),
|
|
prefix
|
|
});
|
|
}
|
|
function _endsWith2(suffix, params) {
|
|
return new $ZodCheckEndsWith2({
|
|
check: "string_format",
|
|
format: "ends_with",
|
|
...normalizeParams2(params),
|
|
suffix
|
|
});
|
|
}
|
|
function _property2(property, schema, params) {
|
|
return new $ZodCheckProperty2({
|
|
check: "property",
|
|
property,
|
|
schema,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _mime2(types3, params) {
|
|
return new $ZodCheckMimeType2({
|
|
check: "mime_type",
|
|
mime: types3,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _overwrite2(tx) {
|
|
return new $ZodCheckOverwrite2({
|
|
check: "overwrite",
|
|
tx
|
|
});
|
|
}
|
|
function _normalize2(form) {
|
|
return _overwrite2((input) => input.normalize(form));
|
|
}
|
|
function _trim2() {
|
|
return _overwrite2((input) => input.trim());
|
|
}
|
|
function _toLowerCase2() {
|
|
return _overwrite2((input) => input.toLowerCase());
|
|
}
|
|
function _toUpperCase2() {
|
|
return _overwrite2((input) => input.toUpperCase());
|
|
}
|
|
function _array2(Class3, element, params) {
|
|
return new Class3({
|
|
type: "array",
|
|
element,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _union2(Class3, options, params) {
|
|
return new Class3({
|
|
type: "union",
|
|
options,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _discriminatedUnion2(Class3, discriminator, options, params) {
|
|
return new Class3({
|
|
type: "union",
|
|
options,
|
|
discriminator,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _intersection2(Class3, left, right) {
|
|
return new Class3({
|
|
type: "intersection",
|
|
left,
|
|
right
|
|
});
|
|
}
|
|
function _tuple2(Class3, items, _paramsOrRest, _params) {
|
|
const hasRest = _paramsOrRest instanceof $ZodType2;
|
|
const params = hasRest ? _params : _paramsOrRest;
|
|
const rest = hasRest ? _paramsOrRest : null;
|
|
return new Class3({
|
|
type: "tuple",
|
|
items,
|
|
rest,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _record2(Class3, keyType, valueType, params) {
|
|
return new Class3({
|
|
type: "record",
|
|
keyType,
|
|
valueType,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _map2(Class3, keyType, valueType, params) {
|
|
return new Class3({
|
|
type: "map",
|
|
keyType,
|
|
valueType,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _set2(Class3, valueType, params) {
|
|
return new Class3({
|
|
type: "set",
|
|
valueType,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _enum3(Class3, values, params) {
|
|
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
|
|
return new Class3({
|
|
type: "enum",
|
|
entries,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _nativeEnum2(Class3, entries, params) {
|
|
return new Class3({
|
|
type: "enum",
|
|
entries,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _literal2(Class3, value, params) {
|
|
return new Class3({
|
|
type: "literal",
|
|
values: Array.isArray(value) ? value : [value],
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _file2(Class3, params) {
|
|
return new Class3({
|
|
type: "file",
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _transform2(Class3, fn) {
|
|
return new Class3({
|
|
type: "transform",
|
|
transform: fn
|
|
});
|
|
}
|
|
function _optional2(Class3, innerType) {
|
|
return new Class3({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
function _nullable2(Class3, innerType) {
|
|
return new Class3({
|
|
type: "nullable",
|
|
innerType
|
|
});
|
|
}
|
|
function _default3(Class3, innerType, defaultValue) {
|
|
return new Class3({
|
|
type: "default",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : shallowClone2(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
function _nonoptional2(Class3, innerType, params) {
|
|
return new Class3({
|
|
type: "nonoptional",
|
|
innerType,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _success2(Class3, innerType) {
|
|
return new Class3({
|
|
type: "success",
|
|
innerType
|
|
});
|
|
}
|
|
function _catch3(Class3, innerType, catchValue) {
|
|
return new Class3({
|
|
type: "catch",
|
|
innerType,
|
|
catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
|
|
});
|
|
}
|
|
function _pipe2(Class3, in_, out) {
|
|
return new Class3({
|
|
type: "pipe",
|
|
in: in_,
|
|
out
|
|
});
|
|
}
|
|
function _readonly2(Class3, innerType) {
|
|
return new Class3({
|
|
type: "readonly",
|
|
innerType
|
|
});
|
|
}
|
|
function _templateLiteral2(Class3, parts, params) {
|
|
return new Class3({
|
|
type: "template_literal",
|
|
parts,
|
|
...normalizeParams2(params)
|
|
});
|
|
}
|
|
function _lazy2(Class3, getter) {
|
|
return new Class3({
|
|
type: "lazy",
|
|
getter
|
|
});
|
|
}
|
|
function _promise2(Class3, innerType) {
|
|
return new Class3({
|
|
type: "promise",
|
|
innerType
|
|
});
|
|
}
|
|
function _custom2(Class3, fn, _params) {
|
|
const norm = normalizeParams2(_params);
|
|
norm.abort ?? (norm.abort = true);
|
|
const schema = new Class3({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn,
|
|
...norm
|
|
});
|
|
return schema;
|
|
}
|
|
function _refine2(Class3, fn, _params) {
|
|
const schema = new Class3({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn,
|
|
...normalizeParams2(_params)
|
|
});
|
|
return schema;
|
|
}
|
|
function _superRefine2(fn) {
|
|
const ch = _check2((payload) => {
|
|
payload.addIssue = (issue3) => {
|
|
if (typeof issue3 === "string") {
|
|
payload.issues.push(issue2(issue3, payload.value, ch._zod.def));
|
|
} else {
|
|
const _issue = issue3;
|
|
if (_issue.fatal)
|
|
_issue.continue = false;
|
|
_issue.code ?? (_issue.code = "custom");
|
|
_issue.input ?? (_issue.input = payload.value);
|
|
_issue.inst ?? (_issue.inst = ch);
|
|
_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
|
|
payload.issues.push(issue2(_issue));
|
|
}
|
|
};
|
|
return fn(payload.value, payload);
|
|
});
|
|
return ch;
|
|
}
|
|
function _check2(fn, params) {
|
|
const ch = new $ZodCheck2({
|
|
check: "custom",
|
|
...normalizeParams2(params)
|
|
});
|
|
ch._zod.check = fn;
|
|
return ch;
|
|
}
|
|
function _stringbool2(Classes, _params) {
|
|
const params = normalizeParams2(_params);
|
|
let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
|
|
let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
|
|
if (params.case !== "sensitive") {
|
|
truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
|
|
falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
|
|
}
|
|
const truthySet = new Set(truthyArray);
|
|
const falsySet = new Set(falsyArray);
|
|
const _Codec = Classes.Codec ?? $ZodCodec2;
|
|
const _Boolean = Classes.Boolean ?? $ZodBoolean2;
|
|
const _String = Classes.String ?? $ZodString2;
|
|
const stringSchema = new _String({ type: "string", error: params.error });
|
|
const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
|
|
const codec2 = new _Codec({
|
|
type: "pipe",
|
|
in: stringSchema,
|
|
out: booleanSchema,
|
|
transform: (input, payload) => {
|
|
let data = input;
|
|
if (params.case !== "sensitive")
|
|
data = data.toLowerCase();
|
|
if (truthySet.has(data)) {
|
|
return true;
|
|
} else if (falsySet.has(data)) {
|
|
return false;
|
|
} else {
|
|
payload.issues.push({
|
|
code: "invalid_value",
|
|
expected: "stringbool",
|
|
values: [...truthySet, ...falsySet],
|
|
input: payload.value,
|
|
inst: codec2,
|
|
continue: false
|
|
});
|
|
return {};
|
|
}
|
|
},
|
|
reverseTransform: (input, _payload) => {
|
|
if (input === true) {
|
|
return truthyArray[0] || "true";
|
|
} else {
|
|
return falsyArray[0] || "false";
|
|
}
|
|
},
|
|
error: params.error
|
|
});
|
|
return codec2;
|
|
}
|
|
function _stringFormat2(Class3, format2, fnOrRegex, _params = {}) {
|
|
const params = normalizeParams2(_params);
|
|
const def = {
|
|
...normalizeParams2(_params),
|
|
check: "string_format",
|
|
type: "string",
|
|
format: format2,
|
|
fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
|
|
...params
|
|
};
|
|
if (fnOrRegex instanceof RegExp) {
|
|
def.pattern = fnOrRegex;
|
|
}
|
|
const inst = new Class3(def);
|
|
return inst;
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/to-json-schema.js
|
|
class JSONSchemaGenerator2 {
|
|
constructor(params) {
|
|
this.counter = 0;
|
|
this.metadataRegistry = params?.metadata ?? globalRegistry2;
|
|
this.target = params?.target ?? "draft-2020-12";
|
|
this.unrepresentable = params?.unrepresentable ?? "throw";
|
|
this.override = params?.override ?? (() => {});
|
|
this.io = params?.io ?? "output";
|
|
this.seen = new Map;
|
|
}
|
|
process(schema, _params = { path: [], schemaPath: [] }) {
|
|
var _a2;
|
|
const def = schema._zod.def;
|
|
const formatMap2 = {
|
|
guid: "uuid",
|
|
url: "uri",
|
|
datetime: "date-time",
|
|
json_string: "json-string",
|
|
regex: ""
|
|
};
|
|
const seen = this.seen.get(schema);
|
|
if (seen) {
|
|
seen.count++;
|
|
const isCycle = _params.schemaPath.includes(schema);
|
|
if (isCycle) {
|
|
seen.cycle = _params.path;
|
|
}
|
|
return seen.schema;
|
|
}
|
|
const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };
|
|
this.seen.set(schema, result);
|
|
const overrideSchema = schema._zod.toJSONSchema?.();
|
|
if (overrideSchema) {
|
|
result.schema = overrideSchema;
|
|
} else {
|
|
const params = {
|
|
..._params,
|
|
schemaPath: [..._params.schemaPath, schema],
|
|
path: _params.path
|
|
};
|
|
const parent = schema._zod.parent;
|
|
if (parent) {
|
|
result.ref = parent;
|
|
this.process(parent, params);
|
|
this.seen.get(parent).isParent = true;
|
|
} else {
|
|
const _json = result.schema;
|
|
switch (def.type) {
|
|
case "string": {
|
|
const json2 = _json;
|
|
json2.type = "string";
|
|
const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json2.minLength = minimum;
|
|
if (typeof maximum === "number")
|
|
json2.maxLength = maximum;
|
|
if (format2) {
|
|
json2.format = formatMap2[format2] ?? format2;
|
|
if (json2.format === "")
|
|
delete json2.format;
|
|
}
|
|
if (contentEncoding)
|
|
json2.contentEncoding = contentEncoding;
|
|
if (patterns && patterns.size > 0) {
|
|
const regexes = [...patterns];
|
|
if (regexes.length === 1)
|
|
json2.pattern = regexes[0].source;
|
|
else if (regexes.length > 1) {
|
|
result.schema.allOf = [
|
|
...regexes.map((regex) => ({
|
|
...this.target === "draft-7" || this.target === "draft-4" || this.target === "openapi-3.0" ? { type: "string" } : {},
|
|
pattern: regex.source
|
|
}))
|
|
];
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case "number": {
|
|
const json2 = _json;
|
|
const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
|
|
if (typeof format2 === "string" && format2.includes("int"))
|
|
json2.type = "integer";
|
|
else
|
|
json2.type = "number";
|
|
if (typeof exclusiveMinimum === "number") {
|
|
if (this.target === "draft-4" || this.target === "openapi-3.0") {
|
|
json2.minimum = exclusiveMinimum;
|
|
json2.exclusiveMinimum = true;
|
|
} else {
|
|
json2.exclusiveMinimum = exclusiveMinimum;
|
|
}
|
|
}
|
|
if (typeof minimum === "number") {
|
|
json2.minimum = minimum;
|
|
if (typeof exclusiveMinimum === "number" && this.target !== "draft-4") {
|
|
if (exclusiveMinimum >= minimum)
|
|
delete json2.minimum;
|
|
else
|
|
delete json2.exclusiveMinimum;
|
|
}
|
|
}
|
|
if (typeof exclusiveMaximum === "number") {
|
|
if (this.target === "draft-4" || this.target === "openapi-3.0") {
|
|
json2.maximum = exclusiveMaximum;
|
|
json2.exclusiveMaximum = true;
|
|
} else {
|
|
json2.exclusiveMaximum = exclusiveMaximum;
|
|
}
|
|
}
|
|
if (typeof maximum === "number") {
|
|
json2.maximum = maximum;
|
|
if (typeof exclusiveMaximum === "number" && this.target !== "draft-4") {
|
|
if (exclusiveMaximum <= maximum)
|
|
delete json2.maximum;
|
|
else
|
|
delete json2.exclusiveMaximum;
|
|
}
|
|
}
|
|
if (typeof multipleOf === "number")
|
|
json2.multipleOf = multipleOf;
|
|
break;
|
|
}
|
|
case "boolean": {
|
|
const json2 = _json;
|
|
json2.type = "boolean";
|
|
break;
|
|
}
|
|
case "bigint": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("BigInt cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "symbol": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Symbols cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "null": {
|
|
if (this.target === "openapi-3.0") {
|
|
_json.type = "string";
|
|
_json.nullable = true;
|
|
_json.enum = [null];
|
|
} else
|
|
_json.type = "null";
|
|
break;
|
|
}
|
|
case "any": {
|
|
break;
|
|
}
|
|
case "unknown": {
|
|
break;
|
|
}
|
|
case "undefined": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Undefined cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "void": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Void cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "never": {
|
|
_json.not = {};
|
|
break;
|
|
}
|
|
case "date": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Date cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "array": {
|
|
const json2 = _json;
|
|
const { minimum, maximum } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json2.minItems = minimum;
|
|
if (typeof maximum === "number")
|
|
json2.maxItems = maximum;
|
|
json2.type = "array";
|
|
json2.items = this.process(def.element, { ...params, path: [...params.path, "items"] });
|
|
break;
|
|
}
|
|
case "object": {
|
|
const json2 = _json;
|
|
json2.type = "object";
|
|
json2.properties = {};
|
|
const shape = def.shape;
|
|
for (const key in shape) {
|
|
json2.properties[key] = this.process(shape[key], {
|
|
...params,
|
|
path: [...params.path, "properties", key]
|
|
});
|
|
}
|
|
const allKeys = new Set(Object.keys(shape));
|
|
const requiredKeys = new Set([...allKeys].filter((key) => {
|
|
const v = def.shape[key]._zod;
|
|
if (this.io === "input") {
|
|
return v.optin === undefined;
|
|
} else {
|
|
return v.optout === undefined;
|
|
}
|
|
}));
|
|
if (requiredKeys.size > 0) {
|
|
json2.required = Array.from(requiredKeys);
|
|
}
|
|
if (def.catchall?._zod.def.type === "never") {
|
|
json2.additionalProperties = false;
|
|
} else if (!def.catchall) {
|
|
if (this.io === "output")
|
|
json2.additionalProperties = false;
|
|
} else if (def.catchall) {
|
|
json2.additionalProperties = this.process(def.catchall, {
|
|
...params,
|
|
path: [...params.path, "additionalProperties"]
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case "union": {
|
|
const json2 = _json;
|
|
const options = def.options.map((x, i) => this.process(x, {
|
|
...params,
|
|
path: [...params.path, "anyOf", i]
|
|
}));
|
|
json2.anyOf = options;
|
|
break;
|
|
}
|
|
case "intersection": {
|
|
const json2 = _json;
|
|
const a = this.process(def.left, {
|
|
...params,
|
|
path: [...params.path, "allOf", 0]
|
|
});
|
|
const b = this.process(def.right, {
|
|
...params,
|
|
path: [...params.path, "allOf", 1]
|
|
});
|
|
const isSimpleIntersection = (val) => ("allOf" in val) && Object.keys(val).length === 1;
|
|
const allOf = [
|
|
...isSimpleIntersection(a) ? a.allOf : [a],
|
|
...isSimpleIntersection(b) ? b.allOf : [b]
|
|
];
|
|
json2.allOf = allOf;
|
|
break;
|
|
}
|
|
case "tuple": {
|
|
const json2 = _json;
|
|
json2.type = "array";
|
|
const prefixPath = this.target === "draft-2020-12" ? "prefixItems" : "items";
|
|
const restPath = this.target === "draft-2020-12" ? "items" : this.target === "openapi-3.0" ? "items" : "additionalItems";
|
|
const prefixItems = def.items.map((x, i) => this.process(x, {
|
|
...params,
|
|
path: [...params.path, prefixPath, i]
|
|
}));
|
|
const rest = def.rest ? this.process(def.rest, {
|
|
...params,
|
|
path: [...params.path, restPath, ...this.target === "openapi-3.0" ? [def.items.length] : []]
|
|
}) : null;
|
|
if (this.target === "draft-2020-12") {
|
|
json2.prefixItems = prefixItems;
|
|
if (rest) {
|
|
json2.items = rest;
|
|
}
|
|
} else if (this.target === "openapi-3.0") {
|
|
json2.items = {
|
|
anyOf: prefixItems
|
|
};
|
|
if (rest) {
|
|
json2.items.anyOf.push(rest);
|
|
}
|
|
json2.minItems = prefixItems.length;
|
|
if (!rest) {
|
|
json2.maxItems = prefixItems.length;
|
|
}
|
|
} else {
|
|
json2.items = prefixItems;
|
|
if (rest) {
|
|
json2.additionalItems = rest;
|
|
}
|
|
}
|
|
const { minimum, maximum } = schema._zod.bag;
|
|
if (typeof minimum === "number")
|
|
json2.minItems = minimum;
|
|
if (typeof maximum === "number")
|
|
json2.maxItems = maximum;
|
|
break;
|
|
}
|
|
case "record": {
|
|
const json2 = _json;
|
|
json2.type = "object";
|
|
if (this.target === "draft-7" || this.target === "draft-2020-12") {
|
|
json2.propertyNames = this.process(def.keyType, {
|
|
...params,
|
|
path: [...params.path, "propertyNames"]
|
|
});
|
|
}
|
|
json2.additionalProperties = this.process(def.valueType, {
|
|
...params,
|
|
path: [...params.path, "additionalProperties"]
|
|
});
|
|
break;
|
|
}
|
|
case "map": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Map cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "set": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Set cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "enum": {
|
|
const json2 = _json;
|
|
const values = getEnumValues2(def.entries);
|
|
if (values.every((v) => typeof v === "number"))
|
|
json2.type = "number";
|
|
if (values.every((v) => typeof v === "string"))
|
|
json2.type = "string";
|
|
json2.enum = values;
|
|
break;
|
|
}
|
|
case "literal": {
|
|
const json2 = _json;
|
|
const vals = [];
|
|
for (const val of def.values) {
|
|
if (val === undefined) {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Literal `undefined` cannot be represented in JSON Schema");
|
|
} else {}
|
|
} else if (typeof val === "bigint") {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("BigInt literals cannot be represented in JSON Schema");
|
|
} else {
|
|
vals.push(Number(val));
|
|
}
|
|
} else {
|
|
vals.push(val);
|
|
}
|
|
}
|
|
if (vals.length === 0) {} else if (vals.length === 1) {
|
|
const val = vals[0];
|
|
json2.type = val === null ? "null" : typeof val;
|
|
if (this.target === "draft-4" || this.target === "openapi-3.0") {
|
|
json2.enum = [val];
|
|
} else {
|
|
json2.const = val;
|
|
}
|
|
} else {
|
|
if (vals.every((v) => typeof v === "number"))
|
|
json2.type = "number";
|
|
if (vals.every((v) => typeof v === "string"))
|
|
json2.type = "string";
|
|
if (vals.every((v) => typeof v === "boolean"))
|
|
json2.type = "string";
|
|
if (vals.every((v) => v === null))
|
|
json2.type = "null";
|
|
json2.enum = vals;
|
|
}
|
|
break;
|
|
}
|
|
case "file": {
|
|
const json2 = _json;
|
|
const file2 = {
|
|
type: "string",
|
|
format: "binary",
|
|
contentEncoding: "binary"
|
|
};
|
|
const { minimum, maximum, mime } = schema._zod.bag;
|
|
if (minimum !== undefined)
|
|
file2.minLength = minimum;
|
|
if (maximum !== undefined)
|
|
file2.maxLength = maximum;
|
|
if (mime) {
|
|
if (mime.length === 1) {
|
|
file2.contentMediaType = mime[0];
|
|
Object.assign(json2, file2);
|
|
} else {
|
|
json2.anyOf = mime.map((m) => {
|
|
const mFile = { ...file2, contentMediaType: m };
|
|
return mFile;
|
|
});
|
|
}
|
|
} else {
|
|
Object.assign(json2, file2);
|
|
}
|
|
break;
|
|
}
|
|
case "transform": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Transforms cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "nullable": {
|
|
const inner = this.process(def.innerType, params);
|
|
if (this.target === "openapi-3.0") {
|
|
result.ref = def.innerType;
|
|
_json.nullable = true;
|
|
} else {
|
|
_json.anyOf = [inner, { type: "null" }];
|
|
}
|
|
break;
|
|
}
|
|
case "nonoptional": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
break;
|
|
}
|
|
case "success": {
|
|
const json2 = _json;
|
|
json2.type = "boolean";
|
|
break;
|
|
}
|
|
case "default": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
_json.default = JSON.parse(JSON.stringify(def.defaultValue));
|
|
break;
|
|
}
|
|
case "prefault": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
if (this.io === "input")
|
|
_json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
|
|
break;
|
|
}
|
|
case "catch": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
let catchValue;
|
|
try {
|
|
catchValue = def.catchValue(undefined);
|
|
} catch {
|
|
throw new Error("Dynamic catch values are not supported in JSON Schema");
|
|
}
|
|
_json.default = catchValue;
|
|
break;
|
|
}
|
|
case "nan": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("NaN cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "template_literal": {
|
|
const json2 = _json;
|
|
const pattern = schema._zod.pattern;
|
|
if (!pattern)
|
|
throw new Error("Pattern not found in template literal");
|
|
json2.type = "string";
|
|
json2.pattern = pattern.source;
|
|
break;
|
|
}
|
|
case "pipe": {
|
|
const innerType = this.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
|
|
this.process(innerType, params);
|
|
result.ref = innerType;
|
|
break;
|
|
}
|
|
case "readonly": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
_json.readOnly = true;
|
|
break;
|
|
}
|
|
case "promise": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
break;
|
|
}
|
|
case "optional": {
|
|
this.process(def.innerType, params);
|
|
result.ref = def.innerType;
|
|
break;
|
|
}
|
|
case "lazy": {
|
|
const innerType = schema._zod.innerType;
|
|
this.process(innerType, params);
|
|
result.ref = innerType;
|
|
break;
|
|
}
|
|
case "custom": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Custom types cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
case "function": {
|
|
if (this.unrepresentable === "throw") {
|
|
throw new Error("Function types cannot be represented in JSON Schema");
|
|
}
|
|
break;
|
|
}
|
|
default: {}
|
|
}
|
|
}
|
|
}
|
|
const meta3 = this.metadataRegistry.get(schema);
|
|
if (meta3)
|
|
Object.assign(result.schema, meta3);
|
|
if (this.io === "input" && isTransforming2(schema)) {
|
|
delete result.schema.examples;
|
|
delete result.schema.default;
|
|
}
|
|
if (this.io === "input" && result.schema._prefault)
|
|
(_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
|
|
delete result.schema._prefault;
|
|
const _result = this.seen.get(schema);
|
|
return _result.schema;
|
|
}
|
|
emit(schema, _params) {
|
|
const params = {
|
|
cycles: _params?.cycles ?? "ref",
|
|
reused: _params?.reused ?? "inline",
|
|
external: _params?.external ?? undefined
|
|
};
|
|
const root = this.seen.get(schema);
|
|
if (!root)
|
|
throw new Error("Unprocessed schema. This is a bug in Zod.");
|
|
const makeURI = (entry) => {
|
|
const defsSegment = this.target === "draft-2020-12" ? "$defs" : "definitions";
|
|
if (params.external) {
|
|
const externalId = params.external.registry.get(entry[0])?.id;
|
|
const uriGenerator = params.external.uri ?? ((id2) => id2);
|
|
if (externalId) {
|
|
return { ref: uriGenerator(externalId) };
|
|
}
|
|
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
|
|
entry[1].defId = id;
|
|
return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
|
|
}
|
|
if (entry[1] === root) {
|
|
return { ref: "#" };
|
|
}
|
|
const uriPrefix = `#`;
|
|
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
|
|
const defId = entry[1].schema.id ?? `__schema${this.counter++}`;
|
|
return { defId, ref: defUriPrefix + defId };
|
|
};
|
|
const extractToDef = (entry) => {
|
|
if (entry[1].schema.$ref) {
|
|
return;
|
|
}
|
|
const seen = entry[1];
|
|
const { ref, defId } = makeURI(entry);
|
|
seen.def = { ...seen.schema };
|
|
if (defId)
|
|
seen.defId = defId;
|
|
const schema2 = seen.schema;
|
|
for (const key in schema2) {
|
|
delete schema2[key];
|
|
}
|
|
schema2.$ref = ref;
|
|
};
|
|
if (params.cycles === "throw") {
|
|
for (const entry of this.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (seen.cycle) {
|
|
throw new Error("Cycle detected: " + `#/${seen.cycle?.join("/")}/<root>` + '\n\nSet the `cycles` parameter to `"ref"` to resolve cyclical schemas with defs.');
|
|
}
|
|
}
|
|
}
|
|
for (const entry of this.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (schema === entry[0]) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (params.external) {
|
|
const ext = params.external.registry.get(entry[0])?.id;
|
|
if (schema !== entry[0] && ext) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
const id = this.metadataRegistry.get(entry[0])?.id;
|
|
if (id) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (seen.cycle) {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
if (seen.count > 1) {
|
|
if (params.reused === "ref") {
|
|
extractToDef(entry);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
const flattenRef = (zodSchema, params2) => {
|
|
const seen = this.seen.get(zodSchema);
|
|
const schema2 = seen.def ?? seen.schema;
|
|
const _cached = { ...schema2 };
|
|
if (seen.ref === null) {
|
|
return;
|
|
}
|
|
const ref = seen.ref;
|
|
seen.ref = null;
|
|
if (ref) {
|
|
flattenRef(ref, params2);
|
|
const refSchema = this.seen.get(ref).schema;
|
|
if (refSchema.$ref && (params2.target === "draft-7" || params2.target === "draft-4" || params2.target === "openapi-3.0")) {
|
|
schema2.allOf = schema2.allOf ?? [];
|
|
schema2.allOf.push(refSchema);
|
|
} else {
|
|
Object.assign(schema2, refSchema);
|
|
Object.assign(schema2, _cached);
|
|
}
|
|
}
|
|
if (!seen.isParent)
|
|
this.override({
|
|
zodSchema,
|
|
jsonSchema: schema2,
|
|
path: seen.path ?? []
|
|
});
|
|
};
|
|
for (const entry of [...this.seen.entries()].reverse()) {
|
|
flattenRef(entry[0], { target: this.target });
|
|
}
|
|
const result = {};
|
|
if (this.target === "draft-2020-12") {
|
|
result.$schema = "https://json-schema.org/draft/2020-12/schema";
|
|
} else if (this.target === "draft-7") {
|
|
result.$schema = "http://json-schema.org/draft-07/schema#";
|
|
} else if (this.target === "draft-4") {
|
|
result.$schema = "http://json-schema.org/draft-04/schema#";
|
|
} else if (this.target === "openapi-3.0") {} else {
|
|
console.warn(`Invalid target: ${this.target}`);
|
|
}
|
|
if (params.external?.uri) {
|
|
const id = params.external.registry.get(schema)?.id;
|
|
if (!id)
|
|
throw new Error("Schema is missing an `id` property");
|
|
result.$id = params.external.uri(id);
|
|
}
|
|
Object.assign(result, root.def);
|
|
const defs = params.external?.defs ?? {};
|
|
for (const entry of this.seen.entries()) {
|
|
const seen = entry[1];
|
|
if (seen.def && seen.defId) {
|
|
defs[seen.defId] = seen.def;
|
|
}
|
|
}
|
|
if (params.external) {} else {
|
|
if (Object.keys(defs).length > 0) {
|
|
if (this.target === "draft-2020-12") {
|
|
result.$defs = defs;
|
|
} else {
|
|
result.definitions = defs;
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
return JSON.parse(JSON.stringify(result));
|
|
} catch (_err) {
|
|
throw new Error("Error converting schema to JSON.");
|
|
}
|
|
}
|
|
}
|
|
function toJSONSchema2(input, _params) {
|
|
if (input instanceof $ZodRegistry2) {
|
|
const gen2 = new JSONSchemaGenerator2(_params);
|
|
const defs = {};
|
|
for (const entry of input._idmap.entries()) {
|
|
const [_, schema] = entry;
|
|
gen2.process(schema);
|
|
}
|
|
const schemas3 = {};
|
|
const external2 = {
|
|
registry: input,
|
|
uri: _params?.uri,
|
|
defs
|
|
};
|
|
for (const entry of input._idmap.entries()) {
|
|
const [key, schema] = entry;
|
|
schemas3[key] = gen2.emit(schema, {
|
|
..._params,
|
|
external: external2
|
|
});
|
|
}
|
|
if (Object.keys(defs).length > 0) {
|
|
const defsSegment = gen2.target === "draft-2020-12" ? "$defs" : "definitions";
|
|
schemas3.__shared = {
|
|
[defsSegment]: defs
|
|
};
|
|
}
|
|
return { schemas: schemas3 };
|
|
}
|
|
const gen = new JSONSchemaGenerator2(_params);
|
|
gen.process(input);
|
|
return gen.emit(input, _params);
|
|
}
|
|
function isTransforming2(_schema, _ctx) {
|
|
const ctx = _ctx ?? { seen: new Set };
|
|
if (ctx.seen.has(_schema))
|
|
return false;
|
|
ctx.seen.add(_schema);
|
|
const schema = _schema;
|
|
const def = schema._zod.def;
|
|
switch (def.type) {
|
|
case "string":
|
|
case "number":
|
|
case "bigint":
|
|
case "boolean":
|
|
case "date":
|
|
case "symbol":
|
|
case "undefined":
|
|
case "null":
|
|
case "any":
|
|
case "unknown":
|
|
case "never":
|
|
case "void":
|
|
case "literal":
|
|
case "enum":
|
|
case "nan":
|
|
case "file":
|
|
case "template_literal":
|
|
return false;
|
|
case "array": {
|
|
return isTransforming2(def.element, ctx);
|
|
}
|
|
case "object": {
|
|
for (const key in def.shape) {
|
|
if (isTransforming2(def.shape[key], ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case "union": {
|
|
for (const option of def.options) {
|
|
if (isTransforming2(option, ctx))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case "intersection": {
|
|
return isTransforming2(def.left, ctx) || isTransforming2(def.right, ctx);
|
|
}
|
|
case "tuple": {
|
|
for (const item of def.items) {
|
|
if (isTransforming2(item, ctx))
|
|
return true;
|
|
}
|
|
if (def.rest && isTransforming2(def.rest, ctx))
|
|
return true;
|
|
return false;
|
|
}
|
|
case "record": {
|
|
return isTransforming2(def.keyType, ctx) || isTransforming2(def.valueType, ctx);
|
|
}
|
|
case "map": {
|
|
return isTransforming2(def.keyType, ctx) || isTransforming2(def.valueType, ctx);
|
|
}
|
|
case "set": {
|
|
return isTransforming2(def.valueType, ctx);
|
|
}
|
|
case "promise":
|
|
case "optional":
|
|
case "nonoptional":
|
|
case "nullable":
|
|
case "readonly":
|
|
return isTransforming2(def.innerType, ctx);
|
|
case "lazy":
|
|
return isTransforming2(def.getter(), ctx);
|
|
case "default": {
|
|
return isTransforming2(def.innerType, ctx);
|
|
}
|
|
case "prefault": {
|
|
return isTransforming2(def.innerType, ctx);
|
|
}
|
|
case "custom": {
|
|
return false;
|
|
}
|
|
case "transform": {
|
|
return true;
|
|
}
|
|
case "pipe": {
|
|
return isTransforming2(def.in, ctx) || isTransforming2(def.out, ctx);
|
|
}
|
|
case "success": {
|
|
return false;
|
|
}
|
|
case "catch": {
|
|
return false;
|
|
}
|
|
case "function": {
|
|
return false;
|
|
}
|
|
default:
|
|
}
|
|
throw new Error(`Unknown schema type: ${def.type}`);
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/json-schema.js
|
|
var exports_json_schema2 = {};
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/iso.js
|
|
var exports_iso2 = {};
|
|
__export(exports_iso2, {
|
|
time: () => time4,
|
|
duration: () => duration4,
|
|
datetime: () => datetime4,
|
|
date: () => date6,
|
|
ZodISOTime: () => ZodISOTime2,
|
|
ZodISODuration: () => ZodISODuration2,
|
|
ZodISODateTime: () => ZodISODateTime2,
|
|
ZodISODate: () => ZodISODate2
|
|
});
|
|
var ZodISODateTime2 = /* @__PURE__ */ $constructor2("ZodISODateTime", (inst, def) => {
|
|
$ZodISODateTime2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function datetime4(params) {
|
|
return _isoDateTime2(ZodISODateTime2, params);
|
|
}
|
|
var ZodISODate2 = /* @__PURE__ */ $constructor2("ZodISODate", (inst, def) => {
|
|
$ZodISODate2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function date6(params) {
|
|
return _isoDate2(ZodISODate2, params);
|
|
}
|
|
var ZodISOTime2 = /* @__PURE__ */ $constructor2("ZodISOTime", (inst, def) => {
|
|
$ZodISOTime2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function time4(params) {
|
|
return _isoTime2(ZodISOTime2, params);
|
|
}
|
|
var ZodISODuration2 = /* @__PURE__ */ $constructor2("ZodISODuration", (inst, def) => {
|
|
$ZodISODuration2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function duration4(params) {
|
|
return _isoDuration2(ZodISODuration2, params);
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/errors.js
|
|
var initializer4 = (inst, issues) => {
|
|
$ZodError2.init(inst, issues);
|
|
inst.name = "ZodError";
|
|
Object.defineProperties(inst, {
|
|
format: {
|
|
value: (mapper) => formatError2(inst, mapper)
|
|
},
|
|
flatten: {
|
|
value: (mapper) => flattenError2(inst, mapper)
|
|
},
|
|
addIssue: {
|
|
value: (issue3) => {
|
|
inst.issues.push(issue3);
|
|
inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer2, 2);
|
|
}
|
|
},
|
|
addIssues: {
|
|
value: (issues2) => {
|
|
inst.issues.push(...issues2);
|
|
inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer2, 2);
|
|
}
|
|
},
|
|
isEmpty: {
|
|
get() {
|
|
return inst.issues.length === 0;
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var ZodError2 = $constructor2("ZodError", initializer4);
|
|
var ZodRealError2 = $constructor2("ZodError", initializer4, {
|
|
Parent: Error
|
|
});
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/parse.js
|
|
var parse9 = /* @__PURE__ */ _parse2(ZodRealError2);
|
|
var parseAsync4 = /* @__PURE__ */ _parseAsync2(ZodRealError2);
|
|
var safeParse4 = /* @__PURE__ */ _safeParse2(ZodRealError2);
|
|
var safeParseAsync4 = /* @__PURE__ */ _safeParseAsync2(ZodRealError2);
|
|
var encode4 = /* @__PURE__ */ _encode2(ZodRealError2);
|
|
var decode4 = /* @__PURE__ */ _decode2(ZodRealError2);
|
|
var encodeAsync4 = /* @__PURE__ */ _encodeAsync2(ZodRealError2);
|
|
var decodeAsync4 = /* @__PURE__ */ _decodeAsync2(ZodRealError2);
|
|
var safeEncode4 = /* @__PURE__ */ _safeEncode2(ZodRealError2);
|
|
var safeDecode4 = /* @__PURE__ */ _safeDecode2(ZodRealError2);
|
|
var safeEncodeAsync4 = /* @__PURE__ */ _safeEncodeAsync2(ZodRealError2);
|
|
var safeDecodeAsync4 = /* @__PURE__ */ _safeDecodeAsync2(ZodRealError2);
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/schemas.js
|
|
var ZodType2 = /* @__PURE__ */ $constructor2("ZodType", (inst, def) => {
|
|
$ZodType2.init(inst, def);
|
|
inst.def = def;
|
|
inst.type = def.type;
|
|
Object.defineProperty(inst, "_def", { value: def });
|
|
inst.check = (...checks4) => {
|
|
return inst.clone({
|
|
...def,
|
|
checks: [
|
|
...def.checks ?? [],
|
|
...checks4.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
|
|
]
|
|
});
|
|
};
|
|
inst.clone = (def2, params) => clone2(inst, def2, params);
|
|
inst.brand = () => inst;
|
|
inst.register = (reg, meta3) => {
|
|
reg.add(inst, meta3);
|
|
return inst;
|
|
};
|
|
inst.parse = (data, params) => parse9(inst, data, params, { callee: inst.parse });
|
|
inst.safeParse = (data, params) => safeParse4(inst, data, params);
|
|
inst.parseAsync = async (data, params) => parseAsync4(inst, data, params, { callee: inst.parseAsync });
|
|
inst.safeParseAsync = async (data, params) => safeParseAsync4(inst, data, params);
|
|
inst.spa = inst.safeParseAsync;
|
|
inst.encode = (data, params) => encode4(inst, data, params);
|
|
inst.decode = (data, params) => decode4(inst, data, params);
|
|
inst.encodeAsync = async (data, params) => encodeAsync4(inst, data, params);
|
|
inst.decodeAsync = async (data, params) => decodeAsync4(inst, data, params);
|
|
inst.safeEncode = (data, params) => safeEncode4(inst, data, params);
|
|
inst.safeDecode = (data, params) => safeDecode4(inst, data, params);
|
|
inst.safeEncodeAsync = async (data, params) => safeEncodeAsync4(inst, data, params);
|
|
inst.safeDecodeAsync = async (data, params) => safeDecodeAsync4(inst, data, params);
|
|
inst.refine = (check2, params) => inst.check(refine2(check2, params));
|
|
inst.superRefine = (refinement) => inst.check(superRefine2(refinement));
|
|
inst.overwrite = (fn) => inst.check(_overwrite2(fn));
|
|
inst.optional = () => optional2(inst);
|
|
inst.nullable = () => nullable2(inst);
|
|
inst.nullish = () => optional2(nullable2(inst));
|
|
inst.nonoptional = (params) => nonoptional2(inst, params);
|
|
inst.array = () => array2(inst);
|
|
inst.or = (arg) => union2([inst, arg]);
|
|
inst.and = (arg) => intersection2(inst, arg);
|
|
inst.transform = (tx) => pipe2(inst, transform2(tx));
|
|
inst.default = (def2) => _default4(inst, def2);
|
|
inst.prefault = (def2) => prefault2(inst, def2);
|
|
inst.catch = (params) => _catch4(inst, params);
|
|
inst.pipe = (target) => pipe2(inst, target);
|
|
inst.readonly = () => readonly2(inst);
|
|
inst.describe = (description) => {
|
|
const cl = inst.clone();
|
|
globalRegistry2.add(cl, { description });
|
|
return cl;
|
|
};
|
|
Object.defineProperty(inst, "description", {
|
|
get() {
|
|
return globalRegistry2.get(inst)?.description;
|
|
},
|
|
configurable: true
|
|
});
|
|
inst.meta = (...args) => {
|
|
if (args.length === 0) {
|
|
return globalRegistry2.get(inst);
|
|
}
|
|
const cl = inst.clone();
|
|
globalRegistry2.add(cl, args[0]);
|
|
return cl;
|
|
};
|
|
inst.isOptional = () => inst.safeParse(undefined).success;
|
|
inst.isNullable = () => inst.safeParse(null).success;
|
|
return inst;
|
|
});
|
|
var _ZodString2 = /* @__PURE__ */ $constructor2("_ZodString", (inst, def) => {
|
|
$ZodString2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
const bag = inst._zod.bag;
|
|
inst.format = bag.format ?? null;
|
|
inst.minLength = bag.minimum ?? null;
|
|
inst.maxLength = bag.maximum ?? null;
|
|
inst.regex = (...args) => inst.check(_regex2(...args));
|
|
inst.includes = (...args) => inst.check(_includes2(...args));
|
|
inst.startsWith = (...args) => inst.check(_startsWith2(...args));
|
|
inst.endsWith = (...args) => inst.check(_endsWith2(...args));
|
|
inst.min = (...args) => inst.check(_minLength2(...args));
|
|
inst.max = (...args) => inst.check(_maxLength2(...args));
|
|
inst.length = (...args) => inst.check(_length2(...args));
|
|
inst.nonempty = (...args) => inst.check(_minLength2(1, ...args));
|
|
inst.lowercase = (params) => inst.check(_lowercase2(params));
|
|
inst.uppercase = (params) => inst.check(_uppercase2(params));
|
|
inst.trim = () => inst.check(_trim2());
|
|
inst.normalize = (...args) => inst.check(_normalize2(...args));
|
|
inst.toLowerCase = () => inst.check(_toLowerCase2());
|
|
inst.toUpperCase = () => inst.check(_toUpperCase2());
|
|
});
|
|
var ZodString2 = /* @__PURE__ */ $constructor2("ZodString", (inst, def) => {
|
|
$ZodString2.init(inst, def);
|
|
_ZodString2.init(inst, def);
|
|
inst.email = (params) => inst.check(_email2(ZodEmail2, params));
|
|
inst.url = (params) => inst.check(_url2(ZodURL2, params));
|
|
inst.jwt = (params) => inst.check(_jwt2(ZodJWT2, params));
|
|
inst.emoji = (params) => inst.check(_emoji4(ZodEmoji2, params));
|
|
inst.guid = (params) => inst.check(_guid2(ZodGUID2, params));
|
|
inst.uuid = (params) => inst.check(_uuid2(ZodUUID2, params));
|
|
inst.uuidv4 = (params) => inst.check(_uuidv42(ZodUUID2, params));
|
|
inst.uuidv6 = (params) => inst.check(_uuidv62(ZodUUID2, params));
|
|
inst.uuidv7 = (params) => inst.check(_uuidv72(ZodUUID2, params));
|
|
inst.nanoid = (params) => inst.check(_nanoid2(ZodNanoID2, params));
|
|
inst.guid = (params) => inst.check(_guid2(ZodGUID2, params));
|
|
inst.cuid = (params) => inst.check(_cuid3(ZodCUID3, params));
|
|
inst.cuid2 = (params) => inst.check(_cuid22(ZodCUID22, params));
|
|
inst.ulid = (params) => inst.check(_ulid2(ZodULID2, params));
|
|
inst.base64 = (params) => inst.check(_base642(ZodBase642, params));
|
|
inst.base64url = (params) => inst.check(_base64url2(ZodBase64URL2, params));
|
|
inst.xid = (params) => inst.check(_xid2(ZodXID2, params));
|
|
inst.ksuid = (params) => inst.check(_ksuid2(ZodKSUID2, params));
|
|
inst.ipv4 = (params) => inst.check(_ipv42(ZodIPv42, params));
|
|
inst.ipv6 = (params) => inst.check(_ipv62(ZodIPv62, params));
|
|
inst.cidrv4 = (params) => inst.check(_cidrv42(ZodCIDRv42, params));
|
|
inst.cidrv6 = (params) => inst.check(_cidrv62(ZodCIDRv62, params));
|
|
inst.e164 = (params) => inst.check(_e1642(ZodE1642, params));
|
|
inst.datetime = (params) => inst.check(datetime4(params));
|
|
inst.date = (params) => inst.check(date6(params));
|
|
inst.time = (params) => inst.check(time4(params));
|
|
inst.duration = (params) => inst.check(duration4(params));
|
|
});
|
|
function string5(params) {
|
|
return _string2(ZodString2, params);
|
|
}
|
|
var ZodStringFormat2 = /* @__PURE__ */ $constructor2("ZodStringFormat", (inst, def) => {
|
|
$ZodStringFormat2.init(inst, def);
|
|
_ZodString2.init(inst, def);
|
|
});
|
|
var ZodEmail2 = /* @__PURE__ */ $constructor2("ZodEmail", (inst, def) => {
|
|
$ZodEmail2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function email4(params) {
|
|
return _email2(ZodEmail2, params);
|
|
}
|
|
var ZodGUID2 = /* @__PURE__ */ $constructor2("ZodGUID", (inst, def) => {
|
|
$ZodGUID2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function guid4(params) {
|
|
return _guid2(ZodGUID2, params);
|
|
}
|
|
var ZodUUID2 = /* @__PURE__ */ $constructor2("ZodUUID", (inst, def) => {
|
|
$ZodUUID2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function uuid5(params) {
|
|
return _uuid2(ZodUUID2, params);
|
|
}
|
|
function uuidv42(params) {
|
|
return _uuidv42(ZodUUID2, params);
|
|
}
|
|
function uuidv62(params) {
|
|
return _uuidv62(ZodUUID2, params);
|
|
}
|
|
function uuidv72(params) {
|
|
return _uuidv72(ZodUUID2, params);
|
|
}
|
|
var ZodURL2 = /* @__PURE__ */ $constructor2("ZodURL", (inst, def) => {
|
|
$ZodURL2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function url2(params) {
|
|
return _url2(ZodURL2, params);
|
|
}
|
|
function httpUrl2(params) {
|
|
return _url2(ZodURL2, {
|
|
protocol: /^https?$/,
|
|
hostname: exports_regexes2.domain,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodEmoji2 = /* @__PURE__ */ $constructor2("ZodEmoji", (inst, def) => {
|
|
$ZodEmoji2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function emoji4(params) {
|
|
return _emoji4(ZodEmoji2, params);
|
|
}
|
|
var ZodNanoID2 = /* @__PURE__ */ $constructor2("ZodNanoID", (inst, def) => {
|
|
$ZodNanoID2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function nanoid4(params) {
|
|
return _nanoid2(ZodNanoID2, params);
|
|
}
|
|
var ZodCUID3 = /* @__PURE__ */ $constructor2("ZodCUID", (inst, def) => {
|
|
$ZodCUID3.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function cuid6(params) {
|
|
return _cuid3(ZodCUID3, params);
|
|
}
|
|
var ZodCUID22 = /* @__PURE__ */ $constructor2("ZodCUID2", (inst, def) => {
|
|
$ZodCUID22.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function cuid24(params) {
|
|
return _cuid22(ZodCUID22, params);
|
|
}
|
|
var ZodULID2 = /* @__PURE__ */ $constructor2("ZodULID", (inst, def) => {
|
|
$ZodULID2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function ulid4(params) {
|
|
return _ulid2(ZodULID2, params);
|
|
}
|
|
var ZodXID2 = /* @__PURE__ */ $constructor2("ZodXID", (inst, def) => {
|
|
$ZodXID2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function xid4(params) {
|
|
return _xid2(ZodXID2, params);
|
|
}
|
|
var ZodKSUID2 = /* @__PURE__ */ $constructor2("ZodKSUID", (inst, def) => {
|
|
$ZodKSUID2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function ksuid4(params) {
|
|
return _ksuid2(ZodKSUID2, params);
|
|
}
|
|
var ZodIPv42 = /* @__PURE__ */ $constructor2("ZodIPv4", (inst, def) => {
|
|
$ZodIPv42.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function ipv44(params) {
|
|
return _ipv42(ZodIPv42, params);
|
|
}
|
|
var ZodIPv62 = /* @__PURE__ */ $constructor2("ZodIPv6", (inst, def) => {
|
|
$ZodIPv62.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function ipv64(params) {
|
|
return _ipv62(ZodIPv62, params);
|
|
}
|
|
var ZodCIDRv42 = /* @__PURE__ */ $constructor2("ZodCIDRv4", (inst, def) => {
|
|
$ZodCIDRv42.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function cidrv44(params) {
|
|
return _cidrv42(ZodCIDRv42, params);
|
|
}
|
|
var ZodCIDRv62 = /* @__PURE__ */ $constructor2("ZodCIDRv6", (inst, def) => {
|
|
$ZodCIDRv62.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function cidrv64(params) {
|
|
return _cidrv62(ZodCIDRv62, params);
|
|
}
|
|
var ZodBase642 = /* @__PURE__ */ $constructor2("ZodBase64", (inst, def) => {
|
|
$ZodBase642.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function base644(params) {
|
|
return _base642(ZodBase642, params);
|
|
}
|
|
var ZodBase64URL2 = /* @__PURE__ */ $constructor2("ZodBase64URL", (inst, def) => {
|
|
$ZodBase64URL2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function base64url4(params) {
|
|
return _base64url2(ZodBase64URL2, params);
|
|
}
|
|
var ZodE1642 = /* @__PURE__ */ $constructor2("ZodE164", (inst, def) => {
|
|
$ZodE1642.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function e1644(params) {
|
|
return _e1642(ZodE1642, params);
|
|
}
|
|
var ZodJWT2 = /* @__PURE__ */ $constructor2("ZodJWT", (inst, def) => {
|
|
$ZodJWT2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function jwt2(params) {
|
|
return _jwt2(ZodJWT2, params);
|
|
}
|
|
var ZodCustomStringFormat2 = /* @__PURE__ */ $constructor2("ZodCustomStringFormat", (inst, def) => {
|
|
$ZodCustomStringFormat2.init(inst, def);
|
|
ZodStringFormat2.init(inst, def);
|
|
});
|
|
function stringFormat2(format2, fnOrRegex, _params = {}) {
|
|
return _stringFormat2(ZodCustomStringFormat2, format2, fnOrRegex, _params);
|
|
}
|
|
function hostname4(_params) {
|
|
return _stringFormat2(ZodCustomStringFormat2, "hostname", exports_regexes2.hostname, _params);
|
|
}
|
|
function hex4(_params) {
|
|
return _stringFormat2(ZodCustomStringFormat2, "hex", exports_regexes2.hex, _params);
|
|
}
|
|
function hash2(alg, params) {
|
|
const enc = params?.enc ?? "hex";
|
|
const format2 = `${alg}_${enc}`;
|
|
const regex = exports_regexes2[format2];
|
|
if (!regex)
|
|
throw new Error(`Unrecognized hash format: ${format2}`);
|
|
return _stringFormat2(ZodCustomStringFormat2, format2, regex, params);
|
|
}
|
|
var ZodNumber2 = /* @__PURE__ */ $constructor2("ZodNumber", (inst, def) => {
|
|
$ZodNumber2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.gt = (value, params) => inst.check(_gt2(value, params));
|
|
inst.gte = (value, params) => inst.check(_gte2(value, params));
|
|
inst.min = (value, params) => inst.check(_gte2(value, params));
|
|
inst.lt = (value, params) => inst.check(_lt2(value, params));
|
|
inst.lte = (value, params) => inst.check(_lte2(value, params));
|
|
inst.max = (value, params) => inst.check(_lte2(value, params));
|
|
inst.int = (params) => inst.check(int2(params));
|
|
inst.safe = (params) => inst.check(int2(params));
|
|
inst.positive = (params) => inst.check(_gt2(0, params));
|
|
inst.nonnegative = (params) => inst.check(_gte2(0, params));
|
|
inst.negative = (params) => inst.check(_lt2(0, params));
|
|
inst.nonpositive = (params) => inst.check(_lte2(0, params));
|
|
inst.multipleOf = (value, params) => inst.check(_multipleOf2(value, params));
|
|
inst.step = (value, params) => inst.check(_multipleOf2(value, params));
|
|
inst.finite = () => inst;
|
|
const bag = inst._zod.bag;
|
|
inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
|
|
inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
|
|
inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
|
|
inst.isFinite = true;
|
|
inst.format = bag.format ?? null;
|
|
});
|
|
function number5(params) {
|
|
return _number2(ZodNumber2, params);
|
|
}
|
|
var ZodNumberFormat2 = /* @__PURE__ */ $constructor2("ZodNumberFormat", (inst, def) => {
|
|
$ZodNumberFormat2.init(inst, def);
|
|
ZodNumber2.init(inst, def);
|
|
});
|
|
function int2(params) {
|
|
return _int2(ZodNumberFormat2, params);
|
|
}
|
|
function float322(params) {
|
|
return _float322(ZodNumberFormat2, params);
|
|
}
|
|
function float642(params) {
|
|
return _float642(ZodNumberFormat2, params);
|
|
}
|
|
function int322(params) {
|
|
return _int322(ZodNumberFormat2, params);
|
|
}
|
|
function uint322(params) {
|
|
return _uint322(ZodNumberFormat2, params);
|
|
}
|
|
var ZodBoolean2 = /* @__PURE__ */ $constructor2("ZodBoolean", (inst, def) => {
|
|
$ZodBoolean2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function boolean5(params) {
|
|
return _boolean2(ZodBoolean2, params);
|
|
}
|
|
var ZodBigInt2 = /* @__PURE__ */ $constructor2("ZodBigInt", (inst, def) => {
|
|
$ZodBigInt2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.gte = (value, params) => inst.check(_gte2(value, params));
|
|
inst.min = (value, params) => inst.check(_gte2(value, params));
|
|
inst.gt = (value, params) => inst.check(_gt2(value, params));
|
|
inst.gte = (value, params) => inst.check(_gte2(value, params));
|
|
inst.min = (value, params) => inst.check(_gte2(value, params));
|
|
inst.lt = (value, params) => inst.check(_lt2(value, params));
|
|
inst.lte = (value, params) => inst.check(_lte2(value, params));
|
|
inst.max = (value, params) => inst.check(_lte2(value, params));
|
|
inst.positive = (params) => inst.check(_gt2(BigInt(0), params));
|
|
inst.negative = (params) => inst.check(_lt2(BigInt(0), params));
|
|
inst.nonpositive = (params) => inst.check(_lte2(BigInt(0), params));
|
|
inst.nonnegative = (params) => inst.check(_gte2(BigInt(0), params));
|
|
inst.multipleOf = (value, params) => inst.check(_multipleOf2(value, params));
|
|
const bag = inst._zod.bag;
|
|
inst.minValue = bag.minimum ?? null;
|
|
inst.maxValue = bag.maximum ?? null;
|
|
inst.format = bag.format ?? null;
|
|
});
|
|
function bigint5(params) {
|
|
return _bigint2(ZodBigInt2, params);
|
|
}
|
|
var ZodBigIntFormat2 = /* @__PURE__ */ $constructor2("ZodBigIntFormat", (inst, def) => {
|
|
$ZodBigIntFormat2.init(inst, def);
|
|
ZodBigInt2.init(inst, def);
|
|
});
|
|
function int642(params) {
|
|
return _int642(ZodBigIntFormat2, params);
|
|
}
|
|
function uint642(params) {
|
|
return _uint642(ZodBigIntFormat2, params);
|
|
}
|
|
var ZodSymbol2 = /* @__PURE__ */ $constructor2("ZodSymbol", (inst, def) => {
|
|
$ZodSymbol2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function symbol2(params) {
|
|
return _symbol2(ZodSymbol2, params);
|
|
}
|
|
var ZodUndefined2 = /* @__PURE__ */ $constructor2("ZodUndefined", (inst, def) => {
|
|
$ZodUndefined2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function _undefined6(params) {
|
|
return _undefined5(ZodUndefined2, params);
|
|
}
|
|
var ZodNull2 = /* @__PURE__ */ $constructor2("ZodNull", (inst, def) => {
|
|
$ZodNull2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function _null6(params) {
|
|
return _null5(ZodNull2, params);
|
|
}
|
|
var ZodAny2 = /* @__PURE__ */ $constructor2("ZodAny", (inst, def) => {
|
|
$ZodAny2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function any2() {
|
|
return _any2(ZodAny2);
|
|
}
|
|
var ZodUnknown2 = /* @__PURE__ */ $constructor2("ZodUnknown", (inst, def) => {
|
|
$ZodUnknown2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function unknown2() {
|
|
return _unknown2(ZodUnknown2);
|
|
}
|
|
var ZodNever2 = /* @__PURE__ */ $constructor2("ZodNever", (inst, def) => {
|
|
$ZodNever2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function never2(params) {
|
|
return _never2(ZodNever2, params);
|
|
}
|
|
var ZodVoid2 = /* @__PURE__ */ $constructor2("ZodVoid", (inst, def) => {
|
|
$ZodVoid2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function _void4(params) {
|
|
return _void3(ZodVoid2, params);
|
|
}
|
|
var ZodDate2 = /* @__PURE__ */ $constructor2("ZodDate", (inst, def) => {
|
|
$ZodDate2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.min = (value, params) => inst.check(_gte2(value, params));
|
|
inst.max = (value, params) => inst.check(_lte2(value, params));
|
|
const c = inst._zod.bag;
|
|
inst.minDate = c.minimum ? new Date(c.minimum) : null;
|
|
inst.maxDate = c.maximum ? new Date(c.maximum) : null;
|
|
});
|
|
function date7(params) {
|
|
return _date2(ZodDate2, params);
|
|
}
|
|
var ZodArray2 = /* @__PURE__ */ $constructor2("ZodArray", (inst, def) => {
|
|
$ZodArray2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.element = def.element;
|
|
inst.min = (minLength, params) => inst.check(_minLength2(minLength, params));
|
|
inst.nonempty = (params) => inst.check(_minLength2(1, params));
|
|
inst.max = (maxLength, params) => inst.check(_maxLength2(maxLength, params));
|
|
inst.length = (len, params) => inst.check(_length2(len, params));
|
|
inst.unwrap = () => inst.element;
|
|
});
|
|
function array2(element, params) {
|
|
return _array2(ZodArray2, element, params);
|
|
}
|
|
function keyof2(schema) {
|
|
const shape = schema._zod.def.shape;
|
|
return _enum4(Object.keys(shape));
|
|
}
|
|
var ZodObject2 = /* @__PURE__ */ $constructor2("ZodObject", (inst, def) => {
|
|
$ZodObjectJIT2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
exports_util2.defineLazy(inst, "shape", () => def.shape);
|
|
inst.keyof = () => _enum4(Object.keys(inst._zod.def.shape));
|
|
inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
|
|
inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown2() });
|
|
inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown2() });
|
|
inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never2() });
|
|
inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
|
|
inst.extend = (incoming) => {
|
|
return exports_util2.extend(inst, incoming);
|
|
};
|
|
inst.safeExtend = (incoming) => {
|
|
return exports_util2.safeExtend(inst, incoming);
|
|
};
|
|
inst.merge = (other) => exports_util2.merge(inst, other);
|
|
inst.pick = (mask) => exports_util2.pick(inst, mask);
|
|
inst.omit = (mask) => exports_util2.omit(inst, mask);
|
|
inst.partial = (...args) => exports_util2.partial(ZodOptional2, inst, args[0]);
|
|
inst.required = (...args) => exports_util2.required(ZodNonOptional2, inst, args[0]);
|
|
});
|
|
function object2(shape, params) {
|
|
const def = {
|
|
type: "object",
|
|
get shape() {
|
|
exports_util2.assignProp(this, "shape", shape ? exports_util2.objectClone(shape) : {});
|
|
return this.shape;
|
|
},
|
|
...exports_util2.normalizeParams(params)
|
|
};
|
|
return new ZodObject2(def);
|
|
}
|
|
function strictObject2(shape, params) {
|
|
return new ZodObject2({
|
|
type: "object",
|
|
get shape() {
|
|
exports_util2.assignProp(this, "shape", exports_util2.objectClone(shape));
|
|
return this.shape;
|
|
},
|
|
catchall: never2(),
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
function looseObject2(shape, params) {
|
|
return new ZodObject2({
|
|
type: "object",
|
|
get shape() {
|
|
exports_util2.assignProp(this, "shape", exports_util2.objectClone(shape));
|
|
return this.shape;
|
|
},
|
|
catchall: unknown2(),
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodUnion2 = /* @__PURE__ */ $constructor2("ZodUnion", (inst, def) => {
|
|
$ZodUnion2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.options = def.options;
|
|
});
|
|
function union2(options, params) {
|
|
return new ZodUnion2({
|
|
type: "union",
|
|
options,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodDiscriminatedUnion2 = /* @__PURE__ */ $constructor2("ZodDiscriminatedUnion", (inst, def) => {
|
|
ZodUnion2.init(inst, def);
|
|
$ZodDiscriminatedUnion2.init(inst, def);
|
|
});
|
|
function discriminatedUnion2(discriminator, options, params) {
|
|
return new ZodDiscriminatedUnion2({
|
|
type: "union",
|
|
options,
|
|
discriminator,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodIntersection2 = /* @__PURE__ */ $constructor2("ZodIntersection", (inst, def) => {
|
|
$ZodIntersection2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function intersection2(left, right) {
|
|
return new ZodIntersection2({
|
|
type: "intersection",
|
|
left,
|
|
right
|
|
});
|
|
}
|
|
var ZodTuple2 = /* @__PURE__ */ $constructor2("ZodTuple", (inst, def) => {
|
|
$ZodTuple2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.rest = (rest) => inst.clone({
|
|
...inst._zod.def,
|
|
rest
|
|
});
|
|
});
|
|
function tuple2(items, _paramsOrRest, _params) {
|
|
const hasRest = _paramsOrRest instanceof $ZodType2;
|
|
const params = hasRest ? _params : _paramsOrRest;
|
|
const rest = hasRest ? _paramsOrRest : null;
|
|
return new ZodTuple2({
|
|
type: "tuple",
|
|
items,
|
|
rest,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodRecord2 = /* @__PURE__ */ $constructor2("ZodRecord", (inst, def) => {
|
|
$ZodRecord2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.keyType = def.keyType;
|
|
inst.valueType = def.valueType;
|
|
});
|
|
function record2(keyType, valueType, params) {
|
|
return new ZodRecord2({
|
|
type: "record",
|
|
keyType,
|
|
valueType,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
function partialRecord2(keyType, valueType, params) {
|
|
const k = clone2(keyType);
|
|
k._zod.values = undefined;
|
|
return new ZodRecord2({
|
|
type: "record",
|
|
keyType: k,
|
|
valueType,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodMap2 = /* @__PURE__ */ $constructor2("ZodMap", (inst, def) => {
|
|
$ZodMap2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.keyType = def.keyType;
|
|
inst.valueType = def.valueType;
|
|
});
|
|
function map2(keyType, valueType, params) {
|
|
return new ZodMap2({
|
|
type: "map",
|
|
keyType,
|
|
valueType,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodSet2 = /* @__PURE__ */ $constructor2("ZodSet", (inst, def) => {
|
|
$ZodSet2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.min = (...args) => inst.check(_minSize2(...args));
|
|
inst.nonempty = (params) => inst.check(_minSize2(1, params));
|
|
inst.max = (...args) => inst.check(_maxSize2(...args));
|
|
inst.size = (...args) => inst.check(_size2(...args));
|
|
});
|
|
function set2(valueType, params) {
|
|
return new ZodSet2({
|
|
type: "set",
|
|
valueType,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodEnum2 = /* @__PURE__ */ $constructor2("ZodEnum", (inst, def) => {
|
|
$ZodEnum2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.enum = def.entries;
|
|
inst.options = Object.values(def.entries);
|
|
const keys = new Set(Object.keys(def.entries));
|
|
inst.extract = (values, params) => {
|
|
const newEntries = {};
|
|
for (const value of values) {
|
|
if (keys.has(value)) {
|
|
newEntries[value] = def.entries[value];
|
|
} else
|
|
throw new Error(`Key ${value} not found in enum`);
|
|
}
|
|
return new ZodEnum2({
|
|
...def,
|
|
checks: [],
|
|
...exports_util2.normalizeParams(params),
|
|
entries: newEntries
|
|
});
|
|
};
|
|
inst.exclude = (values, params) => {
|
|
const newEntries = { ...def.entries };
|
|
for (const value of values) {
|
|
if (keys.has(value)) {
|
|
delete newEntries[value];
|
|
} else
|
|
throw new Error(`Key ${value} not found in enum`);
|
|
}
|
|
return new ZodEnum2({
|
|
...def,
|
|
checks: [],
|
|
...exports_util2.normalizeParams(params),
|
|
entries: newEntries
|
|
});
|
|
};
|
|
});
|
|
function _enum4(values, params) {
|
|
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
|
|
return new ZodEnum2({
|
|
type: "enum",
|
|
entries,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
function nativeEnum2(entries, params) {
|
|
return new ZodEnum2({
|
|
type: "enum",
|
|
entries,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodLiteral2 = /* @__PURE__ */ $constructor2("ZodLiteral", (inst, def) => {
|
|
$ZodLiteral2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.values = new Set(def.values);
|
|
Object.defineProperty(inst, "value", {
|
|
get() {
|
|
if (def.values.length > 1) {
|
|
throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
|
|
}
|
|
return def.values[0];
|
|
}
|
|
});
|
|
});
|
|
function literal2(value, params) {
|
|
return new ZodLiteral2({
|
|
type: "literal",
|
|
values: Array.isArray(value) ? value : [value],
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodFile2 = /* @__PURE__ */ $constructor2("ZodFile", (inst, def) => {
|
|
$ZodFile2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.min = (size, params) => inst.check(_minSize2(size, params));
|
|
inst.max = (size, params) => inst.check(_maxSize2(size, params));
|
|
inst.mime = (types3, params) => inst.check(_mime2(Array.isArray(types3) ? types3 : [types3], params));
|
|
});
|
|
function file2(params) {
|
|
return _file2(ZodFile2, params);
|
|
}
|
|
var ZodTransform2 = /* @__PURE__ */ $constructor2("ZodTransform", (inst, def) => {
|
|
$ZodTransform2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst._zod.parse = (payload, _ctx) => {
|
|
if (_ctx.direction === "backward") {
|
|
throw new $ZodEncodeError2(inst.constructor.name);
|
|
}
|
|
payload.addIssue = (issue3) => {
|
|
if (typeof issue3 === "string") {
|
|
payload.issues.push(exports_util2.issue(issue3, payload.value, def));
|
|
} else {
|
|
const _issue = issue3;
|
|
if (_issue.fatal)
|
|
_issue.continue = false;
|
|
_issue.code ?? (_issue.code = "custom");
|
|
_issue.input ?? (_issue.input = payload.value);
|
|
_issue.inst ?? (_issue.inst = inst);
|
|
payload.issues.push(exports_util2.issue(_issue));
|
|
}
|
|
};
|
|
const output = def.transform(payload.value, payload);
|
|
if (output instanceof Promise) {
|
|
return output.then((output2) => {
|
|
payload.value = output2;
|
|
return payload;
|
|
});
|
|
}
|
|
payload.value = output;
|
|
return payload;
|
|
};
|
|
});
|
|
function transform2(fn) {
|
|
return new ZodTransform2({
|
|
type: "transform",
|
|
transform: fn
|
|
});
|
|
}
|
|
var ZodOptional2 = /* @__PURE__ */ $constructor2("ZodOptional", (inst, def) => {
|
|
$ZodOptional2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function optional2(innerType) {
|
|
return new ZodOptional2({
|
|
type: "optional",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodNullable2 = /* @__PURE__ */ $constructor2("ZodNullable", (inst, def) => {
|
|
$ZodNullable2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nullable2(innerType) {
|
|
return new ZodNullable2({
|
|
type: "nullable",
|
|
innerType
|
|
});
|
|
}
|
|
function nullish4(innerType) {
|
|
return optional2(nullable2(innerType));
|
|
}
|
|
var ZodDefault2 = /* @__PURE__ */ $constructor2("ZodDefault", (inst, def) => {
|
|
$ZodDefault2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeDefault = inst.unwrap;
|
|
});
|
|
function _default4(innerType, defaultValue) {
|
|
return new ZodDefault2({
|
|
type: "default",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : exports_util2.shallowClone(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
var ZodPrefault2 = /* @__PURE__ */ $constructor2("ZodPrefault", (inst, def) => {
|
|
$ZodPrefault2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function prefault2(innerType, defaultValue) {
|
|
return new ZodPrefault2({
|
|
type: "prefault",
|
|
innerType,
|
|
get defaultValue() {
|
|
return typeof defaultValue === "function" ? defaultValue() : exports_util2.shallowClone(defaultValue);
|
|
}
|
|
});
|
|
}
|
|
var ZodNonOptional2 = /* @__PURE__ */ $constructor2("ZodNonOptional", (inst, def) => {
|
|
$ZodNonOptional2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function nonoptional2(innerType, params) {
|
|
return new ZodNonOptional2({
|
|
type: "nonoptional",
|
|
innerType,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodSuccess2 = /* @__PURE__ */ $constructor2("ZodSuccess", (inst, def) => {
|
|
$ZodSuccess2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function success2(innerType) {
|
|
return new ZodSuccess2({
|
|
type: "success",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodCatch2 = /* @__PURE__ */ $constructor2("ZodCatch", (inst, def) => {
|
|
$ZodCatch2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
inst.removeCatch = inst.unwrap;
|
|
});
|
|
function _catch4(innerType, catchValue) {
|
|
return new ZodCatch2({
|
|
type: "catch",
|
|
innerType,
|
|
catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
|
|
});
|
|
}
|
|
var ZodNaN2 = /* @__PURE__ */ $constructor2("ZodNaN", (inst, def) => {
|
|
$ZodNaN2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function nan2(params) {
|
|
return _nan2(ZodNaN2, params);
|
|
}
|
|
var ZodPipe2 = /* @__PURE__ */ $constructor2("ZodPipe", (inst, def) => {
|
|
$ZodPipe2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.in = def.in;
|
|
inst.out = def.out;
|
|
});
|
|
function pipe2(in_, out) {
|
|
return new ZodPipe2({
|
|
type: "pipe",
|
|
in: in_,
|
|
out
|
|
});
|
|
}
|
|
var ZodCodec2 = /* @__PURE__ */ $constructor2("ZodCodec", (inst, def) => {
|
|
ZodPipe2.init(inst, def);
|
|
$ZodCodec2.init(inst, def);
|
|
});
|
|
function codec2(in_, out, params) {
|
|
return new ZodCodec2({
|
|
type: "pipe",
|
|
in: in_,
|
|
out,
|
|
transform: params.decode,
|
|
reverseTransform: params.encode
|
|
});
|
|
}
|
|
var ZodReadonly2 = /* @__PURE__ */ $constructor2("ZodReadonly", (inst, def) => {
|
|
$ZodReadonly2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function readonly2(innerType) {
|
|
return new ZodReadonly2({
|
|
type: "readonly",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodTemplateLiteral2 = /* @__PURE__ */ $constructor2("ZodTemplateLiteral", (inst, def) => {
|
|
$ZodTemplateLiteral2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function templateLiteral2(parts, params) {
|
|
return new ZodTemplateLiteral2({
|
|
type: "template_literal",
|
|
parts,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
}
|
|
var ZodLazy2 = /* @__PURE__ */ $constructor2("ZodLazy", (inst, def) => {
|
|
$ZodLazy2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.getter();
|
|
});
|
|
function lazy2(getter) {
|
|
return new ZodLazy2({
|
|
type: "lazy",
|
|
getter
|
|
});
|
|
}
|
|
var ZodPromise2 = /* @__PURE__ */ $constructor2("ZodPromise", (inst, def) => {
|
|
$ZodPromise2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
inst.unwrap = () => inst._zod.def.innerType;
|
|
});
|
|
function promise2(innerType) {
|
|
return new ZodPromise2({
|
|
type: "promise",
|
|
innerType
|
|
});
|
|
}
|
|
var ZodFunction2 = /* @__PURE__ */ $constructor2("ZodFunction", (inst, def) => {
|
|
$ZodFunction2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function _function2(params) {
|
|
return new ZodFunction2({
|
|
type: "function",
|
|
input: Array.isArray(params?.input) ? tuple2(params?.input) : params?.input ?? array2(unknown2()),
|
|
output: params?.output ?? unknown2()
|
|
});
|
|
}
|
|
var ZodCustom2 = /* @__PURE__ */ $constructor2("ZodCustom", (inst, def) => {
|
|
$ZodCustom2.init(inst, def);
|
|
ZodType2.init(inst, def);
|
|
});
|
|
function check2(fn) {
|
|
const ch = new $ZodCheck2({
|
|
check: "custom"
|
|
});
|
|
ch._zod.check = fn;
|
|
return ch;
|
|
}
|
|
function custom2(fn, _params) {
|
|
return _custom2(ZodCustom2, fn ?? (() => true), _params);
|
|
}
|
|
function refine2(fn, _params = {}) {
|
|
return _refine2(ZodCustom2, fn, _params);
|
|
}
|
|
function superRefine2(fn) {
|
|
return _superRefine2(fn);
|
|
}
|
|
function _instanceof2(cls, params = {
|
|
error: `Input not instance of ${cls.name}`
|
|
}) {
|
|
const inst = new ZodCustom2({
|
|
type: "custom",
|
|
check: "custom",
|
|
fn: (data) => data instanceof cls,
|
|
abort: true,
|
|
...exports_util2.normalizeParams(params)
|
|
});
|
|
inst._zod.bag.Class = cls;
|
|
return inst;
|
|
}
|
|
var stringbool2 = (...args) => _stringbool2({
|
|
Codec: ZodCodec2,
|
|
Boolean: ZodBoolean2,
|
|
String: ZodString2
|
|
}, ...args);
|
|
function json2(params) {
|
|
const jsonSchema = lazy2(() => {
|
|
return union2([string5(params), number5(), boolean5(), _null6(), array2(jsonSchema), record2(string5(), jsonSchema)]);
|
|
});
|
|
return jsonSchema;
|
|
}
|
|
function preprocess2(fn, schema) {
|
|
return pipe2(transform2(fn), schema);
|
|
}
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/compat.js
|
|
var ZodIssueCode2 = {
|
|
invalid_type: "invalid_type",
|
|
too_big: "too_big",
|
|
too_small: "too_small",
|
|
invalid_format: "invalid_format",
|
|
not_multiple_of: "not_multiple_of",
|
|
unrecognized_keys: "unrecognized_keys",
|
|
invalid_union: "invalid_union",
|
|
invalid_key: "invalid_key",
|
|
invalid_element: "invalid_element",
|
|
invalid_value: "invalid_value",
|
|
custom: "custom"
|
|
};
|
|
function setErrorMap2(map3) {
|
|
config2({
|
|
customError: map3
|
|
});
|
|
}
|
|
function getErrorMap2() {
|
|
return config2().customError;
|
|
}
|
|
var ZodFirstPartyTypeKind2;
|
|
(function(ZodFirstPartyTypeKind3) {})(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {}));
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/coerce.js
|
|
var exports_coerce2 = {};
|
|
__export(exports_coerce2, {
|
|
string: () => string6,
|
|
number: () => number6,
|
|
date: () => date8,
|
|
boolean: () => boolean6,
|
|
bigint: () => bigint6
|
|
});
|
|
function string6(params) {
|
|
return _coercedString2(ZodString2, params);
|
|
}
|
|
function number6(params) {
|
|
return _coercedNumber2(ZodNumber2, params);
|
|
}
|
|
function boolean6(params) {
|
|
return _coercedBoolean2(ZodBoolean2, params);
|
|
}
|
|
function bigint6(params) {
|
|
return _coercedBigint2(ZodBigInt2, params);
|
|
}
|
|
function date8(params) {
|
|
return _coercedDate2(ZodDate2, params);
|
|
}
|
|
|
|
// node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
|
|
config2(en_default2());
|
|
// node_modules/@opencode-ai/plugin/dist/tool.js
|
|
function tool(input) {
|
|
return input;
|
|
}
|
|
tool.schema = exports_external2;
|
|
|
|
// src/shared/spawn-with-windows-hide.ts
|
|
var {spawn: bunSpawn } = globalThis.Bun;
|
|
import { spawn as nodeSpawn } from "child_process";
|
|
import { Readable } from "stream";
|
|
function toReadableStream(stream) {
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
return Readable.toWeb(stream);
|
|
}
|
|
function wrapNodeProcess(proc) {
|
|
let resolveExited;
|
|
let exitCode = null;
|
|
const exited = new Promise((resolve2) => {
|
|
resolveExited = resolve2;
|
|
});
|
|
proc.on("exit", (code) => {
|
|
exitCode = code ?? 1;
|
|
resolveExited(exitCode);
|
|
});
|
|
proc.on("error", () => {
|
|
if (exitCode === null) {
|
|
exitCode = 1;
|
|
resolveExited(1);
|
|
}
|
|
});
|
|
return {
|
|
get exitCode() {
|
|
return exitCode;
|
|
},
|
|
exited,
|
|
stdout: toReadableStream(proc.stdout),
|
|
stderr: toReadableStream(proc.stderr),
|
|
kill(signal) {
|
|
try {
|
|
if (!signal) {
|
|
proc.kill();
|
|
return;
|
|
}
|
|
proc.kill(signal);
|
|
} catch {}
|
|
}
|
|
};
|
|
}
|
|
function spawnWithWindowsHide(command, options) {
|
|
if (process.platform !== "win32") {
|
|
return bunSpawn(command, options);
|
|
}
|
|
const [cmd, ...args] = command;
|
|
const proc = nodeSpawn(cmd, args, {
|
|
cwd: options.cwd,
|
|
env: options.env,
|
|
stdio: [options.stdin ?? "pipe", options.stdout ?? "pipe", options.stderr ?? "pipe"],
|
|
windowsHide: true,
|
|
shell: true
|
|
});
|
|
return wrapNodeProcess(proc);
|
|
}
|
|
|
|
// src/tools/interactive-bash/constants.ts
|
|
var DEFAULT_TIMEOUT_MS = 60000;
|
|
var BLOCKED_TMUX_SUBCOMMANDS = [
|
|
"capture-pane",
|
|
"capturep",
|
|
"save-buffer",
|
|
"saveb",
|
|
"show-buffer",
|
|
"showb",
|
|
"pipe-pane",
|
|
"pipep"
|
|
];
|
|
var INTERACTIVE_BASH_DESCRIPTION = `WARNING: This is TMUX ONLY. Pass tmux subcommands directly (without 'tmux' prefix).
|
|
|
|
Examples: new-session -d -s omo-dev, send-keys -t omo-dev "vim" Enter
|
|
|
|
For TUI apps needing ongoing interaction (vim, htop, pudb). One-shot commands -> use Bash with &.`;
|
|
|
|
// src/tools/interactive-bash/tools.ts
|
|
function tokenizeCommand(cmd) {
|
|
const tokens = [];
|
|
let current = "";
|
|
let inQuote = false;
|
|
let quoteChar = "";
|
|
let escaped = false;
|
|
for (let i = 0;i < cmd.length; i++) {
|
|
const char = cmd[i];
|
|
if (escaped) {
|
|
current += char;
|
|
escaped = false;
|
|
continue;
|
|
}
|
|
if (char === "\\") {
|
|
escaped = true;
|
|
continue;
|
|
}
|
|
if ((char === "'" || char === '"') && !inQuote) {
|
|
inQuote = true;
|
|
quoteChar = char;
|
|
} else if (char === quoteChar && inQuote) {
|
|
inQuote = false;
|
|
quoteChar = "";
|
|
} else if (char === " " && !inQuote) {
|
|
if (current) {
|
|
tokens.push(current);
|
|
current = "";
|
|
}
|
|
} else {
|
|
current += char;
|
|
}
|
|
}
|
|
if (current)
|
|
tokens.push(current);
|
|
return tokens;
|
|
}
|
|
var interactive_bash = tool({
|
|
description: INTERACTIVE_BASH_DESCRIPTION,
|
|
args: {
|
|
tmux_command: tool.schema.string().describe("The tmux command to execute (without 'tmux' prefix)")
|
|
},
|
|
execute: async (args) => {
|
|
try {
|
|
const tmuxPath2 = getCachedTmuxPath() ?? "tmux";
|
|
const parts = tokenizeCommand(args.tmux_command);
|
|
if (parts.length === 0) {
|
|
return "Error: Empty tmux command";
|
|
}
|
|
const subcommand = parts[0].toLowerCase();
|
|
if (BLOCKED_TMUX_SUBCOMMANDS.includes(subcommand)) {
|
|
const sessionIdx = parts.findIndex((p) => p === "-t" || p.startsWith("-t"));
|
|
let sessionName = "omo-session";
|
|
if (sessionIdx !== -1) {
|
|
if (parts[sessionIdx] === "-t" && parts[sessionIdx + 1]) {
|
|
sessionName = parts[sessionIdx + 1];
|
|
} else if (parts[sessionIdx].startsWith("-t")) {
|
|
sessionName = parts[sessionIdx].slice(2);
|
|
}
|
|
}
|
|
return `Error: '${parts[0]}' is blocked in interactive_bash.
|
|
|
|
**USE BASH TOOL INSTEAD:**
|
|
|
|
\`\`\`bash
|
|
# Capture terminal output
|
|
tmux capture-pane -p -t ${sessionName}
|
|
|
|
# Or capture with history (last 1000 lines)
|
|
tmux capture-pane -p -t ${sessionName} -S -1000
|
|
\`\`\`
|
|
|
|
The Bash tool can execute these commands directly. Do NOT retry with interactive_bash.`;
|
|
}
|
|
const proc = spawnWithWindowsHide([tmuxPath2, ...parts], {
|
|
stdout: "pipe",
|
|
stderr: "pipe"
|
|
});
|
|
const timeoutPromise = new Promise((_, reject) => {
|
|
const id = setTimeout(() => {
|
|
const timeoutError = new Error(`Timeout after ${DEFAULT_TIMEOUT_MS}ms`);
|
|
try {
|
|
proc.kill();
|
|
proc.exited.catch(() => {});
|
|
} catch {}
|
|
reject(timeoutError);
|
|
}, DEFAULT_TIMEOUT_MS);
|
|
proc.exited.then(() => clearTimeout(id)).catch(() => clearTimeout(id));
|
|
});
|
|
const [stdout, stderr, exitCode] = await Promise.race([
|
|
Promise.all([
|
|
new Response(proc.stdout).text(),
|
|
new Response(proc.stderr).text(),
|
|
proc.exited
|
|
]),
|
|
timeoutPromise
|
|
]);
|
|
if (exitCode !== 0) {
|
|
const errorMsg = stderr.trim() || `Command failed with exit code ${exitCode}`;
|
|
return `Error: ${errorMsg}`;
|
|
}
|
|
return stdout || "(no output)";
|
|
} catch (e) {
|
|
return `Error: ${e instanceof Error ? e.message : String(e)}`;
|
|
}
|
|
}
|
|
});
|
|
// src/index.ts
|
|
var activeManager = null;
|
|
var TmuxUtilsPlugin = async (ctx) => {
|
|
startBackgroundCheck();
|
|
await activeManager?.cleanup().catch((error92) => {
|
|
log("[tmux-utils] cleanup error", { error: String(error92) });
|
|
});
|
|
const pluginConfig = loadPluginConfig(ctx.directory);
|
|
const tmuxConfig = TmuxConfigSchema.parse(pluginConfig.tmux ?? {});
|
|
const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
|
|
activeManager = tmuxSessionManager;
|
|
const eventHandler = async (input) => {
|
|
const { event } = input;
|
|
if (event.type === "session.created") {
|
|
await tmuxSessionManager.onSessionCreated(event);
|
|
return;
|
|
}
|
|
if (event.type === "session.deleted") {
|
|
const props = event.properties;
|
|
const info = props?.info;
|
|
if (info?.id) {
|
|
await tmuxSessionManager.onSessionDeleted({ sessionID: info.id });
|
|
}
|
|
}
|
|
};
|
|
return {
|
|
tool: {
|
|
interactive_bash
|
|
},
|
|
event: eventHandler
|
|
};
|
|
};
|
|
var src_default = TmuxUtilsPlugin;
|
|
export {
|
|
src_default as default
|
|
};
|