mcp-remote
Version:
Remote proxy for Model Context Protocol, allowing local-only clients to connect to remote servers using oAuth
42,160 lines • 1.69 MB
JavaScript
import {
__export
} from "./chunk-MLKGABMK.js";
// node_modules/.pnpm/@modelcontextprotocol+client@2.4.0/node_modules/@modelcontextprotocol/client/dist/chunk-DYPzFuB5.mjs
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __exportAll = (all, symbols) => {
let target = {};
for (var name in all) {
__defProp(target, name, {
get: all[name],
enumerable: true
});
}
if (symbols) {
__defProp(target, Symbol.toStringTag, { value: "Module" });
}
return target;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
key = keys[i];
if (!__hasOwnProp.call(to, key) && key !== except) {
__defProp(to, key, {
get: ((k) => from[k]).bind(null, key),
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
}
}
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod));
// node_modules/.pnpm/@modelcontextprotocol+client@2.4.0/node_modules/@modelcontextprotocol/client/dist/dialects-BAIiebX0.mjs
var DRAFT_2020_12_URIS = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2020-12/schema", "http://json-schema.org/draft/2020-12/schema"]);
var DRAFT_2019_09_URIS = /* @__PURE__ */ new Set(["https://json-schema.org/draft/2019-09/schema", "http://json-schema.org/draft/2019-09/schema"]);
var DRAFT_07_URIS = /* @__PURE__ */ new Set(["https://json-schema.org/draft-07/schema", "http://json-schema.org/draft-07/schema"]);
var DRAFT_06_URIS = /* @__PURE__ */ new Set(["https://json-schema.org/draft-06/schema", "http://json-schema.org/draft-06/schema"]);
function declares2019Dialect($schema) {
return typeof $schema === "string" && DRAFT_2019_09_URIS.has($schema.replace(/#$/, ""));
}
function declaredDialect(schema, remedy) {
if (!("$schema" in schema) || typeof schema.$schema !== "string") return "2020-12";
const declared = schema.$schema.replace(/#$/, "");
if (DRAFT_2020_12_URIS.has(declared)) return "2020-12";
if (DRAFT_2019_09_URIS.has(declared)) return "2019-09";
if (DRAFT_07_URIS.has(declared) || DRAFT_06_URIS.has(declared)) return "draft-7";
throw new Error(`JSON Schema declares an unsupported dialect ("$schema": "${schema.$schema.slice(0, 200)}"). The default validator supports JSON Schema 2020-12, 2019-09, draft-07, and draft-06; ${remedy}`);
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/external.js
var external_exports = {};
__export(external_exports, {
$brand: () => $brand,
$input: () => $input,
$output: () => $output,
INVALID: () => INVALID,
NEVER: () => NEVER,
TimePrecision: () => TimePrecision,
ZodAny: () => ZodAny,
ZodArray: () => ZodArray,
ZodBase64: () => ZodBase64,
ZodBase64URL: () => ZodBase64URL,
ZodBigInt: () => ZodBigInt,
ZodBigIntFormat: () => ZodBigIntFormat,
ZodBoolean: () => ZodBoolean,
ZodCIDRv4: () => ZodCIDRv4,
ZodCIDRv6: () => ZodCIDRv6,
ZodCUID: () => ZodCUID,
ZodCUID2: () => ZodCUID2,
ZodCatch: () => ZodCatch,
ZodCodec: () => ZodCodec,
ZodCompileAsyncError: () => ZodCompileAsyncError,
ZodCompileUnsupportedError: () => ZodCompileUnsupportedError,
ZodCreditCard: () => ZodCreditCard,
ZodCustom: () => ZodCustom,
ZodCustomStringFormat: () => ZodCustomStringFormat,
ZodDate: () => ZodDate,
ZodDefault: () => ZodDefault,
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
ZodE164: () => ZodE164,
ZodEmail: () => ZodEmail,
ZodEmoji: () => ZodEmoji,
ZodEnum: () => ZodEnum,
ZodError: () => ZodError,
ZodExactOptional: () => ZodExactOptional,
ZodFile: () => ZodFile,
ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
ZodFunction: () => ZodFunction,
ZodGUID: () => ZodGUID,
ZodIBAN: () => ZodIBAN,
ZodIPv4: () => ZodIPv4,
ZodIPv6: () => ZodIPv6,
ZodISODate: () => ZodISODate,
ZodISODateTime: () => ZodISODateTime,
ZodISODuration: () => ZodISODuration,
ZodISOTime: () => ZodISOTime,
ZodInstanceOf: () => ZodInstanceOf,
ZodIntersection: () => ZodIntersection,
ZodIssueCode: () => ZodIssueCode,
ZodJWT: () => ZodJWT,
ZodKSUID: () => ZodKSUID,
ZodLazy: () => ZodLazy,
ZodLiteral: () => ZodLiteral,
ZodMAC: () => ZodMAC,
ZodMap: () => ZodMap,
ZodNaN: () => ZodNaN,
ZodNanoID: () => ZodNanoID,
ZodNever: () => ZodNever,
ZodNonOptional: () => ZodNonOptional,
ZodNull: () => ZodNull,
ZodNullable: () => ZodNullable,
ZodNumber: () => ZodNumber,
ZodNumberFormat: () => ZodNumberFormat,
ZodObject: () => ZodObject,
ZodOptional: () => ZodOptional,
ZodPipe: () => ZodPipe,
ZodPrefault: () => ZodPrefault,
ZodPreprocess: () => ZodPreprocess,
ZodPromise: () => ZodPromise,
ZodReadonly: () => ZodReadonly,
ZodRealError: () => ZodRealError,
ZodRecord: () => ZodRecord,
ZodSet: () => ZodSet,
ZodString: () => ZodString,
ZodStringFormat: () => ZodStringFormat,
ZodSuccess: () => ZodSuccess,
ZodSymbol: () => ZodSymbol,
ZodTemplateLiteral: () => ZodTemplateLiteral,
ZodTransform: () => ZodTransform,
ZodTuple: () => ZodTuple,
ZodType: () => ZodType,
ZodULID: () => ZodULID,
ZodURL: () => ZodURL,
ZodUUID: () => ZodUUID,
ZodUndefined: () => ZodUndefined,
ZodUnion: () => ZodUnion,
ZodUnknown: () => ZodUnknown,
ZodVoid: () => ZodVoid,
ZodXID: () => ZodXID,
ZodXor: () => ZodXor,
_ZodString: () => _ZodString,
_default: () => _default2,
_function: () => _function,
any: () => any,
array: () => array,
base64: () => base642,
base64url: () => base64url2,
bigint: () => bigint2,
boolean: () => boolean2,
catch: () => _catch2,
check: () => check,
cidrv4: () => cidrv42,
cidrv6: () => cidrv62,
clone: () => clone,
codec: () => codec,
coerce: () => coerce_exports,
compile: () => compile,
config: () => config,
core: () => core_exports2,
creditCard: () => creditCard2,
cuid: () => cuid3,
cuid2: () => cuid22,
currencyCode: () => currencyCode2,
custom: () => custom,
date: () => date2,
decode: () => decode2,
decodeAsync: () => decodeAsync2,
deepPartial: () => deepPartial,
describe: () => describe2,
discriminatedUnion: () => discriminatedUnion,
e164: () => e1642,
email: () => email2,
emoji: () => emoji2,
encode: () => encode2,
encodeAsync: () => encodeAsync2,
endsWith: () => _endsWith,
enum: () => _enum2,
exactOptional: () => exactOptional,
file: () => file,
flattenError: () => flattenError,
float32: () => float32,
float64: () => float64,
formatError: () => formatError,
fromJSONSchema: () => fromJSONSchema,
function: () => _function,
getDiscriminatedOption: () => getDiscriminatedOption,
getErrorMap: () => getErrorMap,
globalRegistry: () => globalRegistry,
gt: () => _gt,
gte: () => _gte,
guid: () => guid2,
hash: () => hash,
hex: () => hex2,
hostname: () => hostname2,
httpUrl: () => httpUrl,
iban: () => iban2,
includes: () => _includes,
input: () => input,
instanceof: () => _instanceof,
int: () => int,
int32: () => int32,
int64: () => int64,
intersection: () => intersection,
invertCodec: () => invertCodec,
ipv4: () => ipv42,
ipv6: () => ipv62,
iso: () => iso_exports,
json: () => json,
jwt: () => jwt,
keyof: () => keyof,
ksuid: () => ksuid2,
lazy: () => lazy,
length: () => _length,
literal: () => literal,
locales: () => locales_exports,
looseObject: () => looseObject,
looseRecord: () => looseRecord,
lowercase: () => _lowercase,
lt: () => _lt,
lte: () => _lte,
mac: () => mac2,
map: () => map,
maxLength: () => _maxLength,
maxSize: () => _maxSize,
memoizer: () => memoizer,
meta: () => meta2,
mime: () => _mime,
minLength: () => _minLength,
minSize: () => _minSize,
multipleOf: () => _multipleOf,
nan: () => nan,
nanoid: () => nanoid2,
nativeEnum: () => nativeEnum,
negative: () => _negative,
never: () => never,
nonnegative: () => _nonnegative,
nonoptional: () => nonoptional,
nonpositive: () => _nonpositive,
normalize: () => _normalize,
null: () => _null3,
nullable: () => nullable,
nullish: () => nullish2,
number: () => number2,
object: () => object,
optional: () => optional,
output: () => output,
overwrite: () => _overwrite,
parse: () => parse2,
parseAsync: () => parseAsync2,
partialRecord: () => partialRecord,
pipe: () => pipe,
positive: () => _positive,
prefault: () => prefault,
preprocess: () => preprocess,
prettifyError: () => prettifyError,
promise: () => promise,
properties: () => _properties,
property: () => _property,
readonly: () => readonly,
record: () => record,
refine: () => refine,
regex: () => _regex,
regexes: () => regexes_exports,
registry: () => registry,
safeDecode: () => safeDecode2,
safeDecodeAsync: () => safeDecodeAsync2,
safeEncode: () => safeEncode2,
safeEncodeAsync: () => safeEncodeAsync2,
safeParse: () => safeParse2,
safeParseAsync: () => safeParseAsync2,
set: () => set,
setErrorMap: () => setErrorMap,
size: () => _size,
slugify: () => _slugify,
startsWith: () => _startsWith,
strictObject: () => strictObject,
string: () => string2,
stringFormat: () => stringFormat,
stringbool: () => stringbool,
success: () => success,
superRefine: () => superRefine,
symbol: () => symbol,
templateLiteral: () => templateLiteral,
toJSONSchema: () => toJSONSchema,
toLowerCase: () => _toLowerCase,
toUpperCase: () => _toUpperCase,
toZod: () => toZod,
transform: () => transform,
treeifyError: () => treeifyError,
trim: () => _trim,
tuple: () => tuple,
uint32: () => uint32,
uint64: () => uint64,
ulid: () => ulid2,
undefined: () => _undefined3,
union: () => union,
unknown: () => unknown,
uppercase: () => _uppercase,
url: () => url,
util: () => util_exports,
uuid: () => uuid2,
uuidv4: () => uuidv4,
uuidv6: () => uuidv6,
uuidv7: () => uuidv7,
validate: () => validate,
validateAsync: () => validateAsync,
void: () => _void2,
withParser: () => withParser,
xid: () => xid2,
xor: () => xor
});
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/index.js
var core_exports2 = {};
__export(core_exports2, {
$ZodAny: () => $ZodAny,
$ZodArray: () => $ZodArray,
$ZodAsyncError: () => $ZodAsyncError,
$ZodBase64: () => $ZodBase64,
$ZodBase64URL: () => $ZodBase64URL,
$ZodBigInt: () => $ZodBigInt,
$ZodBigIntFormat: () => $ZodBigIntFormat,
$ZodBoolean: () => $ZodBoolean,
$ZodCIDRv4: () => $ZodCIDRv4,
$ZodCIDRv6: () => $ZodCIDRv6,
$ZodCUID: () => $ZodCUID,
$ZodCUID2: () => $ZodCUID2,
$ZodCatch: () => $ZodCatch,
$ZodCheck: () => $ZodCheck,
$ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
$ZodCheckEndsWith: () => $ZodCheckEndsWith,
$ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
$ZodCheckIncludes: () => $ZodCheckIncludes,
$ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
$ZodCheckLessThan: () => $ZodCheckLessThan,
$ZodCheckLowerCase: () => $ZodCheckLowerCase,
$ZodCheckMaxLength: () => $ZodCheckMaxLength,
$ZodCheckMaxSize: () => $ZodCheckMaxSize,
$ZodCheckMimeType: () => $ZodCheckMimeType,
$ZodCheckMinLength: () => $ZodCheckMinLength,
$ZodCheckMinSize: () => $ZodCheckMinSize,
$ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
$ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
$ZodCheckOverwrite: () => $ZodCheckOverwrite,
$ZodCheckProperties: () => $ZodCheckProperties,
$ZodCheckProperty: () => $ZodCheckProperty,
$ZodCheckRegex: () => $ZodCheckRegex,
$ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
$ZodCheckStartsWith: () => $ZodCheckStartsWith,
$ZodCheckStringFormat: () => $ZodCheckStringFormat,
$ZodCheckUpperCase: () => $ZodCheckUpperCase,
$ZodCodec: () => $ZodCodec,
$ZodCreditCard: () => $ZodCreditCard,
$ZodCustom: () => $ZodCustom,
$ZodCustomStringFormat: () => $ZodCustomStringFormat,
$ZodCyclicError: () => $ZodCyclicError,
$ZodDate: () => $ZodDate,
$ZodDefault: () => $ZodDefault,
$ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
$ZodE164: () => $ZodE164,
$ZodEmail: () => $ZodEmail,
$ZodEmoji: () => $ZodEmoji,
$ZodEncodeError: () => $ZodEncodeError,
$ZodEnum: () => $ZodEnum,
$ZodError: () => $ZodError,
$ZodExactOptional: () => $ZodExactOptional,
$ZodFile: () => $ZodFile,
$ZodFunction: () => $ZodFunction,
$ZodGUID: () => $ZodGUID,
$ZodIBAN: () => $ZodIBAN,
$ZodIPv4: () => $ZodIPv4,
$ZodIPv6: () => $ZodIPv6,
$ZodISODate: () => $ZodISODate,
$ZodISODateTime: () => $ZodISODateTime,
$ZodISODuration: () => $ZodISODuration,
$ZodISOTime: () => $ZodISOTime,
$ZodIntersection: () => $ZodIntersection,
$ZodJWT: () => $ZodJWT,
$ZodKSUID: () => $ZodKSUID,
$ZodLazy: () => $ZodLazy,
$ZodLiteral: () => $ZodLiteral,
$ZodMAC: () => $ZodMAC,
$ZodMap: () => $ZodMap,
$ZodNaN: () => $ZodNaN,
$ZodNanoID: () => $ZodNanoID,
$ZodNever: () => $ZodNever,
$ZodNonOptional: () => $ZodNonOptional,
$ZodNull: () => $ZodNull,
$ZodNullable: () => $ZodNullable,
$ZodNumber: () => $ZodNumber,
$ZodNumberFormat: () => $ZodNumberFormat,
$ZodObject: () => $ZodObject,
$ZodObjectJIT: () => $ZodObjectJIT,
$ZodOptional: () => $ZodOptional,
$ZodPipe: () => $ZodPipe,
$ZodPrefault: () => $ZodPrefault,
$ZodPreprocess: () => $ZodPreprocess,
$ZodPromise: () => $ZodPromise,
$ZodReadonly: () => $ZodReadonly,
$ZodRealError: () => $ZodRealError,
$ZodRecord: () => $ZodRecord,
$ZodRegistry: () => $ZodRegistry,
$ZodSet: () => $ZodSet,
$ZodString: () => $ZodString,
$ZodStringFormat: () => $ZodStringFormat,
$ZodSuccess: () => $ZodSuccess,
$ZodSymbol: () => $ZodSymbol,
$ZodTemplateLiteral: () => $ZodTemplateLiteral,
$ZodTransform: () => $ZodTransform,
$ZodTuple: () => $ZodTuple,
$ZodType: () => $ZodType,
$ZodULID: () => $ZodULID,
$ZodURL: () => $ZodURL,
$ZodUUID: () => $ZodUUID,
$ZodUndefined: () => $ZodUndefined,
$ZodUnion: () => $ZodUnion,
$ZodUnknown: () => $ZodUnknown,
$ZodVoid: () => $ZodVoid,
$ZodXID: () => $ZodXID,
$ZodXor: () => $ZodXor,
$brand: () => $brand,
$constructor: () => $constructor,
$input: () => $input,
$output: () => $output,
Doc: () => Doc,
INVALID: () => INVALID,
JSONSchema: () => json_schema_exports,
JSONSchemaGenerator: () => JSONSchemaGenerator,
NEVER: () => NEVER,
TimePrecision: () => TimePrecision,
URL_BAD_FORMAT: () => URL_BAD_FORMAT,
URL_UNPARSEABLE: () => URL_UNPARSEABLE,
ZodCompileAsyncError: () => ZodCompileAsyncError,
ZodCompileUnsupportedError: () => ZodCompileUnsupportedError,
_any: () => _any,
_array: () => _array,
_base64: () => _base64,
_base64url: () => _base64url,
_bigint: () => _bigint,
_boolean: () => _boolean,
_catch: () => _catch,
_check: () => _check,
_cidrv4: () => _cidrv4,
_cidrv6: () => _cidrv6,
_coercedBigint: () => _coercedBigint,
_coercedBoolean: () => _coercedBoolean,
_coercedDate: () => _coercedDate,
_coercedNumber: () => _coercedNumber,
_coercedString: () => _coercedString,
_creditCard: () => _creditCard,
_cuid: () => _cuid,
_cuid2: () => _cuid2,
_custom: () => _custom,
_date: () => _date,
_decode: () => _decode,
_decodeAsync: () => _decodeAsync,
_default: () => _default,
_discriminatedUnion: () => _discriminatedUnion,
_e164: () => _e164,
_email: () => _email,
_emoji: () => _emoji2,
_encode: () => _encode,
_encodeAsync: () => _encodeAsync,
_endsWith: () => _endsWith,
_enum: () => _enum,
_file: () => _file,
_float32: () => _float32,
_float64: () => _float64,
_gt: () => _gt,
_gte: () => _gte,
_guid: () => _guid,
_iban: () => _iban,
_includes: () => _includes,
_int: () => _int,
_int32: () => _int32,
_int64: () => _int64,
_intersection: () => _intersection,
_ipv4: () => _ipv4,
_ipv6: () => _ipv6,
_isoDate: () => _isoDate,
_isoDateTime: () => _isoDateTime,
_isoDuration: () => _isoDuration,
_isoTime: () => _isoTime,
_jwt: () => _jwt,
_ksuid: () => _ksuid,
_lazy: () => _lazy,
_length: () => _length,
_literal: () => _literal,
_lowercase: () => _lowercase,
_lt: () => _lt,
_lte: () => _lte,
_mac: () => _mac,
_map: () => _map,
_max: () => _lte,
_maxLength: () => _maxLength,
_maxSize: () => _maxSize,
_mime: () => _mime,
_min: () => _gte,
_minLength: () => _minLength,
_minSize: () => _minSize,
_multipleOf: () => _multipleOf,
_nan: () => _nan,
_nanoid: () => _nanoid,
_nativeEnum: () => _nativeEnum,
_negative: () => _negative,
_never: () => _never,
_nonnegative: () => _nonnegative,
_nonoptional: () => _nonoptional,
_nonpositive: () => _nonpositive,
_normalize: () => _normalize,
_null: () => _null2,
_nullable: () => _nullable,
_number: () => _number,
_optional: () => _optional,
_overwrite: () => _overwrite,
_parse: () => _parse,
_parseAsync: () => _parseAsync,
_pipe: () => _pipe,
_positive: () => _positive,
_promise: () => _promise,
_properties: () => _properties,
_property: () => _property,
_readonly: () => _readonly,
_record: () => _record,
_refine: () => _refine,
_regex: () => _regex,
_safeDecode: () => _safeDecode,
_safeDecodeAsync: () => _safeDecodeAsync,
_safeEncode: () => _safeEncode,
_safeEncodeAsync: () => _safeEncodeAsync,
_safeParse: () => _safeParse,
_safeParseAsync: () => _safeParseAsync,
_set: () => _set,
_size: () => _size,
_slugify: () => _slugify,
_startsWith: () => _startsWith,
_string: () => _string,
_stringFormat: () => _stringFormat,
_stringbool: () => _stringbool,
_success: () => _success,
_superRefine: () => _superRefine,
_symbol: () => _symbol,
_templateLiteral: () => _templateLiteral,
_toLowerCase: () => _toLowerCase,
_toUpperCase: () => _toUpperCase,
_transform: () => _transform,
_trim: () => _trim,
_tuple: () => _tuple,
_uint32: () => _uint32,
_uint64: () => _uint64,
_ulid: () => _ulid,
_undefined: () => _undefined2,
_union: () => _union,
_unknown: () => _unknown,
_uppercase: () => _uppercase,
_url: () => _url,
_uuid: () => _uuid,
_uuidv4: () => _uuidv4,
_uuidv6: () => _uuidv6,
_uuidv7: () => _uuidv7,
_void: () => _void,
_xid: () => _xid,
_xor: () => _xor,
base64Charset: () => base64Charset,
base64urlCharset: () => base64urlCharset,
canParseURL: () => canParseURL,
clone: () => clone,
compile: () => compile,
compileFn: () => compileFn,
config: () => config,
createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
createToJSONSchemaMethod: () => createToJSONSchemaMethod,
decode: () => decode,
decodeAsync: () => decodeAsync,
describe: () => describe,
encode: () => encode,
encodeAsync: () => encodeAsync,
extractDefs: () => extractDefs,
finalize: () => finalize,
flattenError: () => flattenError,
formatError: () => formatError,
getDiscriminatedOption: () => getDiscriminatedOption,
globalConfig: () => globalConfig,
globalRegistry: () => globalRegistry,
handleUnrepresentable: () => handleUnrepresentable,
initializeContext: () => initializeContext,
isBackEdge: () => isBackEdge,
isRecursiveSchema: () => isRecursiveSchema,
isValidBase64: () => isValidBase64,
isValidBase64URL: () => isValidBase64URL,
isValidCIDRv6: () => isValidCIDRv6,
isValidCreditCard: () => isValidCreditCard,
isValidIBAN: () => isValidIBAN,
isValidIPv6: () => isValidIPv6,
isValidJWT: () => isValidJWT,
locales: () => locales_exports,
memoizer: () => memoizer,
mergeValues: () => mergeValues,
meta: () => meta,
parse: () => parse,
parseAsync: () => parseAsync,
parseURLObject: () => parseURLObject,
prettifyError: () => prettifyError,
process: () => processSchema,
processSchema: () => processSchema,
regexes: () => regexes_exports,
registry: () => registry,
safeDecode: () => safeDecode,
safeDecodeAsync: () => safeDecodeAsync,
safeEncode: () => safeEncode,
safeEncodeAsync: () => safeEncodeAsync,
safeParse: () => safeParse,
safeParseAsync: () => safeParseAsync,
standardProps: () => standardProps,
stripTabAndNewline: () => stripTabAndNewline,
toDotPath: () => toDotPath,
toJSONSchema: () => toJSONSchema,
toZod: () => toZod,
treeifyError: () => treeifyError,
urlHostnameOk: () => urlHostnameOk,
urlProtocolOk: () => urlProtocolOk,
util: () => util_exports,
validate: () => validate,
validateAsync: () => validateAsync,
validateURL: () => validateURL,
version: () => version,
withParser: () => withParser
});
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/util.js
var util_exports = {};
__export(util_exports, {
BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
CONSTANT_CATCH: () => CONSTANT_CATCH,
Class: () => Class,
NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
aborted: () => aborted,
allowsEval: () => allowsEval,
assert: () => assert,
assertEqual: () => assertEqual,
assertIs: () => assertIs,
assertNever: () => assertNever,
assertNotEqual: () => assertNotEqual,
assignProp: () => assignProp,
attachSchema: () => attachSchema,
base64ToUint8Array: () => base64ToUint8Array,
base64urlToUint8Array: () => base64urlToUint8Array,
cached: () => cached,
captureStackTrace: () => captureStackTrace,
cleanEnum: () => cleanEnum,
cleanRegex: () => cleanRegex,
clone: () => clone,
cloneDef: () => cloneDef,
codePointLength: () => codePointLength,
constantCatch: () => constantCatch,
createTransparentProxy: () => createTransparentProxy,
defineLazy: () => defineLazy,
defineLazyInternal: () => defineLazyInternal,
derived: () => derived,
esc: () => esc,
escapeRegex: () => escapeRegex,
explicitlyAborted: () => explicitlyAborted,
extend: () => extend,
finalizeIssue: () => finalizeIssue,
floatSafeRemainder: () => floatSafeRemainder,
getElementAtPath: () => getElementAtPath,
getEnumValues: () => getEnumValues,
getLengthableOrigin: () => getLengthableOrigin,
getParsedType: () => getParsedType,
getSizableOrigin: () => getSizableOrigin,
hexToUint8Array: () => hexToUint8Array,
hide: () => hide,
installLazyProp: () => installLazyProp,
isObject: () => isObject,
isPlainObject: () => isPlainObject,
issue: () => issue,
joinValues: () => joinValues,
jsonStringifyReplacer: () => jsonStringifyReplacer,
members: () => members,
merge: () => merge,
mergeDefs: () => mergeDefs,
normalizeParams: () => normalizeParams,
nullish: () => nullish,
numKeys: () => numKeys,
objectClone: () => objectClone,
omit: () => omit,
optionalKeys: () => optionalKeys,
own: () => own,
parsedType: () => parsedType,
partial: () => partial,
pick: () => pick,
prefixIssues: () => prefixIssues,
primitiveTypes: () => primitiveTypes,
promiseAllObject: () => promiseAllObject,
propertyKeyTypes: () => propertyKeyTypes,
randomString: () => randomString,
rawShape: () => rawShape,
required: () => required,
safeExtend: () => safeExtend,
shallowClone: () => shallowClone,
sizeCaps: () => sizeCaps,
slugify: () => slugify,
stringifyPrimitive: () => stringifyPrimitive,
toZod: () => toZod,
uint8ArrayToBase64: () => uint8ArrayToBase64,
uint8ArrayToBase64url: () => uint8ArrayToBase64url,
uint8ArrayToHex: () => uint8ArrayToHex,
unwrapMessage: () => unwrapMessage
});
function assertEqual(val) {
return val;
}
function assertNotEqual(val) {
return val;
}
function toZod() {
return (schema) => schema;
}
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(array2, separator = "|") {
return array2.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
if (typeof value === "bigint")
return value.toString();
return value;
}
var Cached = class {
constructor(getter) {
this._getter = getter;
this._value = void 0;
}
get value() {
const getter = this._getter;
if (getter !== void 0) {
this._value = getter();
this._getter = void 0;
}
return this._value;
}
};
function cached(getter) {
return new Cached(getter);
}
function nullish(input2) {
return input2 === null || input2 === void 0;
}
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 ratio = val / step;
const roundedRatio = Math.round(ratio);
const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
if (Math.abs(ratio - roundedRatio) < tolerance)
return 0;
return ratio - roundedRatio;
}
var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
function defineLazy(object2, key, getter) {
let value = void 0;
Object.defineProperty(object2, key, {
get() {
if (value === EVALUATING) {
return void 0;
}
if (value === void 0) {
value = EVALUATING;
value = getter();
}
return value;
},
set(v) {
Object.defineProperty(object2, key, {
value: v
// configurable: true,
});
},
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 rawShape(def) {
const desc = Object.getOwnPropertyDescriptor(def, "shape");
return desc?.get ? desc.get.raw : desc?.value;
}
function sourceShape(schema) {
return rawShape(schema._zod.def) ?? schema._zod.def.shape;
}
function deferProp(target, key, getter) {
Object.defineProperty(target, key, {
get() {
const value = getter();
assignProp(this, key, value);
return value;
},
enumerable: true,
configurable: true
});
}
function putProp(target, key, value) {
if (key in target)
assignProp(target, key, value);
else
target[key] = value;
}
function mirrorShape(target, source, keys, wrap) {
const raw = sourceShape(source);
for (const key of keys) {
const desc = Object.getOwnPropertyDescriptor(raw, key);
if (!desc.enumerable)
continue;
if (desc.get) {
deferProp(target, key, () => {
const value = source._zod.def.shape[key];
return wrap ? wrap(value, key) : value;
});
} else
putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);
}
}
function mirrorProps(target, source) {
for (const key of Reflect.ownKeys(source)) {
const desc = Object.getOwnPropertyDescriptor(source, key);
if (!desc.enumerable)
continue;
if (desc.get)
deferProp(target, key, () => source[key]);
else
putProp(target, key, desc.value);
}
}
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, path3) {
if (!path3)
return obj;
return path3.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(input2) {
return input2.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 = /* @__PURE__ */ cached(() => {
if (globalConfig.jitless) {
return false;
}
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 === void 0)
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];
if (o instanceof Map)
return new Map(o);
if (o instanceof Set)
return new Set(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 = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
var primitiveTypes = /* @__PURE__ */ 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 !== void 0) {
if (params?.error !== void 0)
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 !== void 0 && shape[k]._zod.optout === "optional";
});
}
var NUMBER_FORMAT_RANGES = /* @__PURE__ */ (() => ({
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
int32: [-2147483648, 2147483647],
uint32: [0, 4294967295],
float32: [-34028234663852886e22, 34028234663852886e22],
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 newShape = {};
mirrorShape(newShape, schema, maskedKeys(schema, mask));
return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
}
function maskedKeys(schema, mask) {
const raw = sourceShape(schema);
const keys = [];
for (const key of Reflect.ownKeys(mask)) {
if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) {
throw new Error(`Unrecognized key: "${String(key)}"`);
}
if (mask[key])
keys.push(key);
}
return keys;
}
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 omitted = new Set(maskedKeys(schema, mask));
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));
return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
}
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 = sourceShape(schema);
for (const key of Reflect.ownKeys(shape)) {
if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
}
}
}
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
}
function extended(schema, shape) {
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));
mirrorProps(newShape, shape);
return newShape;
}
function safeExtend(schema, shape) {
if (!isPlainObject(shape)) {
throw new Error("Invalid input to safeExtend: expected a plain object");
}
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
}
function merge(a, b) {
if (!b?._zod?.def) {
throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
}
if (a._zod.def.checks?.length) {
throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
}
const newShape = {};
mirrorShape(newShape, a, Reflect.ownKeys(sourceShape(a)));
mirrorShape(newShape, b, Reflect.ownKeys(sourceShape(b)));
const def = mergeDefs(a._zod.def, {
shape: newShape,
get catchall() {
return b._zod.def.catchall;
},
checks: b._zod.def.checks ?? []
});
return clone(a, def);
}
function partial(Class2, schema, mask, name = "partial") {
const currDef = schema._zod.def;
const checks = currDef.checks;
const hasChecks = checks && checks.length > 0;
if (hasChecks) {
throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
}
const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class2 && ((value, key) => selected && !selected.has(key) ? value : new Class2({ type: "optional", innerType: value })));
return clone(schema, mergeDefs(schema._zod.def, { shape: newShape, checks: [] }));
}
function required(Class2, schema, mask) {
const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) => (
// overwrite with non-optional
selected && !selected.has(key) ? value : new Class2({ type: "nonoptional", innerType: value })
));
return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));
}
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 explicitlyAborted(x, startIndex = 0) {
if (x.aborted === true)
return true;
for (let i = startIndex; i < x.issues.length; i++) {
if (x.issues[i]?.continue === false) {
return true;
}
}
return false;
}
function prefixIssues(path3, issues) {
return issues.map((iss) => {
var _a3;
(_a3 = iss).path ?? (_a3.path = []);
iss.path.unshift(path3);
return iss;
});
}
function unwrapMessage(message) {
return typeof message === "string" ? message : message?.message;
}
function sizeCaps(defChecks) {
const caps = [];
for (const ch of defChecks ?? []) {
const d = ch._zod.def;
if (!/_(length|size)$|_equals$/.test(d.check))
break;
const max = d.maximum ?? d.length ?? d.size;
if (max >= 0)
caps.push([max, ch]);
}
return caps;
}
function attachSchema(issues, start, inst) {
var _a3;
for (let i = start; i < issues.length; i++) {
(_a3 = issues[i]).schema ?? (_a3.schema = inst);
}
}
function finalizeIssue(iss, ctx, config2) {
var _a3;
const traits = iss.inst?._zod?.traits;
if (traits?.has("$ZodType")) {
if (traits.has("$ZodCheck"))
(_a3 = iss).schema ?? (_a3.schema = iss.inst);
else
iss.schema = iss.inst;
}
const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : void 0;
const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
const full = {};
for (const k of Object.keys(iss)) {
if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__")
continue;
full[k] = iss[k];
}
full.path ?? (full.path = []);
full.message = message;
if (ctx?.reportInput) {
full.input = iss.input;
}
return full;
}
function getSizableOrigin(input2) {
if (input2 instanceof Set)
return "set";
if (input2 instanceof Map)
return "map";
if (input2 instanceof File)
return "file";
return "unknown";
}
var highSurrogate = /[\uD800-\uDBFF]/;
function codePointLength(str) {
const units = str.length;
if (!highSurrogate.test(str))
return units;
let count = units;
for (let i = 0; i < units - 1; i++) {
if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
count--;
i++;
}
}
return count;
}
function getLengthableOrigin(input2) {
if (Array.isArray(input2))
return "array";
if (typeof input2 === "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, input2, inst] = args;
if (typeof iss === "string") {
return {
message: iss,
code: "custom",
input: input2,
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(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 uint8ArrayToBase64(bytes) {
let binaryString = "";
for (let i = 0; i < bytes.length; i++) {
binaryString += String.fromCharCode(bytes[i]);
}
return btoa(binaryString);
}
function base64urlToUint8Array(base64url3) {
const base643 = base64url3.replace(/-/g, "+").replace(/_/g, "/");
const padding = "=".repeat((4 - base643.length % 4) % 4);
return base64ToUint8Array(base643 + padding);
}
function uint8ArrayToBase64url(bytes) {
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function hexToUint8Array(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 uint8ArrayToHex(bytes) {
return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
}
var Class = class {
constructor(..._args) {
}
};
function members(proto, table) {
for (const key in table) {
const desc = Object.getOwnPropertyDescriptor(table, key);
if (desc.get)
Object.defineProperty(proto, key, { ...desc, enumerable: false });
else
defineBound(proto, key, desc.value);
}
}
function own(inst, key, value, enumerable = true) {
Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
return value;
}
function hide(inst, key, value) {
return own(inst, key, value, false);
}
// @__NO_SIDE_EFFECTS__
function derived(computes, table) {
for (const key in computes) {
const compute = computes[key];
Object.defineProperty(table, key, {
configurable: true,
enumerable: true,
get() {
return own(this, key, compute(this));
},
set(value) {
own(this, key, value);
}
});
}
return table;
}
function defineBound(proto, key, fn) {
Object.defineProperty(proto, key, {
configurable: true,
get() {
return this == null ? fn : own(this, key, fn.bind(this));
},
set(value) {
own(this, key, value);
}
});
}
function claim(inst, sentinel) {
const proto = Object.getPrototypeOf(inst);
return sentinel in proto ? void 0 : proto;
}
var installing;
var broke = false;
var breaker = {
configurable: true,
get() {
broke = true;
return void 0;
}
};
function defineLazyInternal(inst, key, compute) {
const proto = Object.getPrototypeOf(inst._zod);
if (key in proto && installing !== inst._zod) {
installing = void 0;
return;
}
installing = inst._zod;
Object.defineProperty(proto, key, {
configurable: true,
get() {
Object.defineProperty(this, key, breaker);
const outer = broke;
broke = false;
try {
const value = compute(this);
if (broke)
delete this[key];
else
Object.defineProperty(this, key, { configurable: true, writable: true, value });
broke = broke || outer;
return value;
} catch (err) {
delete this[key];
broke = broke || outer;
throw err;
}
},
set(value) {
Object.defineProperty(this, key, { configurable: true, writable: true, value });
}
});
}
function installLazyProp(inst, key, make, enumerable) {
const proto = claim(inst, key);
if (!proto)
return;
Object.defineProperty(proto, key, {
configurable: true,
get() {
const desc = { configurable: true, writable: true, enumerable, value: void 0 };
Object.defineProperty(this, key, desc);
desc.value = make(this);
Object.defineProperty(this, key, desc);
return desc.value;
},
set(value) {
Object.defineProperty(this, key, { configurable: true, writable: true, enumerable, value });
}
});
}
var CONSTANT_CATCH = "~constantCatch";
function constantCatch(value) {
const fn = () => value;
fn[CONSTANT_CATCH] = true;
return fn;
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/core.js
var _a;
var NEVER = /* @__PURE__ */ Object.freeze({
status: "aborted"
});
var _zodDesc = { value: void 0, enumerable: false };
var _E = "captureStackTrace" in Error ? Error : null;
function newError(Definition) {
const E = _E;
if (E) {
const saved = E.stackTraceLimit;
if (typeof saved === "number") {
try {
E.stackTraceLimit = 0;
} catch {
_E = null;
return new Definition();
}
try {
return new Definition();
} finally {
E.stackTraceLimit = saved;
}
}
}
return new Definition();
}
// @__NO_SIDE_EFFECTS__
function $constructor(name, initializer3, proto, params) {
const zodProto = {};
function Internals(def) {
this.def = def;
this.constr = _;
this.traits = /* @__PURE__ */ new Set();
}
Internals.prototype = zodProto;
const protoMembers = proto;
const initialized = protoMembers && /* @__PURE__ */ new WeakSet();
function init(inst, def) {
if (!inst._zod) {
_zodDesc.value = new Internals(def);
try {
Object.defineProperty(inst, "_zod", _zodDesc);
} finally {
_zodDesc.value = void 0;
}
} else if (inst._zod.traits.has(name)) {
return;
}
inst._zod.traits.add(name);
initializer3(inst, def);
if (initialized) {
const own2 = Object.getPrototypeOf(inst);
const ctorProto = inst._zod.constr.prototype;
let up = own2;
while (up && up !== ctorProto)
up = Object.getPrototypeOf(up);
const target = up ?? own2;
if (!initialized.has(target)) {
initialized.add(target);
members(target, protoMembers);
}
}
const proto2 = _.prototype;
for (const k in proto2) {
if (!Object.prototype.hasOwnProperty.call(proto2, k))
continue;
if (!(k in inst)) {
inst[k] = proto2[k].bind(inst);
}
}
}
const Parent = params?.Parent ?? Object;
class Definition extends Parent {
}
Object.defineProperty(Definition, "name", { value: name });
function _(def) {
const inst = params?.Parent ? newError(Definition) : this;
init(inst, def);
const deferred = inst._zod.deferred;
if (deferred) {
for (const fn of deferred) {
fn();
}
inst._zod.deferred = void 0;
}
const pp = globalThis.__zod_globalConfig?.postProcessor;
if (pp)
pp(inst);
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 = /* @__PURE__ */ Symbol("zod_brand");
var $ZodAsyncError = class extends Error {
constructor() {
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
}
};
var $ZodEncodeError = class extends Error {
constructor(name) {
super(`Encountered unidirectional transform during encode: ${name}`);
this.name = "ZodEncodeError";
}
};
(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
var globalConfig = globalThis.__zod_globalConfig;
function config(newConfig) {
if (newConfig)
Object.assign(globalConfig, newConfig);
return globalConfig;
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/errors.js
function _getMessage() {
const internals = this._zod;
internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
return internals.message;
}
function _setMessage(value) {
this._zod.message = value;
}
var _messageDesc = {
get: _getMessage,
set: _setMessage,
enumerable: true,
configurable: true
};
var _issuesDesc = { value: void 0, enumerable: false };
var _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
var initializer = (inst, def) => {
inst.name = "$ZodError";
_issuesDesc.value = def;
Object.defineProperty(inst, "issues", _issuesDesc);
_issuesDesc.value = void 0;
Object.defineProperty(inst, "message", _messageDesc);
const proto = Object.getPrototypeOf(inst);
if (!_installedToString.has(proto)) {
_installedToString.add(proto);
Object.defineProperty(proto, "toString", {
configurable: true,
enumerable: false,
get() {
const value = () => this.message;
Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
return value;
},
set(value) {
Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
}
});
}
};
var $ZodError = $constructor("$ZodError", initializer);
var $ZodRealError = $constructor("$ZodError", initializer, void 0, {
Parent: Error
});
function node(obj, key, make) {
if (!Object.prototype.hasOwnProperty.call(obj, key)) {
if (key === "__proto__") {
Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
} else {
obj[key] = make();
}
}
return obj[key];
}
function flattenError(error62, mapper = (issue2) => issue2.message) {
const fieldErrors = {};
const formErrors = [];
for (const sub of error62.issues) {
if (sub.path.length > 0) {
node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
} else {
formErrors.push(mapper(sub));
}
}
return { formErrors, fieldErrors };
}
function formatError(error62, mapper = (issue2) => issue2.message) {
const fieldErrors = { _errors: [] };
const processError = (error63, path3 = []) => {
for (const issue2 of error63.issues) {
if (issue2.code === "invalid_union" && issue2.errors.length) {
issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
} else if (issue2.code === "invalid_key") {
processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
} else if (issue2.code === "invalid_element") {
processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
} else {
const fullpath = [...path3, ...issue2.path];
if (fullpath.length === 0) {
fieldErrors._errors.push(mapper(issue2));
} else {
let curr = fieldErrors;
let i = 0;
while (i < fullpath.length) {
const el = fullpath[i];
const terminal = i === fullpath.length - 1;
if (el === "_errors") {
if (terminal)
curr._errors.push(mapper(issue2));
i++;
continue;
}
if (!Object.prototype.hasOwnProperty.call(curr, el)) {
Object.defineProperty(curr, el, {
value: { _errors: [] },
enumerable: true,
writable: true,
configurable: true
});
}
const node2 = curr[el];
if (terminal) {
node2._errors.push(mapper(issue2));
}
curr = node2;
i++;
}
}
}
}
};
processError(error62);
return fieldErrors;
}
function treeifyError(error62, mapper = (issue2) => issue2.message) {
const result = { errors: [] };
const processError = (error63, path3 = []) => {
var _a3;
for (const issue2 of error63.issues) {
if (issue2.code === "invalid_union" && issue2.errors.length) {
issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
} else if (issue2.code === "invalid_key") {
processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
} else if (issue2.code === "invalid_element") {
processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
} else {
const fullpath = [...path3, ...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 = {});
if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {
Object.defineProperty(curr.properties, el, {
value: { errors: [] },
enumerable: true,
writable: true,
configurable: true
});
}
curr = curr.properties[el];
} else {
curr.items ?? (curr.items = []);
(_a3 = curr.items)[el] ?? (_a3[el] = { errors: [] });
curr = curr.items[el];
}
if (terminal) {
curr.errors.push(mapper(issue2));
}
i++;
}
}
}
};
processError(error62);
return result;
}
function toDotPath(_path) {
const segs = [];
const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
for (const seg of path3) {
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(error62) {
const lines = [];
const issues = [...error62.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("\n");
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/parse.js
function finalizeParams(callee, params) {
return { callee: params?.callee ?? callee, Err: params?.Err };
}
var _parse = (_Err) => {
const fn = (schema, value, _ctx, _params) => {
const ctx = _ctx ? { ..._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 ?? fn);
throw e;
}
return result.value;
};
return fn;
};
var parse = /* @__PURE__ */ _parse($ZodRealError);
var _parseAsync = (_Err) => {
const fn = async (schema, value, _ctx, params) => {
const ctx = _ctx ? { ..._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 ?? fn);
throw e;
}
return result.value;
};
return fn;
};
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 ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
};
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
function failure(Err, issues, ctx) {
let error62;
return {
success: false,
get error() {
if (!error62) {
error62 = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));
issues = void 0;
ctx = void 0;
}
return error62;
},
set error(e) {
error62 = e;
issues = void 0;
ctx = void 0;
}
};
}
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
let result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise)
result = await result;
return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };
};
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
var COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
var COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
var validate = (schema, value, _ctx) => {
const validator = schema._zod.bag.validator;
if (validator !== void 0) {
if (validator(value) !== COMPILE_INVALID)
return true;
if (validator.definite === true && _ctx === void 0)
return false;
}
return validateFallback(schema, value, _ctx);
};
function validateFallback(schema, value, _ctx) {
const ctx = _ctx ? { ..._ctx, async: false, abortEarly: true } : { async: false, abortEarly: true };
const fallbackRun = schema._zod.bag.fallbackRun;
let result;
if (fallbackRun) {
ctx[COMPILE_FALLBACK] = true;
result = fallbackRun({ value, issues: [] }, ctx);
} else {
result = schema._zod.run({ value, issues: [] }, ctx);
}
if (result instanceof Promise) {
throw new $ZodAsyncError();
}
return result.issues.length === 0;
}
var validateAsync = async (schema, value, _ctx) => {
const ctx = _ctx ? { ..._ctx, async: true, abortEarly: true } : { async: true, abortEarly: true };
let result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise)
result = await result;
return result.issues.length === 0;
};
var _encode = (_Err) => {
const parse3 = _parse(_Err);
const fn = (schema, value, _ctx, _params) => {
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
return parse3(schema, value, ctx, finalizeParams(fn, _params));
};
return fn;
};
var encode = /* @__PURE__ */ _encode($ZodRealError);
var _decode = (_Err) => {
const parse3 = _parse(_Err);
const fn = (schema, value, _ctx, _params) => {
return parse3(schema, value, _ctx, finalizeParams(fn, _params));
};
return fn;
};
var decode = /* @__PURE__ */ _decode($ZodRealError);
var _encodeAsync = (_Err) => {
const parseAsync3 = _parseAsync(_Err);
const fn = async (schema, value, _ctx, _params) => {
const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
return await parseAsync3(schema, value, ctx, finalizeParams(fn, _params));
};
return fn;
};
var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
var _decodeAsync = (_Err) => {
const parseAsync3 = _parseAsync(_Err);
const fn = async (schema, value, _ctx, _params) => {
return await parseAsync3(schema, value, _ctx, finalizeParams(fn, _params));
};
return fn;
};
var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
var _safeEncode = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? { ..._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 ? { ..._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/.pnpm/zod@4.6.7/node_modules/zod/v4/core/regexes.js
var regexes_exports = {};
__export(regexes_exports, {
anyString: () => anyString,
base64: () => base64,
base64url: () => base64url,
bigint: () => bigint,
boolean: () => boolean,
browserEmail: () => browserEmail,
cidrv4: () => cidrv4,
cidrv6: () => cidrv6,
creditCard: () => creditCard,
cuid: () => cuid,
cuid2: () => cuid2,
currencyCode: () => currencyCode,
date: () => date,
datetime: () => datetime,
domain: () => domain,
duration: () => duration,
e164: () => e164,
email: () => email,
emoji: () => emoji,
extendedDuration: () => extendedDuration,
guid: () => guid,
hex: () => hex,
hostname: () => hostname,
html5Email: () => html5Email,
httpProtocol: () => httpProtocol,
iban: () => iban,
idnEmail: () => idnEmail,
integer: () => integer,
ipv4: () => ipv4,
ipv6: () => ipv6,
ksuid: () => ksuid,
lowercase: () => lowercase,
mac: () => mac,
md5_base64: () => md5_base64,
md5_base64url: () => md5_base64url,
md5_hex: () => md5_hex,
nanoid: () => nanoid,
nanoidOfLength: () => nanoidOfLength,
null: () => _null,
number: () => number,
rfc5322Email: () => rfc5322Email,
sha1_base64: () => sha1_base64,
sha1_base64url: () => sha1_base64url,
sha1_hex: () => sha1_hex,
sha256_base64: () => sha256_base64,
sha256_base64url: () => sha256_base64url,
sha256_hex: () => sha256_hex,
sha384_base64: () => sha384_base64,
sha384_base64url: () => sha384_base64url,
sha384_hex: () => sha384_hex,
sha512_base64: () => sha512_base64,
sha512_base64url: () => sha512_base64url,
sha512_hex: () => sha512_hex,
string: () => string,
time: () => time,
ulid: () => ulid,
undefined: () => _undefined,
unicodeEmail: () => unicodeEmail,
uppercase: () => uppercase,
uuid: () => uuid,
uuid4: () => uuid4,
uuid6: () => uuid6,
uuid7: () => uuid7,
xid: () => xid
});
var cuid = /^[cC][0-9a-z]{6,}$/;
var cuid2 = /^[0-9a-z]+$/;
var ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;
var xid = /^[0-9a-vA-V]{20}$/;
var ksuid = /^[A-Za-z0-9]{27}$/;
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
function nanoidOfLength(length) {
return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);
}
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 = (version3) => {
if (!version3)
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}-${version3}[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-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 = `^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\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}:){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}|:))\/(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_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/;
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 = /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
var httpProtocol = /^https?$/;
var e164 = /^\+[1-9]\d{6,14}$/;
var creditCard = /^\d(?:[ -]?\d){11,18}$/;
var currencyCode = /^(?:AED|AFN|ALL|AMD|AOA|ARS|AUD|AWG|AZN|BAM|BBD|BDT|BHD|BIF|BMD|BND|BOB|BOV|BRL|BSD|BTN|BWP|BYN|BZD|CAD|CDF|CHE|CHF|CHW|CLF|CLP|CNY|COP|COU|CRC|CUP|CVE|CZK|DJF|DKK|DOP|DZD|EGP|ERN|ETB|EUR|FJD|FKP|GBP|GEL|GHS|GIP|GMD|GNF|GTQ|GYD|HKD|HNL|HTG|HUF|IDR|ILS|INR|IQD|IRR|ISK|JMD|JOD|JPY|KES|KGS|KHR|KMF|KPW|KRW|KWD|KYD|KZT|LAK|LBP|LKR|LRD|LSL|LYD|MAD|MDL|MGA|MKD|MMK|MNT|MOP|MRU|MUR|MVR|MWK|MXN|MXV|MYR|MZN|NAD|NGN|NIO|NOK|NPR|NZD|OMR|PAB|PEN|PGK|PHP|PKR|PLN|PYG|QAR|RON|RSD|RUB|RWF|SAR|SBD|SCR|SDG|SEK|SGD|SHP|SLE|SOS|SRD|SSP|STN|SVC|SYP|SZL|THB|TJS|TMT|TND|TOP|TRY|TTD|TWD|TZS|UAH|UGX|USD|USN|UYI|UYU|UYW|UZS|VED|VES|VND|VUV|WST|XAD|XAF|XAG|XAU|XBA|XBB|XBC|XBD|XCD|XCG|XDR|XOF|XPD|XPF|XPT|XSU|XTS|XUA|XXX|YER|ZAR|ZMW|ZWG)$/;
var iban = /^[A-Z]{2}(?!00|01|99)\d{2}[A-Z0-9]{11,30}$/;
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])))`;
function anchor(source) {
return new RegExp(`^${source}$`);
}
var date = /* @__PURE__ */ anchor(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}}` : args.seconds ? `${hhmm}:[0-5]\\d(?:\\.\\d+)?` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
return regex;
}
function time(args) {
return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
const opts = ["Z"];
if (args.offset)
opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
const qualified = `${timeSource({ precision: args.precision, seconds: true })}(?:${opts.join("|")})`;
const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
}
var anyString = /^[\s\S]{0,}$/;
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/.pnpm/zod@4.6.7/node_modules/zod/v4/core/checks.js
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
var _a3;
inst._zod ?? (inst._zod = {});
inst._zod.def = def;
(_a3 = inst._zod).onattach ?? (_a3.onattach = []);
});
var _whenHasSize = (payload) => {
const val = payload.value;
return !nullish(val) && val.size !== void 0;
};
var _whenHasLength = (payload) => {
const val = payload.value;
return !nullish(val) && val.length !== void 0;
};
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.check = (payload) => {
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
return;
}
payload.issues.push({
origin: numericOriginMap[typeof payload.value] ?? 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.check = (payload) => {
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
return;
}
payload.issues.push({
origin: numericOriginMap[typeof payload.value] ?? 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.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" ? (
// `value % 0n` throws, and nothing is a multiple of zero — the number branch already fails this way via NaN
def.value !== BigInt(0) && 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.check = (payload) => {
const input2 = payload.value;
if (isInt) {
if (!Number.isInteger(input2)) {
payload.issues.push({
expected: origin,
format: def.format,
code: "invalid_type",
continue: false,
input: input2,
inst
});
return;
}
if (!Number.isSafeInteger(input2)) {
if (input2 > 0) {
payload.issues.push({
input: input2,
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: input2,
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 (input2 < minimum) {
payload.issues.push({
origin: "number",
input: input2,
code: "too_small",
minimum,
inclusive: true,
inst,
continue: !def.abort
});
}
if (input2 > maximum) {
payload.issues.push({
origin: "number",
input: input2,
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.check = (payload) => {
const input2 = payload.value;
if (input2 < minimum) {
payload.issues.push({
origin: "bigint",
input: input2,
code: "too_small",
minimum,
inclusive: true,
inst,
continue: !def.abort
});
}
if (input2 > maximum) {
payload.issues.push({
origin: "bigint",
input: input2,
code: "too_big",
maximum,
inclusive: true,
inst,
continue: !def.abort
});
}
};
});
var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
var _a3;
$ZodCheck.init(inst, def);
(_a3 = inst._zod.def).when ?? (_a3.when = _whenHasSize);
inst._zod.check = (payload) => {
const input2 = payload.value;
const size = input2.size;
if (size <= def.maximum)
return;
payload.issues.push({
origin: getSizableOrigin(input2),
code: "too_big",
maximum: def.maximum,
inclusive: true,
input: input2,
inst,
continue: !def.abort
});
};
});
var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
var _a3;
$ZodCheck.init(inst, def);
(_a3 = inst._zod.def).when ?? (_a3.when = _whenHasSize);
inst._zod.check = (payload) => {
const input2 = payload.value;
const size = input2.size;
if (size >= def.minimum)
return;
payload.issues.push({
origin: getSizableOrigin(input2),
code: "too_small",
minimum: def.minimum,
inclusive: true,
input: input2,
inst,
continue: !def.abort
});
};
});
var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
var _a3;
$ZodCheck.init(inst, def);
(_a3 = inst._zod.def).when ?? (_a3.when = _whenHasSize);
inst._zod.check = (payload) => {
const input2 = payload.value;
const size = input2.size;
if (size === def.size)
return;
const tooBig = size > def.size;
payload.issues.push({
origin: getSizableOrigin(input2),
...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 _a3;
$ZodCheck.init(inst, def);
(_a3 = inst._zod.def).when ?? (_a3.when = _whenHasLength);
inst._zod.check = (payload) => {
const input2 = payload.value;
const units = input2.length;
const length = typeof input2 === "string" && units > def.maximum ? codePointLength(input2) : units;
if (length <= def.maximum)
return;
const origin = getLengthableOrigin(input2);
payload.issues.push({
origin,
code: "too_big",
maximum: def.maximum,
inclusive: true,
input: input2,
inst,
continue: !def.abort
});
};
});
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
var _a3;
$ZodCheck.init(inst, def);
(_a3 = inst._zod.def).when ?? (_a3.when = _whenHasLength);
inst._zod.check = (payload) => {
const input2 = payload.value;
const units = input2.length;
const length = typeof input2 === "string" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input2) : units;
if (length >= def.minimum)
return;
const origin = getLengthableOrigin(input2);
payload.issues.push({
origin,
code: "too_small",
minimum: def.minimum,
inclusive: true,
input: input2,
inst,
continue: !def.abort
});
};
});
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
var _a3;
$ZodCheck.init(inst, def);
(_a3 = inst._zod.def).when ?? (_a3.when = _whenHasLength);
inst._zod.check = (payload) => {
const input2 = payload.value;
const units = input2.length;
const length = typeof input2 === "string" && units >= def.length && units <= def.length * 2 ? codePointLength(input2) : units;
if (length === def.length)
return;
const origin = getLengthableOrigin(input2);
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 _a3, _b;
$ZodCheck.init(inst, def);
if (def.pattern)
(_a3 = inst._zod).check ?? (_a3.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.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.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.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 $ZodCheckProperties = /* @__PURE__ */ $constructor("$ZodCheckProperties", (inst, def) => {
$ZodCheck.init(inst, def);
hide(inst, Symbol.iterator, function* () {
yield inst;
});
let entries;
inst._zod.check = (payload) => {
if (payload.value == null) {
payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
return void 0;
}
entries ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
const input2 = payload.value;
let proms;
for (const [key, schema] of entries) {
const result = schema._zod.run({ value: input2[key], issues: [] }, {});
if (result instanceof Promise) {
proms ?? (proms = []);
proms.push(result.then((result2) => handleCheckPropertyResult(result2, payload, key)));
} else {
handleCheckPropertyResult(result, payload, key);
}
}
if (proms)
return Promise.all(proms).then(() => void 0);
return void 0;
};
});
var $ZodCheckMimeType = /* @__PURE__ */ $constructor("$ZodCheckMimeType", (inst, def) => {
$ZodCheck.init(inst, def);
const mimeSet = new Set(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/.pnpm/zod@4.6.7/node_modules/zod/v4/core/doc.js
var Doc = class {
constructor(args = [], closed = {}) {
this.content = [];
this.indent = 0;
this.args = args;
this.closed = closed;
}
// the compiler catches a child's throw and keeps writing into this doc, so the indent has to unwind with it
indented(fn) {
this.indent += 1;
try {
fn(this);
} finally {
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("\n").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 content = this?.content ?? [``];
const factory = new F(...Object.keys(this.closed), `return function (${this.args.join(", ")}) {
${content.join("\n")}
};`);
return factory(...Object.values(this.closed));
}
};
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/versions.js
var version = {
major: 4,
minor: 6,
patch: 7
};
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/schemas.js
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
var _a3;
inst ?? (inst = {});
inst._zod.def = def;
inst._zod.bag = inst._zod.bag || {};
inst._zod.version = version;
const defChecks = inst._zod.def.checks;
const checks = inst._zod.traits.has("$ZodCheck") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];
for (const ch of checks) {
for (const fn of ch._zod.onattach) {
fn(inst);
}
}
if (checks.length === 0) {
(_a3 = inst._zod).deferred ?? (_a3.deferred = []);
inst._zod.deferred?.push(() => {
inst._zod.run = inst._zod.parse;
});
} else {
const runChecks = (payload, checks2, ctx) => {
if (payload.memo)
return payload;
let isAborted = aborted(payload);
let asyncResult;
for (const ch of checks2) {
if (ch._zod.def.when) {
if (explicitlyAborted(payload))
continue;
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;
attachSchema(payload.issues, currLen, inst);
if (!isAborted)
isAborted = aborted(payload, currLen);
});
} else {
const nextLen = payload.issues.length;
if (nextLen === currLen)
continue;
attachSchema(payload.issues, currLen, inst);
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);
};
}
}, {
// Wrappers extend this by installing a richer factory over it; reading it eagerly would defeat the laziness.
get "~standard"() {
return hide(this, "~standard", standardProps(this));
},
set "~standard"(value) {
own(this, "~standard", value);
}
});
var toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value };
async function validateAsync2(inst, value) {
const ctx = { async: true };
return toStandardResult(await inst._zod.run({ value, issues: [] }, ctx), ctx);
}
function standardProps(inst) {
return {
validate: (value) => {
const ctx = { async: false };
try {
const r = inst._zod.run({ value, issues: [] }, ctx);
if (!(r instanceof Promise))
return toStandardResult(r, ctx);
} catch (_) {
}
return validateAsync2(inst, value);
},
vendor: "zod",
version: 1
};
}
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = def.pattern ?? anyString;
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 === void 0)
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 URL_BAD_FORMAT = 1;
var URL_UNPARSEABLE = 2;
function canParseURL(input2) {
try {
if (typeof URL !== "undefined" && typeof URL.canParse === "function")
return URL.canParse(input2);
new URL(input2);
return true;
} catch {
return false;
}
}
function validateURL(trimmed, def) {
if (!("normalize" in def) && !("hostname" in def) && !("protocol" in def)) {
return canParseURL(trimmed) || URL_UNPARSEABLE;
}
return parseURLObject(trimmed, def);
}
function parseURLObject(trimmed, def) {
if (!def.normalize && def.protocol?.source === httpProtocol.source && !/^https?:\/\//i.test(trimmed)) {
return URL_BAD_FORMAT;
}
try {
if (typeof URL !== "undefined") {
const URLStatic = URL;
if (typeof URLStatic.parse === "function")
return URLStatic.parse(trimmed) ?? URL_UNPARSEABLE;
}
return new URL(trimmed);
} catch {
return URL_UNPARSEABLE;
}
}
var asciiTabOrNewline = /[\t\n\r]/g;
function stripTabAndNewline(value) {
return value.replace(asciiTabOrNewline, "");
}
function urlHostnameOk(url2, hostname3) {
hostname3.lastIndex = 0;
return hostname3.test(url2.hostname);
}
function urlProtocolOk(url2, protocol) {
protocol.lastIndex = 0;
return protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol);
}
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
try {
const trimmed = payload.value.trim();
const url2 = validateURL(trimmed, def);
if (url2 === URL_BAD_FORMAT) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid URL format",
input: payload.value,
inst,
continue: !def.abort
});
return;
}
if (url2 === URL_UNPARSEABLE) {
payload.issues.push({
code: "invalid_format",
format: "url",
input: payload.value,
inst,
continue: !def.abort
});
return;
}
if (url2 === true) {
payload.value = stripTabAndNewline(trimmed);
return;
}
if (def.hostname && !urlHostnameOk(url2, def.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 && !urlProtocolOk(url2, def.protocol)) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid protocol",
pattern: def.protocol.source,
input: payload.value,
inst,
continue: !def.abort
});
}
payload.value = def.normalize ? url2.href : stripTabAndNewline(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) => {
if (def.length !== void 0 && (!Number.isInteger(def.length) || def.length < 1))
throw new Error(`Invalid nanoid length: ${def.length}`);
def.pattern ?? (def.pattern = def.length === void 0 ? nanoid : nanoidOfLength(def.length));
$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);
});
var ipv6Alphabet = /^[0-9a-fA-F:.]+$/;
function isValidIPv6(value) {
if (!ipv6Alphabet.test(value))
return false;
return canParseURL(`http://[${value}]`);
}
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
def.pattern ?? (def.pattern = ipv6);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (!isValidIPv6(payload.value)) {
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);
});
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
def.pattern ?? (def.pattern = cidrv4);
$ZodStringFormat.init(inst, def);
});
function isValidCIDRv6(value) {
const parts = value.split("/");
if (parts.length !== 2)
return false;
const [address, prefix] = parts;
if (!prefix)
return false;
const prefixNum = Number(prefix);
if (`${prefixNum}` !== prefix)
return false;
if (prefixNum < 0 || prefixNum > 128)
return false;
return isValidIPv6(address);
}
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
def.pattern ?? (def.pattern = cidrv6);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (!isValidCIDRv6(payload.value)) {
payload.issues.push({
code: "invalid_format",
format: "cidrv6",
input: payload.value,
inst,
continue: !def.abort
});
}
};
});
function isValidBase64(data) {
if (data === "")
return true;
if (/\s/.test(data))
return false;
if (data.length % 4 !== 0)
return false;
try {
atob(data);
return true;
} catch {
return false;
}
}
var base64Charset = /^[0-9a-zA-Z+/]*={0,2}$/;
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
def.pattern ?? (def.pattern = base64Charset);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidBase64(payload.value))
return;
payload.issues.push({
code: "invalid_format",
format: "base64",
input: payload.value,
inst,
continue: !def.abort
});
};
});
var base64urlCharset = /^[A-Za-z0-9_-]*$/;
function isValidBase64URL(data) {
if (!base64urlCharset.test(data))
return false;
const base643 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, "=");
return isValidBase64(padded);
}
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
def.pattern ?? (def.pattern = base64urlCharset);
$ZodStringFormat.init(inst, def);
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);
});
var CC_SANITIZE = /[- ]/g;
function isLuhnAlgo(digits) {
let length = digits.length;
let bit = 1;
let sum = 0;
while (length) {
const value = digits.charCodeAt(--length) - 48;
bit ^= 1;
sum += bit ? [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][value] : value;
}
return sum % 10 === 0;
}
function isValidCreditCard(input2) {
if (!creditCard.test(input2))
return false;
return isLuhnAlgo(input2.replace(CC_SANITIZE, ""));
}
var $ZodCreditCard = /* @__PURE__ */ $constructor("$ZodCreditCard", (inst, def) => {
def.pattern ?? (def.pattern = creditCard);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidCreditCard(payload.value))
return;
payload.issues.push({
code: "invalid_format",
format: "credit_card",
input: payload.value,
inst,
continue: !def.abort
});
};
});
function isIso7064Mod97(iban3) {
let remainder = 0;
const len = iban3.length;
for (let i = 4; i < len; i++) {
const code = iban3.charCodeAt(i);
remainder = (code >= 65 ? remainder * 100 + (code - 55) : remainder * 10 + (code - 48)) % 97;
}
for (let i = 0; i < 4; i++) {
const code = iban3.charCodeAt(i);
remainder = (code >= 65 ? remainder * 100 + (code - 55) : remainder * 10 + (code - 48)) % 97;
}
return remainder === 1;
}
function isValidIBAN(input2) {
if (!iban.test(input2))
return false;
return isIso7064Mod97(input2);
}
var $ZodIBAN = /* @__PURE__ */ $constructor("$ZodIBAN", (inst, def) => {
def.pattern ?? (def.pattern = iban);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidIBAN(payload.value))
return;
payload.issues.push({
code: "invalid_format",
format: "iban",
input: payload.value,
inst,
continue: !def.abort
});
};
});
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 = number;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce)
try {
payload.value = Number(payload.value);
} catch (_) {
}
const input2 = payload.value;
if (typeof input2 === "number" && !Number.isNaN(input2) && Number.isFinite(input2)) {
return payload;
}
const received = typeof input2 === "number" ? Number.isNaN(input2) ? "NaN" : !Number.isFinite(input2) ? String(input2) : void 0 : void 0;
payload.issues.push({
expected: "number",
code: "invalid_type",
input: input2,
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 input2 = payload.value;
if (typeof input2 === "boolean")
return payload;
payload.issues.push({
expected: "boolean",
code: "invalid_type",
input: input2,
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 input2 = payload.value;
if (typeof input2 === "symbol")
return payload;
payload.issues.push({
expected: "symbol",
code: "invalid_type",
input: input2,
inst
});
return payload;
};
});
var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = _undefined;
inst._zod.values = /* @__PURE__ */ new Set([void 0]);
inst._zod.parse = (payload, _ctx) => {
const input2 = payload.value;
if (typeof input2 === "undefined")
return payload;
payload.issues.push({
expected: "undefined",
code: "invalid_type",
input: input2,
inst
});
return payload;
};
});
var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = _null;
inst._zod.values = /* @__PURE__ */ new Set([null]);
inst._zod.parse = (payload, _ctx) => {
const input2 = payload.value;
if (input2 === null)
return payload;
payload.issues.push({
expected: "null",
code: "invalid_type",
input: input2,
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 input2 = payload.value;
if (typeof input2 === "undefined")
return payload;
payload.issues.push({
expected: "void",
code: "invalid_type",
input: input2,
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 input2 = payload.value;
const isDate = input2 instanceof Date;
const isValidDate = isDate && !Number.isNaN(input2.getTime());
if (isValidDate)
return payload;
payload.issues.push({
expected: "date",
code: "invalid_type",
input: input2,
...isDate ? { received: "Invalid Date" } : {},
inst
});
return payload;
};
});
function capSize(inst, size) {
const caps = sizeCaps(inst._zod.def.checks);
if (!caps.length)
return;
const cap = Math.min(...caps.map((c) => c[0]));
const parse3 = inst._zod.parse;
inst._zod.parse = (payload, ctx) => {
const n = size(payload.value);
if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
for (const [max, ch] of sizeCaps(inst._zod.def.checks)) {
if (n > max && ch._zod.def.when(payload)) {
const start = payload.issues.length;
ch._zod.check(payload);
payload.issues[start].continue = false;
attachSchema(payload.issues, start, inst);
return payload;
}
}
}
return parse3(payload, ctx);
};
}
var arraySize = (input2) => Array.isArray(input2) ? input2.length : -1;
var mapSize = (input2) => input2 instanceof Map ? input2.size : -1;
var setSize = (input2) => input2 instanceof Set ? input2.size : -1;
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);
const memo3 = globalConfig.memoizer;
memo3?.attach(inst);
inst._zod.parse = (payload, ctx) => {
const input2 = payload.value;
if (!Array.isArray(input2)) {
payload.issues.push({
expected: "array",
code: "invalid_type",
input: input2,
inst
});
return payload;
}
payload.value = memo3 ? memo3.alloc(inst, payload, Array(input2.length), ctx) : Array(input2.length);
const proms = [];
const abortEarly = ctx?.abortEarly;
for (let i = 0; i < input2.length; i++) {
const item = input2[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 (abortEarly && result.issues.length !== 0 && aborted(result))
break;
}
}
if (proms.length) {
return Promise.all(proms).then(() => payload);
}
return payload;
};
capSize(inst, arraySize);
});
function handlePropertyResult(result, final, key, input2, optin, optout) {
const isPresent = key in input2;
const isOptionalOut = optout === "optional";
if (!isPresent && isOptionalOut && optin === "optional") {
return;
}
if (result.issues.length) {
if (optin !== void 0 && isOptionalOut && !isPresent) {
return;
}
final.issues.push(...prefixIssues(key, result.issues));
}
if (!isPresent && optin === void 0) {
if (!result.issues.length) {
final.issues.push({
code: "invalid_type",
expected: "nonoptional",
input: void 0,
path: [key]
});
}
return;
}
if (result.value === void 0) {
if (isPresent || optin === "defaulted" && !isOptionalOut) {
final.value[key] = void 0;
}
} else {
final.value[key] = result.value;
}
}
var NO_SYMBOL_KEYS = [];
function normalizeDef(def) {
const keys = Object.keys(def.shape);
const ownSymbols = Object.getOwnPropertySymbols(def.shape);
const symbolKeys = ownSymbols.length ? ownSymbols : NO_SYMBOL_KEYS;
const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;
for (const k of allKeys) {
if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
throw new Error(`Invalid element at key "${String(k)}": expected a Zod schema`);
}
}
const okeys = optionalKeys(def.shape);
return {
...def,
allKeys,
symbolKeys,
// string-only: handleCatchall matches it against `for...in`, which never yields a symbol
keySet: new Set(keys),
numKeys: keys.length,
optionalKeys: new Set(okeys)
};
}
function handleCatchall(proms, input2, payload, ctx, def, inst, abortEarly) {
const unrecognized = [];
const keySet = def.keySet;
const _catchall = def.catchall._zod;
const t = _catchall.def.type;
const optin = _catchall.optin;
const optout = _catchall.optout;
let seen = 0;
for (const key in input2) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen))
break;
seen = payload.issues.length;
}
if (keySet.has(key))
continue;
if (key === "__proto__") {
if (t === "never")
unrecognized.push(key);
continue;
}
if (t === "never") {
unrecognized.push(key);
continue;
}
const r = _catchall.run({ value: input2[key], issues: [] }, ctx);
if (r instanceof Promise) {
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input2, optin, optout)));
} else {
handlePropertyResult(r, payload, key, input2, optin, optout);
}
}
if (unrecognized.length) {
payload.issues.push({
code: "unrecognized_keys",
keys: unrecognized,
input: input2,
inst,
// Describes the shape of the input, not the validity of the parsed value, so it never aborts. The parse still fails; the schema's own checks just get to run first, and an enclosing intersection can reconcile the key against a sibling operand.
continue: true
});
}
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");
const sh = desc?.get ? desc.get.raw : def.shape ?? {};
if (sh) {
const get = () => {
const newSh = { ...sh };
Object.defineProperty(def, "shape", { value: newSh });
get.raw = newSh;
return newSh;
};
get.raw = sh;
Object.defineProperty(def, "shape", { get });
}
const _normalized = cached(() => normalizeDef(def));
defineLazyInternal(inst, "propValues", (zod) => {
const shape = zod.def.shape;
const propValues = {};
for (const key in shape) {
const field = shape[key]._zod;
if (field.values) {
if (!Object.prototype.hasOwnProperty.call(propValues, key)) {
assignProp(propValues, key, /* @__PURE__ */ new Set());
}
for (const v of field.values)
propValues[key].add(v);
if (field.optin !== void 0)
propValues[key].add(void 0);
}
}
return propValues;
});
const isObject2 = isObject;
const catchall = def.catchall;
let value;
const memo3 = globalConfig.memoizer;
memo3?.attach(inst);
inst._zod.parse = (payload, ctx) => {
value ?? (value = _normalized.value);
const input2 = payload.value;
if (!isObject2(input2)) {
payload.issues.push({
expected: "object",
code: "invalid_type",
input: input2,
inst
});
return payload;
}
payload.value = memo3 ? memo3.alloc(inst, payload, {}, ctx) : {};
const proms = [];
const shape = value.shape;
const abortEarly = ctx?.abortEarly;
let seen = payload.issues.length;
for (const key of value.allKeys) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen))
break;
seen = payload.issues.length;
}
if (key === "__proto__")
continue;
const el = shape[key];
const optin = el._zod.optin;
const optout = el._zod.optout;
const r = el._zod.run({ value: input2[key], issues: [] }, ctx);
if (r instanceof Promise) {
proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input2, optin, optout)));
} else {
handlePropertyResult(r, payload, key, input2, optin, optout);
}
}
if (!catchall) {
return proms.length ? Promise.all(proms).then(() => payload) : payload;
}
return handleCatchall(proms, input2, payload, ctx, _normalized.value, inst, abortEarly === true);
};
});
var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
$ZodObject.init(inst, def);
const superParse = inst._zod.parse;
const _normalized = cached(() => normalizeDef(def));
const memo3 = globalConfig.memoizer;
const generateFastpass = (shape) => {
const normalized = _normalized.value;
const syms = normalized.symbolKeys;
const doc = new Doc(["payload", "ctx"], { shape, inst, memo: memo3, syms });
const parseStr = (k) => `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
const prefixStr = (id, k) => `
let ${id}_ab = false;
for (let i = 0; i < ${id}.issues.length; i++) {
const iss = ${id}.issues[i];
iss.path = iss.path ? [${k}, ...iss.path] : [${k}];
payload.issues.push(iss);
if (iss.continue !== true) ${id}_ab = true;
}
if (${id}_ab && ctx && ctx.abortEarly) {
payload.value = newResult;
return payload;
}`;
doc.write(`const input = payload.value;`);
const ids = /* @__PURE__ */ Object.create(null);
let counter = 0;
for (const key of normalized.allKeys) {
ids[key] = `key_${counter++}`;
}
doc.write(memo3 ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);
for (const key of normalized.allKeys) {
if (key === "__proto__")
continue;
const id = ids[key];
const k = typeof key === "symbol" ? `syms[${syms.indexOf(key)}]` : esc(key);
const isPresent = `${k} in input`;
const schema = shape[key];
const optin = schema?._zod?.optin;
const isOptionalIn = optin !== void 0;
const isOptionalOut = schema?._zod?.optout === "optional";
doc.write(`const ${id} = ${parseStr(k)};`);
if (isOptionalIn && isOptionalOut) {
const assign = optin === "optional" ? `${id}_present` : `${id}.value !== undefined || ${id}_present`;
doc.write(`
const ${id}_present = ${isPresent};
if (!${id}.issues.length || ${id}_present) {
if (${id}.issues.length) {${prefixStr(id, k)}
}
if (${assign}) {
newResult[${k}] = ${id}.value;
}
}
`);
} else if (!isOptionalIn) {
doc.write(`
const ${id}_present = ${isPresent};
if (${id}.issues.length) {${prefixStr(id, k)}
}
if (!${id}_present && !${id}.issues.length) {
payload.issues.push({
code: "invalid_type",
expected: "nonoptional",
input: undefined,
path: [${k}]
});
if (ctx && ctx.abortEarly) {
payload.value = newResult;
return payload;
}
}
if (${id}_present) {
newResult[${k}] = ${id}.value;
}
`);
} else {
doc.write(`
if (${id}.issues.length) {${prefixStr(id, k)}
}
`);
if (optin === "defaulted") {
doc.write(`newResult[${k}] = ${id}.value;`);
} else {
doc.write(`
if (${id}.value !== undefined || ${isPresent}) {
newResult[${k}] = ${id}.value;
}
`);
}
}
}
doc.write(`payload.value = newResult;`);
doc.write(`return payload;`);
return doc.compile();
};
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 input2 = payload.value;
if (!isObject2(input2)) {
payload.issues.push({
expected: "object",
code: "invalid_type",
input: input2,
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([], input2, payload, ctx, value, inst, ctx?.abortEarly === true);
}
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);
defineLazyInternal(inst, "optin", (zod) => zod.def.options.some((o) => o._zod.optin === "defaulted") ? "defaulted" : zod.def.options.some((o) => o._zod.optin !== void 0) ? "optional" : void 0);
defineLazyInternal(inst, "optout", (zod) => zod.def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
defineLazyInternal(inst, "values", (zod) => {
if (zod.def.options.every((o) => o._zod.values)) {
return new Set(zod.def.options.flatMap((option) => Array.from(option._zod.values)));
}
return void 0;
});
defineLazyInternal(inst, "pattern", (zod) => {
if (zod.def.options.every((o) => o._zod.pattern)) {
const patterns = zod.def.options.map((o) => o._zod.pattern);
return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
}
return void 0;
});
const first = def.options.length === 1 ? def.options[0]._zod.run : null;
inst._zod.parse = (payload, ctx) => {
if (first) {
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 matches = [];
for (let i = 0; i < results.length; i++) {
if (results[i].issues.length === 0)
matches.push(i);
}
if (matches.length === 1) {
final.value = results[matches[0]].value;
return final;
}
if (matches.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,
matches
});
}
return final;
}
var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
$ZodUnion.init(inst, def);
def.inclusive = false;
const first = def.options.length === 1 ? def.options[0]._zod.run : null;
inst._zod.parse = (payload, ctx) => {
if (first) {
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);
});
};
});
function getDiscriminatedOption(union2, value) {
const internals = union2._zod;
let map2 = internals.bag.optionsMap;
if (!map2) {
map2 = discriminatorMap(internals.def);
internals.bag.optionsMap = map2;
}
const option = map2.get(value);
if (option === null)
throw new Error(`Ambiguous discriminator value "${String(value)}"`);
return option;
}
function discriminatorMap(def) {
const map2 = /* @__PURE__ */ new Map();
for (const option of def.options) {
const values = option._zod.propValues?.[def.discriminator];
if (!values || values.size === 0)
throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
for (const value of values) {
if (map2.has(value)) {
if (value !== void 0)
throw new Error(`Duplicate discriminator value "${String(value)}"`);
map2.set(value, null);
} else {
map2.set(value, option);
}
}
}
return map2;
}
var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
def.inclusive = false;
$ZodUnion.init(inst, def);
const _super = inst._zod.parse;
defineLazyInternal(inst, "propValues", (zod) => {
const propValues = {};
let undefinedCount = 0;
for (const option of zod.def.options) {
const pv = option._zod.propValues;
if (!pv || Object.keys(pv).length === 0)
throw new Error(`Invalid discriminated union option at index "${zod.def.options.indexOf(option)}"`);
if (pv[zod.def.discriminator]?.has(void 0))
undefinedCount++;
for (const [k, v] of Object.entries(pv)) {
if (!Object.prototype.hasOwnProperty.call(propValues, k)) {
assignProp(propValues, k, /* @__PURE__ */ new Set());
}
for (const val of v) {
propValues[k].add(val);
}
}
}
if (!zod.def.unionFallback && undefinedCount > 1)
propValues[zod.def.discriminator]?.delete(void 0);
return propValues;
});
def.options.forEach((option, i) => {
const propShape = rawShape(option._zod.def);
if (propShape && !Object.prototype.hasOwnProperty.call(propShape, def.discriminator)) {
throw new Error(`Invalid discriminated union option at index "${i}"`);
}
});
const disc = cached(() => discriminatorMap(def));
inst._zod.parse = (payload, ctx) => {
const input2 = payload.value;
if (!isObject(input2)) {
payload.issues.push({
code: "invalid_type",
expected: "object",
input: input2,
inst
});
return payload;
}
const value = input2?.[def.discriminator];
const opt = disc.value.get(value);
if (opt && (value !== void 0 || ctx.direction !== "backward")) {
return opt._zod.run(payload, ctx);
}
if (def.unionFallback || ctx.direction === "backward") {
return _super(payload, ctx);
}
payload.issues.push({
code: "invalid_union",
errors: [],
note: "No matching discriminator",
discriminator: def.discriminator,
options: Array.from(disc.value.keys()).filter((value2) => disc.value.get(value2) !== null),
input: input2,
path: [def.discriminator],
inst
});
return payload;
};
});
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input2 = payload.value;
const left = def.left._zod.run({ value: input2, issues: [] }, ctx);
const right = def.right._zod.run({ value: input2, 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 };
if (Object.prototype.hasOwnProperty.call(newObj, "__proto__"))
delete newObj.__proto__;
for (const key of sharedKeys) {
if (key === "__proto__")
continue;
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 = /* @__PURE__ */ new Map();
let unrecIssue;
const keyIssues = /* @__PURE__ */ new Map();
const collect = (iss, side) => {
let keys;
if (iss.code === "unrecognized_keys" && !iss.path?.length) {
unrecIssue ?? (unrecIssue = iss);
keys = iss.keys;
} else if (iss.code === "invalid_key" && iss.origin === "record" && iss.path?.length === 1) {
const k = String(iss.path[0]);
if (!keyIssues.has(k))
keyIssues.set(k, iss);
keys = [k];
} else {
return false;
}
for (const k of keys) {
if (!unrecKeys.has(k))
unrecKeys.set(k, {});
unrecKeys.get(k)[side] = true;
}
return true;
};
for (const iss of left.issues) {
if (!collect(iss, "l"))
result.issues.push(iss);
}
for (const iss of right.issues) {
if (!collect(iss, "r"))
result.issues.push(iss);
}
const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
if (bothKeys.length) {
const aggregated = unrecIssue ? bothKeys.filter((k) => unrecIssue.keys.includes(k)) : [];
if (aggregated.length)
result.issues.push({ ...unrecIssue, keys: aggregated });
for (const k of bothKeys) {
if (!aggregated.includes(k) && keyIssues.has(k))
result.issues.push(keyIssues.get(k));
}
}
const merged = mergeValues(left.value, right.value);
if (!merged.valid) {
if (aborted(result))
return result;
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;
const memo3 = globalConfig.memoizer;
memo3?.attach(inst);
inst._zod.parse = (payload, ctx) => {
const input2 = payload.value;
if (!Array.isArray(input2)) {
payload.issues.push({
input: input2,
inst,
expected: "tuple",
code: "invalid_type"
});
return payload;
}
payload.value = memo3 ? memo3.alloc(inst, payload, [], ctx) : [];
const proms = [];
const optinStart = getTupleOptStart(items, "optin");
const optoutStart = getTupleOptStart(items, "optout");
if (!def.rest) {
if (input2.length < optinStart) {
payload.issues.push({
code: "too_small",
minimum: optinStart,
inclusive: true,
input: input2,
inst,
origin: "array"
});
return payload;
}
if (input2.length > items.length) {
payload.issues.push({
code: "too_big",
maximum: items.length,
inclusive: true,
input: input2,
inst,
origin: "array"
});
}
}
const itemResults = new Array(items.length);
const abortEarly = def.rest ? ctx?.abortEarly : void 0;
let itemAborted = false;
for (let i = 0; i < items.length; i++) {
const r = items[i]._zod.run({ value: input2[i], issues: [] }, ctx);
if (r instanceof Promise) {
proms.push(r.then((rr) => {
itemResults[i] = rr;
}));
} else {
itemResults[i] = r;
if (abortEarly && !itemAborted && r.issues.length)
itemAborted = aborted(r);
}
}
if (def.rest && !itemAborted) {
let i = items.length - 1;
const rest = input2.slice(items.length);
let seen = payload.issues.length;
for (const el of rest) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen))
break;
seen = payload.issues.length;
}
i++;
const result = def.rest._zod.run({ value: el, issues: [] }, ctx);
if (result instanceof Promise) {
proms.push(result.then((r) => handleTupleResult(r, payload, i)));
} else {
handleTupleResult(result, payload, i);
}
}
}
if (proms.length) {
return Promise.all(proms).then(() => handleTupleResults(itemResults, payload, items, input2, optoutStart));
}
return handleTupleResults(itemResults, payload, items, input2, optoutStart);
};
});
function getTupleOptStart(items, key) {
for (let i = items.length - 1; i >= 0; i--) {
const omittable = key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
if (!omittable)
return i + 1;
}
return 0;
}
function handleTupleResult(result, final, index) {
if (result.issues.length) {
final.issues.push(...prefixIssues(index, result.issues));
}
final.value[index] = result.value;
}
function handleTupleResults(itemResults, final, items, input2, optoutStart) {
for (let i = 0; i < items.length; i++) {
const r = itemResults[i];
const isPresent = i < input2.length;
if (!isPresent && i >= optoutStart && items[i]._zod.optin === "optional") {
final.value.length = i;
break;
}
if (r.issues.length) {
if (!isPresent && i >= optoutStart) {
final.value.length = i;
break;
}
final.issues.push(...prefixIssues(i, r.issues));
}
final.value[i] = r.value;
}
for (let i = final.value.length - 1; i >= input2.length; i--) {
if (items[i]._zod.optout === "optional" && final.value[i] === void 0) {
final.value.length = i;
} else {
break;
}
}
return final;
}
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
$ZodType.init(inst, def);
const memo3 = globalConfig.memoizer;
memo3?.attach(inst);
inst._zod.parse = (payload, ctx) => {
const input2 = payload.value;
if (!isPlainObject(input2)) {
payload.issues.push({
expected: "record",
code: "invalid_type",
input: input2,
inst
});
return payload;
}
const proms = [];
const values = def.keyType._zod.values;
if (values && !def.partial) {
payload.value = memo3 ? memo3.alloc(inst, payload, {}, ctx) : {};
const recordKeys = /* @__PURE__ */ 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);
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) => finalizeIssue(iss, ctx, config())),
input: key,
path: [key],
inst
});
continue;
}
const outKey = keyResult.value;
if (outKey === "__proto__")
continue;
const result = def.valueType._zod.run({ value: input2[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[outKey] = result2.value;
}));
} else {
if (result.issues.length) {
payload.issues.push(...prefixIssues(key, result.issues));
}
payload.value[outKey] = result.value;
}
}
}
let unrecognized;
for (const key in input2) {
if (!recordKeys.has(key)) {
if (def.mode === "loose") {
if (key === "__proto__")
continue;
payload.value[key] = input2[key];
} else {
unrecognized = unrecognized ?? [];
unrecognized.push(key);
}
}
}
if (unrecognized && unrecognized.length > 0) {
payload.issues.push({
code: "unrecognized_keys",
input: input2,
inst,
keys: unrecognized,
continue: true
});
}
} else {
payload.value = memo3 ? memo3.alloc(inst, payload, {}, ctx) : {};
let unrecognized;
for (const key of Reflect.ownKeys(input2)) {
if (key === "__proto__")
continue;
if (!Object.prototype.propertyIsEnumerable.call(input2, key))
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] = input2[key];
} else if (values) {
unrecognized = unrecognized ?? [];
unrecognized.push(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 outKey = keyResult.value;
if (outKey === "__proto__")
continue;
const result = def.valueType._zod.run({ value: input2[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[outKey] = result2.value;
}));
} else {
if (result.issues.length) {
payload.issues.push(...prefixIssues(key, result.issues));
}
payload.value[outKey] = result.value;
}
}
if (unrecognized && unrecognized.length > 0) {
payload.issues.push({
code: "unrecognized_keys",
input: input2,
inst,
keys: unrecognized,
continue: true
});
}
}
if (proms.length) {
return Promise.all(proms).then(() => payload);
}
return payload;
};
});
var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
$ZodType.init(inst, def);
const memo3 = globalConfig.memoizer;
memo3?.attach(inst);
inst._zod.parse = (payload, ctx) => {
const input2 = payload.value;
if (!(input2 instanceof Map)) {
payload.issues.push({
expected: "map",
code: "invalid_type",
input: input2,
inst
});
return payload;
}
const proms = [];
payload.value = memo3 ? memo3.alloc(inst, payload, /* @__PURE__ */ new Map(), ctx) : /* @__PURE__ */ new Map();
const abortEarly = ctx?.abortEarly;
let seen = payload.issues.length;
for (const [key, value] of input2) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen))
break;
seen = payload.issues.length;
}
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, input2, inst, ctx);
}));
} else {
handleMapResult(keyResult, valueResult, payload, key, input2, inst, ctx);
}
}
if (proms.length)
return Promise.all(proms).then(() => payload);
return payload;
};
capSize(inst, mapSize);
});
function handleMapResult(keyResult, valueResult, final, key, input2, 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: input2,
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: input2,
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);
const memo3 = globalConfig.memoizer;
memo3?.attach(inst);
inst._zod.parse = (payload, ctx) => {
const input2 = payload.value;
if (!(input2 instanceof Set)) {
payload.issues.push({
input: input2,
inst,
expected: "set",
code: "invalid_type"
});
return payload;
}
const proms = [];
payload.value = memo3 ? memo3.alloc(inst, payload, /* @__PURE__ */ new Set(), ctx) : /* @__PURE__ */ new Set();
const abortEarly = ctx?.abortEarly;
let seen = payload.issues.length;
for (const item of input2) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen))
break;
seen = payload.issues.length;
}
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;
};
capSize(inst, setSize);
});
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;
defineLazyInternal(inst, "pattern", (zod) => {
const patternValues = getEnumValues(zod.def.entries).filter((k) => propertyKeyTypes.has(typeof k));
return new RegExp(patternValues.length ? `^(${patternValues.map((o) => escapeRegex(o.toString())).join("|")})$` : "^[^\\s\\S]$");
});
inst._zod.parse = (payload, _ctx) => {
const input2 = payload.value;
if (valuesSet.has(input2)) {
return payload;
}
payload.issues.push({
code: "invalid_value",
values,
input: input2,
inst
});
return payload;
};
});
var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
$ZodType.init(inst, def);
const values = new Set(def.values);
inst._zod.values = values;
defineLazyInternal(inst, "pattern", (zod) => {
const vals = zod.def.values;
return new RegExp(vals.length ? `^(${vals.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$` : "^[^\\s\\S]$");
});
inst._zod.parse = (payload, _ctx) => {
const input2 = payload.value;
if (values.has(input2)) {
return payload;
}
payload.issues.push({
code: "invalid_value",
values: def.values,
input: input2,
inst
});
return payload;
};
});
var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
const input2 = payload.value;
if (input2 instanceof File)
return payload;
payload.issues.push({
expected: "file",
code: "invalid_type",
input: input2,
inst
});
return payload;
};
});
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "optional";
globalConfig.memoizer?.guard(inst);
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 output2 = _out instanceof Promise ? _out : Promise.resolve(_out);
return output2.then((output3) => {
payload.value = output3;
return payload;
});
}
if (_out instanceof Promise) {
throw new $ZodAsyncError();
}
payload.value = _out;
return payload;
};
});
function handleOptionalResult(payload, result) {
payload.value = result.issues.length ? void 0 : result.value;
return payload;
}
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional");
inst._zod.optout = "optional";
defineLazyInternal(inst, "values", (zod) => {
const values = zod.def.innerType._zod.values;
return values ? /* @__PURE__ */ new Set([...values, void 0]) : void 0;
});
defineLazyInternal(inst, "pattern", (zod) => {
const pattern = zod.def.innerType._zod.pattern;
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
});
inst._zod.parse = (payload, ctx) => {
if (payload.value === void 0) {
if (def.innerType._zod.optin !== "defaulted")
return payload;
const result = def.innerType._zod.run({ value: payload.value, issues: [] }, ctx);
if (result instanceof Promise)
return result.then((result2) => handleOptionalResult(payload, result2));
return handleOptionalResult(payload, result);
}
return def.innerType._zod.run(payload, ctx);
};
});
var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
$ZodOptional.init(inst, def);
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
defineLazyInternal(inst, "pattern", (zod) => zod.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);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin);
defineLazyInternal(inst, "optout", (zod) => zod.def.innerType._zod.optout);
defineLazyInternal(inst, "pattern", (zod) => {
const pattern = zod.def.innerType._zod.pattern;
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
});
defineLazyInternal(inst, "values", (zod) => {
return zod.def.innerType._zod.values ? /* @__PURE__ */ new Set([...zod.def.innerType._zod.values, null]) : void 0;
});
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 = "defaulted";
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") {
return def.innerType._zod.run(payload, ctx);
}
if (payload.value === void 0) {
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 === void 0) {
payload.value = def.defaultValue;
}
return payload;
}
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "defaulted";
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") {
return def.innerType._zod.run(payload, ctx);
}
if (payload.value === void 0) {
payload.value = def.defaultValue;
}
return def.innerType._zod.run(payload, ctx);
};
});
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "values", (zod) => {
const v = zod.def.innerType._zod.values;
return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
});
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 === void 0) {
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;
};
});
function handleCatchResult(payload, result, def, ctx) {
if (!result.issues.length) {
payload.value = result.value;
if (result.memo)
payload.memo = true;
return payload;
}
payload.value = def.catchValue({
...result,
value: payload.value,
error: {
issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
},
input: payload.value
});
return payload;
}
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional");
defineLazyInternal(inst, "optout", (zod) => zod.def.innerType._zod.optout);
defineLazyInternal(inst, "values", (zod) => zod.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({ value: payload.value, issues: [] }, ctx);
if (result instanceof Promise) {
return result.then((result2) => handleCatchResult(payload, result2, def, ctx));
}
return handleCatchResult(payload, result, def, ctx);
};
});
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);
defineLazyInternal(inst, "values", (zod) => zod.def.in._zod.values);
defineLazyInternal(inst, "optin", (zod) => zod.def.in._zod.optin);
defineLazyInternal(inst, "optout", (zod) => zod.def.out._zod.optout);
defineLazyInternal(inst, "propValues", (zod) => zod.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.some((iss) => iss.code !== "unrecognized_keys")) {
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);
defineLazyInternal(inst, "values", (zod) => zod.def.in._zod.values);
defineLazyInternal(inst, "optin", (zod) => zod.def.in._zod.optin);
defineLazyInternal(inst, "optout", (zod) => zod.def.out._zod.optout);
defineLazyInternal(inst, "propValues", (zod) => zod.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 $ZodPreprocess = /* @__PURE__ */ $constructor("$ZodPreprocess", (inst, def) => {
$ZodPipe.init(inst, def);
});
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "propValues", (zod) => zod.def.innerType._zod.propValues);
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType?._zod?.optin);
defineLazyInternal(inst, "optout", (zod) => zod.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) {
if (!payload.memo)
payload.value = Object.freeze(payload.value);
return payload;
}
function leafPattern(schema) {
const def = schema._zod.def;
let pattern = def.pattern;
let isInt = !!def.format?.includes("int");
let minimum;
let maximum;
for (const ch of def.checks ?? []) {
const d = ch._zod.def;
if (d.pattern)
pattern = d.pattern;
isInt || (isInt = !!d.format?.includes("int"));
const lo = d.minimum ?? d.length;
const hi = d.maximum ?? d.length;
if (lo !== void 0 && (minimum === void 0 || lo > minimum))
minimum = lo;
if (hi !== void 0 && (maximum === void 0 || hi < maximum))
maximum = hi;
}
if (pattern)
return pattern.source;
if (minimum !== void 0 && maximum !== void 0 && minimum > maximum)
return "(?!)";
if (minimum !== void 0 || maximum !== void 0)
return string({ minimum, maximum }).source;
const own2 = schema._zod.pattern;
return (isInt && own2 === number ? integer : own2)?.source;
}
function partPattern(schema) {
const def = schema._zod.def;
const own2 = schema._zod.pattern?.source;
const inner = def.innerType ?? schema._zod.innerType;
if (inner) {
const before = inner._zod.pattern?.source;
const after = partPattern(inner);
if (own2 && before && after && after !== before) {
return own2.replace(cleanRegex(before), () => cleanRegex(after));
}
return own2;
}
if (def.options) {
const sources = def.options.map(partPattern);
if (sources.every(Boolean))
return `^(${sources.map((s) => cleanRegex(s)).join("|")})$`;
}
return leafPattern(schema);
}
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) {
const source = partPattern(part);
if (!source) {
throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
}
regexParts.push(cleanRegex(source));
} 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);
Object.defineProperty(inst, "_def", { value: def });
inst._zod.def = def;
inst.implement = (func) => {
if (typeof func !== "function") {
throw new Error("implement() must be called with a function");
}
return Object.defineProperty(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;
}, "_zod", { value: inst._zod, enumerable: false });
};
inst.implementAsync = (func) => {
if (typeof func !== "function") {
throw new Error("implementAsync() must be called with a function");
}
return Object.defineProperty(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;
}, "_zod", { value: inst._zod, enumerable: false });
};
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 = (output2) => {
const F = inst.constructor;
return new F({
type: "function",
input: inst._def.input,
output: output2
});
};
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", () => {
const d = def;
if (!d._cachedInner)
d._cachedInner = def.getter();
return d._cachedInner;
});
defineLazyInternal(inst, "pattern", (zod) => zod.innerType?._zod?.pattern);
defineLazyInternal(inst, "propValues", (zod) => zod.innerType?._zod?.propValues);
defineLazyInternal(inst, "optin", (zod) => zod.innerType?._zod?.optin ?? void 0);
defineLazyInternal(inst, "optout", (zod) => zod.innerType?._zod?.optout ?? void 0);
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 input2 = payload.value;
const r = def.fn(input2);
if (r instanceof Promise) {
return r.then((r2) => handleRefineResult(r2, payload, input2, inst));
}
handleRefineResult(r, payload, input2, inst);
return;
};
});
function handleRefineResult(result, payload, input2, inst) {
if (!result) {
const _iss = {
code: "custom",
input: input2,
inst,
// incorporates params.error into issue reporting
path: [...inst._zod.def.path ?? []],
// incorporates params.error into issue reporting
continue: !inst._zod.def.abort
// params: inst._zod.def.params,
};
if (inst._zod.def.params)
_iss.params = inst._zod.def.params;
payload.issues.push(issue(_iss));
}
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/memoizer.js
var $ZodCyclicError = class extends Error {
constructor() {
super(`Cannot parse a reference cycle that closes through a transform`);
this.name = "ZodCyclicError";
}
};
var STATE = "~memo";
var NO_ISSUES = [];
function isRef(value) {
return value !== null && typeof value === "object";
}
function cloneIssues(issues) {
return issues.map((iss) => iss.path ? { ...iss, path: iss.path.slice() } : { ...iss });
}
var recursive = /* @__PURE__ */ new WeakMap();
var NONE = 0;
var ASSUMED = 1;
var PROVEN = 2;
function isRecursive(inst, stack, resolve) {
const cached2 = recursive.get(inst);
if (cached2 !== void 0)
return cached2 ? PROVEN : NONE;
if (stack.has(inst))
return PROVEN;
stack.add(inst);
let result = NONE;
const check2 = (child) => {
if (result !== PROVEN && child?._zod) {
const answer = isRecursive(child, stack, resolve);
if (answer > result)
result = answer;
}
};
const shape = (sh, spread) => {
let answer = NONE;
for (const key of Reflect.ownKeys(sh)) {
const desc = Object.getOwnPropertyDescriptor(sh, key);
if (spread && !desc.enumerable)
continue;
const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
if (child > answer)
answer = child;
}
return answer;
};
const merge2 = (answer) => {
if (answer > result)
result = answer;
};
const def = inst._zod.def;
const kind = def.type;
switch (kind) {
case "object": {
const raw = rawShape(def);
merge2(raw ? shape(raw, true) : ASSUMED);
check2(def.catchall);
break;
}
case "array":
check2(def.element);
break;
case "tuple":
for (const el of def.items)
check2(el);
check2(def.rest);
break;
case "record":
case "map":
check2(def.keyType);
check2(def.valueType);
break;
case "set":
check2(def.valueType);
break;
case "union":
for (const el of def.options)
check2(el);
break;
case "intersection":
check2(def.left);
check2(def.right);
break;
case "optional":
case "nullable":
case "default":
case "prefault":
case "catch":
case "readonly":
case "nonoptional":
case "promise":
case "success":
check2(def.innerType);
break;
case "pipe":
check2(def.in);
check2(def.out);
break;
case "function":
check2(def.input);
check2(def.output);
break;
// `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
case "lazy": {
const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : void 0);
merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
break;
}
// a leaf by choice: `parts` are regex fragments, not data positions
case "template_literal":
// leaves
case "string":
case "number":
case "int":
case "boolean":
case "bigint":
case "symbol":
case "undefined":
case "null":
case "void":
case "never":
case "any":
case "unknown":
case "date":
case "nan":
case "enum":
case "literal":
case "file":
case "transform":
case "custom":
break;
default: {
kind;
for (const key in def) {
const desc = Object.getOwnPropertyDescriptor(def, key);
if (!desc || desc.get)
continue;
const value = desc.value;
if (!value || typeof value !== "object")
continue;
if (value._zod)
check2(value);
else if (Array.isArray(value))
for (const el of value)
check2(el);
}
}
}
stack.delete(inst);
return settle(inst, result);
}
function settle(inst, answer) {
if (answer !== ASSUMED)
recursive.set(inst, answer === PROVEN);
return answer;
}
function isRecursiveSchema(inst) {
return isRecursive(inst, /* @__PURE__ */ new Set(), true) !== NONE;
}
function bucketFor(state, inst) {
let bucket = state.buckets.get(inst);
if (!bucket) {
bucket = /* @__PURE__ */ new WeakMap();
state.buckets.set(inst, bucket);
}
return bucket;
}
var handoff;
var open = [];
var memo = {
alloc(_inst, payload, empty) {
const bucket = handoff;
if (!bucket)
return empty;
handoff = void 0;
const entry = { value: empty, issues: null };
bucket.set(payload.value, entry);
open.push(entry);
return empty;
},
guard(inst) {
var _a3;
(_a3 = inst._zod).deferred ?? (_a3.deferred = []);
inst._zod.deferred.push(() => {
const base = inst._zod.parse;
const wrapped = (payload, ctx) => {
if (ctx.direction !== "backward" && isBackEdge(ctx, payload.value))
throw new $ZodCyclicError();
return base(payload, ctx);
};
inst._zod.parse = wrapped;
if (inst._zod.run === base)
inst._zod.run = wrapped;
});
},
attach(inst) {
var _a3;
let isRecursiveInst;
let rechecked = false;
let lastCtx;
let lastBucket;
(_a3 = inst._zod).deferred ?? (_a3.deferred = []);
inst._zod.deferred.push(() => {
const base = inst._zod.parse;
const wrapped = (payload, ctx) => {
if (isRecursiveInst === void 0) {
const walked = isRecursive(inst, /* @__PURE__ */ new Set(), false);
if (walked === NONE) {
inst._zod.parse = base;
if (inst._zod.run === wrapped)
inst._zod.run = base;
return base(payload, ctx);
}
if (walked === PROVEN || rechecked)
isRecursiveInst = true;
else
rechecked = true;
}
const input2 = payload.value;
if (!isRef(input2))
return base(payload, ctx);
let state = ctx[STATE];
if (!state) {
state = { buckets: /* @__PURE__ */ new WeakMap(), backEdges: void 0 };
ctx[STATE] = state;
}
let bucket;
if (lastCtx === ctx) {
bucket = lastBucket;
} else {
bucket = bucketFor(state, inst);
lastCtx = ctx;
lastBucket = bucket;
}
const hit = bucket.get(input2);
if (hit) {
payload.value = hit.value;
if (hit.issues) {
if (hit.issues.length)
payload.issues.push(...cloneIssues(hit.issues));
} else {
payload.memo = true;
state.backEdges ?? (state.backEdges = /* @__PURE__ */ new WeakSet());
state.backEdges.add(hit.value);
}
return payload;
}
handoff = bucket;
const depth = open.length;
const result = base(payload, ctx);
handoff = void 0;
const entry = open.length > depth ? open.pop() : void 0;
if (result instanceof Promise) {
return result.then((r) => {
if (entry)
entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;
return r;
});
}
if (entry)
entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;
return result;
};
inst._zod.parse = wrapped;
if (inst._zod.run === base)
inst._zod.run = wrapped;
});
}
};
function memoizer() {
return memo;
}
function isBackEdge(ctx, value) {
const backEdges = ctx[STATE]?.backEdges;
return backEdges !== void 0 && isRef(value) && backEdges.has(value);
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/index.js
var locales_exports = {};
__export(locales_exports, {
ar: () => ar_default,
az: () => az_default,
be: () => be_default,
bg: () => bg_default,
bn: () => bn_default,
ca: () => ca_default,
ckb: () => ckb_default,
cs: () => cs_default,
da: () => da_default,
de: () => de_default,
el: () => el_default,
en: () => en_default,
eo: () => eo_default,
es: () => es_default,
fa: () => fa_default,
fi: () => fi_default,
fr: () => fr_default,
frCA: () => fr_CA_default,
gu: () => gu_default,
he: () => he_default,
hi: () => hi_default,
hr: () => hr_default,
hu: () => hu_default,
hy: () => hy_default,
id: () => id_default,
is: () => is_default,
it: () => it_default,
ja: () => ja_default,
ka: () => ka_default,
kh: () => kh_default,
km: () => km_default,
kn: () => kn_default,
ko: () => ko_default,
lt: () => lt_default,
mk: () => mk_default,
ms: () => ms_default,
ne: () => ne_default,
nl: () => nl_default,
nn: () => nn_default,
no: () => no_default,
ota: () => ota_default,
pl: () => pl_default,
ps: () => ps_default,
pt: () => pt_default,
ptBR: () => pt_BR_default,
ro: () => ro_default,
ru: () => ru_default,
sk: () => sk_default,
sl: () => sl_default,
sv: () => sv_default,
ta: () => ta_default,
tg: () => tg_default,
th: () => th_default,
tk: () => tk_default,
tr: () => tr_default,
ua: () => ua_default,
uk: () => uk_default,
ur: () => ur_default,
uz: () => uz_default,
vi: () => vi_default,
yo: () => yo_default,
zhCN: () => zh_CN_default,
zhTW: () => zh_TW_default
});
// node_modules/.pnpm/zod@4.6.7/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" },
map: { 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",
mac: "\u0639\u0646\u0648\u0627\u0646 MAC",
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",
credit_card: "\u0631\u0642\u0645 \u0628\u0637\u0627\u0642\u0629 \u0627\u0644\u0627\u0626\u062A\u0645\u0627\u0646",
currency_code: "\u0631\u0645\u0632 \u0627\u0644\u0639\u0645\u0644\u0629",
iban: "IBAN",
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/.pnpm/zod@4.6.7/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" },
map: { 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",
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",
credit_card: "kredit kart\u0131 n\xF6mr\u0259si",
currency_code: "valyuta kodu",
iban: "IBAN",
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/.pnpm/zod@4.6.7/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"
},
map: {
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",
mac: "MAC \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",
credit_card: "\u043D\u0443\u043C\u0430\u0440 \u043A\u0440\u044D\u0434\u044B\u0442\u043D\u0430\u0439 \u043A\u0430\u0440\u0442\u044B",
currency_code: "\u043A\u043E\u0434 \u0432\u0430\u043B\u044E\u0442\u044B",
iban: "IBAN",
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/.pnpm/zod@4.6.7/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" },
map: { 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",
mac: "MAC \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",
credit_card: "\u043D\u043E\u043C\u0435\u0440 \u043D\u0430 \u043A\u0440\u0435\u0434\u0438\u0442\u043D\u0430 \u043A\u0430\u0440\u0442\u0430",
currency_code: "\u043A\u043E\u0434 \u043D\u0430 \u0432\u0430\u043B\u0443\u0442\u0430",
iban: "IBAN",
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/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/bn.js
var error5 = () => {
const Sizable = {
string: { unit: "\u0985\u0995\u09CD\u09B7\u09B0", verb: "\u09A5\u09BE\u0995\u09A4\u09C7 \u09B9\u09AC\u09C7" },
file: { unit: "\u09AC\u09BE\u0987\u099F", verb: "\u09A5\u09BE\u0995\u09A4\u09C7 \u09B9\u09AC\u09C7" },
array: { unit: "\u0986\u0987\u099F\u09C7\u09AE", verb: "\u09A5\u09BE\u0995\u09A4\u09C7 \u09B9\u09AC\u09C7" },
set: { unit: "\u0986\u0987\u099F\u09C7\u09AE", verb: "\u09A5\u09BE\u0995\u09A4\u09C7 \u09B9\u09AC\u09C7" },
map: { unit: "\u098F\u09A8\u09CD\u099F\u09CD\u09B0\u09BF", verb: "\u09A5\u09BE\u0995\u09A4\u09C7 \u09B9\u09AC\u09C7" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "\u0987\u09A8\u09AA\u09C1\u099F",
email: "\u0987\u09AE\u09C7\u0987\u09B2 \u09A0\u09BF\u0995\u09BE\u09A8\u09BE",
url: "URL",
emoji: "\u0987\u09AE\u09CB\u099C\u09BF",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO \u09A4\u09BE\u09B0\u09BF\u0996 \u0993 \u09B8\u09AE\u09AF\u09BC",
date: "ISO \u09A4\u09BE\u09B0\u09BF\u0996",
time: "ISO \u09B8\u09AE\u09AF\u09BC",
duration: "ISO \u09B8\u09AE\u09AF\u09BC\u0995\u09BE\u09B2",
ipv4: "IPv4 \u09A0\u09BF\u0995\u09BE\u09A8\u09BE",
ipv6: "IPv6 \u09A0\u09BF\u0995\u09BE\u09A8\u09BE",
mac: "MAC \u09A0\u09BF\u0995\u09BE\u09A8\u09BE",
cidrv4: "IPv4 \u09B0\u09C7\u099E\u09CD\u099C",
cidrv6: "IPv6 \u09B0\u09C7\u099E\u09CD\u099C",
base64: "base64-\u098F\u09A8\u0995\u09CB\u09A1\u09C7\u09A1 \u09B8\u09CD\u099F\u09CD\u09B0\u09BF\u0982",
base64url: "base64url-\u098F\u09A8\u0995\u09CB\u09A1\u09C7\u09A1 \u09B8\u09CD\u099F\u09CD\u09B0\u09BF\u0982",
json_string: "JSON \u09B8\u09CD\u099F\u09CD\u09B0\u09BF\u0982",
e164: "E.164 \u09A8\u09AE\u09CD\u09AC\u09B0",
credit_card: "\u0995\u09CD\u09B0\u09C7\u09A1\u09BF\u099F \u0995\u09BE\u09B0\u09CD\u09A1 \u09A8\u09AE\u09CD\u09AC\u09B0",
currency_code: "\u09AE\u09C1\u09A6\u09CD\u09B0\u09BE \u0995\u09CB\u09A1",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u0987\u09A8\u09AA\u09C1\u099F"
};
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 `\u0985\u09AC\u09C8\u09A7 \u0987\u09A8\u09AA\u09C1\u099F: \u09AA\u09CD\u09B0\u09A4\u09CD\u09AF\u09BE\u09B6\u09BF\u09A4 ${expected}, \u09AA\u09CD\u09B0\u09BE\u09AA\u09CD\u09A4 ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u0985\u09AC\u09C8\u09A7 \u0987\u09A8\u09AA\u09C1\u099F: \u09AA\u09CD\u09B0\u09A4\u09CD\u09AF\u09BE\u09B6\u09BF\u09A4 ${stringifyPrimitive(issue2.values[0])}`;
return `\u0985\u09AC\u09C8\u09A7 \u0985\u09AA\u09B6\u09A8: ${joinValues(issue2.values, " | ")} \u098F\u09B0 \u09AE\u09A7\u09CD\u09AF\u09C7 \u098F\u0995\u099F\u09BF \u09AA\u09CD\u09B0\u09A4\u09CD\u09AF\u09BE\u09B6\u09BF\u09A4`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u0985\u09A8\u09C7\u0995 \u09AC\u09A1\u09BC: ${issue2.origin ?? "\u09AE\u09BE\u09A8"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u098F\u09B2\u09BF\u09AE\u09C7\u09A8\u09CD\u099F"} \u09B9\u09A4\u09C7 \u09B9\u09AC\u09C7`;
return `\u0985\u09A8\u09C7\u0995 \u09AC\u09A1\u09BC: ${issue2.origin ?? "\u09AE\u09BE\u09A8"} ${adj}${issue2.maximum.toString()} \u09B9\u09A4\u09C7 \u09B9\u09AC\u09C7`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `\u0985\u09A8\u09C7\u0995 \u099B\u09CB\u099F: ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} \u09B9\u09A4\u09C7 \u09B9\u09AC\u09C7`;
}
return `\u0985\u09A8\u09C7\u0995 \u099B\u09CB\u099F: ${issue2.origin} ${adj}${issue2.minimum.toString()} \u09B9\u09A4\u09C7 \u09B9\u09AC\u09C7`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with") {
return `\u0985\u09AC\u09C8\u09A7 \u09B8\u09CD\u099F\u09CD\u09B0\u09BF\u0982: "${_issue.prefix}" \u09A6\u09BF\u09AF\u09BC\u09C7 \u09B6\u09C1\u09B0\u09C1 \u09B9\u09A4\u09C7 \u09B9\u09AC\u09C7`;
}
if (_issue.format === "ends_with")
return `\u0985\u09AC\u09C8\u09A7 \u09B8\u09CD\u099F\u09CD\u09B0\u09BF\u0982: "${_issue.suffix}" \u09A6\u09BF\u09AF\u09BC\u09C7 \u09B6\u09C7\u09B7 \u09B9\u09A4\u09C7 \u09B9\u09AC\u09C7`;
if (_issue.format === "includes")
return `\u0985\u09AC\u09C8\u09A7 \u09B8\u09CD\u099F\u09CD\u09B0\u09BF\u0982: "${_issue.includes}" \u0985\u09A8\u09CD\u09A4\u09B0\u09CD\u09AD\u09C1\u0995\u09CD\u09A4 \u09A5\u09BE\u0995\u09A4\u09C7 \u09B9\u09AC\u09C7`;
if (_issue.format === "regex")
return `\u0985\u09AC\u09C8\u09A7 \u09B8\u09CD\u099F\u09CD\u09B0\u09BF\u0982: ${_issue.pattern} \u09AA\u09CD\u09AF\u09BE\u099F\u09BE\u09B0\u09CD\u09A8 \u09AE\u09BF\u09B2\u09A4\u09C7 \u09B9\u09AC\u09C7`;
return `\u0985\u09AC\u09C8\u09A7 ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `\u0985\u09AC\u09C8\u09A7 \u09A8\u09AE\u09CD\u09AC\u09B0: ${issue2.divisor} \u098F\u09B0 \u0997\u09C1\u09A3\u09BF\u09A4\u0995 \u09B9\u09A4\u09C7 \u09B9\u09AC\u09C7`;
case "unrecognized_keys":
return `\u0985\u099A\u09C7\u09A8\u09BE \u0995\u09C0${issue2.keys.length > 1 ? "\u0997\u09C1\u09B2\u09CB" : ""}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `${issue2.origin} \u098F \u0985\u09AC\u09C8\u09A7 \u0995\u09C0`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `\u0985\u09AC\u09C8\u09A7 \u09A1\u09BF\u09B8\u0995\u09CD\u09B0\u09BF\u09AE\u09BF\u09A8\u09C7\u099F\u09B0 \u09AE\u09BE\u09A8\u0964 \u09AA\u09CD\u09B0\u09A4\u09CD\u09AF\u09BE\u09B6\u09BF\u09A4 ${opts}`;
}
return "\u0985\u09AC\u09C8\u09A7 \u0987\u09A8\u09AA\u09C1\u099F";
case "invalid_element":
return `${issue2.origin} \u098F \u0985\u09AC\u09C8\u09A7 \u09AE\u09BE\u09A8`;
default:
return "\u0985\u09AC\u09C8\u09A7 \u0987\u09A8\u09AA\u09C1\u099F";
}
};
};
function bn_default() {
return {
localeError: error5()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ca.js
var error6 = () => {
const Sizable = {
string: { unit: "car\xE0cters", verb: "contenir" },
file: { unit: "bytes", verb: "contenir" },
array: { unit: "elements", verb: "contenir" },
set: { unit: "elements", verb: "contenir" },
map: { 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",
mac: "adre\xE7a MAC",
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",
credit_card: "n\xFAmero de targeta de cr\xE8dit",
currency_code: "codi de moneda",
iban: "IBAN",
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";
// Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general
case "invalid_element":
return `Element inv\xE0lid a ${issue2.origin}`;
default:
return `Entrada inv\xE0lida`;
}
};
};
function ca_default() {
return {
localeError: error6()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ckb.js
var error7 = () => {
const Sizable = {
string: { unit: "\u067E\u06CC\u062A", verb: "\u0628\u06CE\u062A" },
file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u0628\u06CE\u062A" },
array: { unit: "\u062F\u0627\u0646\u06D5", verb: "\u0628\u06CE\u062A" },
set: { unit: "\u062F\u0627\u0646\u06D5", verb: "\u0628\u06CE\u062A" },
map: { unit: "\u062F\u0627\u0646\u06D5", verb: "\u0628\u06CE\u062A" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "regex",
email: "\u0626\u06CC\u0645\u06D5\u06CC\u06B5",
url: "\u0628\u06D5\u0633\u062A\u06D5\u0631 (URL)",
emoji: "\u0626\u06CC\u0645\u06C6\u062C\u06CC",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "\u0695\u06CE\u06A9\u06D5\u0648\u062A \u0648 \u06A9\u0627\u062A",
date: "\u0695\u06CE\u06A9\u06D5\u0648\u062A",
time: "\u06A9\u0627\u062A",
duration: "\u0645\u0627\u0648\u06D5",
ipv4: "\u0646\u0627\u0648\u0646\u06CC\u0634\u0627\u0646\u06CC IPv4",
ipv6: "\u0646\u0627\u0648\u0646\u06CC\u0634\u0627\u0646\u06CC IPv6",
mac: "\u0646\u0627\u0648\u0646\u06CC\u0634\u0627\u0646\u06CC MAC",
cidrv4: "\u0645\u06D5\u0648\u062F\u0627\u06CC IPv4",
cidrv6: "\u0645\u06D5\u0648\u062F\u0627\u06CC IPv6",
base64: "\u062F\u06D5\u0642\u06CC base64",
base64url: "\u062F\u06D5\u0642\u06CC base64url",
json_string: "\u062F\u06D5\u0642\u06CC JSON",
e164: "\u0698\u0645\u0627\u0631\u06D5\u06CC E.164",
credit_card: "\u0698\u0645\u0627\u0631\u06D5\u06CC \u06A9\u0627\u0631\u062A\u06CC \u06A9\u0631\u06CE\u062F\u06CC\u062A",
currency_code: "\u06A9\u06C6\u062F\u06CC \u062F\u0631\u0627\u0648",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u062A\u06CE\u06A9\u0631\u062F\u06D5"
};
const TypeDictionary = {
nan: "NaN",
string: "\u0646\u0648\u0648\u0633\u06CC\u0646",
number: "\u0698\u0645\u0627\u0631\u06D5",
boolean: "boolean",
array: "array",
object: "object",
date: "\u0695\u06CE\u06A9\u06D5\u0648\u062A",
integer: "\u0698\u0645\u0627\u0631\u06D5",
float: "\u0698\u0645\u0627\u0631\u06D5",
null: "null",
undefined: "undefined",
function: "function",
symbol: "symbol",
unknown: "unknown",
promise: "promise",
void: "void",
never: "never",
map: "map",
set: "set"
};
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;
const postfix = ["\u0627", "\u0648", "\u06C6", "\u0648\u0648", "\u06D5", "\u06CC", "\u06CE"].some((p) => received.endsWith(p)) ? "\u06CC\u06D5" : "\u06D5";
const isEnglish = /^[a-zA-Z]+$/.test(received);
if (receivedType === "null" || receivedType === "undefined")
return `\u062F\u0627\u0648\u0627\u06A9\u0631\u0627\u0648\u06D5`;
return `\u0686\u0627\u0648\u06D5\u0695\u0648\u0627\u0646\u06A9\u0631\u0627\u0648\u06D5 ${expected} \u0628\u06CE\u062A\u060C \u0628\u06D5\u06B5\u0627\u0645 ${received}${isEnglish ? "" : postfix}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u0628\u06D5\u0647\u0627\u06A9\u06D5 \u0646\u0627\u062F\u0631\u0648\u0648\u0633\u062A\u06D5: \u0686\u0627\u0648\u06D5\u0695\u0648\u0627\u0646\u06A9\u0631\u0627\u0648\u06D5 ${stringifyPrimitive(issue2.values[0])} \u0628\u06CE\u062A`;
return `\u0647\u06D5\u06B5\u0628\u0698\u0627\u0631\u062F\u06D5\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A: \u0686\u0627\u0648\u06D5\u0695\u0648\u0627\u0646\u06A9\u0631\u0627\u0648\u06D5 \u06CC\u06D5\u06A9\u06CE\u06A9 \u0628\u06CE\u062A \u0644\u06D5 ${joinValues(issue2.values, "|")}`;
case "too_big": {
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 \u0628\u06D5 \u0644\u0627\u06CC\u06D5\u0646\u06CC \u0632\u06C6\u0631\u06D5\u0648\u06D5 ${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
return `\u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 \u0628\u06D5 \u0644\u0627\u06CC\u06D5\u0646\u06CC \u0632\u06C6\u0631\u06D5\u0648\u06D5 ${issue2.maximum.toString()} \u0628\u06CE\u062A`;
}
case "too_small": {
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 \u0628\u06D5 \u0644\u0627\u06CC\u06D5\u0646\u06CC \u06A9\u06D5\u0645\u06D5\u0648\u06D5 ${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
return `\u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 \u0628\u06D5 \u0644\u0627\u06CC\u06D5\u0646\u06CC \u06A9\u06D5\u0645\u06D5\u0648\u06D5 ${issue2.minimum.toString()} \u0628\u06CE\u062A`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with") {
return `\u062F\u06D5\u0642\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A: \u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 \u062F\u06D5\u0633\u062A\u067E\u06CE\u0628\u06A9\u0627\u062A \u0628\u06D5 "${_issue.prefix}"`;
}
if (_issue.format === "ends_with")
return `\u062F\u06D5\u0642\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A: \u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 \u06A9\u06C6\u062A\u0627\u06CC\u06CC\u0628\u06CE\u062A \u0628\u06D5 "${_issue.suffix}"`;
if (_issue.format === "includes")
return `\u062F\u06D5\u0642\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A: \u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 "${_issue.includes}" \u0644\u06D5\u062E\u06C6\u0628\u06AF\u0631\u06CE\u062A`;
if (_issue.format === "regex")
return `\u062F\u06D5\u0642\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A: \u067E\u06CE\u0648\u06CC\u0633\u062A\u06D5 \u0644\u06D5\u06AF\u06D5\u06B5 \u067E\u0627\u062A\u06CE\u0631\u0646\u06CC ${_issue.pattern} \u0628\u06AF\u0648\u0646\u062C\u06CE\u062A`;
return `\u0628\u06D5\u0647\u0627\u06CC ${FormatDictionary[_issue.format] ?? issue2.format} \u0646\u0627\u062F\u0631\u0648\u0633\u062A\u06D5`;
}
case "not_multiple_of":
return `\u0698\u0645\u0627\u0631\u06D5\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A: \u062F\u06D5\u0628\u06CE\u062A \u0686\u06D5\u0646\u062F \u0647\u06CE\u0646\u062F\u06D5 \u0628\u06CE\u062A \u0628\u06C6 ${issue2.divisor}`;
case "unrecognized_keys":
return `\u06A9\u0644\u06CC\u0644\u06CC \u0646\u06D5\u0646\u0627\u0633\u0631\u0627\u0648: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `\u06A9\u0644\u06CC\u0644\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A \u0644\u06D5 ${issue2.origin}`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `\u0628\u06D5\u0647\u0627\u06CC \u0646\u06D5\u0646\u0627\u0633\u0631\u0627\u0648 \u0647\u06D5\u06CC\u06D5. \u0628\u06D5\u0647\u0627\u06CC \u0686\u0627\u0648\u06D5\u0695\u0648\u0627\u0646\u06A9\u0631\u0627\u0648: ${opts}`;
}
return "\u06CC\u06D5\u06A9\u06AF\u0631\u062A\u0646\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A";
case "invalid_element":
return `${issue2.origin} \u0628\u06D5\u0647\u0627\u06A9\u06D5 \u0646\u0627\u062F\u0631\u0648\u0633\u062A\u06D5`;
default:
return `\u062A\u06CE\u06A9\u0631\u062F\u06D5\u06CC \u0646\u0627\u062F\u0631\u0648\u0633\u062A`;
}
};
};
function ckb_default() {
return {
localeError: error7()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/cs.js
var error8 = () => {
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" },
map: { 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",
mac: "MAC 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",
credit_card: "\u010D\xEDslo kreditn\xED karty",
currency_code: "k\xF3d m\u011Bny",
iban: "IBAN",
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: error8()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/da.js
var error9 = () => {
const Sizable = {
string: { unit: "tegn", verb: "havde" },
file: { unit: "bytes", verb: "havde" },
array: { unit: "elementer", verb: "indeholdt" },
set: { unit: "elementer", verb: "indeholdt" },
map: { 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-adresse",
ipv6: "IPv6-adresse",
mac: "MAC-adresse",
cidrv4: "IPv4-spektrum",
cidrv6: "IPv6-spektrum",
base64: "base64-kodet streng",
base64url: "base64url-kodet streng",
json_string: "JSON-streng",
e164: "E.164-nummer",
credit_card: "kreditkortnummer",
currency_code: "valutakode",
iban: "IBAN",
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: error9()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/de.js
var error10 = () => {
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" },
map: { 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",
mac: "MAC-Adresse",
cidrv4: "IPv4-Bereich",
cidrv6: "IPv6-Bereich",
base64: "Base64-codierter String",
base64url: "Base64-URL-codierter String",
json_string: "JSON-String",
e164: "E.164-Nummer",
credit_card: "Kreditkartennummer",
currency_code: "W\xE4hrungscode",
iban: "IBAN",
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: error10()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/el.js
var error11 = () => {
const Sizable = {
string: { unit: "\u03C7\u03B1\u03C1\u03B1\u03BA\u03C4\u03AE\u03C1\u03B5\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
file: { unit: "bytes", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
array: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
set: { unit: "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" },
map: { unit: "\u03BA\u03B1\u03C4\u03B1\u03C7\u03C9\u03C1\u03AE\u03C3\u03B5\u03B9\u03C2", verb: "\u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2",
email: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1 \u03BA\u03B1\u03B9 \u03CE\u03C1\u03B1",
date: "ISO \u03B7\u03BC\u03B5\u03C1\u03BF\u03BC\u03B7\u03BD\u03AF\u03B1",
time: "ISO \u03CE\u03C1\u03B1",
duration: "ISO \u03B4\u03B9\u03AC\u03C1\u03BA\u03B5\u03B9\u03B1",
ipv4: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv4",
ipv6: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 IPv6",
mac: "\u03B4\u03B9\u03B5\u03CD\u03B8\u03C5\u03BD\u03C3\u03B7 MAC",
cidrv4: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv4",
cidrv6: "\u03B5\u03CD\u03C1\u03BF\u03C2 IPv6",
base64: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64",
base64url: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC \u03BA\u03C9\u03B4\u03B9\u03BA\u03BF\u03C0\u03BF\u03B9\u03B7\u03BC\u03AD\u03BD\u03B7 \u03C3\u03B5 base64url",
json_string: "\u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC JSON",
e164: "\u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2 E.164",
credit_card: "\u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2 \u03C0\u03B9\u03C3\u03C4\u03C9\u03C4\u03B9\u03BA\u03AE\u03C2 \u03BA\u03AC\u03C1\u03C4\u03B1\u03C2",
currency_code: "\u03BA\u03C9\u03B4\u03B9\u03BA\u03CC\u03C2 \u03BD\u03BF\u03BC\u03AF\u03C3\u03BC\u03B1\u03C4\u03BF\u03C2",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2"
};
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 (typeof issue2.expected === "string" && /^[A-Z]/.test(issue2.expected)) {
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD instanceof ${issue2.expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
}
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${expected}, \u03BB\u03AE\u03C6\u03B8\u03B7\u03BA\u03B5 ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${stringifyPrimitive(issue2.values[0])}`;
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03C0\u03B9\u03BB\u03BF\u03B3\u03AE: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD \u03AD\u03BD\u03B1 \u03B1\u03C0\u03CC ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u03C3\u03C4\u03BF\u03B9\u03C7\u03B5\u03AF\u03B1"}`;
return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B5\u03B3\u03AC\u03BB\u03BF: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin ?? "\u03C4\u03B9\u03BC\u03AE"} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03AD\u03C7\u03B5\u03B9 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
}
return `\u03A0\u03BF\u03BB\u03CD \u03BC\u03B9\u03BA\u03C1\u03CC: \u03B1\u03BD\u03B1\u03BC\u03B5\u03BD\u03CC\u03C4\u03B1\u03BD ${issue2.origin} \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 ${adj}${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with") {
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03BE\u03B5\u03BA\u03B9\u03BD\u03AC \u03BC\u03B5 "${_issue.prefix}"`;
}
if (_issue.format === "ends_with")
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B5\u03BB\u03B5\u03B9\u03CE\u03BD\u03B5\u03B9 \u03BC\u03B5 "${_issue.suffix}"`;
if (_issue.format === "includes")
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C0\u03B5\u03C1\u03B9\u03AD\u03C7\u03B5\u03B9 "${_issue.includes}"`;
if (_issue.format === "regex")
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C3\u03C5\u03BC\u03B2\u03BF\u03BB\u03BF\u03C3\u03B5\u03B9\u03C1\u03AC: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03C4\u03B1\u03B9\u03C1\u03B9\u03AC\u03B6\u03B5\u03B9 \u03BC\u03B5 \u03C4\u03BF \u03BC\u03BF\u03C4\u03AF\u03B2\u03BF ${_issue.pattern}`;
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF: ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF\u03C2 \u03B1\u03C1\u03B9\u03B8\u03BC\u03CC\u03C2: \u03C0\u03C1\u03AD\u03C0\u03B5\u03B9 \u03BD\u03B1 \u03B5\u03AF\u03BD\u03B1\u03B9 \u03C0\u03BF\u03BB\u03BB\u03B1\u03C0\u03BB\u03AC\u03C3\u03B9\u03BF \u03C4\u03BF\u03C5 ${issue2.divisor}`;
case "unrecognized_keys":
return `\u0386\u03B3\u03BD\u03C9\u03C3\u03C4${issue2.keys.length > 1 ? "\u03B1" : "\u03BF"} \u03BA\u03BB\u03B5\u03B9\u03B4${issue2.keys.length > 1 ? "\u03B9\u03AC" : "\u03AF"}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03BF \u03BA\u03BB\u03B5\u03B9\u03B4\u03AF \u03C3\u03C4\u03BF ${issue2.origin}`;
case "invalid_union":
return "\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2";
case "invalid_element":
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03C4\u03B9\u03BC\u03AE \u03C3\u03C4\u03BF ${issue2.origin}`;
default:
return `\u039C\u03B7 \u03AD\u03B3\u03BA\u03C5\u03C1\u03B7 \u03B5\u03AF\u03C3\u03BF\u03B4\u03BF\u03C2`;
}
};
};
function el_default() {
return {
localeError: error11()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/en.js
var error12 = () => {
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",
currency_code: "currency code",
credit_card: "credit card number",
iban: "IBAN",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = {
// Compatibility: "nan" -> "NaN" for display
nan: "NaN"
// All other type names omitted - they fall back to raw values via ?? operator
};
function getTypeName(type, input2) {
if (type === "number" && typeof input2 === "number" && !Number.isFinite(input2)) {
return String(input2);
}
return TypeDictionary[type] ?? type;
}
return (issue2) => {
switch (issue2.code) {
case "invalid_type": {
const expected = getTypeName(issue2.expected);
const receivedType = parsedType(issue2.input);
const received = getTypeName(receivedType, issue2.input);
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.exact ? "exactly " : 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.exact ? "exactly " : 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":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `Invalid discriminator value. Expected ${opts}`;
}
if (issue2.inclusive === false) {
return "Invalid input: more than one option matched";
}
return "Invalid input";
case "invalid_element":
return `Invalid value in ${issue2.origin}`;
default:
return `Invalid input`;
}
};
};
function en_default() {
return {
localeError: error12()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/eo.js
var error13 = () => {
const Sizable = {
string: { unit: "karaktrojn", verb: "havi" },
file: { unit: "bajtojn", verb: "havi" },
array: { unit: "elementojn", verb: "havi" },
set: { unit: "elementojn", verb: "havi" },
map: { 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",
mac: "MAC-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",
credit_card: "kreditkarta numero",
currency_code: "valuta kodo",
iban: "IBAN",
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: error13()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/es.js
var error14 = () => {
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",
mac: "direcci\xF3n MAC",
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",
credit_card: "n\xFAmero de tarjeta de cr\xE9dito",
currency_code: "c\xF3digo de moneda",
iban: "IBAN",
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: error14()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/fa.js
var error15 = () => {
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" },
map: { 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",
mac: "MAC \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",
credit_card: "\u0634\u0645\u0627\u0631\u0647 \u06A9\u0627\u0631\u062A \u0627\u0639\u062A\u0628\u0627\u0631\u06CC",
currency_code: "\u06A9\u062F \u0627\u0631\u0632",
iban: "IBAN",
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: error15()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/fi.js
var error16 = () => {
const Sizable = {
string: { unit: "merkki\xE4", subject: "merkkijonon" },
file: { unit: "tavua", subject: "tiedoston" },
array: { unit: "alkiota", subject: "listan" },
set: { unit: "alkiota", subject: "joukon" },
map: { unit: "alkiota", subject: "kuvauksen" },
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",
mac: "MAC-osoite",
cidrv4: "IPv4-alue",
cidrv6: "IPv6-alue",
base64: "base64-koodattu merkkijono",
base64url: "base64url-koodattu merkkijono",
json_string: "JSON-merkkijono",
e164: "E.164-luku",
credit_card: "luottokortin numero",
currency_code: "valuuttakoodi",
iban: "IBAN",
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: error16()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/fr.js
var error17 = () => {
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: "expression r\xE9guli\xE8re",
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",
mac: "adresse MAC",
cidrv4: "plage IPv4",
cidrv6: "plage IPv6",
base64: "cha\xEEne de caract\xE8res encod\xE9e en base64",
base64url: "cha\xEEne de caract\xE8res encod\xE9e en base64url",
json_string: "cha\xEEne de caract\xE8res JSON",
e164: "num\xE9ro au format E.164",
credit_card: "num\xE9ro de carte de cr\xE9dit",
currency_code: "code de devise",
iban: "IBAN",
jwt: "JWT",
template_literal: "entr\xE9e"
};
const TypeDictionary = {
string: "cha\xEEne de caract\xE8res",
number: "nombre",
int: "entier",
boolean: "bool\xE9en",
bigint: "grand entier",
symbol: "symbole",
undefined: "ind\xE9fini",
null: "null",
never: "jamais",
void: "vide",
date: "date",
array: "tableau",
object: "objet",
tuple: "tuple",
record: "record",
map: "map",
set: "ensemble",
file: "fichier",
nonoptional: "non optionnel",
nan: "NaN",
function: "fonction"
};
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 : instance de ${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 : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
return `Trop grand : ${TypeDictionary[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 : ${TypeDictionary[issue2.origin] ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
return `Trop petit : ${TypeDictionary[issue2.origin] ?? "valeur"} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `Cha\xEEne de caract\xE8res invalide : doit commencer par "${_issue.prefix}"`;
if (_issue.format === "ends_with")
return `Cha\xEEne de caract\xE8res invalide : doit se terminer par "${_issue.suffix}"`;
if (_issue.format === "includes")
return `Cha\xEEne de caract\xE8res invalide : doit inclure "${_issue.includes}"`;
if (_issue.format === "regex")
return `Cha\xEEne de caract\xE8res 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_default() {
return {
localeError: error17()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/fr-CA.js
var error18 = () => {
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" },
map: { 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",
mac: "adresse MAC",
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",
credit_card: "num\xE9ro de carte de cr\xE9dit",
currency_code: "code de devise",
iban: "IBAN",
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: error18()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/gu.js
var error19 = () => {
const Sizable = {
string: { unit: "\u0A85\u0A95\u0ACD\u0AB7\u0AB0", verb: "\u0AB9\u0ACB\u0AB5\u0ABE \u0A9C\u0ACB\u0A88\u0A8F" },
file: { unit: "\u0AAC\u0ABE\u0AAF\u0A9F", verb: "\u0AB9\u0ACB\u0AB5\u0ABE \u0A9C\u0ACB\u0A88\u0A8F" },
array: { unit: "\u0A86\u0A87\u0A9F\u0AAE", verb: "\u0AB9\u0ACB\u0AB5\u0ABE \u0A9C\u0ACB\u0A88\u0A8F" },
set: { unit: "\u0A86\u0A87\u0A9F\u0AAE", verb: "\u0AB9\u0ACB\u0AB5\u0ABE \u0A9C\u0ACB\u0A88\u0A8F" },
map: { unit: "\u0A8F\u0AA8\u0ACD\u0A9F\u0ACD\u0AB0\u0AC0", verb: "\u0AB9\u0ACB\u0AB5\u0ABE \u0A9C\u0ACB\u0A88\u0A8F" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "\u0A87\u0AA8\u0AAA\u0AC1\u0A9F",
email: "\u0A88\u0AAE\u0AC7\u0A87\u0AB2 \u0A8F\u0AA1\u0ACD\u0AB0\u0AC7\u0AB8",
url: "URL",
emoji: "\u0A87\u0AAE\u0ACB\u0A9C\u0AC0",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO \u0AA4\u0ABE\u0AB0\u0AC0\u0A96 \u0A85\u0AA8\u0AC7 \u0AB8\u0AAE\u0AAF",
date: "ISO \u0AA4\u0ABE\u0AB0\u0AC0\u0A96",
time: "ISO \u0AB8\u0AAE\u0AAF",
duration: "ISO \u0A85\u0AB5\u0AA7\u0ABF",
ipv4: "IPv4 \u0A8F\u0AA1\u0ACD\u0AB0\u0AC7\u0AB8",
ipv6: "IPv6 \u0A8F\u0AA1\u0ACD\u0AB0\u0AC7\u0AB8",
mac: "MAC \u0A8F\u0AA1\u0ACD\u0AB0\u0AC7\u0AB8",
cidrv4: "IPv4 \u0AB6\u0ACD\u0AB0\u0AC7\u0AA3\u0AC0",
cidrv6: "IPv6 \u0AB6\u0ACD\u0AB0\u0AC7\u0AA3\u0AC0",
base64: "base64-\u0A8F\u0AA8\u0ACD\u0A95\u0ACB\u0AA1\u0AC7\u0AA1 \u0AB8\u0ACD\u0A9F\u0ACD\u0AB0\u0ABF\u0A82\u0A97",
base64url: "base64url-\u0A8F\u0AA8\u0ACD\u0A95\u0ACB\u0AA1\u0AC7\u0AA1 \u0AB8\u0ACD\u0A9F\u0ACD\u0AB0\u0ABF\u0A82\u0A97",
json_string: "JSON \u0AB8\u0ACD\u0A9F\u0ACD\u0AB0\u0ABF\u0A82\u0A97",
e164: "E.164 \u0AA8\u0A82\u0AAC\u0AB0",
credit_card: "\u0A95\u0ACD\u0AB0\u0AC7\u0AA1\u0ABF\u0A9F \u0A95\u0ABE\u0AB0\u0ACD\u0AA1 \u0AA8\u0A82\u0AAC\u0AB0",
currency_code: "\u0A9A\u0AB2\u0AA3 \u0A95\u0ACB\u0AA1",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u0A87\u0AA8\u0AAA\u0AC1\u0A9F"
};
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 `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0A87\u0AA8\u0AAA\u0AC1\u0A9F: \u0A85\u0AAA\u0AC7\u0A95\u0ACD\u0AB7\u0ABF\u0AA4 ${expected}, \u0AAA\u0ACD\u0AB0\u0ABE\u0AAA\u0ACD\u0AA4 ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0A87\u0AA8\u0AAA\u0AC1\u0A9F: \u0A85\u0AAA\u0AC7\u0A95\u0ACD\u0AB7\u0ABF\u0AA4 ${stringifyPrimitive(issue2.values[0])}`;
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AB5\u0ABF\u0A95\u0AB2\u0ACD\u0AAA: ${joinValues(issue2.values, " | ")} \u0AAE\u0ABE\u0AA7\u0ACD\u0AAF\u0AAE\u0AA5\u0AC0 \u0A8F\u0A95 \u0A85\u0AAA\u0AC7\u0A95\u0ACD\u0AB7\u0ABF\u0AA4`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u0A96\u0AC2\u0AAC \u0AAE\u0ACB\u0A9F\u0AC1\u0A82: ${issue2.origin ?? "\u0AAE\u0AC2\u0AB2\u0ACD\u0AAF"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0A8F\u0AB2\u0ABF\u0AAE\u0AC7\u0AA8\u0ACD\u0A9F"} \u0AB9\u0ACB\u0AB5\u0ABE \u0A9C\u0ACB\u0A88\u0A8F`;
return `\u0A96\u0AC2\u0AAC \u0AAE\u0ACB\u0A9F\u0AC1\u0A82: ${issue2.origin ?? "\u0AAE\u0AC2\u0AB2\u0ACD\u0AAF"} ${adj}${issue2.maximum.toString()} \u0AB9\u0ACB\u0AB5\u0AC1\u0A82 \u0A9C\u0ACB\u0A88\u0A8F`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `\u0A96\u0AC2\u0AAC \u0AA8\u0ABE\u0AA8\u0AC1\u0A82: ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0AB9\u0ACB\u0AB5\u0ABE \u0A9C\u0ACB\u0A88\u0A8F`;
}
return `\u0A96\u0AC2\u0AAC \u0AA8\u0ABE\u0AA8\u0AC1\u0A82: ${issue2.origin} ${adj}${issue2.minimum.toString()} \u0AB9\u0ACB\u0AB5\u0AC1\u0A82 \u0A9C\u0ACB\u0A88\u0A8F`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with") {
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AB8\u0ACD\u0A9F\u0ACD\u0AB0\u0ABF\u0A82\u0A97: "${_issue.prefix}" \u0AA5\u0AC0 \u0AB6\u0AB0\u0AC2 \u0AA5\u0AB5\u0AC1\u0A82 \u0A9C\u0ACB\u0A88\u0A8F`;
}
if (_issue.format === "ends_with")
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AB8\u0ACD\u0A9F\u0ACD\u0AB0\u0ABF\u0A82\u0A97: "${_issue.suffix}" \u0AAA\u0AB0 \u0AB8\u0AAE\u0ABE\u0AAA\u0ACD\u0AA4 \u0AA5\u0AB5\u0AC1\u0A82 \u0A9C\u0ACB\u0A88\u0A8F`;
if (_issue.format === "includes")
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AB8\u0ACD\u0A9F\u0ACD\u0AB0\u0ABF\u0A82\u0A97: "${_issue.includes}" \u0AB6\u0ABE\u0AAE\u0AC7\u0AB2 \u0AB9\u0ACB\u0AB5\u0AC1\u0A82 \u0A9C\u0ACB\u0A88\u0A8F`;
if (_issue.format === "regex")
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AB8\u0ACD\u0A9F\u0ACD\u0AB0\u0ABF\u0A82\u0A97: \u0AAA\u0AC7\u0A9F\u0AB0\u0ACD\u0AA8 ${_issue.pattern} \u0AB8\u0ABE\u0AA5\u0AC7 \u0AAE\u0AC7\u0AB3 \u0A96\u0ABE\u0AB5\u0AC1\u0A82 \u0A9C\u0ACB\u0A88\u0A8F`;
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AA8\u0A82\u0AAC\u0AB0: ${issue2.divisor} \u0AA8\u0ACB \u0A97\u0AC1\u0AA3\u0ABE\u0A82\u0A95 \u0AB9\u0ACB\u0AB5\u0ACB \u0A9C\u0ACB\u0A88\u0A8F`;
case "unrecognized_keys":
return `\u0A93\u0AB3\u0A96\u0AC0 \u0AB6\u0A95\u0ABE\u0AA4\u0ABE \u0AA8\u0AB9\u0AC0\u0A82 \u0AA4\u0AC7 \u0A95\u0AC0${issue2.keys.length > 1 ? "\u0A93" : ""}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `${issue2.origin} \u0AAE\u0ABE\u0A82 \u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0A95\u0AC0`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AA1\u0ABF\u0AB8\u0ACD\u0A95\u0ACD\u0AB0\u0ABF\u0AAE\u0ABF\u0AA8\u0AC7\u0A9F\u0AB0 \u0AAE\u0AC2\u0AB2\u0ACD\u0AAF. \u0A85\u0AAA\u0AC7\u0A95\u0ACD\u0AB7\u0ABF\u0AA4 ${opts}`;
}
return "\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0A87\u0AA8\u0AAA\u0AC1\u0A9F";
case "invalid_element":
return `${issue2.origin} \u0AAE\u0ABE\u0A82 \u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0AAE\u0AC2\u0AB2\u0ACD\u0AAF`;
default:
return "\u0A85\u0AAE\u0ABE\u0AA8\u0ACD\u0AAF \u0A87\u0AA8\u0AAA\u0AC1\u0A9F";
}
};
};
function gu_default() {
return {
localeError: error19()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/he.js
var error20 = () => {
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" }
// no unit
};
const typeEntry = (t) => t ? TypeNames[t] : void 0;
const typeLabel = (t) => {
const e = typeEntry(t);
if (e)
return e.label;
return t ?? TypeNames.unknown.label;
};
const withDefinite = (t) => `\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" },
uuidv4: { label: "UUIDv4", gender: "m" },
uuidv6: { label: "UUIDv6", 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" },
mac: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA MAC", 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" },
credit_card: { label: "\u05DE\u05E1\u05E4\u05E8 \u05DB\u05E8\u05D8\u05D9\u05E1 \u05D0\u05E9\u05E8\u05D0\u05D9", gender: "m" },
currency_code: { label: "\u05E7\u05D5\u05D3 \u05DE\u05D8\u05D1\u05E2", gender: "m" },
iban: { label: "IBAN", gender: "m" },
jwt: { label: "JWT", gender: "m" },
template_literal: { label: "\u05E7\u05DC\u05D8", 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: error20()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/hi.js
var error21 = () => {
const Sizable = {
string: { unit: "\u0905\u0915\u094D\u0937\u0930", verb: "\u0930\u0916\u0928\u0947 \u0915\u0947 \u0932\u093F\u090F" },
file: { unit: "\u092C\u093E\u0907\u091F\u094D\u0938", verb: "\u0930\u0916\u0928\u0947 \u0915\u0947 \u0932\u093F\u090F" },
array: { unit: "\u0924\u0924\u094D\u0935", verb: "\u0930\u0916\u0928\u0947 \u0915\u0947 \u0932\u093F\u090F" },
set: { unit: "\u0924\u0924\u094D\u0935", verb: "\u0930\u0916\u0928\u0947 \u0915\u0947 \u0932\u093F\u090F" },
map: { unit: "\u092A\u094D\u0930\u0935\u093F\u0937\u094D\u091F\u093F\u092F\u093E\u0901", verb: "\u0930\u0916\u0928\u0947 \u0915\u0947 \u0932\u093F\u090F" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "\u0907\u0928\u092A\u0941\u091F",
email: "\u0908\u092E\u0947\u0932 \u092A\u0924\u093E",
url: "URL",
emoji: "\u0907\u092E\u094B\u091C\u0940",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO \u0924\u093F\u0925\u093F \u0914\u0930 \u0938\u092E\u092F",
date: "ISO \u0924\u093F\u0925\u093F",
time: "ISO \u0938\u092E\u092F",
duration: "ISO \u0905\u0935\u0927\u093F",
ipv4: "IPv4 \u092A\u0924\u093E",
ipv6: "IPv6 \u092A\u0924\u093E",
mac: "MAC \u092A\u0924\u093E",
cidrv4: "IPv4 \u0936\u094D\u0930\u0947\u0923\u0940",
cidrv6: "IPv6 \u0936\u094D\u0930\u0947\u0923\u0940",
base64: "Base64-\u090F\u0928\u094D\u0915\u094B\u0921\u0947\u0921 \u0938\u094D\u091F\u094D\u0930\u093F\u0902\u0917",
base64url: "Base64URL-\u090F\u0928\u094D\u0915\u094B\u0921\u0947\u0921 \u0938\u094D\u091F\u094D\u0930\u093F\u0902\u0917",
json_string: "JSON \u0938\u094D\u091F\u094D\u0930\u093F\u0902\u0917",
e164: "E.164 \u0938\u0902\u0916\u094D\u092F\u093E",
credit_card: "\u0915\u094D\u0930\u0947\u0921\u093F\u091F \u0915\u093E\u0930\u094D\u0921 \u0938\u0902\u0916\u094D\u092F\u093E",
currency_code: "\u092E\u0941\u0926\u094D\u0930\u093E \u0915\u094B\u0921",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u0907\u0928\u092A\u0941\u091F"
};
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 `\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 ${expected}, \u092A\u094D\u0930\u093E\u092A\u094D\u0924 ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 ${stringifyPrimitive(issue2.values[0])}`;
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0935\u093F\u0915\u0932\u094D\u092A: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 \u092E\u093E\u0928\u094B\u0902 \u092E\u0947\u0902 \u0938\u0947 \u090F\u0915 ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u092C\u0939\u0941\u0924 \u092C\u0921\u093C\u093E: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 \u0925\u093E \u0915\u093F ${issue2.origin ?? "\u092E\u093E\u0928"} \u092E\u0947\u0902 ${adj}${issue2.maximum} ${sizing.unit} \u0939\u094B\u0902`;
return `\u092C\u0939\u0941\u0924 \u092C\u0921\u093C\u093E: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 \u0925\u093E \u0915\u093F ${issue2.origin ?? "\u092E\u093E\u0928"} ${adj}${issue2.maximum} \u0939\u094B`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u092C\u0939\u0941\u0924 \u091B\u094B\u091F\u093E: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 \u0925\u093E \u0915\u093F ${issue2.origin} \u092E\u0947\u0902 ${adj}${issue2.minimum} ${sizing.unit} \u0939\u094B\u0902`;
return `\u092C\u0939\u0941\u0924 \u091B\u094B\u091F\u093E: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 \u0925\u093E \u0915\u093F ${issue2.origin} ${adj}${issue2.minimum} \u0939\u094B`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0902\u0917: "${_issue.prefix}" \u0938\u0947 \u0936\u0941\u0930\u0942 \u0939\u094B\u0928\u093E \u091A\u093E\u0939\u093F\u090F`;
if (_issue.format === "ends_with")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0902\u0917: "${_issue.suffix}" \u092A\u0930 \u0938\u092E\u093E\u092A\u094D\u0924 \u0939\u094B\u0928\u093E \u091A\u093E\u0939\u093F\u090F`;
if (_issue.format === "includes")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0902\u0917: \u0907\u0938\u092E\u0947\u0902 "${_issue.includes}" \u0936\u093E\u092E\u093F\u0932 \u0939\u094B\u0928\u093E \u091A\u093E\u0939\u093F\u090F`;
if (_issue.format === "regex")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0902\u0917: \u092A\u0948\u091F\u0930\u094D\u0928 ${_issue.pattern} \u0938\u0947 \u092E\u0947\u0932 \u0916\u093E\u0928\u093E \u091A\u093E\u0939\u093F\u090F`;
return `\u0905\u092E\u093E\u0928\u094D\u092F ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u0902\u0916\u094D\u092F\u093E: \u092F\u0939 ${issue2.divisor} \u0915\u093E \u0917\u0941\u0923\u091C \u0939\u094B\u0928\u093E \u091A\u093E\u0939\u093F\u090F`;
case "unrecognized_keys":
return `\u0905\u092A\u0930\u093F\u091A\u093F\u0924 \u0915\u0941\u0902\u091C\u0940${issue2.keys.length > 1 ? "\u092F\u093E\u0901" : ""}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0915\u0941\u0902\u091C\u0940: ${issue2.origin} \u092E\u0947\u0902`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0921\u093F\u0938\u094D\u0915\u094D\u0930\u093F\u092E\u093F\u0928\u0947\u091F\u0930 \u092E\u093E\u0928: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 ${opts}`;
}
return "\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F";
case "invalid_element":
return `\u0905\u092E\u093E\u0928\u094D\u092F \u092E\u093E\u0928: ${issue2.origin} \u092E\u0947\u0902`;
default:
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F`;
}
};
};
function hi_default() {
return {
localeError: error21()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/hr.js
var error22 = () => {
const Sizable = {
string: { unit: "znakova", verb: "imati" },
file: { unit: "bajtova", verb: "imati" },
array: { unit: "stavki", verb: "imati" },
set: { unit: "stavki", verb: "imati" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "unos",
email: "email adresa",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO datum i vrijeme",
date: "ISO datum",
time: "ISO vrijeme",
duration: "ISO trajanje",
ipv4: "IPv4 adresa",
ipv6: "IPv6 adresa",
mac: "MAC adresa",
cidrv4: "IPv4 raspon",
cidrv6: "IPv6 raspon",
base64: "base64 kodirani tekst",
base64url: "base64url kodirani tekst",
json_string: "JSON tekst",
e164: "E.164 broj",
credit_card: "broj kreditne kartice",
currency_code: "kod valute",
iban: "IBAN",
jwt: "JWT",
template_literal: "unos"
};
const TypeDictionary = {
nan: "NaN",
string: "tekst",
number: "broj",
boolean: "boolean",
array: "niz",
object: "objekt",
set: "skup",
file: "datoteka",
date: "datum",
bigint: "bigint",
symbol: "simbol",
undefined: "undefined",
null: "null",
function: "funkcija",
map: "mapa"
};
return (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 `Neispravan unos: o\u010Dekuje se instanceof ${issue2.expected}, a primljeno je ${received}`;
}
return `Neispravan unos: o\u010Dekuje se ${expected}, a primljeno je ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `Neispravna vrijednost: o\u010Dekivano ${stringifyPrimitive(issue2.values[0])}`;
return `Neispravna opcija: o\u010Dekivano jedno od ${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 `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} ima ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemenata"}`;
return `Preveliko: o\u010Dekivano da ${origin ?? "vrijednost"} bude ${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 `Premalo: o\u010Dekivano da ${origin} ima ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
}
return `Premalo: o\u010Dekivano da ${origin} bude ${adj}${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `Neispravan tekst: mora zapo\u010Dinjati s "${_issue.prefix}"`;
if (_issue.format === "ends_with")
return `Neispravan tekst: mora zavr\u0161avati s "${_issue.suffix}"`;
if (_issue.format === "includes")
return `Neispravan tekst: mora sadr\u017Eavati "${_issue.includes}"`;
if (_issue.format === "regex")
return `Neispravan tekst: mora odgovarati uzorku ${_issue.pattern}`;
return `Neispravna ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `Neispravan broj: mora biti vi\u0161ekratnik od ${issue2.divisor}`;
case "unrecognized_keys":
return `Neprepoznat${issue2.keys.length > 1 ? "i klju\u010Devi" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `Neispravan klju\u010D u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
case "invalid_union":
return "Neispravan unos";
case "invalid_element":
return `Neispravna vrijednost u ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
default:
return `Neispravan unos`;
}
};
};
function hr_default() {
return {
localeError: error22()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/hu.js
var error23 = () => {
const Sizable = {
string: { unit: "karakter", verb: "legyen" },
file: { unit: "byte", verb: "legyen" },
array: { unit: "elem", verb: "legyen" },
set: { unit: "elem", verb: "legyen" },
map: { 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",
mac: "MAC 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",
credit_card: "hitelk\xE1rtyasz\xE1m",
currency_code: "p\xE9nznemk\xF3d",
iban: "IBAN",
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: error23()
};
}
// node_modules/.pnpm/zod@4.6.7/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 error24 = () => {
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"
},
map: {
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",
mac: "MAC \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",
credit_card: "\u056F\u0580\u0565\u0564\u056B\u057F \u0584\u0561\u0580\u057F\u056B \u0570\u0561\u0574\u0561\u0580",
currency_code: "\u0561\u0580\u056A\u0578\u0582\u0575\u0569\u056B \u056F\u0578\u0564",
iban: "IBAN",
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: error24()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/id.js
var error25 = () => {
const Sizable = {
string: { unit: "karakter", verb: "memiliki" },
file: { unit: "byte", verb: "memiliki" },
array: { unit: "item", verb: "memiliki" },
set: { unit: "item", verb: "memiliki" },
map: { 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",
mac: "alamat MAC",
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",
credit_card: "nomor kartu kredit",
currency_code: "kode mata uang",
iban: "IBAN",
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: error25()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/is.js
var error26 = () => {
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" },
map: { 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",
mac: "MAC address",
cidrv4: "IPv4 range",
cidrv6: "IPv6 range",
base64: "base64-encoded strengur",
base64url: "base64url-encoded strengur",
json_string: "JSON strengur",
e164: "E.164 t\xF6lugildi",
credit_card: "kreditkortan\xFAmer",
currency_code: "gjaldmi\xF0ilsk\xF3\xF0i",
iban: "IBAN",
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: error26()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/it.js
var error27 = () => {
const Sizable = {
string: { unit: "caratteri", verb: "avere" },
file: { unit: "byte", verb: "avere" },
array: { unit: "elementi", verb: "avere" },
set: { unit: "elementi", verb: "avere" },
map: { 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",
mac: "indirizzo MAC",
cidrv4: "intervallo IPv4",
cidrv6: "intervallo IPv6",
base64: "stringa codificata in base64",
base64url: "URL codificata in base64",
json_string: "stringa JSON",
e164: "numero E.164",
credit_card: "numero di carta di credito",
currency_code: "codice valuta",
iban: "IBAN",
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 `Input non valido: ${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: error27()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ja.js
var error28 = () => {
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" },
map: { 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",
mac: "MAC\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",
credit_card: "\u30AF\u30EC\u30B8\u30C3\u30C8\u30AB\u30FC\u30C9\u756A\u53F7",
currency_code: "\u901A\u8CA8\u30B3\u30FC\u30C9",
iban: "IBAN",
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: error28()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ka.js
var error29 = () => {
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" },
map: { 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",
mac: "MAC \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 \u10D5\u10D4\u10DA\u10D8",
base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10D5\u10D4\u10DA\u10D8",
json_string: "JSON \u10D5\u10D4\u10DA\u10D8",
e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
credit_card: "\u10E1\u10D0\u10D9\u10E0\u10D4\u10D3\u10D8\u10E2\u10DD \u10D1\u10D0\u10E0\u10D0\u10D7\u10D8\u10E1 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
currency_code: "\u10D5\u10D0\u10DA\u10E3\u10E2\u10D8\u10E1 \u10D9\u10DD\u10D3\u10D8",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
};
const TypeDictionary = {
nan: "NaN",
number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
string: "\u10D5\u10D4\u10DA\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 \u10D5\u10D4\u10DA\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 \u10D5\u10D4\u10DA\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 \u10D5\u10D4\u10DA\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 \u10D5\u10D4\u10DA\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
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: error29()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/km.js
var error30 = () => {
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" },
map: { 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",
mac: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 MAC",
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",
credit_card: "\u179B\u17C1\u1781\u1794\u17D0\u178E\u17D2\u178E\u17A5\u178E\u1791\u17B6\u1793",
currency_code: "\u1780\u17BC\u178A\u179A\u17BC\u1794\u17B7\u1799\u1794\u17D0\u178E\u17D2\u178E",
iban: "IBAN",
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: error30()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/kh.js
function kh_default() {
return km_default();
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/kn.js
var error31 = () => {
const Sizable = {
string: { unit: "\u0C85\u0C95\u0CCD\u0CB7\u0CB0\u0C97\u0CB3\u0CC1", verb: "\u0CB9\u0CCA\u0C82\u0CA6\u0CB2\u0CC1" },
file: { unit: "\u0CAC\u0CC8\u0C9F\u0CCD\u200C\u0C97\u0CB3\u0CC1", verb: "\u0CB9\u0CCA\u0C82\u0CA6\u0CB2\u0CC1" },
array: { unit: "\u0CB5\u0CB8\u0CCD\u0CA4\u0CC1\u0C97\u0CB3\u0CC1", verb: "\u0CB9\u0CCA\u0C82\u0CA6\u0CB2\u0CC1" },
set: { unit: "\u0CB5\u0CB8\u0CCD\u0CA4\u0CC1\u0C97\u0CB3\u0CC1", verb: "\u0CB9\u0CCA\u0C82\u0CA6\u0CB2\u0CC1" },
map: { unit: "entries", verb: "\u0CB9\u0CCA\u0C82\u0CA6\u0CB2\u0CC1" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "\u0C87\u0CA8\u0CCD\u0CAA\u0CC1\u0C9F\u0CCD",
email: "email \u0CB5\u0CBF\u0CB3\u0CBE\u0CB8",
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 \u0CA6\u0CBF\u0CA8\u0CBE\u0C82\u0C95\u0CA6 \u0CB8\u0CAE\u0CAF",
date: "ISO \u0CA6\u0CBF\u0CA8\u0CBE\u0C82\u0C95",
time: "ISO \u0CB8\u0CAE\u0CAF",
duration: "ISO \u0C85\u0CB5\u0CA7\u0CBF",
ipv4: "IPv4 \u0CB5\u0CBF\u0CB3\u0CBE\u0CB8",
ipv6: "IPv6 \u0CB5\u0CBF\u0CB3\u0CBE\u0CB8",
mac: "MAC \u0CB5\u0CBF\u0CB3\u0CBE\u0CB8",
cidrv4: "IPv4 \u0CB5\u0CCD\u0CAF\u0CBE\u0CAA\u0CCD\u0CA4\u0CBF\u0CAF",
cidrv6: "IPv6 \u0CB5\u0CCD\u0CAF\u0CBE\u0CAA\u0CCD\u0CA4\u0CBF\u0CAF",
base64: "base64-encoded\u0CB8\u0CCD\u0C9F\u0CCD\u0CB0\u0CBF\u0C82\u0C97\u0CCD",
base64url: "base64url-encoded\u0CB8\u0CCD\u0C9F\u0CCD\u0CB0\u0CBF\u0C82\u0C97\u0CCD",
json_string: "JSON\u0CB8\u0CCD\u0C9F\u0CCD\u0CB0\u0CBF\u0C82\u0C97\u0CCD",
e164: "E.164 \u0CB8\u0C82\u0C96\u0CCD\u0CAF\u0CC6",
credit_card: "\u0C95\u0CCD\u0CB0\u0CC6\u0CA1\u0CBF\u0C9F\u0CCD \u0C95\u0CBE\u0CB0\u0CCD\u0CA1\u0CCD \u0CB8\u0C82\u0C96\u0CCD\u0CAF\u0CC6",
currency_code: "\u0C95\u0CB0\u0CC6\u0CA8\u0CCD\u0CB8\u0CBF \u0C95\u0CCB\u0CA1\u0CCD",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u0C87\u0CA8\u0CCD\u0CAA\u0CC1\u0C9F\u0CCD"
};
const TypeDictionary = {
// Compatibility: "nan" -> "NaN" for display
nan: "NaN"
// All other type names omitted - they fall back to raw values via ?? operator
};
return (issue2) => {
switch (issue2.code) {
case "invalid_type": {
const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
const receivedType = parsedType(issue2.input);
const received = TypeDictionary[receivedType] ?? receivedType;
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0C87\u0CA8\u0CCD\u200C\u0CAA\u0CC1\u0C9F\u0CCD: \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${expected}, \u0CB8\u0CCD\u0CB5\u0CC0\u0C95\u0CB0\u0CBF\u0CB8\u0CBF\u0CA6\u0CA8\u0CC1 ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0C87\u0CA8\u0CCD\u200C\u0CAA\u0CC1\u0C9F\u0CCD: \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${stringifyPrimitive(issue2.values[0])}`;
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0C86\u0CAF\u0CCD\u0C95\u0CC6: \u0C87\u0CB5\u0CC1\u0C97\u0CB3\u0CB2\u0CCD\u0CB2\u0CBF \u0C92\u0C82\u0CA6\u0CA8\u0CCD\u0CA8\u0CC1 \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u0CA4\u0CC1\u0C82\u0CAC\u0CBE \u0CA6\u0CCA\u0CA1\u0CCD\u0CA1\u0CA6\u0CC1: \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${issue2.origin ?? "value"} \u0CB9\u0CCA\u0C82\u0CA6\u0CB2\u0CC1 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0C85\u0C82\u0CB6\u0C97\u0CB3\u0CC1"}`;
return `\u0CA4\u0CC1\u0C82\u0CAC\u0CBE \u0CA6\u0CCA\u0CA1\u0CCD\u0CA1\u0CA6\u0CC1: \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${issue2.origin ?? "value"} \u0C8E\u0C82\u0CA6\u0CC1 ${adj}${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `\u0CA4\u0CC1\u0C82\u0CAC\u0CBE \u0C9A\u0CBF\u0C95\u0CCD\u0C95\u0CA6\u0CC1: \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${issue2.origin} \u0CB9\u0CCA\u0C82\u0CA6\u0CB2\u0CC1 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
}
return `\u0CA4\u0CC1\u0C82\u0CAC\u0CBE \u0C9A\u0CBF\u0C95\u0CCD\u0C95\u0CA6\u0CC1: \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${issue2.origin} \u0C8E\u0C82\u0CA6\u0CC1 ${adj}${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with") {
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF\u0CB5\u0CBE\u0CA6 \u0CB8\u0CCD\u0C9F\u0CCD\u0CB0\u0CBF\u0C82\u0C97\u0CCD: \u0C87\u0CA6\u0CB0\u0CCA\u0C82\u0CA6\u0CBF\u0C97\u0CC6 \u0CAA\u0CCD\u0CB0\u0CBE\u0CB0\u0C82\u0CAD\u0CBF\u0CB8\u0CAC\u0CC7\u0C95\u0CC1 "${_issue.prefix}"`;
}
if (_issue.format === "ends_with")
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF\u0CB5\u0CBE\u0CA6 \u0CB8\u0CCD\u0C9F\u0CCD\u0CB0\u0CBF\u0C82\u0C97\u0CCD: \u0C87\u0CA6\u0CB0\u0CCA\u0C82\u0CA6\u0CBF\u0C97\u0CC6 \u0C95\u0CCA\u0CA8\u0CC6\u0C97\u0CCA\u0CB3\u0CCD\u0CB3\u0CAC\u0CC7\u0C95\u0CC1 "${_issue.suffix}"`;
if (_issue.format === "includes")
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0CB8\u0CCD\u0C9F\u0CCD\u0CB0\u0CBF\u0C82\u0C97\u0CCD: \u0C92\u0CB3\u0C97\u0CCA\u0C82\u0CA1\u0CBF\u0CB0\u0CAC\u0CC7\u0C95\u0CC1 "${_issue.includes}"`;
if (_issue.format === "regex")
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF\u0CB5\u0CBE\u0CA6 \u0CB8\u0CCD\u0C9F\u0CCD\u0CB0\u0CBF\u0C82\u0C97\u0CCD: \u0CAE\u0CBE\u0CA6\u0CB0\u0CBF\u0C97\u0CC6 \u0CB9\u0CCA\u0C82\u0CA6\u0CBF\u0C95\u0CC6\u0CAF\u0CBE\u0C97\u0CAC\u0CC7\u0C95\u0CC1 ${_issue.pattern}`;
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0CB8\u0C82\u0C96\u0CCD\u0CAF\u0CC6: \u0CAC\u0CB9\u0CC1\u0CB8\u0C82\u0C96\u0CCD\u0CAF\u0CC6\u0CAF\u0CBE\u0C97\u0CBF\u0CB0\u0CAC\u0CC7\u0C95\u0CC1 ${issue2.divisor}`;
case "unrecognized_keys":
return `\u0C97\u0CC1\u0CB0\u0CC1\u0CA4\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CA6 \u0C95\u0CC0 ${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF\u0CB5\u0CBE\u0CA6 \u0C95\u0CC0 \u0C87\u0CA8\u0CCD ${issue2.origin}`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0CA4\u0CBE\u0CB0\u0CA4\u0CAE\u0CCD\u0CAF \u0CAE\u0CCC\u0CB2\u0CCD\u0CAF. \u0CA8\u0CBF\u0CB0\u0CC0\u0C95\u0CCD\u0CB7\u0CBF\u0CB8\u0CB2\u0CBE\u0C97\u0CBF\u0CA6\u0CC6 ${opts}`;
}
return "\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0C87\u0CA8\u0CCD\u200C\u0CAA\u0CC1\u0C9F\u0CCD";
case "invalid_element":
return `\u0CB0\u0CB2\u0CCD\u0CB2\u0CBF \u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0CAE\u0CCC\u0CB2\u0CCD\u0CAF ${issue2.origin}`;
default:
return `\u0C85\u0CAE\u0CBE\u0CA8\u0CCD\u0CAF \u0C87\u0CA8\u0CCD\u200C\u0CAA\u0CC1\u0C9F\u0CCD`;
}
};
};
function kn_default() {
return {
localeError: error31()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ko.js
var error32 = () => {
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" },
map: { 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",
mac: "MAC \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",
credit_card: "\uC2E0\uC6A9\uCE74\uB4DC \uBC88\uD638",
currency_code: "\uD1B5\uD654 \uCF54\uB4DC",
iban: "IBAN",
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: error32()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/lt.js
var capitalizeFirstCharacter = (text) => {
return text.charAt(0).toUpperCase() + text.slice(1);
};
function getUnitTypeFromNumber(number4) {
const abs = Math.abs(number4);
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 error33 = () => {
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",
mac: "MAC 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",
credit_card: "kredito kortel\u0117s numeris",
currency_code: "valiutos kodas",
iban: "IBAN",
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: error33()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/mk.js
var error34 = () => {
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" },
map: { 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",
mac: "MAC \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",
credit_card: "\u0431\u0440\u043E\u0458 \u043D\u0430 \u043A\u0440\u0435\u0434\u0438\u0442\u043D\u0430 \u043A\u0430\u0440\u0442\u0438\u0447\u043A\u0430",
currency_code: "\u043A\u043E\u0434 \u043D\u0430 \u0432\u0430\u043B\u0443\u0442\u0430",
iban: "IBAN",
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: error34()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ms.js
var error35 = () => {
const Sizable = {
string: { unit: "aksara", verb: "mempunyai" },
file: { unit: "bait", verb: "mempunyai" },
array: { unit: "elemen", verb: "mempunyai" },
set: { unit: "elemen", verb: "mempunyai" },
map: { 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",
mac: "alamat MAC",
cidrv4: "julat IPv4",
cidrv6: "julat IPv6",
base64: "string dikodkan base64",
base64url: "string dikodkan base64url",
json_string: "string JSON",
e164: "nombor E.164",
credit_card: "nombor kad kredit",
currency_code: "kod mata wang",
iban: "IBAN",
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: error35()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ne.js
var error36 = () => {
const Sizable = {
string: { unit: "\u0905\u0915\u094D\u0937\u0930", verb: "\u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B" },
file: { unit: "\u092C\u093E\u0907\u091F", verb: "\u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B" },
array: { unit: "\u0924\u0924\u094D\u0935", verb: "\u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B" },
set: { unit: "\u0924\u0924\u094D\u0935", verb: "\u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B" },
map: { unit: "\u092A\u094D\u0930\u0935\u093F\u0937\u094D\u091F\u093F", verb: "\u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "\u0907\u0928\u092A\u0941\u091F",
email: "\u0907\u092E\u0947\u0932 \u0920\u0947\u0917\u093E\u0928\u093E",
url: "URL",
emoji: "\u0907\u092E\u094B\u091C\u0940",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO \u092E\u093F\u0924\u093F \u0930 \u0938\u092E\u092F",
date: "ISO \u092E\u093F\u0924\u093F",
time: "ISO \u0938\u092E\u092F",
duration: "ISO \u0905\u0935\u0927\u093F",
ipv4: "IPv4 \u0920\u0947\u0917\u093E\u0928\u093E",
ipv6: "IPv6 \u0920\u0947\u0917\u093E\u0928\u093E",
mac: "MAC \u0920\u0947\u0917\u093E\u0928\u093E",
cidrv4: "IPv4 \u0926\u093E\u092F\u0930\u093E",
cidrv6: "IPv6 \u0926\u093E\u092F\u0930\u093E",
base64: "base64-\u0907\u0928\u094D\u0915\u094B\u0921 \u0917\u0930\u093F\u090F\u0915\u094B \u0938\u094D\u091F\u094D\u0930\u093F\u0919",
base64url: "base64url-\u0907\u0928\u094D\u0915\u094B\u0921 \u0917\u0930\u093F\u090F\u0915\u094B \u0938\u094D\u091F\u094D\u0930\u093F\u0919",
json_string: "JSON \u0938\u094D\u091F\u094D\u0930\u093F\u0919",
e164: "E.164 \u0928\u092E\u094D\u092C\u0930",
credit_card: "\u0915\u094D\u0930\u0947\u0921\u093F\u091F \u0915\u093E\u0930\u094D\u0921 \u0928\u092E\u094D\u092C\u0930",
currency_code: "\u092E\u0941\u0926\u094D\u0930\u093E \u0915\u094B\u0921",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u0907\u0928\u092A\u0941\u091F"
};
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 `\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 ${expected}, \u092A\u094D\u0930\u093E\u092A\u094D\u0924 ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 ${stringifyPrimitive(issue2.values[0])}`;
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0935\u093F\u0915\u0932\u094D\u092A: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 \u092E\u093E\u0928\u0939\u0930\u0942 \u092E\u0927\u094D\u092F\u0947 \u090F\u0915 ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u0927\u0947\u0930\u0948 \u0920\u0942\u0932\u094B: ${issue2.origin ?? "\u092E\u093E\u0928"} \u092E\u093E ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
return `\u0927\u0947\u0930\u0948 \u0920\u0942\u0932\u094B: ${issue2.origin ?? "\u092E\u093E\u0928"} ${adj}${issue2.maximum.toString()} \u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u0927\u0947\u0930\u0948 \u0938\u093E\u0928\u094B: ${issue2.origin} \u092E\u093E ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
return `\u0927\u0947\u0930\u0948 \u0938\u093E\u0928\u094B: ${issue2.origin} ${adj}${issue2.minimum.toString()} \u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0919: "${_issue.prefix}" \u092C\u093E\u091F \u0938\u0941\u0930\u0941 \u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B`;
if (_issue.format === "ends_with")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0919: "${_issue.suffix}" \u092E\u093E \u0938\u092E\u093E\u092A\u094D\u0924 \u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B`;
if (_issue.format === "includes")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0919: "${_issue.includes}" \u0938\u092E\u093E\u0935\u0947\u0936 \u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B`;
if (_issue.format === "regex")
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u094D\u091F\u094D\u0930\u093F\u0919: \u0922\u093E\u0901\u091A\u093E ${_issue.pattern} \u0938\u0901\u0917 \u092E\u0947\u0932 \u0916\u093E\u0928\u0941\u092A\u0930\u094D\u091B`;
return `\u0905\u092E\u093E\u0928\u094D\u092F ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0938\u0902\u0916\u094D\u092F\u093E: ${issue2.divisor} \u0915\u094B \u0917\u0941\u0923\u091C \u0939\u0941\u0928\u0941\u092A\u0930\u094D\u091B`;
case "unrecognized_keys":
return `\u0905\u092A\u0930\u093F\u091A\u093F\u0924 \u0915\u0941\u091E\u094D\u091C\u0940${issue2.keys.length > 1 ? "\u0939\u0930\u0942" : ""}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0915\u0941\u091E\u094D\u091C\u0940: ${issue2.origin} \u092E\u093E`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0921\u093F\u0938\u094D\u0915\u094D\u0930\u093F\u092E\u093F\u0928\u0947\u091F\u0930 \u092E\u093E\u0928: \u0905\u092A\u0947\u0915\u094D\u0937\u093F\u0924 ${opts}`;
}
return "\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F";
case "invalid_element":
return `\u0905\u092E\u093E\u0928\u094D\u092F \u092E\u093E\u0928: ${issue2.origin} \u092E\u093E`;
default:
return `\u0905\u092E\u093E\u0928\u094D\u092F \u0907\u0928\u092A\u0941\u091F`;
}
};
};
function ne_default() {
return {
localeError: error36()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/nl.js
var error37 = () => {
const Sizable = {
string: { unit: "tekens", verb: "heeft" },
file: { unit: "bytes", verb: "heeft" },
array: { unit: "elementen", verb: "heeft" },
set: { unit: "elementen", verb: "heeft" },
map: { 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",
mac: "MAC-adres",
cidrv4: "IPv4-bereik",
cidrv6: "IPv6-bereik",
base64: "base64-gecodeerde tekst",
base64url: "base64 URL-gecodeerde tekst",
json_string: "JSON string",
e164: "E.164-nummer",
credit_card: "creditcardnummer",
currency_code: "valutacode",
iban: "IBAN",
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: error37()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/nn.js
var error38 = () => {
const Sizable = {
string: { unit: "teikn", verb: "\xE5 ha" },
file: { unit: "bytes", verb: "\xE5 ha" },
array: { unit: "element", verb: "\xE5 innehalde" },
set: { unit: "element", verb: "\xE5 innehalde" },
map: { unit: "element", verb: "\xE5 innehalde" }
};
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-varigheit",
ipv4: "IPv4-adresse",
ipv6: "IPv6-adresse",
mac: "MAC-adresse",
cidrv4: "IPv4-spekter",
cidrv6: "IPv6-spekter",
base64: "base64-enkoda streng",
base64url: "base64url-enkoda streng",
json_string: "JSON-streng",
e164: "E.164-nummer",
credit_card: "kredittkortnummer",
currency_code: "valutakode",
iban: "IBAN",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = {
nan: "NaN",
number: "tal",
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: forventa instanceof ${issue2.expected}, fekk ${received}`;
}
return `Ugyldig input: forventa ${expected}, fekk ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `Ugyldig verdi: forventa ${stringifyPrimitive(issue2.values[0])}`;
return `Ugyldig val: forventa eitt av ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `For stor(t): forventa ${issue2.origin ?? "value"} til \xE5 ha ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "element"}`;
return `For stor(t): forventa ${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): forventa ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
}
return `For lite(n): forventa ${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 slutte med "${_issue.suffix}"`;
if (_issue.format === "includes")
return `Ugyldig streng: m\xE5 innehalde "${_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 tal: m\xE5 vere eit multiplum av ${issue2.divisor}`;
case "unrecognized_keys":
return `${issue2.keys.length > 1 ? "Ukjende n\xF8klar" : "Ukjend 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 nn_default() {
return {
localeError: error38()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/no.js
var error39 = () => {
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" },
map: { 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-adresse",
ipv6: "IPv6-adresse",
mac: "MAC-adresse",
cidrv4: "IPv4-spekter",
cidrv6: "IPv6-spekter",
base64: "base64-enkodet streng",
base64url: "base64url-enkodet streng",
json_string: "JSON-streng",
e164: "E.164-nummer",
credit_card: "kredittkortnummer",
currency_code: "valutakode",
iban: "IBAN",
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: error39()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ota.js
var error40 = () => {
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" },
map: { 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",
mac: "MAC 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",
credit_card: "i'tib\xE2r kart\u0131 numaras\u0131",
currency_code: "para birimi kodu",
iban: "IBAN",
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: error40()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ps.js
var error41 = () => {
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" },
map: { 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",
mac: "\u062F MAC \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",
credit_card: "\u062F \u06A9\u0631\u06CC\u0689\u06CC\u067C \u06A9\u0627\u0631\u062A \u0634\u0645\u06CC\u0631\u0647",
currency_code: "\u062F \u0627\u0633\u0639\u0627\u0631\u0648 \u06A9\u0648\u0689",
iban: "IBAN",
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: error41()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/pl.js
var error42 = () => {
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" },
map: { 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",
mac: "adres MAC",
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",
credit_card: "numer karty kredytowej",
currency_code: "kod waluty",
iban: "IBAN",
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: error42()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/pt.js
var error43 = () => {
const Sizable = {
string: { unit: "caracteres" },
file: { unit: "bytes" },
array: { unit: "elementos" },
set: { unit: "elementos" },
map: { unit: "entradas" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "a entrada",
email: "o endere\xE7o de e-mail",
url: "o URL",
emoji: "o emoji",
uuid: "o UUID",
uuidv4: "o UUIDv4",
uuidv6: "o UUIDv6",
nanoid: "o nanoid",
guid: "o GUID",
cuid: "o cuid",
cuid2: "o cuid2",
ulid: "o ULID",
xid: "o XID",
ksuid: "o KSUID",
datetime: "a data e hora ISO",
date: "a data ISO",
time: "a hora ISO",
duration: "a dura\xE7\xE3o ISO",
ipv4: "o endere\xE7o IPv4",
ipv6: "o endere\xE7o IPv6",
mac: "o endere\xE7o MAC",
cidrv4: "o intervalo de endere\xE7os IPv4",
cidrv6: "o intervalo de endere\xE7os IPv6",
base64: "o texto codificado em base64",
base64url: "o texto codificado em base64url",
json_string: "o texto JSON",
e164: "o n\xFAmero E.164",
credit_card: "o n\xFAmero de cart\xE3o de cr\xE9dito",
currency_code: "o c\xF3digo de moeda",
iban: "o IBAN",
jwt: "o JWT",
template_literal: "a entrada"
};
const Gender = {
masculine: { definite: "o", indefinite: "um" },
feminine: { definite: "a", indefinite: "uma" }
};
const TypeDictionary = {
string: { name: "texto", articles: Gender.masculine },
number: { name: "n\xFAmero", articles: Gender.masculine },
int: { name: "n\xFAmero inteiro", articles: Gender.masculine },
boolean: { name: "valor booleano", articles: Gender.masculine },
bigint: { name: "n\xFAmero bigint", articles: Gender.masculine },
symbol: { name: "s\xEDmbolo", articles: Gender.masculine },
undefined: { name: 'valor "undefined"', articles: Gender.masculine },
null: { name: 'valor "nulo"', articles: Gender.masculine },
never: { name: 'valor "never"', articles: Gender.masculine },
void: { name: 'valor "void"', articles: Gender.masculine },
date: { name: "data", articles: Gender.feminine },
array: { name: "vetor", articles: Gender.masculine },
object: { name: "objeto", articles: Gender.masculine },
tuple: { name: "tuplo", articles: Gender.masculine },
record: { name: "registo", articles: Gender.masculine },
map: { name: "mapa", articles: Gender.masculine },
set: { name: "conjunto", articles: Gender.masculine },
file: { name: "ficheiro", articles: Gender.masculine },
nonoptional: { name: "valor n\xE3o opcional", articles: Gender.masculine },
nan: { name: 'valor "NaN"', articles: Gender.masculine },
// Compatibility: "nan" -> "NaN" for display
function: { name: "fun\xE7\xE3o", articles: Gender.feminine }
};
function translateOriginWithArticle(type, articleType) {
const translatedValue = TypeDictionary[type] ?? { name: `valor "${type}"`, articles: Gender.masculine };
return `${translatedValue.articles[articleType]} ${translatedValue.name}`;
}
return (issue2) => {
switch (issue2.code) {
case "invalid_type": {
const expected = translateOriginWithArticle(issue2.expected, "indefinite");
const receivedType = parsedType(issue2.input);
const received = translateOriginWithArticle(receivedType, "indefinite");
return `Entrada inv\xE1lida: esperava ${expected}, recebeu ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `Entrada inv\xE1lida: esperava ${stringifyPrimitive(issue2.values[0])}`;
return `Op\xE7\xE3o inv\xE1lida: esperava uma das seguintes op\xE7\xF5es: ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `Demasiado grande: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} tivesse ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "elementos"}`;
return `Demasiado grande: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} fosse ${adj} ${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `Demasiado pequeno: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} tivesse ${adj} ${issue2.minimum.toString()} ${sizing.unit ?? "elementos"}`;
}
return `Demasiado pequeno: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} fosse ${adj} ${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `Texto inv\xE1lido: deve come\xE7ar por "${_issue.prefix}"`;
if (_issue.format === "ends_with")
return `Texto inv\xE1lido: deve terminar em "${_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 `Formato d${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": {
const plural2 = issue2.keys.length > 1 ? "s" : "";
return `Chave${plural2} inv\xE1lida${plural2}: ${joinValues(issue2.keys, ", ")}`;
}
case "invalid_key":
return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `Valor de discrimina\xE7\xE3o inv\xE1lido. Esperava ${opts}`;
}
return "Entrada inv\xE1lida";
case "invalid_element":
return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
default:
return `Entrada inv\xE1lida`;
}
};
};
function pt_default() {
return {
localeError: error43()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/pt-BR.js
var error44 = () => {
const Sizable = {
string: { unit: "caracteres" },
file: { unit: "bytes" },
array: { unit: "elementos" },
set: { unit: "elementos" },
map: { unit: "entradas" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "a entrada",
email: "o endere\xE7o de e-mail",
url: "o URL",
emoji: "o emoji",
uuid: "o UUID",
uuidv4: "o UUIDv4",
uuidv6: "o UUIDv6",
nanoid: "o nanoid",
guid: "o GUID",
cuid: "o cuid",
cuid2: "o cuid2",
ulid: "o ULID",
xid: "o XID",
ksuid: "o KSUID",
datetime: "a data e hora ISO",
date: "a data ISO",
time: "a hora ISO",
duration: "a dura\xE7\xE3o ISO",
ipv4: "o endere\xE7o IPv4",
ipv6: "o endere\xE7o IPv6",
mac: "o endere\xE7o MAC",
cidrv4: "a faixa de endere\xE7os IPv4",
cidrv6: "a faixa de endere\xE7os IPv6",
base64: "o texto codificado em base64",
base64url: "o texto codificado em base64url",
json_string: "o texto JSON",
e164: "o n\xFAmero E.164",
credit_card: "o n\xFAmero de cart\xE3o de cr\xE9dito",
currency_code: "o c\xF3digo de moeda",
iban: "o IBAN",
jwt: "o JWT",
template_literal: "a entrada"
};
const Gender = {
masculine: { definite: "o", indefinite: "um" },
feminine: { definite: "a", indefinite: "uma" }
};
const TypeDictionary = {
string: { name: "texto", articles: Gender.masculine },
number: { name: "n\xFAmero", articles: Gender.masculine },
int: { name: "n\xFAmero inteiro", articles: Gender.masculine },
boolean: { name: "valor booleano", articles: Gender.masculine },
bigint: { name: "n\xFAmero bigint", articles: Gender.masculine },
symbol: { name: "s\xEDmbolo", articles: Gender.masculine },
undefined: { name: 'valor "undefined"', articles: Gender.masculine },
null: { name: 'valor "nulo"', articles: Gender.masculine },
never: { name: 'valor "never"', articles: Gender.masculine },
void: { name: 'valor "void"', articles: Gender.masculine },
date: { name: "data", articles: Gender.feminine },
array: { name: "vetor", articles: Gender.masculine },
object: { name: "objeto", articles: Gender.masculine },
tuple: { name: "tupla", articles: Gender.feminine },
record: { name: "registro", articles: Gender.masculine },
map: { name: "mapa", articles: Gender.masculine },
set: { name: "conjunto", articles: Gender.masculine },
file: { name: "arquivo", articles: Gender.masculine },
nonoptional: { name: "valor n\xE3o opcional", articles: Gender.masculine },
nan: { name: 'valor "NaN"', articles: Gender.masculine },
// Compatibility: "nan" -> "NaN" for display
function: { name: "fun\xE7\xE3o", articles: Gender.feminine }
};
function translateOriginWithArticle(type, articleType) {
const translatedValue = TypeDictionary[type] ?? { name: `valor "${type}"`, articles: Gender.masculine };
return `${translatedValue.articles[articleType]} ${translatedValue.name}`;
}
return (issue2) => {
switch (issue2.code) {
case "invalid_type": {
const expected = translateOriginWithArticle(issue2.expected, "indefinite");
const receivedType = parsedType(issue2.input);
const received = translateOriginWithArticle(receivedType, "indefinite");
return `Entrada inv\xE1lida: esperava ${expected}, recebeu ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `Entrada inv\xE1lida: esperava ${stringifyPrimitive(issue2.values[0])}`;
return `Op\xE7\xE3o inv\xE1lida: esperava uma das seguintes op\xE7\xF5es: ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `Grande demais: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} tivesse ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "elementos"}`;
return `Grande demais: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} fosse ${adj} ${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `Pequeno demais: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} tivesse ${adj} ${issue2.minimum.toString()} ${sizing.unit ?? "elementos"}`;
}
return `Pequeno demais: esperava que ${translateOriginWithArticle(issue2.origin, "definite")} 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 `Formato d${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": {
const plural2 = issue2.keys.length > 1 ? "s" : "";
return `Chave${plural2} inv\xE1lida${plural2}: ${joinValues(issue2.keys, ", ")}`;
}
case "invalid_key":
return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `Valor de discrimina\xE7\xE3o inv\xE1lido. Esperava ${opts}`;
}
return "Entrada inv\xE1lida";
case "invalid_element":
return `Entrada inv\xE1lida n${translateOriginWithArticle(issue2.origin, "definite")}`;
default:
return `Entrada inv\xE1lida`;
}
};
};
function pt_BR_default() {
return {
localeError: error44()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ro.js
var error45 = () => {
const Sizable = {
string: { unit: "caractere", verb: "s\u0103 aib\u0103" },
file: { unit: "octe\u021Bi", verb: "s\u0103 aib\u0103" },
array: { unit: "elemente", verb: "s\u0103 aib\u0103" },
set: { unit: "elemente", verb: "s\u0103 aib\u0103" },
map: { unit: "intr\u0103ri", verb: "s\u0103 aib\u0103" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "intrare",
email: "adres\u0103 de email",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "dat\u0103 \u0219i or\u0103 ISO",
date: "dat\u0103 ISO",
time: "or\u0103 ISO",
duration: "durat\u0103 ISO",
ipv4: "adres\u0103 IPv4",
ipv6: "adres\u0103 IPv6",
mac: "adres\u0103 MAC",
cidrv4: "interval IPv4",
cidrv6: "interval IPv6",
base64: "\u0219ir codat base64",
base64url: "\u0219ir codat base64url",
json_string: "\u0219ir JSON",
e164: "num\u0103r E.164",
credit_card: "num\u0103r de card de credit",
currency_code: "cod valutar",
iban: "IBAN",
jwt: "JWT",
template_literal: "intrare"
};
const TypeDictionary = {
nan: "NaN",
string: "\u0219ir",
number: "num\u0103r",
boolean: "boolean",
function: "func\u021Bie",
array: "matrice",
object: "obiect",
undefined: "nedefinit",
symbol: "simbol",
bigint: "num\u0103r mare",
void: "void",
never: "never",
map: "hart\u0103",
set: "set"
};
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 `Intrare invalid\u0103: a\u0219teptat ${expected}, primit ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `Intrare invalid\u0103: a\u0219teptat ${stringifyPrimitive(issue2.values[0])}`;
return `Op\u021Biune invalid\u0103: a\u0219teptat una dintre ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemente"}`;
return `Prea mare: a\u0219teptat ca ${issue2.origin ?? "valoarea"} s\u0103 fie ${adj}${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `Prea mic: a\u0219teptat ca ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
}
return `Prea mic: a\u0219teptat ca ${issue2.origin} s\u0103 fie ${adj}${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with") {
return `\u0218ir invalid: trebuie s\u0103 \xEEnceap\u0103 cu "${_issue.prefix}"`;
}
if (_issue.format === "ends_with")
return `\u0218ir invalid: trebuie s\u0103 se termine cu "${_issue.suffix}"`;
if (_issue.format === "includes")
return `\u0218ir invalid: trebuie s\u0103 includ\u0103 "${_issue.includes}"`;
if (_issue.format === "regex")
return `\u0218ir invalid: trebuie s\u0103 se potriveasc\u0103 cu modelul ${_issue.pattern}`;
return `Format invalid: ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `Num\u0103r invalid: trebuie s\u0103 fie multiplu de ${issue2.divisor}`;
case "unrecognized_keys":
return `Chei nerecunoscute: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `Cheie invalid\u0103 \xEEn ${issue2.origin}`;
case "invalid_union":
return "Intrare invalid\u0103";
case "invalid_element":
return `Valoare invalid\u0103 \xEEn ${issue2.origin}`;
default:
return `Intrare invalid\u0103`;
}
};
};
function ro_default() {
return {
localeError: error45()
};
}
// node_modules/.pnpm/zod@4.6.7/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 error46 = () => {
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"
},
map: {
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",
mac: "MAC \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",
credit_card: "\u043D\u043E\u043C\u0435\u0440 \u043A\u0440\u0435\u0434\u0438\u0442\u043D\u043E\u0439 \u043A\u0430\u0440\u0442\u044B",
currency_code: "\u043A\u043E\u0434 \u0432\u0430\u043B\u044E\u0442\u044B",
iban: "IBAN",
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: error46()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/sk.js
var error47 = () => {
const Sizable = {
string: { unit: "znakov", verb: "ma\u0165" },
file: { unit: "bajtov", verb: "ma\u0165" },
array: { unit: "prvkov", verb: "ma\u0165" },
set: { unit: "prvkov", verb: "ma\u0165" },
map: { unit: "polo\u017Eiek", verb: "ma\u0165" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "regul\xE1rny 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: "d\xE1tum a \u010Das vo form\xE1te ISO",
date: "d\xE1tum vo form\xE1te ISO",
time: "\u010Das vo form\xE1te ISO",
duration: "doba trvania ISO",
ipv4: "IPv4 adresa",
ipv6: "IPv6 adresa",
mac: "MAC adresa",
cidrv4: "rozsah IPv4",
cidrv6: "rozsah IPv6",
base64: "re\u0165azec zak\xF3dovan\xFD vo form\xE1te base64",
base64url: "re\u0165azec zak\xF3dovan\xFD vo form\xE1te base64url",
json_string: "re\u0165azec vo form\xE1te JSON",
e164: "\u010D\xEDslo E.164",
credit_card: "\u010D\xEDslo kreditnej karty",
currency_code: "k\xF3d meny",
iban: "IBAN",
jwt: "JWT",
template_literal: "vstup"
};
const TypeDictionary = {
nan: "NaN",
number: "\u010D\xEDslo",
string: "re\u0165azec",
function: "funkcia",
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\u010Dak\xE1van\xE9 instanceof ${issue2.expected}, obdr\u017Ean\xE9 ${received}`;
}
return `Neplatn\xFD vstup: o\u010Dak\xE1van\xE9 ${expected}, obdr\u017Ean\xE9 ${received}`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `Neplatn\xFD vstup: o\u010Dak\xE1van\xE9 ${stringifyPrimitive(issue2.values[0])}`;
return `Neplatn\xFD vstup: o\u010Dak\xE1van\xE1 jedna z hodn\xF4t ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `Hodnota je pr\xEDli\u0161 ve\u013Ek\xE1: ${issue2.origin ?? "hodnota"} mus\xED ma\u0165 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "prvkov"}`;
}
return `Hodnota je pr\xEDli\u0161 ve\u013Ek\xE1: ${issue2.origin ?? "hodnota"} mus\xED by\u0165 ${adj}${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing) {
return `Hodnota je pr\xEDli\u0161 mal\xE1: ${issue2.origin ?? "hodnota"} mus\xED ma\u0165 ${adj}${issue2.minimum.toString()} ${sizing.unit ?? "prvkov"}`;
}
return `Hodnota je pr\xEDli\u0161 mal\xE1: ${issue2.origin ?? "hodnota"} mus\xED by\u0165 ${adj}${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `Neplatn\xFD re\u0165azec: mus\xED za\u010D\xEDna\u0165 na "${_issue.prefix}"`;
if (_issue.format === "ends_with")
return `Neplatn\xFD re\u0165azec: mus\xED kon\u010Di\u0165 na "${_issue.suffix}"`;
if (_issue.format === "includes")
return `Neplatn\xFD re\u0165azec: mus\xED obsahova\u0165 "${_issue.includes}"`;
if (_issue.format === "regex")
return `Neplatn\xFD re\u0165azec: mus\xED zodpoveda\u0165 vzoru ${_issue.pattern}`;
return `Neplatn\xFD form\xE1t ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `Neplatn\xE9 \u010D\xEDslo: mus\xED by\u0165 n\xE1sobkom ${issue2.divisor}`;
case "unrecognized_keys":
return `Nezn\xE1me kl\xFA\u010De: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `Neplatn\xFD kl\xFA\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 sk_default() {
return {
localeError: error47()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/sl.js
var error48 = () => {
const Sizable = {
string: { unit: "znakov", verb: "imeti" },
file: { unit: "bajtov", verb: "imeti" },
array: { unit: "elementov", verb: "imeti" },
set: { unit: "elementov", verb: "imeti" },
map: { 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",
mac: "MAC naslov",
cidrv4: "obseg IPv4",
cidrv6: "obseg IPv6",
base64: "base64 kodiran niz",
base64url: "base64url kodiran niz",
json_string: "JSON niz",
e164: "E.164 \u0161tevilka",
credit_card: "\u0161tevilka kreditne kartice",
currency_code: "koda valute",
iban: "IBAN",
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: error48()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/sv.js
var error49 = () => {
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" },
map: { 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-adress",
ipv6: "IPv6-adress",
mac: "MAC-adress",
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",
credit_card: "kreditkortsnummer",
currency_code: "valutakod",
iban: "IBAN",
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: error49()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ta.js
var error50 = () => {
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" },
map: { 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",
mac: "MAC \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",
credit_card: "\u0B95\u0B9F\u0BA9\u0BCD \u0B85\u0B9F\u0BCD\u0B9F\u0BC8 \u0B8E\u0BA3\u0BCD",
currency_code: "\u0BA8\u0BBE\u0BA3\u0BAF\u0B95\u0BCD \u0B95\u0BC1\u0BB1\u0BBF\u0BAF\u0BC0\u0B9F\u0BC1",
iban: "IBAN",
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: error50()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/tg.js
var error51 = () => {
const Sizable = {
string: { unit: "\u0430\u043B\u043E\u043C\u0430\u0442", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
file: { unit: "\u0431\u0430\u0439\u0442", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
array: { unit: "\u0443\u043D\u0441\u0443\u0440", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
set: { unit: "\u0443\u043D\u0441\u0443\u0440", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" },
map: { unit: "\u0441\u0430\u0431\u0442", verb: "\u0434\u043E\u0448\u0442\u0430 \u0431\u043E\u0448\u0430\u0434" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "\u0432\u0443\u0440\u0443\u0434",
email: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 email",
url: "URL",
emoji: "\u044D\u043C\u043E\u04B7\u0438",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "\u0441\u0430\u043D\u0430\u0432\u0443 \u0432\u0430\u049B\u0442\u0438 ISO",
date: "\u0441\u0430\u043D\u0430\u0438 ISO",
time: "\u0432\u0430\u049B\u0442\u0438 ISO",
duration: "\u0434\u0430\u0432\u043E\u043C\u043D\u043E\u043A\u0438\u0438 ISO",
ipv4: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 IPv4",
ipv6: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 IPv6",
mac: "\u0441\u0443\u0440\u043E\u0493\u0430\u0438 MAC",
cidrv4: "\u043C\u0430\u04B3\u0434\u0443\u0434\u0430\u0438 IPv4",
cidrv6: "\u043C\u0430\u04B3\u0434\u0443\u0434\u0430\u0438 IPv6",
base64: "\u0441\u0430\u0442\u0440\u0438 \u0434\u0430\u0440 \u0444\u043E\u0440\u043C\u0430\u0442\u0438 base64",
base64url: "\u0441\u0430\u0442\u0440\u0438 \u0434\u0430\u0440 \u0444\u043E\u0440\u043C\u0430\u0442\u0438 base64url",
json_string: "\u0441\u0430\u0442\u0440\u0438 JSON",
e164: "\u0440\u0430\u049B\u0430\u043C\u0438 E.164",
credit_card: "\u0440\u0430\u049B\u0430\u043C\u0438 \u043A\u043E\u0440\u0442\u0438 \u043A\u0440\u0435\u0434\u0438\u0442\u04E3",
currency_code: "\u0440\u0430\u043C\u0437\u0438 \u0430\u0441\u044A\u043E\u0440",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u0432\u0443\u0440\u0443\u0434"
};
const TypeDictionary = {
nan: "NaN",
number: "\u0440\u0430\u049B\u0430\u043C",
string: "\u0441\u0430\u0442\u0440",
array: "\u043C\u0430\u0441\u0441\u0438\u0432",
object: "\u043E\u0431\u044A\u0435\u043A\u0442",
date: "\u0441\u0430\u043D\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;
return `\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: ${expected} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442, ${received} \u0433\u0438\u0440\u0438\u0444\u0442\u0430 \u0448\u0443\u0434`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: ${stringifyPrimitive(issue2.values[0])} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442`;
return `\u0418\u043D\u0442\u0438\u0445\u043E\u0431\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u044F\u043A\u0435 \u0430\u0437 ${joinValues(issue2.values, "|")} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u0425\u0435\u043B\u0435 \u043A\u0430\u043B\u043E\u043D: ${issue2.origin ?? "\u049B\u0438\u043C\u0430\u0442"} \u0431\u043E\u044F\u0434 ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
return `\u0425\u0435\u043B\u0435 \u043A\u0430\u043B\u043E\u043D: ${issue2.origin ?? "\u049B\u0438\u043C\u0430\u0442"} \u0431\u043E\u044F\u0434 ${adj}${issue2.maximum.toString()} \u0431\u043E\u0448\u0430\u0434`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing)
return `\u0425\u0435\u043B\u0435 \u0445\u0443\u0440\u0434: ${issue2.origin} \u0431\u043E\u044F\u0434 ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
return `\u0425\u0435\u043B\u0435 \u0445\u0443\u0440\u0434: ${issue2.origin} \u0431\u043E\u044F\u0434 ${adj}${issue2.minimum.toString()} \u0431\u043E\u0448\u0430\u0434`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u043E "${_issue.prefix}" \u043E\u0493\u043E\u0437 \u0448\u0430\u0432\u0430\u0434`;
if (_issue.format === "ends_with")
return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u043E "${_issue.suffix}" \u0430\u043D\u04B7\u043E\u043C \u0451\u0431\u0430\u0434`;
if (_issue.format === "includes")
return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 "${_issue.includes}"-\u0440\u043E \u0434\u0430\u0440 \u0431\u0430\u0440 \u0433\u0438\u0440\u0430\u0434`;
if (_issue.format === "regex")
return `\u0421\u0430\u0442\u0440\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u0430 \u043D\u0430\u043C\u0443\u043D\u0430\u0438 ${_issue.pattern} \u043C\u0443\u0432\u043E\u0444\u0438\u049B\u0430\u0442 \u043A\u0443\u043D\u0430\u0434`;
return `${FormatDictionary[_issue.format] ?? issue2.format}-\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442`;
}
case "not_multiple_of":
return `\u0420\u0430\u049B\u0430\u043C\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442: \u0431\u043E\u044F\u0434 \u0431\u0430 ${issue2.divisor} \u0431\u0435 \u0431\u0430\u049B\u0438\u044F \u0442\u0430\u049B\u0441\u0438\u043C \u0448\u0430\u0432\u0430\u0434`;
case "unrecognized_keys":
return `\u041A\u0430\u043B\u0438\u0434${issue2.keys.length > 1 ? "\u04B3\u043E\u0438" : "\u0438"} \u043D\u043E\u043C\u0430\u044A\u043B\u0443\u043C: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `\u041A\u0430\u043B\u0438\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442 \u0434\u0430\u0440 ${issue2.origin}`;
case "invalid_union":
if (issue2.options && Array.isArray(issue2.options) && issue2.options.length > 0) {
const opts = issue2.options.map((o) => `'${o}'`).join(" | ");
return `\u049A\u0438\u043C\u0430\u0442\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442\u0438 \u0434\u0438\u0441\u043A\u0440\u0438\u043C\u0438\u043D\u0430\u0442\u043E\u0440: ${opts} \u0438\u043D\u0442\u0438\u0437\u043E\u0440 \u043C\u0435\u0440\u0430\u0444\u0442`;
}
return "\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442";
case "invalid_element":
return `\u049A\u0438\u043C\u0430\u0442\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442 \u0434\u0430\u0440 ${issue2.origin}`;
default:
return `\u0412\u0443\u0440\u0443\u0434\u0438 \u043D\u043E\u0434\u0443\u0440\u0443\u0441\u0442`;
}
};
};
function tg_default() {
return {
localeError: error51()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/th.js
var error52 = () => {
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" },
map: { 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",
mac: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 MAC",
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)",
credit_card: "\u0E2B\u0E21\u0E32\u0E22\u0E40\u0E25\u0E02\u0E1A\u0E31\u0E15\u0E23\u0E40\u0E04\u0E23\u0E14\u0E34\u0E15",
currency_code: "\u0E23\u0E2B\u0E31\u0E2A\u0E2A\u0E01\u0E38\u0E25\u0E40\u0E07\u0E34\u0E19",
iban: "IBAN",
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: error52()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/tk.js
var error53 = () => {
const Sizable = {
string: { unit: "simwol", verb: "bolmaly" },
file: { unit: "ba\xFDt", verb: "bolmaly" },
array: { unit: "elementler", verb: "bolmaly" },
set: { unit: "elementler", verb: "bolmaly" },
map: { unit: "elementler", verb: "bolmaly" }
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "giri\u015F",
email: "e-po\xE7ta salgysy",
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 sene we wagt",
date: "ISO sene",
time: "ISO wagt",
duration: "ISO wagt aralygy",
ipv4: "IPv4 salgysy",
ipv6: "IPv6 salgysy",
mac: "MAC salgysy",
cidrv4: "IPv4 aralygy",
cidrv6: "IPv6 aralygy",
base64: "base64 bilen \u015Fifrlenen setir",
base64url: "base64url bilen \u015Fifrlenen setir",
json_string: "JSON setiri",
e164: "E.164 nomeri",
credit_card: "kredit kartyny\u0148 nomeri",
currency_code: "wal\xFDuta kody",
iban: "IBAN",
jwt: "JWT",
template_literal: "\u015Fablon"
};
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 `N\xE4dogry baha: gara\u015Fylan ${expected} \xFDerine ${received} alyndy`;
}
case "invalid_value":
if (issue2.values.length === 1)
return `N\xE4dogry baha: ${stringifyPrimitive(issue2.values[0])} bolmaly`;
return `N\xE4dogry sa\xFDlaw: a\u015Fakdakylardan biri bolmaly: ${joinValues(issue2.values, "|")}`;
case "too_big": {
const adj = issue2.inclusive ? "<=" : "<";
const sizing = getSizing(issue2.origin);
if (sizing)
return `Has uly: gara\u015Fyl\xFDan ${issue2.origin ?? "baha"} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "element"}`;
return `Has uly: gara\u015Fyl\xFDan ${issue2.origin ?? "baha"} ${adj} ${issue2.maximum.toString()}`;
}
case "too_small": {
const adj = issue2.inclusive ? ">=" : ">";
const sizing = getSizing(issue2.origin);
if (sizing)
return `Has ki\xE7i: gara\u015Fyl\xFDan ${issue2.origin} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
return `Has ki\xE7i: gara\u015Fyl\xFDan ${issue2.origin} ${adj} ${issue2.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue2;
if (_issue.format === "starts_with")
return `N\xE4dogry setir: "${_issue.prefix}" bilen ba\u015Flamaly`;
if (_issue.format === "ends_with")
return `N\xE4dogry setir: "${_issue.suffix}" bilen gutarmaly`;
if (_issue.format === "includes")
return `N\xE4dogry setir: "${_issue.includes}" saklamaly`;
if (_issue.format === "regex")
return `N\xE4dogry setir: ${_issue.pattern} nusga la\xFDyk bolmaly`;
return `N\xE4dogry ${FormatDictionary[_issue.format] ?? issue2.format}`;
}
case "not_multiple_of":
return `N\xE4dogry san: ${issue2.divisor} bilen galyndysyz b\xF6l\xFCnmeli`;
case "unrecognized_keys":
return `Tanalma\xFDan a\xE7ar${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
case "invalid_key":
return `${issue2.origin} i\xE7inde n\xE4dogry a\xE7ar`;
case "invalid_union":
return "N\xE4dogry baha";
case "invalid_element":
return `${issue2.origin} i\xE7inde n\xE4dogry baha`;
default:
return `N\xE4dogry baha`;
}
};
};
function tk_default() {
return {
localeError: error53()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/tr.js
var error54 = () => {
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" },
map: { 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",
mac: "MAC 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",
credit_card: "kredi kart\u0131 numaras\u0131",
currency_code: "para birimi kodu",
iban: "IBAN",
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: error54()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/uk.js
var error55 = () => {
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" },
map: { 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",
mac: "\u0430\u0434\u0440\u0435\u0441\u0430 MAC",
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",
credit_card: "\u043D\u043E\u043C\u0435\u0440 \u043A\u0440\u0435\u0434\u0438\u0442\u043D\u043E\u0457 \u043A\u0430\u0440\u0442\u043A\u0438",
currency_code: "\u043A\u043E\u0434 \u0432\u0430\u043B\u044E\u0442\u0438",
iban: "IBAN",
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: error55()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ua.js
function ua_default() {
return uk_default();
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/ur.js
var error56 = () => {
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" },
map: { 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",
mac: "\u0627\u06CC\u0645 \u0627\u06D2 \u0633\u06CC \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",
credit_card: "\u06A9\u0631\u06CC\u0688\u0679 \u06A9\u0627\u0631\u0688 \u0646\u0645\u0628\u0631",
currency_code: "\u06A9\u0631\u0646\u0633\u06CC \u06A9\u0648\u0688",
iban: "IBAN",
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: error56()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/uz.js
var error57 = () => {
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" },
map: { unit: "yozuv", 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",
credit_card: "kredit karta raqami",
currency_code: "valyuta kodi",
iban: "IBAN",
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: error57()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/vi.js
var error58 = () => {
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" },
map: { 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",
mac: "\u0111\u1ECBa ch\u1EC9 MAC",
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",
credit_card: "s\u1ED1 th\u1EBB t\xEDn d\u1EE5ng",
currency_code: "m\xE3 ti\u1EC1n t\u1EC7",
iban: "IBAN",
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: error58()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/zh-CN.js
var error59 = () => {
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" },
map: { 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",
mac: "MAC\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",
credit_card: "\u4FE1\u7528\u5361\u53F7",
currency_code: "\u8D27\u5E01\u4EE3\u7801",
iban: "IBAN",
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: error59()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/zh-TW.js
var error60 = () => {
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" },
map: { 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",
mac: "MAC \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",
credit_card: "\u4FE1\u7528\u5361\u865F",
currency_code: "\u8CA8\u5E63\u4EE3\u78BC",
iban: "IBAN",
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: error60()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/yo.js
var error61 = () => {
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" },
map: { 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",
mac: "\xE0d\xEDr\u1EB9\u0301s\xEC MAC",
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",
credit_card: "n\u1ECDmba kaadi gbese",
currency_code: "koodu ow\xF3",
iban: "IBAN",
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: error61()
};
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/registries.js
var _a2;
var $output = /* @__PURE__ */ Symbol("ZodOutput");
var $input = /* @__PURE__ */ Symbol("ZodInput");
var $ZodRegistry = class {
constructor() {
this._map = /* @__PURE__ */ new WeakMap();
this._idmap = /* @__PURE__ */ new Map();
}
add(schema, ..._meta) {
const meta3 = _meta[0];
this._map.set(schema, meta3);
if (meta3 && typeof meta3 === "object" && "id" in meta3) {
this._idmap.set(meta3.id, schema);
}
return this;
}
clear() {
this._map = /* @__PURE__ */ new WeakMap();
this._idmap = /* @__PURE__ */ 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 : void 0;
}
return this._map.get(schema);
}
has(schema) {
return this._map.has(schema);
}
};
function registry() {
return new $ZodRegistry();
}
(_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
var globalRegistry = globalThis.__zod_globalRegistry;
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/compile.js
var INVALID = Symbol.for("zod.compile.invalid");
var FALLBACK_FLAG = Symbol.for("zod.compile.fallback");
var ZodCompileAsyncError = class extends Error {
constructor(message = "z.compile does not support async refinements, transforms, or checks") {
super(message);
this.name = "ZodCompileAsyncError";
}
};
var ZodCompileUnsupportedError = class extends Error {
constructor(feature, islandable = true) {
super(`z.compile does not support ${feature}; this schema must use the runtime parser`);
this.name = "ZodCompileUnsupportedError";
this.islandable = islandable;
}
};
function compileValidator(schema, parser) {
try {
return compileFn(schema, { assertOnly: true });
} catch {
return parser;
}
}
function compile(schema, options) {
try {
const parser = compileFn(schema);
const clone2 = withParser(schema, parser);
clone2._zod.bag.validator = compileValidator(schema, parser);
return clone2;
} catch (err) {
if (options?.strict)
throw err;
return schema;
}
}
function withParser(schema, parser) {
if (isRecursiveSchema(schema)) {
throw new ZodCompileUnsupportedError("a schema whose subtree contains a reference cycle");
}
const clone2 = clone(schema);
const liveRun = schema._zod.run;
const originalRun = liveRun.__originalRun ?? liveRun;
const wrapped = (payload, ctx) => {
if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks || ctx?.[FALLBACK_FLAG]) {
return originalRun(payload, ctx);
}
if (ctx && isBackEdge(ctx, payload.value)) {
return originalRun(payload, ctx);
}
const out = parser(payload.value);
if (out !== INVALID) {
payload.value = out;
return payload;
}
if (ctx)
ctx[FALLBACK_FLAG] = true;
return originalRun(payload, ctx);
};
wrapped.__originalRun = originalRun;
clone2._zod.bag.fallbackRun = originalRun;
clone2._zod.bag.validator = parser;
clone2._zod.run = wrapped;
if (!liveRun.__originalRun)
installCompiledUserMethods(clone2, schema, parser);
return clone2;
}
function installCompiledUserMethods(target, source, parser) {
const targetAny = target;
const sourceAny = source;
if (typeof sourceAny.safeParse === "function") {
const originalSafeParse = sourceAny.safeParse;
targetAny.safeParse = (data, params) => {
const out = parser(data);
if (out !== INVALID) {
return { success: true, data: out };
}
return originalSafeParse(data, params);
};
}
if (typeof sourceAny.parse === "function") {
const originalParse = sourceAny.parse;
targetAny.parse = (data, params) => {
const out = parser(data);
if (out !== INVALID) {
return out;
}
return originalParse(data, params);
};
}
}
function compileFn(schema, options) {
let recursive2 = true;
try {
recursive2 = isRecursiveSchema(schema);
} catch {
}
if (recursive2) {
throw new ZodCompileUnsupportedError("a schema whose subtree contains a reference cycle");
}
const ctx = {
constants: /* @__PURE__ */ new Map(),
constantCounter: 0,
varCounter: 0,
definite: true
};
const doc = new Doc(["input"]);
const outputAccessor = generateCheck(doc, ctx, schema, "input", !options?.assertOnly);
doc.write(outputAccessor === null ? `return true;` : `return ${outputAccessor};`);
const constantNames = ["INVALID", ...ctx.constants.keys()];
const constantValues = [INVALID, ...ctx.constants.values()];
const code = doc.content.join("\n");
const fullCode = options?.debug ? constantNames.length > 0 ? `// Constants: ${constantNames.join(", ")}
${code}` : code : "";
const F = Function;
const factoryCode = `return (input) => {
${code}
}`;
let fn;
try {
const factory = new F(...constantNames, factoryCode);
fn = factory(...constantValues);
} catch (err) {
throw new ZodCompileUnsupportedError(`this schema (generated code failed to evaluate: ${err.message})`);
}
if (options?.debug) {
fn.code = fullCode;
}
fn.definite = ctx.definite;
return fn;
}
function addConstant(ctx, value) {
for (const [name2, v] of ctx.constants) {
if (v === value)
return name2;
}
const name = `c${ctx.constantCounter++}`;
ctx.constants.set(name, value);
return name;
}
function addUserConstant(ctx, fn) {
ctx.definite = false;
return addConstant(ctx, fn);
}
function newVar(ctx) {
return `v${ctx.varCounter++}`;
}
function runtimeRun(schema, value) {
const result = schema._zod.run({ value, issues: [] }, {});
if (result && typeof result.then === "function")
return INVALID;
const r = result;
return r.issues.length === 0 ? r.value : INVALID;
}
function compileChild(doc, ctx, schema, accessor, needsValue = true) {
const contentLen = doc.content.length;
const constantCount = ctx.constants.size;
const constantCounter = ctx.constantCounter;
const varCounter = ctx.varCounter;
try {
return generateCheck(doc, ctx, schema, accessor, needsValue);
} catch (err) {
if (!(err instanceof ZodCompileUnsupportedError) || !err.islandable)
throw err;
doc.content.length = contentLen;
if (ctx.constants.size > constantCount) {
const trailing = Array.from(ctx.constants.keys()).slice(constantCount);
for (const k of trailing)
ctx.constants.delete(k);
}
ctx.constantCounter = constantCounter;
ctx.varCounter = varCounter;
return emitRuntimeIsland(doc, ctx, schema, accessor);
}
}
function emitRuntimeIsland(doc, ctx, schema, accessor) {
ctx.definite = false;
const schemaConst = addConstant(ctx, schema);
const runConst = addConstant(ctx, runtimeRun);
const outVar = newVar(ctx);
doc.write(`const ${outVar} = ${runConst}(${schemaConst}, ${accessor});`);
doc.write(`if (${outVar} === INVALID) return INVALID;`);
return outVar;
}
var WHEN_DEFAULTED_CHECKS = /* @__PURE__ */ new Set([
"max_size",
"min_size",
"size_equals",
"max_length",
"min_length",
"length_equals"
]);
function generateChecks(doc, ctx, schema, accessor) {
const schemaChecks = schema._zod.def.checks;
if (!schemaChecks || schemaChecks.length === 0)
return accessor;
let currentAccessor = accessor;
for (const check2 of schemaChecks) {
const def = check2._zod.def;
if (def.when && !WHEN_DEFAULTED_CHECKS.has(def.check)) {
throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
}
switch (def.check) {
case "greater_than":
generateGreaterThanCheck(doc, ctx, def, currentAccessor);
break;
case "less_than":
generateLessThanCheck(doc, ctx, def, currentAccessor);
break;
case "multiple_of":
generateMultipleOfCheck(doc, ctx, def, currentAccessor);
break;
case "number_format":
generateNumberFormatCheck(doc, def, currentAccessor);
break;
case "min_length": {
const min = numericOperand(def.minimum, "min_length");
const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length >= ${min} && ${currentAccessor}.length < ${def.minimum * 2}`);
doc.write(`if (${len} < ${min}) return INVALID;`);
break;
}
case "max_length": {
const max = numericOperand(def.maximum, "max_length");
const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length > ${max}`);
doc.write(`if (${len} > ${max}) return INVALID;`);
break;
}
case "length_equals": {
const exact = numericOperand(def.length, "length_equals");
const len = codePointLengthVar(doc, ctx, currentAccessor, `${currentAccessor}.length >= ${exact} && ${currentAccessor}.length <= ${def.length * 2}`);
doc.write(`if (${len} !== ${exact}) return INVALID;`);
break;
}
case "min_size":
doc.write(`if (${currentAccessor}.size < ${numericOperand(def.minimum, "min_size")}) return INVALID;`);
break;
case "max_size":
doc.write(`if (${currentAccessor}.size > ${numericOperand(def.maximum, "max_size")}) return INVALID;`);
break;
case "size_equals":
doc.write(`if (${currentAccessor}.size !== ${numericOperand(def.size, "size_equals")}) return INVALID;`);
break;
case "string_format":
currentAccessor = generateStringFormatCheck(doc, ctx, def, currentAccessor);
break;
case "custom":
currentAccessor = generateCustomRefineCheck(doc, ctx, check2, currentAccessor);
break;
case "bigint_format":
generateBigIntFormatCheck(doc, def, currentAccessor);
break;
case "mime_type":
generateMimeTypeCheck(doc, ctx, def, currentAccessor);
break;
case "property":
generatePropertyCheck(doc, ctx, def, currentAccessor);
break;
case "properties":
generatePropertiesChecks(doc, ctx, def, currentAccessor);
break;
case "overwrite": {
const newAccessor = newVar(ctx);
generateOverwriteCheck(doc, ctx, check2, currentAccessor, newAccessor);
currentAccessor = newAccessor;
break;
}
default: {
void def;
throw new ZodCompileUnsupportedError(`check type ${def.check}`);
}
}
}
return currentAccessor;
}
function codePointLengthVar(doc, ctx, accessor, inDoubt) {
const cpLen = addConstant(ctx, codePointLength);
const v = newVar(ctx);
doc.write(`const ${v} = typeof ${accessor} === "string" && ${inDoubt} ? ${cpLen}(${accessor}) : ${accessor}.length;`);
return v;
}
function numericOperand(value, label) {
if (typeof value !== "number" || !Number.isFinite(value)) {
throw new ZodCompileUnsupportedError(`${label} bound of type ${typeof value}`);
}
return `${value}`;
}
function comparisonOperand(ctx, value) {
if (typeof value === "bigint")
return `${value}n`;
if (typeof value === "number") {
if (Number.isNaN(value))
throw new ZodCompileUnsupportedError("comparison check with NaN bound");
return `${value}`;
}
if (value instanceof Date) {
if (Number.isNaN(value.getTime())) {
throw new ZodCompileUnsupportedError("comparison check with Invalid Date bound");
}
return addConstant(ctx, value);
}
throw new ZodCompileUnsupportedError(`comparison check bound of type ${typeof value}`);
}
function generateGreaterThanCheck(doc, ctx, def, accessor) {
const op = def.inclusive ? "<" : "<=";
doc.write(`if (${accessor} ${op} ${comparisonOperand(ctx, def.value)}) return INVALID;`);
}
function generateLessThanCheck(doc, ctx, def, accessor) {
const op = def.inclusive ? ">" : ">=";
doc.write(`if (${accessor} ${op} ${comparisonOperand(ctx, def.value)}) return INVALID;`);
}
function generateMultipleOfCheck(doc, ctx, def, accessor) {
if (typeof def.value === "bigint") {
if (def.value === BigInt(0))
throw new ZodCompileUnsupportedError("multiple_of check with a zero divisor");
doc.write(`if (${accessor} % ${def.value}n !== 0n) return INVALID;`);
} else {
const remainder = addConstant(ctx, floatSafeRemainder);
doc.write(`if (${remainder}(${accessor}, ${numericOperand(def.value, "multiple_of")}) !== 0) return INVALID;`);
}
}
function generateNumberFormatCheck(doc, def, accessor) {
const format = def.format;
switch (format) {
case "safeint":
doc.write(`if (!Number.isSafeInteger(${accessor})) return INVALID;`);
break;
case "int32":
doc.write(`if (!Number.isInteger(${accessor}) || ${accessor} < -2147483648 || ${accessor} > 2147483647) return INVALID;`);
break;
case "uint32":
doc.write(`if (!Number.isInteger(${accessor}) || ${accessor} < 0 || ${accessor} > 4294967295) return INVALID;`);
break;
case "float32":
doc.write(`if (!Number.isFinite(${accessor}) || ${accessor} < -3.4028234663852886e38 || ${accessor} > 3.4028234663852886e38) return INVALID;`);
break;
case "float64":
doc.write(`if (!Number.isFinite(${accessor})) return INVALID;`);
break;
default: {
void format;
throw new ZodCompileUnsupportedError(`number format ${format}`);
}
}
}
function generateBigIntFormatCheck(doc, def, accessor) {
const format = def.format;
if (!format)
return;
switch (format) {
case "int64":
doc.write(`if (${accessor} < -9223372036854775808n || ${accessor} > 9223372036854775807n) return INVALID;`);
break;
case "uint64":
doc.write(`if (${accessor} < 0n || ${accessor} > 18446744073709551615n) return INVALID;`);
break;
default: {
void format;
throw new ZodCompileUnsupportedError(`bigint format ${format}`);
}
}
}
function generateMimeTypeCheck(doc, ctx, def, accessor) {
const mimeTypes = def.mime;
if (mimeTypes && mimeTypes.length > 0) {
const mimeSet = addConstant(ctx, new Set(mimeTypes));
doc.write(`if (!${mimeSet}.has(${accessor}.type)) return INVALID;`);
}
}
function generatePropertiesChecks(doc, ctx, def, accessor) {
if (def.when) {
throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
}
doc.write(`if (${accessor} == null) return INVALID;`);
const shape = def.shape;
for (const key of Reflect.ownKeys(shape)) {
const keyExpr = typeof key === "symbol" ? addConstant(ctx, key) : esc(key);
const inputVar = newVar(ctx);
doc.write(`const ${inputVar} = ${accessor}[${keyExpr}];`);
compileChild(doc, ctx, shape[key], inputVar, false);
}
}
function generatePropertyCheck(doc, ctx, def, accessor) {
const propAccessor = `${accessor}[${JSON.stringify(def.property)}]`;
generateCheck(doc, ctx, def.schema, propAccessor);
}
function generateOverwriteCheck(doc, ctx, check2, currentAccessor, newAccessor) {
const tx = check2._zod.def.tx;
if (!tx) {
throw new ZodCompileUnsupportedError("overwrite check without a transform function");
}
if (isAsyncFunction(tx)) {
throw new ZodCompileAsyncError("z.compile: async overwrite transforms are not supported");
}
const txConst = addConstant(ctx, tx);
doc.write(`const ${newAccessor} = ${txConst}(${currentAccessor});`);
}
function throwAsync() {
throw new $ZodAsyncError();
}
function pushIssue(issue2) {
this.issues.push(issue2);
}
function generateCustomRefineCheck(doc, ctx, check2, accessor) {
const def = check2._zod.def;
if (def.fn) {
if (isAsyncFunction(def.fn)) {
throw new ZodCompileAsyncError("z.compile: async .refine() predicates are not supported");
}
const fnConst = addUserConstant(ctx, def.fn);
const throwAsyncConst = addConstant(ctx, throwAsync);
const resVar = newVar(ctx);
doc.write(`const ${resVar} = ${fnConst}(${accessor});`);
doc.write(`if (${resVar} instanceof Promise) ${throwAsyncConst}();`);
doc.write(`if (!${resVar}) return INVALID;`);
return accessor;
}
if (check2._zod.check) {
if (isAsyncFunction(check2._zod.check)) {
throw new ZodCompileAsyncError("z.compile: async .superRefine() / check functions are not supported");
}
const checkFn = check2._zod.check;
const helperFn = (value) => {
const fakePayload = { value, issues: [], addIssue: pushIssue };
const result = checkFn(fakePayload);
if (result instanceof Promise)
throwAsync();
return fakePayload.issues.length === 0 ? fakePayload.value : INVALID;
};
const helperConst = addUserConstant(ctx, helperFn);
const outVar = newVar(ctx);
doc.write(`const ${outVar} = ${helperConst}(${accessor});`);
doc.write(`if (${outVar} === INVALID) return INVALID;`);
return outVar;
}
throw new ZodCompileUnsupportedError("custom check without a predicate or check function");
}
var PATTERN_IS_COMPLETE = /* @__PURE__ */ new Set([
"cidrv4",
"cuid",
"cuid2",
"date",
"datetime",
"duration",
"e164",
"email",
"emoji",
"ends_with",
"guid",
"includes",
"ipv4",
"ksuid",
"lowercase",
"mac",
"nanoid",
"regex",
"starts_with",
"time",
"ulid",
"uppercase",
"uuid",
"xid"
]);
function generateStringFormatCheck(doc, ctx, def, accessor, needsValue = true) {
const fmt = def.format;
if (fmt === "base64") {
const validator = addConstant(ctx, isValidBase64);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "base64url") {
const validator = addConstant(ctx, isValidBase64URL);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "jwt") {
const validator = addConstant(ctx, isValidJWT);
const alg = addConstant(ctx, def.alg ?? null);
doc.write(`if (!${validator}(${accessor}, ${alg})) return INVALID;`);
return accessor;
}
if (fmt === "ipv6") {
const validator = addConstant(ctx, isValidIPv6);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "cidrv6") {
const validator = addConstant(ctx, isValidCIDRv6);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "credit_card") {
const validator = addConstant(ctx, isValidCreditCard);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
if (fmt === "iban") {
const validator = addConstant(ctx, isValidIBAN);
doc.write(`if (!${validator}(${accessor})) return INVALID;`);
return accessor;
}
const formatDef = def;
if (fmt === "url" || fmt === "httpurl" || formatDef.normalize || formatDef.hostname !== void 0 || formatDef.protocol !== void 0) {
const parseConst = addConstant(ctx, validateURL);
const defConst = addConstant(ctx, def);
const trimVar = newVar(ctx);
const urlVar = newVar(ctx);
doc.write(`const ${trimVar} = ${accessor}.trim();`);
doc.write(`const ${urlVar} = ${parseConst}(${trimVar}, ${defConst});`);
doc.write(`if (typeof ${urlVar} === "number") return INVALID;`);
if (formatDef.hostname !== void 0) {
const hostnameConst = addConstant(ctx, urlHostnameOk);
doc.write(`if (!${hostnameConst}(${urlVar}, ${defConst}.hostname)) return INVALID;`);
}
if (formatDef.protocol !== void 0) {
const protocolConst = addConstant(ctx, urlProtocolOk);
doc.write(`if (!${protocolConst}(${urlVar}, ${defConst}.protocol)) return INVALID;`);
}
if (!needsValue)
return null;
const outputVar = newVar(ctx);
const outputExpr = formatDef.normalize ? `${urlVar}.href` : `${addConstant(ctx, stripTabAndNewline)}(${trimVar})`;
doc.write(`const ${outputVar} = ${outputExpr};`);
return outputVar;
}
const customFn = def.fn;
if (customFn) {
if (isAsyncFunction(customFn))
throw new ZodCompileUnsupportedError(`async string format ${fmt}`);
const fnConst = addConstant(ctx, customFn);
doc.write(`if (!${fnConst}(${accessor})) return INVALID;`);
return accessor;
}
if (PATTERN_IS_COMPLETE.has(fmt) && def.pattern) {
const patternConst = addConstant(ctx, def.pattern);
doc.write(`${patternConst}.lastIndex = 0;`);
doc.write(`if (!${patternConst}.test(${accessor})) return INVALID;`);
return accessor;
}
const format = def.format;
switch (format) {
case "regex":
throw new ZodCompileUnsupportedError("regex format without a pattern");
case "lowercase":
doc.write(`if (${accessor} !== ${accessor}.toLowerCase()) return INVALID;`);
break;
case "uppercase":
doc.write(`if (${accessor} !== ${accessor}.toUpperCase()) return INVALID;`);
break;
case "includes":
doc.write(`if (!${accessor}.includes(${esc(def.includes)})) return INVALID;`);
break;
case "starts_with": {
const prefix = def.prefix;
doc.write(`if (${accessor}.slice(0, ${prefix.length}) !== ${esc(prefix)}) return INVALID;`);
break;
}
case "ends_with": {
const suffix = def.suffix;
doc.write(`if (${accessor}.slice(-${suffix.length}) !== ${esc(suffix)}) return INVALID;`);
break;
}
default: {
void format;
throw new ZodCompileUnsupportedError(`string format ${format}`);
}
}
return accessor;
}
function generateCheck(doc, ctx, schema, accessor, needsValue = true) {
const def = schema._zod.def;
const type = def.type;
if (def.coerce) {
throw new ZodCompileUnsupportedError(`coercion (z.coerce.${type}())`);
}
const buildsValue = needsValue || !!def.checks?.length;
let typeAccessor;
switch (type) {
case "string":
typeAccessor = generateStringCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "number":
typeAccessor = generateNumberCheck(doc, schema, accessor);
break;
case "boolean":
typeAccessor = generateBooleanCheck(doc, accessor);
break;
case "bigint":
typeAccessor = generateBigIntCheck(doc, schema, accessor);
break;
case "symbol":
typeAccessor = generateSymbolCheck(doc, accessor);
break;
case "undefined":
typeAccessor = generateUndefinedCheck(doc, accessor);
break;
case "null":
typeAccessor = generateNullCheck(doc, accessor);
break;
case "any":
case "unknown":
typeAccessor = accessor;
break;
case "never":
doc.write("return INVALID;");
typeAccessor = accessor;
break;
case "void":
typeAccessor = generateVoidCheck(doc, accessor);
break;
case "nan":
typeAccessor = generateNaNCheck(doc, accessor);
break;
case "date":
typeAccessor = generateDateCheck(doc, accessor);
break;
case "object":
typeAccessor = generateObjectCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "optional":
typeAccessor = generateOptionalCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "nullable":
typeAccessor = generateNullableCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "array":
typeAccessor = generateArrayCheck(doc, ctx, schema, accessor, buildsValue);
break;
case "literal":
typeAccessor = generateLiteralCheck(doc, ctx, schema, accessor);
break;
case "enum":
typeAccessor = generateEnumCheck(doc, ctx, schema, accessor);
break;
case "readonly": {
const innerOut = generateWrapperCheck(doc, ctx, schema, accessor);
const frozenVar = newVar(ctx);
doc.write(`const ${frozenVar} = Object.freeze(${innerOut});`);
typeAccessor = frozenVar;
break;
}
case "success":
generateWrapperCheck(doc, ctx, schema, accessor);
typeAccessor = "true";
break;
case "default":
case "prefault":
typeAccessor = generateDefaultCheck(doc, ctx, schema, accessor);
break;
case "nonoptional":
typeAccessor = generateNonOptionalCheck(doc, ctx, schema, accessor);
break;
case "tuple":
typeAccessor = generateTupleCheck(doc, ctx, schema, accessor);
break;
case "union":
typeAccessor = generateUnionCheck(doc, ctx, schema, accessor);
break;
case "intersection":
typeAccessor = generateIntersectionCheck(doc, ctx, schema, accessor);
break;
case "record":
typeAccessor = generateRecordCheck(doc, ctx, schema, accessor);
break;
case "map":
typeAccessor = generateMapCheck(doc, ctx, schema, accessor);
break;
case "set":
typeAccessor = generateSetCheck(doc, ctx, schema, accessor);
break;
case "file":
typeAccessor = generateFileCheck(doc, accessor);
break;
case "template_literal":
typeAccessor = generateTemplateLiteralCheck(doc, ctx, schema, accessor);
break;
case "lazy":
typeAccessor = generateLazyCheck(doc, ctx, schema, accessor);
break;
case "pipe":
typeAccessor = generatePipeCheck(doc, ctx, schema, accessor);
break;
case "custom":
typeAccessor = generateCustomCheck(doc, ctx, schema, accessor);
break;
case "transform":
typeAccessor = generateTransformCheck(doc, ctx, schema, accessor);
break;
case "catch":
typeAccessor = generateCatchCheck(doc, ctx, schema, accessor);
break;
default: {
void type;
throw new ZodCompileUnsupportedError(`schema type ${type}`);
}
}
if (typeAccessor === null)
return null;
return generateChecks(doc, ctx, schema, typeAccessor);
}
function generateStringCheck(doc, ctx, schema, accessor, needsValue = true) {
doc.write(`if (typeof ${accessor} !== "string") return INVALID;`);
const def = schema._zod.def;
if (def.format === void 0)
return accessor;
return generateStringFormatCheck(doc, ctx, def, accessor, needsValue);
}
function generateNumberCheck(doc, schema, accessor) {
doc.write(`if (typeof ${accessor} !== "number" || !Number.isFinite(${accessor})) return INVALID;`);
const def = schema._zod.def;
if (def.check === "number_format" && def.format) {
generateNumberFormatCheck(doc, { format: def.format }, accessor);
}
return accessor;
}
function generateBooleanCheck(doc, accessor) {
doc.write(`if (typeof ${accessor} !== "boolean") return INVALID;`);
return accessor;
}
function generateBigIntCheck(doc, schema, accessor) {
doc.write(`if (typeof ${accessor} !== "bigint") return INVALID;`);
const def = schema._zod.def;
if (def.format) {
switch (def.format) {
case "int64":
doc.write(`if (${accessor} < -9223372036854775808n || ${accessor} > 9223372036854775807n) return INVALID;`);
break;
case "uint64":
doc.write(`if (${accessor} < 0n || ${accessor} > 18446744073709551615n) return INVALID;`);
break;
}
}
return accessor;
}
function generateSymbolCheck(doc, accessor) {
doc.write(`if (typeof ${accessor} !== "symbol") return INVALID;`);
return accessor;
}
function generateUndefinedCheck(doc, accessor) {
doc.write(`if (${accessor} !== undefined) return INVALID;`);
return accessor;
}
function generateNullCheck(doc, accessor) {
doc.write(`if (${accessor} !== null) return INVALID;`);
return accessor;
}
function generateVoidCheck(doc, accessor) {
doc.write(`if (${accessor} !== undefined) return INVALID;`);
return accessor;
}
function generateNaNCheck(doc, accessor) {
doc.write(`if (typeof ${accessor} !== "number" || !Number.isNaN(${accessor})) return INVALID;`);
return accessor;
}
function generateDateCheck(doc, accessor) {
doc.write(`if (!(${accessor} instanceof Date) || Number.isNaN(${accessor}.getTime())) return INVALID;`);
return accessor;
}
function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
doc.write(`if (typeof ${accessor} !== "object" || ${accessor} === null || Array.isArray(${accessor})) return INVALID;`);
const shape = def.shape;
const keys = Object.keys(shape);
const symbolKeys = Object.getOwnPropertySymbols(shape);
const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;
const keyExpr = (k) => typeof k === "symbol" ? addConstant(ctx, k) : esc(k);
const propKey = (k) => typeof k === "symbol" ? `[${keyExpr(k)}]` : esc(k);
const propShape = shape;
if (keys.includes("__proto__")) {
throw new ZodCompileUnsupportedError('object shape key "__proto__"');
}
const propOutputs = /* @__PURE__ */ new Map();
for (const key of allKeys) {
const propSchema = propShape[key];
const kx = keyExpr(key);
const inputVar = newVar(ctx);
doc.write(`const ${inputVar} = ${accessor}[${kx}];`);
if (propSchema._zod.optin !== void 0) {
const outputVar2 = newVar(ctx);
doc.write(`let ${outputVar2} = (() => {`);
doc.indented((d) => {
const outputAccessor = compileChild(d, ctx, propSchema, inputVar);
d.write(`return ${outputAccessor};`);
});
doc.write(`})();`);
if (propSchema._zod.optout === "optional") {
doc.write(`if (${outputVar2} === INVALID) {`);
doc.indented((d) => {
d.write(`if (${kx} in ${accessor}) return INVALID;`);
d.write(`${outputVar2} = undefined;`);
});
doc.write(`}`);
} else {
doc.write(`if (${outputVar2} === INVALID) return INVALID;`);
}
propOutputs.set(key, outputVar2);
} else {
if (requiresPresenceCheck(propSchema)) {
doc.write(`if (!(${kx} in ${accessor})) return INVALID;`);
}
const outputAccessor = compileChild(doc, ctx, propSchema, inputVar, buildsValue);
if (outputAccessor !== null)
propOutputs.set(key, outputAccessor);
}
}
const catchall = def.catchall;
let unknownKeysMode = "none";
if (catchall) {
const catchallType = catchall._zod.def.type;
if (catchallType === "never") {
const condition = keys.map((k) => `k !== ${esc(k)}`).join(" && ") || "true";
doc.write(`for (const k in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (${condition}) return INVALID;`);
});
doc.write(`}`);
} else if ((catchallType === "unknown" || catchallType === "any") && !catchall._zod.def.checks?.length) {
unknownKeysMode = "passthrough";
} else {
unknownKeysMode = "schema";
}
}
const outputVar = newVar(ctx);
const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]) || dropsWhenAbsent(propShape[k]));
if (!buildsValue) {
if (unknownKeysMode === "schema") {
const knownSet = keys.length > 0 ? addConstant(ctx, new Set(keys)) : null;
doc.write(`for (const k in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (k === "__proto__") continue;`);
if (knownSet)
d.write(`if (${knownSet}.has(k)) continue;`);
const valVar = newVar(ctx);
d.write(`const ${valVar} = ${accessor}[k];`);
compileChild(d, ctx, catchall, valVar, false);
});
doc.write(`}`);
}
return null;
}
if (!hasConditionalKeys) {
const propLiterals = allKeys.map((k) => `${propKey(k)}: ${propOutputs.get(k)}`).join(", ");
doc.write(`const ${outputVar} = { ${propLiterals} };`);
} else {
doc.write(`const ${outputVar} = {};`);
for (const k of allKeys) {
const kx = keyExpr(k);
const out = propOutputs.get(k);
if (dropsWhenAbsent(propShape[k])) {
doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
} else if (mayOmitUndefined(propShape[k])) {
doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
} else {
doc.write(`${outputVar}[${kx}] = ${out};`);
}
}
}
if (unknownKeysMode !== "none") {
const knownSet = keys.length > 0 ? addConstant(ctx, new Set(keys)) : null;
doc.write(`for (const k in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (k === "__proto__") continue;`);
if (knownSet)
d.write(`if (${knownSet}.has(k)) continue;`);
if (unknownKeysMode === "passthrough") {
d.write(`${outputVar}[k] = ${accessor}[k];`);
} else {
const valVar = newVar(ctx);
d.write(`const ${valVar} = ${accessor}[k];`);
const catchallOut = compileChild(d, ctx, catchall, valVar);
d.write(`${outputVar}[k] = ${catchallOut};`);
}
});
doc.write(`}`);
}
return outputVar;
}
function generateOptionalCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
if (isExactOptional(schema)) {
return generateCheck(doc, ctx, def.innerType, accessor, buildsValue);
}
if (def.innerType._zod.optin === "defaulted") {
const outputVar2 = newVar(ctx);
const branchVar = newVar(ctx);
doc.write(`let ${outputVar2};`);
doc.write(`if (${accessor} === undefined) {`);
doc.indented((d) => {
d.write(`const ${branchVar} = (() => {`);
d.indented((d2) => {
const innerOutput = generateCheck(d2, ctx, def.innerType, accessor);
d2.write(`return ${innerOutput};`);
});
d.write(`})();`);
d.write(`if (${branchVar} !== INVALID) ${outputVar2} = ${branchVar};`);
});
doc.write(`} else {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor);
d.write(`${outputVar2} = ${innerOutput};`);
});
doc.write(`}`);
return outputVar2;
}
const outputVar = buildsValue ? newVar(ctx) : null;
if (outputVar)
doc.write(`let ${outputVar};`);
doc.write(`if (${accessor} !== undefined) {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor, buildsValue);
if (outputVar && innerOutput !== null)
d.write(`${outputVar} = ${innerOutput};`);
});
doc.write(`}`);
return outputVar;
}
function isExactOptional(schema) {
return schema._zod.traits?.has("$ZodExactOptional") === true;
}
function requiresPresenceCheck(schema) {
return schema._zod.optin === void 0 && fastPathAcceptsAbsence(schema);
}
function fastPathAcceptsAbsence(schema) {
if (schema._zod.def.coerce)
return true;
const def = schema._zod.def;
switch (def.type) {
case "any":
case "unknown":
case "undefined":
case "void":
case "default":
case "prefault":
case "transform":
case "custom":
case "lazy":
return true;
case "string":
case "number":
case "boolean":
case "bigint":
case "symbol":
case "null":
case "never":
case "nan":
case "date":
case "object":
case "array":
case "tuple":
case "record":
case "map":
case "set":
case "file":
case "template_literal":
return false;
case "nonoptional":
return def.innerType ? fastPathAcceptsAbsence(def.innerType) : false;
case "literal":
return !!def.values?.includes(void 0);
case "enum":
return !!schema._zod.values?.has(void 0);
case "optional":
case "nullable":
case "readonly":
case "success":
return def.innerType ? fastPathAcceptsAbsence(def.innerType) : true;
case "catch":
return true;
case "union":
return def.options ? def.options.some(fastPathAcceptsAbsence) : true;
case "intersection":
if (!def.left || !def.right)
return true;
return fastPathAcceptsAbsence(def.left) && fastPathAcceptsAbsence(def.right);
case "pipe":
return def.in ? fastPathAcceptsAbsence(def.in) : true;
default:
return true;
}
}
function dropsWhenAbsent(schema) {
return schema._zod.optin === "optional" && schema._zod.optout === "optional";
}
function mayOmitUndefined(schema) {
return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
}
function mayOutputUndefined(schema) {
const def = schema._zod.def;
switch (def.type) {
case "string":
case "number":
case "boolean":
case "bigint":
case "symbol":
case "null":
case "nan":
case "date":
case "object":
case "array":
case "tuple":
case "record":
case "map":
case "set":
case "file":
case "template_literal":
case "never":
case "success":
return false;
case "literal":
return !!def.values?.includes(void 0);
case "enum":
return !!schema._zod.values?.has(void 0);
case "optional":
return true;
case "nullable":
case "readonly":
case "nonoptional":
return def.innerType ? mayOutputUndefined(def.innerType) : true;
case "union":
return def.options ? def.options.some(mayOutputUndefined) : true;
case "intersection":
return !def.left || !def.right || mayOutputUndefined(def.left) || mayOutputUndefined(def.right);
case "pipe":
return def.out ? mayOutputUndefined(def.out) : true;
default:
return true;
}
}
function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
const outputVar = buildsValue ? newVar(ctx) : null;
if (outputVar)
doc.write(`let ${outputVar} = null;`);
doc.write(`if (${accessor} !== null) {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor, buildsValue);
if (outputVar && innerOutput !== null)
d.write(`${outputVar} = ${innerOutput};`);
});
doc.write(`}`);
return outputVar;
}
function generateSizeGate(doc, schema, size) {
for (const [max, check2] of sizeCaps(schema._zod.def.checks)) {
doc.write(`if (${size} > ${numericOperand(max, check2._zod.def.check)}) return INVALID;`);
}
}
function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
const def = schema._zod.def;
doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
generateSizeGate(doc, schema, `${accessor}.length`);
const outputVar = buildsValue ? newVar(ctx) : null;
const iVar = newVar(ctx);
const elemVar = newVar(ctx);
if (outputVar)
doc.write(`const ${outputVar} = new Array(${accessor}.length);`);
doc.write(`for (let ${iVar} = 0; ${iVar} < ${accessor}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${elemVar} = ${accessor}[${iVar}];`);
const elemOutput = compileChild(d, ctx, def.element, elemVar, buildsValue);
if (outputVar && elemOutput !== null)
d.write(`${outputVar}[${iVar}] = ${elemOutput};`);
});
doc.write(`}`);
return outputVar;
}
function generateLiteralCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const values = def.values;
if (values.length !== 1) {
const literalSet = addConstant(ctx, new Set(values));
doc.write(`if (!${literalSet}.has(${accessor})) return INVALID;`);
return accessor;
}
const value = values[0];
if (typeof value === "number" && Number.isNaN(value)) {
const literalSet = addConstant(ctx, new Set(values));
doc.write(`if (!${literalSet}.has(${accessor})) return INVALID;`);
return accessor;
}
if (typeof value === "string") {
doc.write(`if (${accessor} !== ${esc(value)}) return INVALID;`);
} else if (typeof value === "number" || typeof value === "boolean") {
doc.write(`if (${accessor} !== ${value}) return INVALID;`);
} else if (value === null) {
doc.write(`if (${accessor} !== null) return INVALID;`);
} else if (value === void 0) {
doc.write(`if (${accessor} !== undefined) return INVALID;`);
} else if (typeof value === "bigint") {
doc.write(`if (${accessor} !== ${value}n) return INVALID;`);
} else {
throw new ZodCompileUnsupportedError(`literal type ${typeof value}`);
}
return accessor;
}
function generateEnumCheck(doc, ctx, schema, accessor) {
const values = schema._zod.values;
if (!values) {
throw new ZodCompileUnsupportedError("enum schema without enumerated values");
}
const enumSet = addConstant(ctx, values);
doc.write(`if (!${enumSet}.has(${accessor})) return INVALID;`);
return accessor;
}
function generateWrapperCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
return generateCheck(doc, ctx, def.innerType, accessor);
}
function generateDefaultCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const descriptor = Object.getOwnPropertyDescriptor(schema._zod.def, "defaultValue");
const defaultGetter = descriptor ? () => schema._zod.def.defaultValue : void 0;
if (schema._zod.def.type === "prefault") {
if (!defaultGetter) {
return generateCheck(doc, ctx, def.innerType, accessor);
}
const defaultFn = addConstant(ctx, defaultGetter);
const inputVar = newVar(ctx);
doc.write(`let ${inputVar} = ${accessor};`);
doc.write(`if (${accessor} === undefined) ${inputVar} = ${defaultFn}();`);
return generateCheck(doc, ctx, def.innerType, inputVar);
}
const outputVar = newVar(ctx);
if (defaultGetter) {
const defaultFn = addConstant(ctx, defaultGetter);
const cloneFn = addConstant(ctx, shallowClone);
doc.write(`let ${outputVar};`);
doc.write(`if (${accessor} === undefined) {`);
doc.indented((d) => {
d.write(`${outputVar} = ${cloneFn}(${defaultFn}());`);
});
doc.write(`} else {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor);
d.write(`${outputVar} = ${innerOutput} === undefined ? ${cloneFn}(${defaultFn}()) : ${innerOutput};`);
});
doc.write(`}`);
} else {
doc.write(`let ${outputVar};`);
doc.write(`if (${accessor} !== undefined) {`);
doc.indented((d) => {
const innerOutput = generateCheck(d, ctx, def.innerType, accessor);
d.write(`${outputVar} = ${innerOutput};`);
});
doc.write(`}`);
}
return outputVar;
}
function generateNonOptionalCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const innerOutput = generateCheck(doc, ctx, def.innerType, accessor);
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = ${innerOutput};`);
doc.write(`if (${outputVar} === undefined) return INVALID;`);
return outputVar;
}
function generateTupleCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const items = def.items;
const rest = def.rest;
doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
const optinStart = getTupleOptStart2(items, "optin");
const optoutStart = getTupleOptStart2(items, "optout");
if (rest) {
doc.write(`if (${accessor}.length < ${optinStart}) return INVALID;`);
} else {
doc.write(`if (${accessor}.length < ${optinStart} || ${accessor}.length > ${items.length}) return INVALID;`);
}
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = [];`);
for (let i = 0; i < items.length; i++) {
const itemSchema = items[i];
if (i >= optoutStart) {
doc.write(`if (${outputVar}.length === ${i}) {`);
doc.indented((d) => {
d.write(`if (${i} < ${accessor}.length) {`);
d.indented((d2) => {
const elemVar = newVar(ctx);
d2.write(`const ${elemVar} = ${accessor}[${i}];`);
const elemOutput = compileChild(d2, ctx, itemSchema, elemVar);
d2.write(`${outputVar}[${i}] = ${elemOutput};`);
});
d.write(`} else {`);
d.indented((d2) => {
if (dropsWhenAbsent(itemSchema)) {
d2.write(`${outputVar}.length = ${i};`);
return;
}
const elemVar = newVar(ctx);
const branchVar = newVar(ctx);
d2.write(`const ${elemVar} = undefined;`);
d2.write(`const ${branchVar} = (() => {`);
d2.indented((d3) => {
const elemOutput = compileChild(d3, ctx, itemSchema, elemVar);
d3.write(`return ${elemOutput};`);
});
d2.write(`})();`);
d2.write(`if (${branchVar} === INVALID || ${branchVar} === undefined) ${outputVar}.length = ${i};`);
d2.write(`else ${outputVar}[${i}] = ${branchVar};`);
});
d.write(`}`);
});
doc.write(`}`);
} else {
const elemVar = newVar(ctx);
doc.write(`const ${elemVar} = ${accessor}[${i}];`);
const elemOutput = compileChild(doc, ctx, itemSchema, elemVar);
doc.write(`${outputVar}[${i}] = ${elemOutput};`);
}
}
if (rest) {
const iVar = newVar(ctx);
const elemVar = newVar(ctx);
doc.write(`for (let ${iVar} = ${items.length}; ${iVar} < ${accessor}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${elemVar} = ${accessor}[${iVar}];`);
const elemOutput = compileChild(d, ctx, rest, elemVar);
d.write(`${outputVar}[${iVar}] = ${elemOutput};`);
});
doc.write(`}`);
}
return outputVar;
}
function getTupleOptStart2(items, key) {
for (let i = items.length - 1; i >= 0; i--) {
const omittable = key === "optin" ? items[i]._zod.optin !== void 0 : items[i]._zod.optout === "optional";
if (!omittable)
return i + 1;
}
return 0;
}
function generateUnionCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const options = def.options;
if (def.discriminator) {
return generateDiscriminatedUnionCheck(doc, ctx, def, accessor);
}
if (def.inclusive === false) {
throw new ZodCompileUnsupportedError("exclusive unions (z.xor)");
}
if (options.length === 0) {
doc.write("return INVALID;");
return accessor;
}
if (options.length === 1) {
return generateCheck(doc, ctx, options[0], accessor);
}
const allLiterals = options.every((opt) => opt._zod.def.type === "literal" && !opt._zod.def.checks?.length);
if (allLiterals) {
const values = new Set(options.flatMap((opt) => opt._zod.def.values));
const valuesConst = addConstant(ctx, values);
doc.write(`if (!${valuesConst}.has(${accessor})) return INVALID;`);
return accessor;
}
const outputVar = newVar(ctx);
doc.write(`let ${outputVar};`);
for (let i = 0; i < options.length; i++) {
const opt = options[i];
if (i === 0) {
doc.write(`${outputVar} = (() => {`);
} else {
doc.write(`if (${outputVar} === INVALID) ${outputVar} = (() => {`);
}
doc.indented((d) => {
const branchOutput = generateCheck(d, ctx, opt, accessor);
d.write(`return ${branchOutput};`);
});
doc.write(`})();`);
}
doc.write(`if (${outputVar} === INVALID) return INVALID;`);
return outputVar;
}
function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
if (def.unionFallback) {
throw new ZodCompileUnsupportedError("discriminated union with unionFallback");
}
if (def.options.length === 0) {
doc.write("return INVALID;");
return accessor;
}
const discVar = newVar(ctx);
const outputVar = newVar(ctx);
doc.write(`const ${discVar} = ${accessor}?.[${esc(def.discriminator)}];`);
doc.write(`let ${outputVar};`);
let firstBranch = true;
const claimed = /* @__PURE__ */ new Set();
for (const option of def.options) {
const values = option._zod.propValues?.[def.discriminator];
if (!values || values.size === 0) {
throw new ZodCompileUnsupportedError("discriminated union option without static discriminator values");
}
for (const value of values) {
if (claimed.has(value)) {
throw new ZodCompileUnsupportedError(`duplicate discriminator value ${String(value)}`);
}
claimed.add(value);
}
const conditions = Array.from(values, (value) => literalEquality(ctx, discVar, value));
const prefix = firstBranch ? "if" : "else if";
doc.write(`${prefix} (${conditions.join(" || ")}) {`);
doc.indented((d) => {
const branchOutput = generateCheck(d, ctx, option, accessor);
d.write(`${outputVar} = ${branchOutput};`);
});
doc.write(`}`);
firstBranch = false;
}
doc.write(`else { return INVALID; }`);
return outputVar;
}
function literalEquality(ctx, accessor, value) {
if (typeof value === "string")
return `${accessor} === ${esc(value)}`;
if (typeof value === "number") {
if (Number.isNaN(value))
return `Number.isNaN(${accessor})`;
return `${accessor} === ${value}`;
}
if (typeof value === "boolean")
return `${accessor} === ${value}`;
if (value === null)
return `${accessor} === null`;
if (value === void 0)
return `${accessor} === undefined`;
if (typeof value === "bigint")
return `${accessor} === ${value}n`;
if (typeof value === "symbol") {
const symbolConst = addConstant(ctx, value);
return `${accessor} === ${symbolConst}`;
}
throw new ZodCompileUnsupportedError(`literal discriminator value ${String(value)}`);
}
function generateIntersectionCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
ctx.definite = false;
const leftOutput = compileChild(doc, ctx, def.left, accessor);
const rightOutput = compileChild(doc, ctx, def.right, accessor);
const mergeConst = addConstant(ctx, mergeValues);
const mergedVar = newVar(ctx);
doc.write(`const ${mergedVar} = ${mergeConst}(${leftOutput}, ${rightOutput});`);
doc.write(`if (!${mergedVar}.valid) return INVALID;`);
return `${mergedVar}.data`;
}
function generateRecordCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const isPlainObjectConst = addConstant(ctx, isPlainObject);
doc.write(`if (!${isPlainObjectConst}(${accessor})) return INVALID;`);
const outputVar = newVar(ctx);
const kVar = newVar(ctx);
const valVar = newVar(ctx);
doc.write(`const ${outputVar} = {};`);
const recordDef = def;
const keyValues = recordDef.partial ? void 0 : def.keyType._zod.values;
if (keyValues) {
const inputKeys = [];
for (const key of keyValues) {
if (!(typeof key === "string" || typeof key === "number" || typeof key === "symbol")) {
throw new ZodCompileUnsupportedError(`record key value ${String(key)}`);
}
const inputKey = typeof key === "number" ? key.toString() : key;
if (inputKey === "__proto__") {
throw new ZodCompileUnsupportedError('record key "__proto__"');
}
inputKeys.push(inputKey);
const keyConst = addConstant(ctx, key);
const outKey = generateCheck(doc, ctx, def.keyType, keyConst);
const valueVar = newVar(ctx);
doc.write(`const ${valueVar} = ${accessor}[${literalPropertyKey(ctx, inputKey)}];`);
const valOutput = compileChild(doc, ctx, def.valueType, valueVar);
doc.write(`${outputVar}[${outKey}] = ${valOutput};`);
}
const knownKeysConst = addConstant(ctx, new Set(inputKeys));
doc.write(`for (const ${kVar} in ${accessor}) {`);
doc.indented((d) => {
d.write(`if (${knownKeysConst}.has(${kVar})) continue;`);
if (recordDef.mode === "loose") {
d.write(`if (${kVar} !== "__proto__") ${outputVar}[${kVar}] = ${accessor}[${kVar}];`);
} else {
d.write(`return INVALID;`);
}
});
doc.write(`}`);
return outputVar;
}
const keyDef = def.keyType._zod.def;
const keyIsBareString = keyDef.type === "string" && keyDef.format === void 0 && !keyDef.coerce && (keyDef.checks?.length ?? 0) === 0;
if (!keyIsBareString) {
const isLoose = def.mode === "loose";
const keyFn = compileFn(def.keyType);
if (keyFn.definite === false)
ctx.definite = false;
const keyFast = addConstant(ctx, keyFn);
const numericConst = addConstant(ctx, number);
const outKeyVar = newVar(ctx);
emitOwnKeys(doc, ctx, accessor, kVar, (d) => {
d.write(`let ${outKeyVar} = ${keyFast}(${kVar});`);
d.write(`if (${outKeyVar} === INVALID && typeof ${kVar} === "string" && ${numericConst}.test(${kVar})) ${outKeyVar} = ${keyFast}(Number(${kVar}));`);
if (isLoose) {
d.write(`if (${outKeyVar} === INVALID) { ${outputVar}[${kVar}] = ${accessor}[${kVar}]; continue; }`);
} else {
d.write(`if (${outKeyVar} === INVALID) return INVALID;`);
}
d.write(`if (${outKeyVar} === "__proto__") continue;`);
const valueVar = newVar(ctx);
d.write(`const ${valueVar} = ${accessor}[${kVar}];`);
const valOutput = compileChild(d, ctx, def.valueType, valueVar);
d.write(`${outputVar}[${outKeyVar}] = ${valOutput};`);
});
return outputVar;
}
emitOwnKeys(doc, ctx, accessor, kVar, (d) => {
d.write(`const ${valVar} = ${accessor}[${kVar}];`);
const valOutput = compileChild(d, ctx, def.valueType, valVar);
d.write(`${outputVar}[${kVar}] = ${valOutput};`);
}, `return INVALID;`);
return outputVar;
}
function emitOwnKeys(doc, ctx, accessor, kVar, body, onSymbol) {
const propIsEnumerableConst = addConstant(ctx, Object.prototype.propertyIsEnumerable);
const symsVar = newVar(ctx);
const keysVar = newVar(ctx);
const iVar = newVar(ctx);
doc.write(`const ${symsVar} = Object.getOwnPropertySymbols(${accessor});`);
doc.write(`const ${keysVar} = Object.getOwnPropertyNames(${accessor});`);
doc.write(`for (let ${iVar} = 0; ${iVar} < ${keysVar}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${kVar} = ${keysVar}[${iVar}];`);
d.write(`if (${kVar} === "__proto__" || !${propIsEnumerableConst}.call(${accessor}, ${kVar})) continue;`);
body(d);
});
doc.write(`}`);
doc.write(`for (let ${iVar} = 0; ${iVar} < ${symsVar}.length; ${iVar}++) {`);
doc.indented((d) => {
d.write(`const ${kVar} = ${symsVar}[${iVar}];`);
d.write(`if (!${propIsEnumerableConst}.call(${accessor}, ${kVar})) continue;`);
if (onSymbol)
d.write(onSymbol);
else
body(d);
});
doc.write(`}`);
}
function literalPropertyKey(ctx, key) {
if (typeof key === "string")
return esc(key);
return addConstant(ctx, key);
}
function generateMapCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
generateSizeGate(doc, schema, `${accessor}.size`);
const outputVar = newVar(ctx);
const kVar = newVar(ctx);
const valVar = newVar(ctx);
doc.write(`const ${outputVar} = new Map();`);
doc.write(`for (const [${kVar}, ${valVar}] of ${accessor}) {`);
doc.indented((d) => {
const keyOutput = generateCheck(d, ctx, def.keyType, kVar);
const valOutput = generateCheck(d, ctx, def.valueType, valVar);
d.write(`${outputVar}.set(${keyOutput}, ${valOutput});`);
});
doc.write(`}`);
return outputVar;
}
function generateSetCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
generateSizeGate(doc, schema, `${accessor}.size`);
const outputVar = newVar(ctx);
const valVar = newVar(ctx);
doc.write(`const ${outputVar} = new Set();`);
doc.write(`for (const ${valVar} of ${accessor}) {`);
doc.indented((d) => {
const valOutput = generateCheck(d, ctx, def.valueType, valVar);
d.write(`${outputVar}.add(${valOutput});`);
});
doc.write(`}`);
return outputVar;
}
function generateFileCheck(doc, accessor) {
doc.write(`if (!(${accessor} instanceof File)) return INVALID;`);
return accessor;
}
function generateTemplateLiteralCheck(doc, ctx, schema, accessor) {
doc.write(`if (typeof ${accessor} !== "string") return INVALID;`);
const pattern = schema._zod.pattern;
if (pattern) {
const patternConst = addConstant(ctx, pattern);
doc.write(`${patternConst}.lastIndex = 0;`);
doc.write(`if (!${patternConst}.test(${accessor})) return INVALID;`);
}
return accessor;
}
function generateLazyCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const getterConst = addUserConstant(ctx, def.getter);
const cacheConst = addConstant(ctx, { parser: null });
doc.write(`if (!${cacheConst}.parser) {`);
doc.indented((d) => {
d.write(`const inner = ${getterConst}();`);
d.write(`${cacheConst}.parser = function(input) {`);
d.indented((d2) => {
d2.write(`const result = inner._zod.run({ value: input, issues: [] }, {});`);
d2.write(`return result.issues.length === 0 ? result.value : INVALID;`);
});
d.write(`};`);
});
doc.write(`}`);
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = ${cacheConst}.parser(${accessor});`);
doc.write(`if (${outputVar} === INVALID) return INVALID;`);
return outputVar;
}
function generatePipeCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
const inputOutput = generateCheck(doc, ctx, def.in, accessor);
if (def.transform) {
if (isAsyncFunction(def.transform)) {
throw new ZodCompileAsyncError("z.compile: async transforms in pipes are not supported");
}
const transformFn = def.transform;
const helperFn = (value) => {
const fakePayload = { value, issues: [], addIssue: pushIssue };
const result = transformFn(value, fakePayload);
if (result instanceof Promise)
return INVALID;
return fakePayload.issues.length === 0 ? result : INVALID;
};
const helperConst = addUserConstant(ctx, helperFn);
const transformedVar = newVar(ctx);
doc.write(`const ${transformedVar} = ${helperConst}(${inputOutput});`);
doc.write(`if (${transformedVar} === INVALID) return INVALID;`);
return generateCheck(doc, ctx, def.out, transformedVar);
} else {
return generateCheck(doc, ctx, def.out, inputOutput);
}
}
function isAsyncFunction(fn) {
return typeof fn === "function" && (fn.constructor.name === "AsyncFunction" || fn[Symbol.toStringTag] === "AsyncFunction");
}
function generateCustomCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
if (def.fn) {
if (isAsyncFunction(def.fn)) {
throw new ZodCompileAsyncError("z.compile: async custom predicates are not supported");
}
const fnConst = addUserConstant(ctx, def.fn);
const throwAsyncConst = addConstant(ctx, throwAsync);
const resVar = newVar(ctx);
doc.write(`const ${resVar} = ${fnConst}(${accessor});`);
doc.write(`if (${resVar} instanceof Promise) ${throwAsyncConst}();`);
doc.write(`if (!${resVar}) return INVALID;`);
} else {
throw new ZodCompileUnsupportedError("custom schema without a predicate function");
}
return accessor;
}
function runtimeCatch(innerSchema, catchValue, value) {
const result = innerSchema._zod.run({ value, issues: [] }, {});
if (result && typeof result.then === "function")
return INVALID;
const r = result;
if (r.issues.length === 0)
return r.value;
return catchValue();
}
function generateCatchCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
if (!def.catchValue[CONSTANT_CATCH]) {
throw new ZodCompileUnsupportedError("catch with a callback (only a constant catch value compiles)", false);
}
const outputVar = newVar(ctx);
doc.write(`let ${outputVar} = (() => {`);
doc.indented((d) => {
const innerOut = compileChild(d, ctx, def.innerType, accessor);
d.write(`return ${innerOut};`);
});
doc.write(`})();`);
const innerConst = addConstant(ctx, def.innerType);
const catchConst = addUserConstant(ctx, def.catchValue);
const catchHelperConst = addConstant(ctx, runtimeCatch);
doc.write(`if (${outputVar} === INVALID) {`);
doc.indented((d) => {
d.write(`${outputVar} = ${catchHelperConst}(${innerConst}, ${catchConst}, ${accessor});`);
d.write(`if (${outputVar} === INVALID) return INVALID;`);
});
doc.write(`}`);
return outputVar;
}
function generateTransformCheck(doc, ctx, schema, accessor) {
const def = schema._zod.def;
if (def.transform) {
if (isAsyncFunction(def.transform)) {
throw new ZodCompileAsyncError("z.compile: async transforms are not supported");
}
const transformFn = def.transform;
const helperFn = (value) => {
const fakePayload = { value, issues: [], addIssue: pushIssue };
const result = transformFn(value, fakePayload);
if (result instanceof Promise)
return INVALID;
return fakePayload.issues.length === 0 ? result : INVALID;
};
const helperConst = addUserConstant(ctx, helperFn);
const outputVar = newVar(ctx);
doc.write(`const ${outputVar} = ${helperConst}(${accessor});`);
doc.write(`if (${outputVar} === INVALID) return INVALID;`);
return outputVar;
}
return accessor;
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/api.js
function snapshotChecks(def) {
if (def.checks)
def.checks = [...def.checks];
return def;
}
// @__NO_SIDE_EFFECTS__
function _string(Class2, params) {
return new Class2(snapshotChecks({ type: "string", ...normalizeParams(params) }));
}
// @__NO_SIDE_EFFECTS__
function _coercedString(Class2, params) {
return new Class2(snapshotChecks({ type: "string", coerce: true, ...normalizeParams(params) }));
}
// @__NO_SIDE_EFFECTS__
function _email(Class2, params) {
return new Class2({
type: "string",
format: "email",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _guid(Class2, params) {
return new Class2({
type: "string",
format: "guid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuid(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuidv4(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v4",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuidv6(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v6",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuidv7(Class2, params) {
return new Class2({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v7",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _url(Class2, params) {
return new Class2({
type: "string",
format: "url",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _emoji2(Class2, params) {
return new Class2({
type: "string",
format: "emoji",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _nanoid(Class2, params) {
return new Class2({
type: "string",
format: "nanoid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _cuid(Class2, params) {
return new Class2({
type: "string",
format: "cuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _cuid2(Class2, params) {
return new Class2({
type: "string",
format: "cuid2",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ulid(Class2, params) {
return new Class2({
type: "string",
format: "ulid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _xid(Class2, params) {
return new Class2({
type: "string",
format: "xid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ksuid(Class2, params) {
return new Class2({
type: "string",
format: "ksuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ipv4(Class2, params) {
return new Class2({
type: "string",
format: "ipv4",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ipv6(Class2, params) {
return new Class2({
type: "string",
format: "ipv6",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _mac(Class2, params) {
return new Class2({
type: "string",
format: "mac",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _cidrv4(Class2, params) {
return new Class2({
type: "string",
format: "cidrv4",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _cidrv6(Class2, params) {
return new Class2({
type: "string",
format: "cidrv6",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _base64(Class2, params) {
return new Class2({
type: "string",
format: "base64",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _base64url(Class2, params) {
return new Class2({
type: "string",
format: "base64url",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _e164(Class2, params) {
return new Class2({
type: "string",
format: "e164",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _creditCard(Class2, params) {
return new Class2({
type: "string",
format: "credit_card",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _iban(Class2, params) {
return new Class2({
type: "string",
format: "iban",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
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
};
// @__NO_SIDE_EFFECTS__
function _isoDateTime(Class2, params) {
return new Class2({
type: "string",
format: "datetime",
check: "string_format",
offset: false,
local: false,
precision: null,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _isoDate(Class2, params) {
return new Class2({
type: "string",
format: "date",
check: "string_format",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _isoTime(Class2, params) {
return new Class2({
type: "string",
format: "time",
check: "string_format",
precision: null,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _isoDuration(Class2, params) {
return new Class2({
type: "string",
format: "duration",
check: "string_format",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _number(Class2, params) {
return new Class2(snapshotChecks({ type: "number", checks: [], ...normalizeParams(params) }));
}
// @__NO_SIDE_EFFECTS__
function _coercedNumber(Class2, params) {
return new Class2(snapshotChecks({ type: "number", coerce: true, checks: [], ...normalizeParams(params) }));
}
// @__NO_SIDE_EFFECTS__
function _int(Class2, params) {
return new Class2({
type: "number",
check: "number_format",
abort: false,
format: "safeint",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _float32(Class2, params) {
return new Class2({
type: "number",
check: "number_format",
abort: false,
format: "float32",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _float64(Class2, params) {
return new Class2({
type: "number",
check: "number_format",
abort: false,
format: "float64",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _int32(Class2, params) {
return new Class2({
type: "number",
check: "number_format",
abort: false,
format: "int32",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uint32(Class2, params) {
return new Class2({
type: "number",
check: "number_format",
abort: false,
format: "uint32",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _boolean(Class2, params) {
return new Class2({
type: "boolean",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _coercedBoolean(Class2, params) {
return new Class2({
type: "boolean",
coerce: true,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _bigint(Class2, params) {
return new Class2({
type: "bigint",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _coercedBigint(Class2, params) {
return new Class2({
type: "bigint",
coerce: true,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _int64(Class2, params) {
return new Class2({
type: "bigint",
check: "bigint_format",
abort: false,
format: "int64",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uint64(Class2, params) {
return new Class2({
type: "bigint",
check: "bigint_format",
abort: false,
format: "uint64",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _symbol(Class2, params) {
return new Class2({
type: "symbol",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _undefined2(Class2, params) {
return new Class2({
type: "undefined",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _null2(Class2, params) {
return new Class2({
type: "null",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _any(Class2) {
return new Class2({
type: "any"
});
}
// @__NO_SIDE_EFFECTS__
function _unknown(Class2) {
return new Class2({
type: "unknown"
});
}
// @__NO_SIDE_EFFECTS__
function _never(Class2, params) {
return new Class2({
type: "never",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _void(Class2, params) {
return new Class2({
type: "void",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _date(Class2, params) {
return new Class2({
type: "date",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _coercedDate(Class2, params) {
return new Class2({
type: "date",
coerce: true,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _nan(Class2, params) {
return new Class2({
type: "nan",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _lt(value, params) {
return new $ZodCheckLessThan({
check: "less_than",
...normalizeParams(params),
value,
inclusive: false
});
}
// @__NO_SIDE_EFFECTS__
function _lte(value, params) {
return new $ZodCheckLessThan({
check: "less_than",
...normalizeParams(params),
value,
inclusive: true
});
}
// @__NO_SIDE_EFFECTS__
function _gt(value, params) {
return new $ZodCheckGreaterThan({
check: "greater_than",
...normalizeParams(params),
value,
inclusive: false
});
}
// @__NO_SIDE_EFFECTS__
function _gte(value, params) {
return new $ZodCheckGreaterThan({
check: "greater_than",
...normalizeParams(params),
value,
inclusive: true
});
}
// @__NO_SIDE_EFFECTS__
function _positive(params) {
return /* @__PURE__ */ _gt(0, params);
}
// @__NO_SIDE_EFFECTS__
function _negative(params) {
return /* @__PURE__ */ _lt(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonpositive(params) {
return /* @__PURE__ */ _lte(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonnegative(params) {
return /* @__PURE__ */ _gte(0, params);
}
// @__NO_SIDE_EFFECTS__
function _multipleOf(value, params) {
return new $ZodCheckMultipleOf({
check: "multiple_of",
...normalizeParams(params),
value
});
}
// @__NO_SIDE_EFFECTS__
function _maxSize(maximum, params) {
return new $ZodCheckMaxSize({
check: "max_size",
...normalizeParams(params),
maximum
});
}
// @__NO_SIDE_EFFECTS__
function _minSize(minimum, params) {
return new $ZodCheckMinSize({
check: "min_size",
...normalizeParams(params),
minimum
});
}
// @__NO_SIDE_EFFECTS__
function _size(size, params) {
return new $ZodCheckSizeEquals({
check: "size_equals",
...normalizeParams(params),
size
});
}
// @__NO_SIDE_EFFECTS__
function _maxLength(maximum, params) {
const ch = new $ZodCheckMaxLength({
check: "max_length",
...normalizeParams(params),
maximum
});
return ch;
}
// @__NO_SIDE_EFFECTS__
function _minLength(minimum, params) {
return new $ZodCheckMinLength({
check: "min_length",
...normalizeParams(params),
minimum
});
}
// @__NO_SIDE_EFFECTS__
function _length(length, params) {
return new $ZodCheckLengthEquals({
check: "length_equals",
...normalizeParams(params),
length
});
}
// @__NO_SIDE_EFFECTS__
function _regex(pattern, params) {
return new $ZodCheckRegex({
check: "string_format",
format: "regex",
...normalizeParams(params),
pattern
});
}
// @__NO_SIDE_EFFECTS__
function _lowercase(params) {
return new $ZodCheckLowerCase({
check: "string_format",
format: "lowercase",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uppercase(params) {
return new $ZodCheckUpperCase({
check: "string_format",
format: "uppercase",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _includes(includes, params) {
return new $ZodCheckIncludes({
check: "string_format",
format: "includes",
...normalizeParams(params),
includes
});
}
// @__NO_SIDE_EFFECTS__
function _startsWith(prefix, params) {
return new $ZodCheckStartsWith({
check: "string_format",
format: "starts_with",
...normalizeParams(params),
prefix
});
}
// @__NO_SIDE_EFFECTS__
function _endsWith(suffix, params) {
return new $ZodCheckEndsWith({
check: "string_format",
format: "ends_with",
...normalizeParams(params),
suffix
});
}
// @__NO_SIDE_EFFECTS__
function _property(property, schema, params) {
return new $ZodCheckProperty({
check: "property",
property,
schema,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _properties(shape, params) {
return new $ZodCheckProperties({
check: "properties",
shape,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _mime(types, params) {
return new $ZodCheckMimeType({
check: "mime_type",
mime: types,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _overwrite(tx) {
return new $ZodCheckOverwrite({
check: "overwrite",
tx
});
}
// @__NO_SIDE_EFFECTS__
function _normalize(form) {
return /* @__PURE__ */ _overwrite((input2) => input2.normalize(form));
}
// @__NO_SIDE_EFFECTS__
function _trim() {
return /* @__PURE__ */ _overwrite((input2) => input2.trim());
}
// @__NO_SIDE_EFFECTS__
function _toLowerCase() {
return /* @__PURE__ */ _overwrite((input2) => input2.toLowerCase());
}
// @__NO_SIDE_EFFECTS__
function _toUpperCase() {
return /* @__PURE__ */ _overwrite((input2) => input2.toUpperCase());
}
// @__NO_SIDE_EFFECTS__
function _slugify() {
return /* @__PURE__ */ _overwrite((input2) => slugify(input2));
}
// @__NO_SIDE_EFFECTS__
function _array(Class2, element, params) {
return new Class2({
type: "array",
element,
// get element() {
// return element;
// },
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
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)
});
}
// @__NO_SIDE_EFFECTS__
function _discriminatedUnion(Class2, discriminator, options, params) {
return new Class2({
type: "union",
options,
discriminator,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _intersection(Class2, left, right) {
return new Class2({
type: "intersection",
left,
right
});
}
// @__NO_SIDE_EFFECTS__
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)
});
}
// @__NO_SIDE_EFFECTS__
function _record(Class2, keyType, valueType, params) {
return new Class2({
type: "record",
keyType,
valueType,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _map(Class2, keyType, valueType, params) {
return new Class2({
type: "map",
keyType,
valueType,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _set(Class2, valueType, params) {
return new Class2({
type: "set",
valueType,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
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)
});
}
// @__NO_SIDE_EFFECTS__
function _nativeEnum(Class2, entries, params) {
return new Class2({
type: "enum",
entries,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _literal(Class2, value, params) {
return new Class2({
type: "literal",
values: Array.isArray(value) ? value : [value],
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _file(Class2, params) {
return new Class2({
type: "file",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _transform(Class2, fn) {
return new Class2({
type: "transform",
transform: fn
});
}
// @__NO_SIDE_EFFECTS__
function _optional(Class2, innerType) {
return new Class2({
type: "optional",
innerType
});
}
// @__NO_SIDE_EFFECTS__
function _nullable(Class2, innerType) {
return new Class2({
type: "nullable",
innerType
});
}
// @__NO_SIDE_EFFECTS__
function _default(Class2, innerType, defaultValue) {
return new Class2({
type: "default",
innerType,
get defaultValue() {
return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
}
});
}
// @__NO_SIDE_EFFECTS__
function _nonoptional(Class2, innerType, params) {
return new Class2({
type: "nonoptional",
innerType,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _success(Class2, innerType) {
return new Class2({
type: "success",
innerType
});
}
// @__NO_SIDE_EFFECTS__
function _catch(Class2, innerType, catchValue) {
return new Class2({
type: "catch",
innerType,
catchValue: typeof catchValue === "function" ? catchValue : constantCatch(catchValue)
});
}
// @__NO_SIDE_EFFECTS__
function _pipe(Class2, in_, out) {
return new Class2({
type: "pipe",
in: in_,
out
});
}
// @__NO_SIDE_EFFECTS__
function _readonly(Class2, innerType) {
return new Class2({
type: "readonly",
innerType
});
}
// @__NO_SIDE_EFFECTS__
function _templateLiteral(Class2, parts, params) {
return new Class2({
type: "template_literal",
parts,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _lazy(Class2, getter) {
return new Class2({
type: "lazy",
getter
});
}
// @__NO_SIDE_EFFECTS__
function _promise(Class2, innerType) {
return new Class2({
type: "promise",
innerType
});
}
// @__NO_SIDE_EFFECTS__
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;
}
// @__NO_SIDE_EFFECTS__
function _refine(Class2, fn, _params) {
const schema = new Class2({
type: "custom",
check: "custom",
fn,
...normalizeParams(_params)
});
return schema;
}
// @__NO_SIDE_EFFECTS__
function _superRefine(fn, params) {
const ch = /* @__PURE__ */ _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");
if (!("input" in _issue))
_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);
}, params);
return ch;
}
// @__NO_SIDE_EFFECTS__
function _check(fn, params) {
const ch = new $ZodCheck({
check: "custom",
...normalizeParams(params)
});
ch._zod.check = fn;
return ch;
}
// @__NO_SIDE_EFFECTS__
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;
}
// @__NO_SIDE_EFFECTS__
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;
}
// @__NO_SIDE_EFFECTS__
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 codec2 = new _Codec({
type: "pipe",
in: stringSchema,
out: booleanSchema,
transform: (input2, payload) => {
let data = input2;
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: (input2, _payload) => {
if (input2 === true) {
return truthyArray[0] || "true";
} else {
return falsyArray[0] || "false";
}
},
error: params.error
});
codec2._zod.bag.truthy = truthyArray;
codec2._zod.bag.falsy = falsyArray;
codec2._zod.bag.case = params.case ?? "insensitive";
return codec2;
}
// @__NO_SIDE_EFFECTS__
function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
const params = normalizeParams(_params);
const def = {
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/.pnpm/zod@4.6.7/node_modules/zod/v4/core/to-json-schema.js
function assignProps(target, ...sources) {
for (const source of sources) {
for (const key of Reflect.ownKeys(source)) {
if (Object.prototype.propertyIsEnumerable.call(source, key)) {
assignProp(target, key, source[key]);
}
}
}
return target;
}
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: /* @__PURE__ */ new Map(),
sharedDefsExtractedFor: void 0,
sharedEmitDoneFor: void 0,
cycles: params?.cycles ?? "ref",
reused: params?.reused ?? "inline",
intersections: [],
deferred: [],
external: params?.external ?? void 0
};
}
function handleUnrepresentable(schema, ctx, json2, params, message) {
const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({ zodSchema: schema, path: params.path, message }) : ctx.unrepresentable;
if (result === "any")
return false;
if (result === void 0 || result === "throw")
throw new Error(message);
Object.assign(json2, result);
return true;
}
function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
var _a3;
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: void 0, path: _params.path };
ctx.seen.set(schema, result);
ctx.sharedDefsExtractedFor = void 0;
ctx.sharedEmitDoneFor = void 0;
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;
processSchema(parent, ctx, params);
ctx.seen.get(parent).isParent = true;
}
}
const meta3 = ctx.metadataRegistry.get(schema);
if (meta3)
assignProps(result.schema, meta3);
if (ctx.io === "input" && isTransforming(schema)) {
delete result.schema.examples;
delete result.schema.default;
}
if (ctx.io === "input" && "_prefault" in result.schema)
(_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
delete result.schema._prefault;
const _result = ctx.seen.get(schema);
return _result.schema;
}
function encodeJSONPointerSegment(segment) {
return segment.replace(/~/g, "~0").replace(/\//g, "~1");
}
function extractDefs(ctx, schema) {
const root = ctx.seen.get(schema);
if (!root)
throw new Error("Unprocessed schema. This is a bug in Zod.");
if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external)
return;
const idToSchema = /* @__PURE__ */ new Map();
for (const entry of ctx.seen.entries()) {
const id = ctx.metadataRegistry.get(entry[0])?.id;
if (id) {
const existing = idToSchema.get(id);
if (existing && existing !== entry[0]) {
throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
}
idToSchema.set(id, entry[0]);
}
}
const makeURI = (entry) => {
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
if (ctx.external) {
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}/${encodeJSONPointerSegment(id)}` };
}
const uriPrefix = `#`;
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
if (entry[1] === root && !entry[1].schema.id) {
return { ref: uriPrefix };
}
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
return { defId, ref: defUriPrefix + encodeJSONPointerSegment(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>
Set 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);
}
}
}
if (ctx.external)
ctx.sharedDefsExtractedFor = ctx.external;
}
function compactTypeUnion(schema) {
const options = schema.anyOf;
if (!Array.isArray(options) || options.length === 0 || schema.type !== void 0)
return;
const types = [];
for (const option of options) {
if (!option || typeof option !== "object")
return;
compactTypeUnion(option);
const keys = Object.keys(option);
if (keys.length !== 1 || keys[0] !== "type")
return;
const type = option.type;
for (const member of Array.isArray(type) ? type : [type]) {
if (typeof member !== "string")
return;
if (!types.includes(member))
types.push(member);
}
}
delete schema.anyOf;
schema.type = types.length === 1 ? types[0] : types;
}
var FOLDABLE_KEYS = /* @__PURE__ */ new Set(["type", "properties", "required", "additionalProperties"]);
var UNION_KEYS = ["oneOf", "anyOf"];
function undeclaredConstraint(member) {
const extra = member.additionalProperties;
if (extra === void 0 || extra === false || typeof extra !== "object" || extra === null)
return null;
return Object.keys(extra).length ? extra : null;
}
function foldObjects(members2) {
const objects = [];
for (const member of members2) {
if (typeof member !== "object" || member.type !== "object")
return null;
for (const key in member) {
if (!FOLDABLE_KEYS.has(key))
return null;
}
objects.push(member);
}
const properties = {};
const required2 = /* @__PURE__ */ new Set();
for (const object2 of objects) {
for (const key in object2.properties) {
if (Object.prototype.hasOwnProperty.call(properties, key))
continue;
const parts = [];
for (const other of objects) {
const part = other.properties?.[key] ?? undeclaredConstraint(other);
if (part === null || part === void 0)
continue;
if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part)))
parts.push(part);
}
const merged = parts.length === 1 ? parts[0] : foldObjects(parts) ?? { allOf: parts };
assignProp(properties, key, merged);
}
for (const key of object2.required ?? [])
required2.add(key);
}
const folded = { type: "object", properties };
if (required2.size)
folded.required = [...required2];
if (objects.every((object2) => object2.additionalProperties === false)) {
folded.additionalProperties = false;
} else {
const constraints = [];
for (const object2 of objects) {
const constraint = undeclaredConstraint(object2);
if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint)))
constraints.push(constraint);
}
if (constraints.length === 1)
folded.additionalProperties = constraints[0];
else if (constraints.length > 1)
folded.additionalProperties = { allOf: constraints };
}
return folded;
}
function foldIntersection(json2) {
const allOf = json2.allOf;
if (!Array.isArray(allOf) || allOf.length < 2)
return;
for (const key of FOLDABLE_KEYS)
if (key in json2)
return;
const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
let folded = null;
if (!unions.length) {
folded = foldObjects(allOf);
} else {
const union2 = unions[0];
const keyword = UNION_KEYS.find((k) => Array.isArray(union2[k]));
if (Object.keys(union2).length !== 1)
return;
const rest = allOf.filter((m) => m !== union2);
const branches = union2[keyword].map((branch) => foldObjects([...rest, branch]));
if (branches.some((b) => !b))
return;
folded = { [keyword]: branches };
}
if (!folded)
return;
delete json2.allOf;
assignProps(json2, folded);
}
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 {
assignProps(schema2, refSchema);
}
assignProps(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 ?? []
});
};
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
for (const entry of [...ctx.seen.entries()].reverse()) {
flattenRef(entry[0]);
}
if (ctx.target !== "openapi-3.0") {
for (const entry of ctx.seen.entries()) {
compactTypeUnion(entry[1].def ?? entry[1].schema);
}
}
for (const rewrite of ctx.deferred)
rewrite();
if (ctx.intersections.length) {
const carriers = /* @__PURE__ */ new Map();
for (const seen of ctx.seen.values()) {
for (const json2 of [seen.schema, seen.def]) {
const allOf = json2?.allOf;
if (!Array.isArray(allOf))
continue;
const existing = carriers.get(allOf);
if (existing)
existing.push(json2);
else
carriers.set(allOf, [json2]);
}
}
for (const allOf of ctx.intersections) {
for (const json2 of carriers.get(allOf) ?? [])
foldIntersection(json2);
}
}
}
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);
}
assignProps(result, root.defId ? root.schema : root.def ?? root.schema);
const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
if (rootMetaId !== void 0 && result.id === rootMetaId)
delete result.id;
const defs = ctx.external?.defs ?? {};
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
for (const entry of ctx.seen.entries()) {
const seen = entry[1];
if (seen.def && seen.defId) {
if (seen.def.id === seen.defId)
delete seen.def.id;
assignProp(defs, seen.defId, seen.def);
}
}
}
if (ctx.external)
ctx.sharedEmitDoneFor = ctx.external;
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: /* @__PURE__ */ 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" || def.type === "catch") {
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") {
if (_schema._zod.traits.has("$ZodCodec"))
return true;
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 });
processSchema(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 });
processSchema(schema, ctx);
extractDefs(ctx, schema);
return finalize(ctx, schema);
};
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/json-schema-processors.js
var narrowMin = (agg, key, value) => {
if (agg[key] === void 0 || value > agg[key])
agg[key] = value;
};
var narrowMax = (agg, key, value) => {
if (agg[key] === void 0 || value < agg[key])
agg[key] = value;
};
var narrowBoth = (agg, value) => {
narrowMin(agg, "minimum", value);
narrowMax(agg, "maximum", value);
};
var addDivisor = (agg, value) => {
agg.multipleOf ?? (agg.multipleOf = []);
if (!agg.multipleOf.includes(value))
agg.multipleOf.push(value);
};
var addPattern = (agg, pattern) => {
agg.patterns ?? (agg.patterns = /* @__PURE__ */ new Set());
agg.patterns.add(pattern);
};
var intersectMime = (agg, mime) => {
agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];
};
var setFormat = (agg, format) => {
agg.format = format;
if (format.includes("int"))
agg.isInt = true;
};
var minContributor = (agg, def) => narrowMin(agg, "minimum", def.minimum);
var maxContributor = (agg, def) => narrowMax(agg, "maximum", def.maximum);
var formatContributor = (ranges) => (agg, def) => {
setFormat(agg, def.format);
const [minimum, maximum] = ranges[def.format];
narrowMin(agg, "minimum", minimum);
narrowMax(agg, "maximum", maximum);
};
var contributors = {
greater_than: (agg, def) => narrowMin(agg, def.inclusive ? "minimum" : "exclusiveMinimum", def.value),
less_than: (agg, def) => narrowMax(agg, def.inclusive ? "maximum" : "exclusiveMaximum", def.value),
multiple_of: (agg, def) => addDivisor(agg, def.value),
number_format: formatContributor(NUMBER_FORMAT_RANGES),
bigint_format: formatContributor(BIGINT_FORMAT_RANGES),
min_length: minContributor,
max_length: maxContributor,
length_equals: (agg, def) => narrowBoth(agg, def.length),
min_size: minContributor,
max_size: maxContributor,
size_equals: (agg, def) => narrowBoth(agg, def.size),
string_format: (agg, def) => {
setFormat(agg, def.format);
if (def.pattern)
addPattern(agg, def.pattern);
if (def.format === "base64" || def.format === "base64url")
agg.contentEncoding = def.format;
if (def.local || def.precision === -1)
agg.laxFormat = true;
},
mime_type: (agg, def) => intersectMime(agg, def.mime)
};
function aggregateChecks(schema) {
const agg = {};
const def = schema._zod.def;
const list = schema._zod.traits.has("$ZodCheck") ? [schema, ...def.checks ?? []] : def.checks ?? [];
for (const ch of list)
contributors[ch._zod.def.check]?.(agg, ch._zod.def);
const bag = schema._zod.bag;
if (bag.minimum !== void 0)
narrowMin(agg, "minimum", bag.minimum);
if (bag.exclusiveMinimum !== void 0)
narrowMin(agg, "exclusiveMinimum", bag.exclusiveMinimum);
if (bag.maximum !== void 0)
narrowMax(agg, "maximum", bag.maximum);
if (bag.exclusiveMaximum !== void 0)
narrowMax(agg, "exclusiveMaximum", bag.exclusiveMaximum);
if (bag.multipleOf !== void 0)
addDivisor(agg, bag.multipleOf);
if (bag.format !== void 0) {
agg.format ?? (agg.format = bag.format);
if (bag.format.includes("int"))
agg.isInt = true;
}
if (bag.mime)
intersectMime(agg, bag.mime);
for (const pattern of bag.patterns ?? [])
addPattern(agg, pattern);
return agg;
}
var formatMap = {
guid: "uuid",
url: "uri",
datetime: "date-time",
json_string: "json-string",
regex: ""
// do not set
};
var exactPatterns = /* @__PURE__ */ new Map([
[base64Charset, base64],
[base64urlCharset, base64url]
]);
var exactPattern = (p) => exactPatterns.get(p) ?? p;
var stringProcessor = (schema, ctx, _json, _params) => {
const json2 = _json;
json2.type = "string";
const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
if (typeof minimum === "number")
json2.minLength = minimum;
if (typeof maximum === "number")
json2.maxLength = maximum;
if (format) {
json2.format = formatMap[format] ?? format;
if (json2.format === "")
delete json2.format;
if (format === "time" || laxFormat) {
delete json2.format;
}
}
if (contentEncoding)
json2.contentEncoding = contentEncoding;
if (patterns && patterns.size > 0) {
const patternList = [...patterns].map(exactPattern);
if (patternList.length === 1)
json2.pattern = patternList[0].source;
else if (patternList.length > 1) {
json2.allOf = [
...patternList.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 json2 = _json;
const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
json2.type = isInt ? "integer" : "number";
const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
if (exMin) {
if (legacy) {
json2.minimum = exclusiveMinimum;
json2.exclusiveMinimum = true;
} else {
json2.exclusiveMinimum = exclusiveMinimum;
}
} else if (typeof minimum === "number") {
json2.minimum = minimum;
}
if (exMax) {
if (legacy) {
json2.maximum = exclusiveMaximum;
json2.exclusiveMaximum = true;
} else {
json2.exclusiveMaximum = exclusiveMaximum;
}
} else if (typeof maximum === "number") {
json2.maximum = maximum;
}
if (multipleOf) {
const divisors = /* @__PURE__ */ new Set();
for (const divisor of multipleOf) {
if (Number.isFinite(divisor) && divisor !== 0)
divisors.add(Math.abs(divisor));
else
handleUnrepresentable(schema, ctx, json2, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
}
const [first, ...rest] = divisors;
if (first !== void 0)
json2.multipleOf = first;
if (rest.length)
json2.allOf = [...json2.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
}
};
var booleanProcessor = (_schema, _ctx, json2, _params) => {
json2.type = "boolean";
};
var bigintProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "BigInt cannot be represented in JSON Schema");
};
var symbolProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Symbols cannot be represented in JSON Schema");
};
var nullProcessor = (_schema, ctx, json2, _params) => {
if (ctx.target === "openapi-3.0") {
json2.type = "string";
json2.nullable = true;
json2.enum = [null];
} else {
json2.type = "null";
}
};
var undefinedProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Undefined cannot be represented in JSON Schema");
};
var voidProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Void cannot be represented in JSON Schema");
};
var neverProcessor = (_schema, _ctx, json2, _params) => {
json2.not = {};
};
var anyProcessor = (_schema, _ctx, _json, _params) => {
};
var unknownProcessor = (_schema, _ctx, _json, _params) => {
};
var dateProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Date cannot be represented in JSON Schema");
};
var enumProcessor = (schema, _ctx, json2, _params) => {
const def = schema._zod.def;
const values = getEnumValues(def.entries);
if (values.length === 0) {
json2.not = {};
return;
}
if (values.every((v) => typeof v === "number"))
json2.type = "number";
if (values.every((v) => typeof v === "string"))
json2.type = "string";
json2.enum = values;
};
var literalProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
if (def.values.length === 0) {
json2.not = {};
return;
}
const vals = [];
for (const val of def.values) {
if (val === void 0) {
if (handleUnrepresentable(schema, ctx, json2, params, "Literal `undefined` cannot be represented in JSON Schema"))
return;
} else if (typeof val === "bigint") {
if (handleUnrepresentable(schema, ctx, json2, params, "BigInt literals cannot be represented in JSON Schema"))
return;
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 (ctx.target === "draft-04" || ctx.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 = "boolean";
if (vals.every((v) => v === null))
json2.type = "null";
json2.enum = vals;
}
};
var nanProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "NaN cannot be represented in JSON Schema");
};
var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
const _json = json2;
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, json2, _params) => {
const _json = json2;
_json.type = "string";
_json.format = "binary";
_json.contentEncoding = "binary";
const { minimum, maximum, mime } = aggregateChecks(schema);
if (minimum !== void 0)
_json.minLength = minimum;
if (maximum !== void 0)
_json.maxLength = maximum;
if (!mime)
return;
if (mime.length === 0)
_json.not = {};
else if (mime.length === 1)
_json.contentMediaType = mime[0];
else
_json.anyOf = mime.map((m) => ({ contentMediaType: m }));
};
var successProcessor = (_schema, _ctx, json2, _params) => {
json2.type = "boolean";
};
var customProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Custom types cannot be represented in JSON Schema");
};
var functionProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Function types cannot be represented in JSON Schema");
};
var transformProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Transforms cannot be represented in JSON Schema");
};
var mapProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Map cannot be represented in JSON Schema");
};
var setProcessor = (schema, ctx, json2, params) => {
handleUnrepresentable(schema, ctx, json2, params, "Set cannot be represented in JSON Schema");
};
var arrayProcessor = (schema, ctx, _json, params) => {
const json2 = _json;
const def = schema._zod.def;
const { minimum, maximum } = aggregateChecks(schema);
if (typeof minimum === "number")
json2.minItems = minimum;
if (typeof maximum === "number")
json2.maxItems = maximum;
json2.type = "array";
json2.items = processSchema(def.element, ctx, {
...params,
path: [...params.path, "items"]
});
};
function inputOptin(schema) {
const def = schema._zod.def;
if (def.type === "pipe" && def.in._zod.traits.has("$ZodTransform")) {
return inputOptin(def.out);
}
if (def.type === "catch") {
return inputOptin(def.innerType);
}
return schema._zod.optin;
}
var objectProcessor = (schema, ctx, _json, params) => {
const json2 = _json;
const def = schema._zod.def;
const shape = def.shape;
const symbolKeys = Object.getOwnPropertySymbols(shape);
if (symbolKeys.length && handleUnrepresentable(schema, ctx, json2, params, "Symbol keys cannot be represented in JSON Schema")) {
return;
}
json2.type = "object";
json2.properties = {};
for (const key in shape) {
assignProp(json2.properties, key, processSchema(shape[key], ctx, {
...params,
path: [...params.path, "properties", key]
}));
}
const requiredKeys = [];
for (const key of Object.keys(shape)) {
const field = def.shape[key];
if (ctx.io === "input" ? inputOptin(field) === void 0 : field._zod.optout === void 0) {
requiredKeys.push(key);
}
}
if (requiredKeys.length > 0) {
json2.required = requiredKeys;
}
if (def.catchall?._zod.def.type === "never") {
json2.additionalProperties = false;
} else if (!def.catchall) {
if (ctx.io === "output")
json2.additionalProperties = false;
} else if (def.catchall) {
json2.additionalProperties = processSchema(def.catchall, ctx, {
...params,
path: [...params.path, "additionalProperties"]
});
}
};
var unionProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
const isExclusive = def.inclusive === false;
const options = def.options.map((x, i) => processSchema(x, ctx, {
...params,
path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
}));
if (isExclusive) {
json2.oneOf = options;
} else {
json2.anyOf = options;
}
};
var intersectionProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
const a = processSchema(def.left, ctx, {
...params,
path: [...params.path, "allOf", 0]
});
const b = processSchema(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]
];
json2.allOf = allOf;
ctx.intersections.push(allOf);
};
var tupleProcessor = (schema, ctx, _json, params) => {
const json2 = _json;
const def = schema._zod.def;
json2.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) => processSchema(x, ctx, {
...params,
path: [...params.path, prefixPath, i]
}));
const rest = def.rest ? processSchema(def.rest, ctx, {
...params,
path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
}) : null;
let minItems = def.items.length;
while (minItems > 0) {
const item = def.items[minItems - 1];
const optional2 = ctx.io === "input" ? inputOptin(item) !== void 0 : item._zod.optout === "optional";
if (!optional2)
break;
minItems--;
}
const maxItems = def.items.length;
const isClosed = !def.rest;
if (ctx.target === "draft-2020-12") {
json2.prefixItems = prefixItems;
if (isClosed) {
json2.items = false;
} else if (rest) {
json2.items = rest;
}
if (minItems > 0)
json2.minItems = minItems;
if (isClosed)
json2.maxItems = maxItems;
} else if (ctx.target === "openapi-3.0") {
json2.items = {
anyOf: prefixItems
};
if (rest) {
json2.items.anyOf.push(rest);
}
if (minItems > 0)
json2.minItems = minItems;
if (isClosed)
json2.maxItems = maxItems;
} else {
json2.items = prefixItems;
if (isClosed) {
json2.additionalItems = false;
} else if (rest) {
json2.additionalItems = rest;
}
if (minItems > 0)
json2.minItems = minItems;
if (isClosed)
json2.maxItems = maxItems;
}
const { minimum, maximum } = aggregateChecks(schema);
if (typeof minimum === "number")
json2.minItems = minimum;
if (typeof maximum === "number")
json2.maxItems = maximum;
};
function stringifyKeyNames(bySchema, json2, visited) {
if (json2.$ref) {
if (visited.has(json2))
return json2;
visited.add(json2);
const def = bySchema.get(json2)?.def;
if (!def)
return json2;
const inlined = stringifyKeyNames(bySchema, def, visited);
return inlined === def ? json2 : inlined;
}
for (const keyword of ["anyOf", "oneOf"]) {
const branches = json2[keyword];
if (!Array.isArray(branches))
continue;
const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
if (mapped.some((branch, i) => branch !== branches[i]))
json2 = { ...json2, [keyword]: mapped };
}
const types = Array.isArray(json2.type) ? json2.type : [json2.type];
const numericType = !types.includes("string") && types.some((t) => t === "number" || t === "integer");
const values = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
if (!numericType && !values?.some((v) => typeof v === "number"))
return json2;
const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json2;
if (rest.enum)
rest.enum = rest.enum.map((v) => typeof v === "number" ? String(v) : v);
else if (typeof rest.const === "number")
rest.const = String(rest.const);
if (!numericType)
return rest;
rest.type = "string";
if (!values)
rest.pattern = (types.includes("number") ? number : integer).source;
return rest;
}
var pendingRecords = /* @__PURE__ */ new WeakMap();
function rewriteKeyNames(ctx) {
const bySchema = /* @__PURE__ */ new Map();
for (const entry of ctx.seen.values()) {
if (entry.def && !bySchema.has(entry.schema))
bySchema.set(entry.schema, entry);
}
const rewrites = /* @__PURE__ */ new Map();
for (const record2 of pendingRecords.get(ctx) ?? []) {
const seen = ctx.seen.get(record2);
const names = (seen?.def ?? seen?.schema)?.propertyNames;
if (!names || names === true || rewrites.has(names))
continue;
const rewritten = stringifyKeyNames(bySchema, names, /* @__PURE__ */ new Set());
if (rewritten !== names)
rewrites.set(names, rewritten);
}
if (!rewrites.size)
return;
for (const entry of ctx.seen.values()) {
for (const carrier of [entry.schema, entry.def]) {
const rewritten = carrier && rewrites.get(carrier.propertyNames);
if (rewritten)
carrier.propertyNames = rewritten;
}
}
}
var recordProcessor = (schema, ctx, _json, params) => {
const json2 = _json;
const def = schema._zod.def;
json2.type = "object";
const keyType = def.keyType;
const patterns = aggregateChecks(keyType).patterns;
if (def.mode === "loose" && patterns && patterns.size > 0) {
const valueSchema = processSchema(def.valueType, ctx, {
...params,
path: [...params.path, "patternProperties", "*"]
});
json2.patternProperties = {};
for (const pattern of patterns) {
assignProp(json2.patternProperties, exactPattern(pattern).source, valueSchema);
}
} else {
if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
json2.propertyNames = processSchema(def.keyType, ctx, {
...params,
path: [...params.path, "propertyNames"]
});
let pending = pendingRecords.get(ctx);
if (!pending) {
pending = [];
pendingRecords.set(ctx, pending);
ctx.deferred.push(() => rewriteKeyNames(ctx));
}
pending.push(schema);
}
json2.additionalProperties = processSchema(def.valueType, ctx, {
...params,
path: [...params.path, "additionalProperties"]
});
}
const keyValues = keyType._zod.values;
const omittableOnInput = ctx.io === "input" && inputOptin(def.valueType) !== void 0;
if (keyValues && !def.partial && !omittableOnInput) {
const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
if (validKeyValues.length > 0) {
json2.required = validKeyValues.map(String);
}
}
};
var nullableProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
const inner = processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
if (ctx.target === "openapi-3.0") {
seen.ref = def.innerType;
json2.nullable = true;
} else {
json2.anyOf = [inner, { type: "null" }];
}
};
var nonoptionalProcessor = (schema, ctx, _json, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
};
var UNREPRESENTABLE_DEFAULT = Symbol();
function serializeDefaultValue(value, schema, ctx, json2, params) {
let unrepresentable = false;
const serialized = JSON.stringify(value, (_, val) => {
if (typeof val !== "bigint")
return val;
unrepresentable = true;
return null;
});
if (!unrepresentable)
return JSON.parse(serialized);
handleUnrepresentable(schema, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
return UNREPRESENTABLE_DEFAULT;
}
var defaultProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
if (value !== UNREPRESENTABLE_DEFAULT)
json2.default = value;
};
var prefaultProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
if (ctx.io !== "input")
return;
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
if (value !== UNREPRESENTABLE_DEFAULT)
json2._prefault = value;
};
var catchProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
let catchValue;
try {
catchValue = def.catchValue(void 0);
} catch {
handleUnrepresentable(schema, ctx, json2, params, "Dynamic catch values are not supported in JSON Schema");
return;
}
json2.default = catchValue;
};
var pipeProcessor = (schema, ctx, _json, params) => {
const def = schema._zod.def;
const inIsTransform = def.in._zod.traits.has("$ZodTransform");
const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
processSchema(innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = innerType;
};
var readonlyProcessor = (schema, ctx, json2, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
json2.readOnly = true;
};
var promiseProcessor = (schema, ctx, _json, params) => {
const def = schema._zod.def;
processSchema(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;
processSchema(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;
processSchema(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(input2, params) {
if ("_idmap" in input2) {
const registry2 = input2;
const ctx2 = initializeContext({ ...params, processors: allProcessors });
const defs = {};
for (const entry of registry2._idmap.entries()) {
const [_, schema] = entry;
processSchema(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);
assignProp(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 });
processSchema(input2, ctx);
extractDefs(ctx, input2);
return finalize(ctx, input2);
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/json-schema-generator.js
var JSONSchemaGenerator = class {
/** @deprecated Access via ctx instead */
get metadataRegistry() {
return this.ctx.metadataRegistry;
}
/** @deprecated Access via ctx instead */
get target() {
return this.ctx.target;
}
// annotated so the .d.cts emits an indexed access rather than an inline `import()` of an ESM path
/** @deprecated Access via ctx instead */
get unrepresentable() {
return this.ctx.unrepresentable;
}
/** @deprecated Access via ctx instead */
get override() {
return this.ctx.override;
}
/** @deprecated Access via ctx instead */
get io() {
return this.ctx.io;
}
/** @deprecated Access via ctx instead */
get counter() {
return this.ctx.counter;
}
set counter(value) {
this.ctx.counter = value;
}
/** @deprecated Access via ctx instead */
get seen() {
return this.ctx.seen;
}
constructor(params) {
let normalizedTarget = params?.target ?? "draft-2020-12";
if (normalizedTarget === "draft-4")
normalizedTarget = "draft-04";
if (normalizedTarget === "draft-7")
normalizedTarget = "draft-07";
this.ctx = initializeContext({
processors: allProcessors,
target: normalizedTarget,
...params?.metadata && { metadata: params.metadata },
...params?.unrepresentable && { unrepresentable: params.unrepresentable },
...params?.override && { override: params.override },
...params?.io && { io: params.io }
});
}
/**
* Process a schema to prepare it for JSON Schema generation.
* This must be called before emit().
*/
process(schema, _params = { path: [], schemaPath: [] }) {
return processSchema(schema, this.ctx, _params);
}
/**
* Emit the final JSON Schema after processing.
* Must call process() first.
*/
emit(schema, _params) {
if (_params) {
if (_params.cycles)
this.ctx.cycles = _params.cycles;
if (_params.reused)
this.ctx.reused = _params.reused;
if (_params.external)
this.ctx.external = _params.external;
}
this.ctx.sharedDefsExtractedFor = void 0;
this.ctx.sharedEmitDoneFor = void 0;
extractDefs(this.ctx, schema);
const result = finalize(this.ctx, schema);
const { "~standard": _, ...plainResult } = result;
return plainResult;
}
};
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/json-schema.js
var json_schema_exports = {};
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/schemas.js
var schemas_exports2 = {};
__export(schemas_exports2, {
ZodAny: () => ZodAny,
ZodArray: () => ZodArray,
ZodBase64: () => ZodBase64,
ZodBase64URL: () => ZodBase64URL,
ZodBigInt: () => ZodBigInt,
ZodBigIntFormat: () => ZodBigIntFormat,
ZodBoolean: () => ZodBoolean,
ZodCIDRv4: () => ZodCIDRv4,
ZodCIDRv6: () => ZodCIDRv6,
ZodCUID: () => ZodCUID,
ZodCUID2: () => ZodCUID2,
ZodCatch: () => ZodCatch,
ZodCodec: () => ZodCodec,
ZodCreditCard: () => ZodCreditCard,
ZodCustom: () => ZodCustom,
ZodCustomStringFormat: () => ZodCustomStringFormat,
ZodDate: () => ZodDate,
ZodDefault: () => ZodDefault,
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
ZodE164: () => ZodE164,
ZodEmail: () => ZodEmail,
ZodEmoji: () => ZodEmoji,
ZodEnum: () => ZodEnum,
ZodExactOptional: () => ZodExactOptional,
ZodFile: () => ZodFile,
ZodFunction: () => ZodFunction,
ZodGUID: () => ZodGUID,
ZodIBAN: () => ZodIBAN,
ZodIPv4: () => ZodIPv4,
ZodIPv6: () => ZodIPv6,
ZodISODate: () => ZodISODate,
ZodISODateTime: () => ZodISODateTime,
ZodISODuration: () => ZodISODuration,
ZodISOTime: () => ZodISOTime,
ZodInstanceOf: () => ZodInstanceOf,
ZodIntersection: () => ZodIntersection,
ZodJWT: () => ZodJWT,
ZodKSUID: () => ZodKSUID,
ZodLazy: () => ZodLazy,
ZodLiteral: () => ZodLiteral,
ZodMAC: () => ZodMAC,
ZodMap: () => ZodMap,
ZodNaN: () => ZodNaN,
ZodNanoID: () => ZodNanoID,
ZodNever: () => ZodNever,
ZodNonOptional: () => ZodNonOptional,
ZodNull: () => ZodNull,
ZodNullable: () => ZodNullable,
ZodNumber: () => ZodNumber,
ZodNumberFormat: () => ZodNumberFormat,
ZodObject: () => ZodObject,
ZodOptional: () => ZodOptional,
ZodPipe: () => ZodPipe,
ZodPrefault: () => ZodPrefault,
ZodPreprocess: () => ZodPreprocess,
ZodPromise: () => ZodPromise,
ZodReadonly: () => ZodReadonly,
ZodRecord: () => ZodRecord,
ZodSet: () => ZodSet,
ZodString: () => ZodString,
ZodStringFormat: () => ZodStringFormat,
ZodSuccess: () => ZodSuccess,
ZodSymbol: () => ZodSymbol,
ZodTemplateLiteral: () => ZodTemplateLiteral,
ZodTransform: () => ZodTransform,
ZodTuple: () => ZodTuple,
ZodType: () => ZodType,
ZodULID: () => ZodULID,
ZodURL: () => ZodURL,
ZodUUID: () => ZodUUID,
ZodUndefined: () => ZodUndefined,
ZodUnion: () => ZodUnion,
ZodUnknown: () => ZodUnknown,
ZodVoid: () => ZodVoid,
ZodXID: () => ZodXID,
ZodXor: () => ZodXor,
_ZodString: () => _ZodString,
_default: () => _default2,
_function: () => _function,
any: () => any,
array: () => array,
base64: () => base642,
base64url: () => base64url2,
bigint: () => bigint2,
boolean: () => boolean2,
catch: () => _catch2,
check: () => check,
cidrv4: () => cidrv42,
cidrv6: () => cidrv62,
codec: () => codec,
creditCard: () => creditCard2,
cuid: () => cuid3,
cuid2: () => cuid22,
currencyCode: () => currencyCode2,
custom: () => custom,
date: () => date2,
describe: () => describe2,
discriminatedUnion: () => discriminatedUnion,
e164: () => e1642,
email: () => email2,
emoji: () => emoji2,
enum: () => _enum2,
exactOptional: () => exactOptional,
file: () => file,
float32: () => float32,
float64: () => float64,
function: () => _function,
guid: () => guid2,
hash: () => hash,
hex: () => hex2,
hostname: () => hostname2,
httpUrl: () => httpUrl,
iban: () => iban2,
instanceof: () => _instanceof,
int: () => int,
int32: () => int32,
int64: () => int64,
intersection: () => intersection,
invertCodec: () => invertCodec,
ipv4: () => ipv42,
ipv6: () => ipv62,
json: () => json,
jwt: () => jwt,
keyof: () => keyof,
ksuid: () => ksuid2,
lazy: () => lazy,
literal: () => literal,
looseObject: () => looseObject,
looseRecord: () => looseRecord,
mac: () => mac2,
map: () => map,
meta: () => meta2,
nan: () => nan,
nanoid: () => nanoid2,
nativeEnum: () => nativeEnum,
never: () => never,
nonoptional: () => nonoptional,
null: () => _null3,
nullable: () => nullable,
nullish: () => nullish2,
number: () => number2,
object: () => object,
optional: () => optional,
partialRecord: () => partialRecord,
pipe: () => pipe,
prefault: () => prefault,
preprocess: () => preprocess,
promise: () => promise,
readonly: () => readonly,
record: () => record,
refine: () => refine,
set: () => set,
strictObject: () => strictObject,
string: () => string2,
stringFormat: () => stringFormat,
stringbool: () => stringbool,
success: () => success,
superRefine: () => superRefine,
symbol: () => symbol,
templateLiteral: () => templateLiteral,
transform: () => transform,
tuple: () => tuple,
uint32: () => uint32,
uint64: () => uint64,
ulid: () => ulid2,
undefined: () => _undefined3,
union: () => union,
unknown: () => unknown,
url: () => url,
uuid: () => uuid2,
uuidv4: () => uuidv4,
uuidv6: () => uuidv6,
uuidv7: () => uuidv7,
void: () => _void2,
xid: () => xid2,
xor: () => xor
});
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/checks.js
var checks_exports2 = {};
__export(checks_exports2, {
endsWith: () => _endsWith,
gt: () => _gt,
gte: () => _gte,
includes: () => _includes,
length: () => _length,
lowercase: () => _lowercase,
lt: () => _lt,
lte: () => _lte,
maxLength: () => _maxLength,
maxSize: () => _maxSize,
mime: () => _mime,
minLength: () => _minLength,
minSize: () => _minSize,
multipleOf: () => _multipleOf,
negative: () => _negative,
nonnegative: () => _nonnegative,
nonpositive: () => _nonpositive,
normalize: () => _normalize,
overwrite: () => _overwrite,
positive: () => _positive,
properties: () => _properties,
property: () => _property,
regex: () => _regex,
size: () => _size,
slugify: () => _slugify,
startsWith: () => _startsWith,
toLowerCase: () => _toLowerCase,
toUpperCase: () => _toUpperCase,
trim: () => _trim,
uppercase: () => _uppercase
});
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/errors.js
var _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
function _lazyMethod(proto, key, make) {
Object.defineProperty(proto, key, {
configurable: true,
enumerable: false,
get() {
const value = make(this);
Object.defineProperty(this, key, { value, configurable: true, writable: true });
return value;
},
set(value) {
Object.defineProperty(this, key, { value, configurable: true, writable: true });
}
});
}
var initializer2 = (inst, issues) => {
$ZodError.init(inst, issues);
inst.name = "ZodError";
const proto = Object.getPrototypeOf(inst);
if (_installedErrorProtos.has(proto))
return;
_installedErrorProtos.add(proto);
_lazyMethod(proto, "format", (self) => (mapper) => formatError(self, mapper));
_lazyMethod(proto, "flatten", (self) => (mapper) => flattenError(self, mapper));
_lazyMethod(proto, "addIssue", (self) => (issue2) => {
self.issues.push(issue2);
self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);
});
_lazyMethod(proto, "addIssues", (self) => (issues2) => {
self.issues.push(...issues2);
self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);
});
Object.defineProperty(proto, "isEmpty", {
configurable: true,
enumerable: false,
get() {
return this.issues.length === 0;
}
});
};
var ZodError = /* @__PURE__ */ $constructor("ZodError", initializer2);
var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, void 0, {
Parent: Error
});
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/parse.js
var parse2 = /* @__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/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/schemas.js
function _ensureDefaultLocale() {
if (!globalConfig.localeError)
config(en_default());
}
function _ensureDefaultMemoizer() {
if (!globalConfig.memoizer)
config({ memoizer: memoizer() });
}
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
_ensureDefaultLocale();
$ZodType.init(inst, def);
inst.def = def;
inst.type = def.type;
return inst;
}, {
check(...chks) {
const def = this.def;
return this.clone(util_exports.mergeDefs(def, {
checks: [
...def.checks ?? [],
...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
]
}), { parent: true });
},
with(...chks) {
return this.check(...chks);
},
clone(def, params) {
return clone(this, def, params);
},
brand() {
return this;
},
register(reg, meta3) {
reg.add(this, meta3);
return this;
},
refine(check2, params) {
return this.check(refine(check2, params));
},
superRefine(refinement, params) {
return this.check(superRefine(refinement, params));
},
overwrite(fn) {
return this.check(_overwrite(fn));
},
optional() {
return optional(this);
},
exactOptional() {
return exactOptional(this);
},
nullable() {
return nullable(this);
},
nullish() {
return optional(nullable(this));
},
nonoptional(params) {
return nonoptional(this, params);
},
array() {
return array(this);
},
or(arg) {
return union([this, arg]);
},
and(arg) {
return intersection(this, arg);
},
transform(tx) {
return pipe(this, transform(tx));
},
default(d) {
return _default2(this, d);
},
prefault(d) {
return prefault(this, d);
},
catch(params) {
return _catch2(this, params);
},
pipe(target) {
return pipe(this, target);
},
readonly() {
return readonly(this);
},
describe(description) {
const cl = this.clone();
globalRegistry.add(cl, { description });
return cl;
},
meta(...args) {
if (args.length === 0)
return globalRegistry.get(this);
const cl = this.clone();
globalRegistry.add(cl, args[0]);
return cl;
},
isOptional() {
return this.safeParse(void 0).success;
},
isNullable() {
return this.safeParse(null).success;
},
apply(fn, ...args) {
return args.length === 0 ? fn(this) : fn(this, ...args);
},
// Overrides core's `~standard` to add `jsonSchema`. Must stay a prototype entry: redefining it per instance demotes instances to dictionary mode.
get "~standard"() {
return util_exports.hide(this, "~standard", {
...standardProps(this),
jsonSchema: {
input: createStandardJSONSchemaMethod(this, "input"),
output: createStandardJSONSchemaMethod(this, "output")
}
});
},
set "~standard"(value) {
util_exports.own(this, "~standard", value);
},
parse: function _parse2(data, params) {
return parse2(this, data, params, { callee: _parse2 });
},
parseAsync: async function _parseAsync2(data, params) {
return await parseAsync2(this, data, params, { callee: _parseAsync2 });
},
safeParse(data, params) {
return safeParse2(this, data, params);
},
async safeParseAsync(data, params) {
return safeParseAsync2(this, data, params);
},
// `spa` is an alias: same function object as `safeParseAsync`, as before.
get spa() {
return this?.safeParseAsync;
},
set spa(value) {
util_exports.own(this, "spa", value);
},
validate(data, params) {
return validate(this, data, params);
},
validateAsync(data, params) {
return validateAsync(this, data, params);
},
encode: function _encode2(data, params) {
return encode2(this, data, params, { callee: _encode2 });
},
decode: function _decode2(data, params) {
return decode2(this, data, params, { callee: _decode2 });
},
encodeAsync: async function _encodeAsync2(data, params) {
return await encodeAsync2(this, data, params, { callee: _encodeAsync2 });
},
decodeAsync: async function _decodeAsync2(data, params) {
return await decodeAsync2(this, data, params, { callee: _decodeAsync2 });
},
safeEncode(data, params) {
return safeEncode2(this, data, params);
},
safeDecode(data, params) {
return safeDecode2(this, data, params);
},
async safeEncodeAsync(data, params) {
return safeEncodeAsync2(this, data, params);
},
async safeDecodeAsync(data, params) {
return safeDecodeAsync2(this, data, params);
},
toJSONSchema(params) {
return createToJSONSchemaMethod(this, {})(params);
},
// Reads through to the registry on every access, so it must not cache.
get description() {
return globalRegistry.get(this)?.description;
},
// No setter: `schema._def = x` throws, as it did when `_def` was a non-writable own property.
get _def() {
return this._zod.def;
}
});
var _ZodString = /* @__PURE__ */ $constructor(
"_ZodString",
(inst, def) => {
$ZodString.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
},
/* @__PURE__ */ util_exports.derived({
format: (inst) => aggregateChecks(inst).format ?? null,
minLength: (inst) => aggregateChecks(inst).minimum ?? null,
maxLength: (inst) => aggregateChecks(inst).maximum ?? null
}, {
regex(...args) {
return this.check(_regex(...args));
},
includes(...args) {
return this.check(_includes(...args));
},
startsWith(...args) {
return this.check(_startsWith(...args));
},
endsWith(...args) {
return this.check(_endsWith(...args));
},
min(...args) {
return this.check(_minLength(...args));
},
max(...args) {
return this.check(_maxLength(...args));
},
length(...args) {
return this.check(_length(...args));
},
nonempty(...args) {
return this.check(_minLength(1, ...args));
},
lowercase(params) {
return this.check(_lowercase(params));
},
uppercase(params) {
return this.check(_uppercase(params));
},
trim() {
return this.check(_trim());
},
normalize(...args) {
return this.check(_normalize(...args));
},
toLowerCase() {
return this.check(_toLowerCase());
},
toUpperCase() {
return this.check(_toUpperCase());
},
slugify() {
return this.check(_slugify());
}
})
);
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
$ZodString.init(inst, def);
_ZodString.init(inst, def);
}, {
email(params) {
return this.check(_email(ZodEmail, params));
},
url(params) {
return this.check(_url(ZodURL, params));
},
jwt(params) {
return this.check(_jwt(ZodJWT, params));
},
emoji(params) {
return this.check(_emoji2(ZodEmoji, params));
},
guid(params) {
return this.check(_guid(ZodGUID, params));
},
uuid(params) {
return this.check(_uuid(ZodUUID, params));
},
uuidv4(params) {
return this.check(_uuidv4(ZodUUID, params));
},
uuidv6(params) {
return this.check(_uuidv6(ZodUUID, params));
},
uuidv7(params) {
return this.check(_uuidv7(ZodUUID, params));
},
nanoid(params) {
return this.check(_nanoid(ZodNanoID, params));
},
cuid(params) {
return this.check(_cuid(ZodCUID, params));
},
cuid2(params) {
return this.check(_cuid2(ZodCUID2, params));
},
ulid(params) {
return this.check(_ulid(ZodULID, params));
},
base64(params) {
return this.check(_base64(ZodBase64, params));
},
base64url(params) {
return this.check(_base64url(ZodBase64URL, params));
},
xid(params) {
return this.check(_xid(ZodXID, params));
},
ksuid(params) {
return this.check(_ksuid(ZodKSUID, params));
},
ipv4(params) {
return this.check(_ipv4(ZodIPv4, params));
},
ipv6(params) {
return this.check(_ipv6(ZodIPv6, params));
},
cidrv4(params) {
return this.check(_cidrv4(ZodCIDRv4, params));
},
cidrv6(params) {
return this.check(_cidrv6(ZodCIDRv6, params));
},
e164(params) {
return this.check(_e164(ZodE164, params));
},
datetime(params) {
return this.check(_isoDateTime(ZodISODateTime, params));
},
date(params) {
return this.check(_isoDate(ZodISODate, params));
},
time(params) {
return this.check(_isoTime(ZodISOTime, params));
},
duration(params) {
return this.check(_isoDuration(ZodISODuration, params));
}
});
function string2(params) {
return _string(ZodString, params);
}
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
$ZodStringFormat.init(inst, def);
_ZodString.init(inst, def);
});
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
$ZodISODateTime.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
$ZodISODate.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
$ZodISOTime.init(inst, def);
ZodStringFormat.init(inst, def);
});
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
$ZodISODuration.init(inst, def);
ZodStringFormat.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: httpProtocol,
hostname: domain,
...util_exports.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 ZodCreditCard = /* @__PURE__ */ $constructor("ZodCreditCard", (inst, def) => {
$ZodCreditCard.init(inst, def);
ZodStringFormat.init(inst, def);
});
function creditCard2(params) {
return _creditCard(ZodCreditCard, params);
}
var ZodIBAN = /* @__PURE__ */ $constructor("ZodIBAN", (inst, def) => {
$ZodIBAN.init(inst, def);
ZodStringFormat.init(inst, def);
});
function iban2(params) {
return _iban(ZodIBAN, 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", hostname, _params);
}
function hex2(_params) {
return _stringFormat(ZodCustomStringFormat, "hex", hex, _params);
}
function currencyCode2(_params) {
return _stringFormat(ZodCustomStringFormat, "currency_code", currencyCode, _params);
}
function hash(alg, params) {
const enc = params?.enc ?? "hex";
const format = `${alg}_${enc}`;
const regex = regexes_exports[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, json2, params) => numberProcessor(inst, ctx, json2, params);
inst.isFinite = true;
},
/* @__PURE__ */ util_exports.derived({
minValue: (inst) => {
const { minimum, exclusiveMinimum } = aggregateChecks(inst);
return Math.max(minimum ?? Number.NEGATIVE_INFINITY, exclusiveMinimum ?? Number.NEGATIVE_INFINITY);
},
maxValue: (inst) => {
const { maximum, exclusiveMaximum } = aggregateChecks(inst);
return Math.min(maximum ?? Number.POSITIVE_INFINITY, exclusiveMaximum ?? Number.POSITIVE_INFINITY);
},
isInt: (inst) => {
const { isInt, multipleOf } = aggregateChecks(inst);
return !!isInt || !!multipleOf?.some(Number.isSafeInteger);
},
format: (inst) => aggregateChecks(inst).format ?? null
}, {
gt(value, params) {
return this.check(_gt(value, params));
},
gte(value, params) {
return this.check(_gte(value, params));
},
min(value, params) {
return this.check(_gte(value, params));
},
lt(value, params) {
return this.check(_lt(value, params));
},
lte(value, params) {
return this.check(_lte(value, params));
},
max(value, params) {
return this.check(_lte(value, params));
},
int(params) {
return this.check(int(params));
},
safe(params) {
return this.check(int(params));
},
positive(params) {
return this.check(_gt(0, params));
},
nonnegative(params) {
return this.check(_gte(0, params));
},
negative(params) {
return this.check(_lt(0, params));
},
nonpositive(params) {
return this.check(_lte(0, params));
},
multipleOf(value, params) {
return this.check(_multipleOf(value, params));
},
step(value, params) {
return this.check(_multipleOf(value, params));
},
finite() {
return this;
}
})
);
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, json2, params) => booleanProcessor(inst, ctx, json2, 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, json2, params) => bigintProcessor(inst, ctx, json2, params);
},
/* @__PURE__ */ util_exports.derived({
minValue: (inst) => aggregateChecks(inst).minimum ?? null,
maxValue: (inst) => aggregateChecks(inst).maximum ?? null,
format: (inst) => aggregateChecks(inst).format ?? null
}, {
gte(value, params) {
return this.check(_gte(value, params));
},
min(value, params) {
return this.check(_gte(value, params));
},
gt(value, params) {
return this.check(_gt(value, params));
},
lt(value, params) {
return this.check(_lt(value, params));
},
lte(value, params) {
return this.check(_lte(value, params));
},
max(value, params) {
return this.check(_lte(value, params));
},
positive(params) {
return this.check(_gt(BigInt(0), params));
},
negative(params) {
return this.check(_lt(BigInt(0), params));
},
nonpositive(params) {
return this.check(_lte(BigInt(0), params));
},
nonnegative(params) {
return this.check(_gte(BigInt(0), params));
},
multipleOf(value, params) {
return this.check(_multipleOf(value, params));
}
})
);
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, json2, params) => symbolProcessor(inst, ctx, json2, 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, json2, params) => undefinedProcessor(inst, ctx, json2, 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, json2, params) => nullProcessor(inst, ctx, json2, 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, json2, params) => anyProcessor(inst, ctx, json2, 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, json2, params) => unknownProcessor(inst, ctx, json2, 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, json2, params) => neverProcessor(inst, ctx, json2, 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, json2, params) => voidProcessor(inst, ctx, json2, 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, json2, params) => dateProcessor(inst, ctx, json2, params);
inst.min = (value, params) => inst.check(_gte(value, params));
inst.max = (value, params) => inst.check(_lte(value, params));
},
/* @__PURE__ */ util_exports.derived({
minDate: (inst) => {
const { minimum } = aggregateChecks(inst);
return minimum ? new Date(minimum) : null;
},
maxDate: (inst) => {
const { maximum } = aggregateChecks(inst);
return maximum ? new Date(maximum) : null;
}
}, {})
);
function date2(params) {
return _date(ZodDate, params);
}
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
_ensureDefaultMemoizer();
$ZodArray.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
inst.element = def.element;
}, {
min(n, params) {
return this.check(_minLength(n, params));
},
nonempty(params) {
return this.check(_minLength(1, params));
},
max(n, params) {
return this.check(_maxLength(n, params));
},
length(n, params) {
return this.check(_length(n, params));
},
unwrap() {
return this.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) => {
_ensureDefaultMemoizer();
$ZodObjectJIT.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
util_exports.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
}, {
keyof() {
return _enum2(Object.keys(this._zod.def.shape));
},
catchall(catchall) {
return this.clone(util_exports.mergeDefs(this._zod.def, { catchall }));
},
passthrough() {
return this.clone(util_exports.mergeDefs(this._zod.def, { catchall: unknown() }));
},
loose() {
return this.clone(util_exports.mergeDefs(this._zod.def, { catchall: unknown() }));
},
strict() {
return this.clone(util_exports.mergeDefs(this._zod.def, { catchall: never() }));
},
strip() {
return this.clone(util_exports.mergeDefs(this._zod.def, { catchall: void 0 }));
},
extend(incoming) {
return util_exports.extend(this, incoming);
},
safeExtend(incoming) {
return util_exports.safeExtend(this, incoming);
},
merge(other) {
return util_exports.merge(this, other);
},
pick(mask) {
return util_exports.pick(this, mask);
},
omit(mask) {
return util_exports.omit(this, mask);
},
partial(...args) {
return util_exports.partial(ZodOptional, this, args[0]);
},
exactPartial(...args) {
return util_exports.partial(ZodExactOptional, this, args[0], "exactPartial");
},
required(...args) {
return util_exports.required(ZodNonOptional, this, args[0]);
}
});
function object(shape, params) {
const def = {
type: "object",
shape: shape ?? {},
...util_exports.normalizeParams(params)
};
return new ZodObject(def);
}
function strictObject(shape, params) {
return new ZodObject({
type: "object",
shape,
catchall: never(),
...util_exports.normalizeParams(params)
});
}
function looseObject(shape, params) {
return new ZodObject({
type: "object",
shape,
catchall: unknown(),
...util_exports.normalizeParams(params)
});
}
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
$ZodUnion.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
inst.options = def.options;
});
function union(options, params) {
return new ZodUnion({
type: "union",
options,
...util_exports.normalizeParams(params)
});
}
var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
ZodUnion.init(inst, def);
$ZodXor.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
inst.options = def.options;
});
function xor(options, params) {
return new ZodXor({
type: "union",
options,
inclusive: false,
...util_exports.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,
...util_exports.normalizeParams(params)
});
}
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
$ZodIntersection.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
});
function intersection(left, right) {
return new ZodIntersection({
type: "intersection",
left,
right
});
}
var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
_ensureDefaultMemoizer();
$ZodTuple.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
}, {
rest(rest) {
return this.clone({
...this._zod.def,
rest
});
},
partial() {
const def = this._zod.def;
if (def.checks?.length)
throw new Error(".partial() cannot be used on tuple schemas containing refinements");
return this.clone({
...def,
items: def.items.map((item) => new ZodOptional({ type: "optional", innerType: item }))
});
}
});
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,
...util_exports.normalizeParams(params)
});
}
var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
_ensureDefaultMemoizer();
$ZodRecord.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
inst.keyType = def.keyType;
inst.valueType = def.valueType;
});
function record(keyType, valueType, params) {
if (!valueType || !valueType._zod) {
return new ZodRecord({
type: "record",
keyType: string2(),
valueType: keyType,
...util_exports.normalizeParams(valueType)
});
}
return new ZodRecord({
type: "record",
keyType,
valueType,
...util_exports.normalizeParams(params)
});
}
function partialRecord(keyType, valueType, params) {
return new ZodRecord({
type: "record",
keyType,
valueType,
...util_exports.normalizeParams(params),
partial: true
});
}
function looseRecord(keyType, valueType, params) {
return new ZodRecord({
type: "record",
keyType,
valueType,
mode: "loose",
...util_exports.normalizeParams(params)
});
}
var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
_ensureDefaultMemoizer();
$ZodMap.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, 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,
...util_exports.normalizeParams(params)
});
}
var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
_ensureDefaultMemoizer();
$ZodSet.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, 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,
...util_exports.normalizeParams(params)
});
}
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
$ZodEnum.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
inst.enum = def.entries;
inst.options = [...inst._zod.values];
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: [],
...util_exports.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: [],
...util_exports.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,
...util_exports.normalizeParams(params)
});
}
function nativeEnum(entries, params) {
return new ZodEnum({
type: "enum",
entries,
...util_exports.normalizeParams(params)
});
}
var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
$ZodLiteral.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, 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],
...util_exports.normalizeParams(params)
});
}
var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
$ZodFile.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, 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) => {
_ensureDefaultMemoizer();
$ZodTransform.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, 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(util_exports.issue(issue2, payload.value, def));
} else {
const _issue = issue2;
if (_issue.fatal)
_issue.continue = false;
_issue.code ?? (_issue.code = "custom");
if (!("input" in _issue))
_issue.input = payload.value;
_issue.inst ?? (_issue.inst = inst);
payload.issues.push(util_exports.issue(_issue));
}
};
const output2 = def.transform(payload.value, payload);
if (output2 instanceof Promise) {
return output2.then((output3) => {
payload.value = output3;
return payload;
});
}
payload.value = output2;
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, json2, params) => optionalProcessor(inst, ctx, json2, 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, json2, params) => optionalProcessor(inst, ctx, json2, 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, json2, params) => nullableProcessor(inst, ctx, json2, 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, json2, params) => defaultProcessor(inst, ctx, json2, 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() : util_exports.shallowClone(defaultValue);
}
});
}
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
$ZodPrefault.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function prefault(innerType, defaultValue) {
return new ZodPrefault({
type: "prefault",
innerType,
get defaultValue() {
return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
}
});
}
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
$ZodNonOptional.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function nonoptional(innerType, params) {
return new ZodNonOptional({
type: "nonoptional",
innerType,
...util_exports.normalizeParams(params)
});
}
var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
$ZodSuccess.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, 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, json2, params) => catchProcessor(inst, ctx, json2, 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 : util_exports.constantCatch(catchValue)
});
}
var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
$ZodNaN.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, 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, json2, params) => pipeProcessor(inst, ctx, json2, params);
inst.in = def.in;
inst.out = def.out;
});
function pipe(in_, out) {
return new ZodPipe({
type: "pipe",
in: in_,
out
// ...util.normalizeParams(params),
});
}
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
});
}
function invertCodec(codec2) {
const def = codec2._zod.def;
return new ZodCodec({
type: "pipe",
in: def.out,
out: def.in,
transform: def.reverseTransform,
reverseTransform: def.transform
});
}
var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) => {
ZodPipe.init(inst, def);
$ZodPreprocess.init(inst, def);
});
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
$ZodReadonly.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, 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, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
});
function templateLiteral(parts, params) {
return new ZodTemplateLiteral({
type: "template_literal",
parts,
...util_exports.normalizeParams(params)
});
}
var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
$ZodLazy.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, 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, json2, params) => promiseProcessor(inst, ctx, json2, 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, json2, params) => functionProcessor(inst, ctx, json2, 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, json2, params) => customProcessor(inst, ctx, json2, params);
});
function check(fn) {
const ch = new $ZodCheck({
check: "custom"
// ...util.normalizeParams(params),
});
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, params) {
return _superRefine(fn, params);
}
var describe2 = describe;
var meta2 = meta;
var ZodInstanceOf = /* @__PURE__ */ $constructor("ZodInstanceOf", (inst, def) => {
ZodCustom.init(inst, def);
}, {
properties(shape, params) {
return this.check(_properties(shape, params));
}
});
function _instanceof(cls, params = {}) {
const inst = new ZodInstanceOf({
type: "custom",
check: "custom",
fn: (data) => data instanceof cls,
abort: true,
...util_exports.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 new ZodPreprocess({
type: "pipe",
in: transform(fn),
out: schema
});
}
// node_modules/.pnpm/zod@4.6.7/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;
/* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/iso.js
var iso_exports = {};
__export(iso_exports, {
ZodISODate: () => ZodISODate,
ZodISODateTime: () => ZodISODateTime,
ZodISODuration: () => ZodISODuration,
ZodISOTime: () => ZodISOTime,
date: () => date3,
datetime: () => datetime2,
duration: () => duration2,
time: () => time2
});
function datetime2(params) {
return _isoDateTime(ZodISODateTime, params);
}
function date3(params) {
return _isoDate(ZodISODate, params);
}
function time2(params) {
return _isoTime(ZodISOTime, params);
}
function duration2(params) {
return _isoDuration(ZodISODuration, params);
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/from-json-schema.js
var z = {
...schemas_exports2,
...checks_exports2,
iso: iso_exports
};
var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
// Schema identification
"$schema",
"$ref",
"$defs",
"definitions",
// Core schema keywords
"$id",
"id",
"$comment",
"$anchor",
"$vocabulary",
"$dynamicRef",
"$dynamicAnchor",
// Type
"type",
"enum",
"const",
// Composition
"anyOf",
"oneOf",
"allOf",
"not",
// Object
"properties",
"required",
"additionalProperties",
"patternProperties",
"propertyNames",
"minProperties",
"maxProperties",
// Array
"items",
"prefixItems",
"additionalItems",
"minItems",
"maxItems",
"uniqueItems",
"contains",
"minContains",
"maxContains",
// String
"minLength",
"maxLength",
"pattern",
"format",
// Number
"minimum",
"maximum",
"exclusiveMinimum",
"exclusiveMaximum",
"multipleOf",
// Already handled metadata
"description",
"default",
// Content
"contentEncoding",
"contentMediaType",
"contentSchema",
// Unsupported (error-throwing)
"unevaluatedItems",
"unevaluatedProperties",
"if",
"then",
"else",
"dependentSchemas",
"dependentRequired",
// OpenAPI
"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 applyMinItems(items, minItems) {
return items.map((item, index) => index < minItems ? item : item.optional());
}
function decodeJSONPointerSegment(segment) {
return segment.replace(/~1/g, "/").replace(/~0/g, "~");
}
function resolveRef(ref, ctx) {
if (!ref.startsWith("#")) {
throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
}
const path3 = ref.slice(1).split("/").filter(Boolean);
if (path3.length === 0) {
return ctx.rootSchema;
}
const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
if (path3[0] === defsKey) {
const key = path3[1] === void 0 ? void 0 : decodeJSONPointerSegment(path3[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 checkObjectGuards(objectSchema, guards) {
const guard = z.transform((value) => value).check((payload) => {
const value = payload.value;
if (typeof value !== "object" || value === null || Array.isArray(value))
return;
const keys = Object.getOwnPropertyNames(value);
if (guards.minProperties !== void 0 && keys.length < guards.minProperties) {
payload.issues.push({
origin: "object",
code: "too_small",
minimum: guards.minProperties,
inclusive: true,
message: `Too small: expected object to have >=${guards.minProperties} properties`,
input: value,
inst: objectSchema,
continue: true
});
}
if (guards.maxProperties !== void 0 && keys.length > guards.maxProperties) {
payload.issues.push({
origin: "object",
code: "too_big",
maximum: guards.maxProperties,
inclusive: true,
message: `Too big: expected object to have <=${guards.maxProperties} properties`,
input: value,
inst: objectSchema,
continue: true
});
}
if (guards.keySchema) {
for (const key of keys) {
const result = guards.keySchema.safeParse(key);
if (result.success)
continue;
payload.issues.push({
code: "invalid_key",
origin: "record",
issues: result.error.issues,
input: key,
path: [key],
continue: true
});
}
}
});
return guard.pipe(objectSchema);
}
function canonicalKey(value, seen) {
if (value === null)
return "z";
const type = typeof value;
if (type !== "object") {
if (type === "number" && Number.isNaN(value))
return null;
const raw = String(value);
return `${type[0]}${raw.length}:${raw}`;
}
if (seen.has(value))
return null;
seen.add(value);
try {
if (Array.isArray(value)) {
const parts2 = [];
for (const item of value) {
const key = canonicalKey(item, seen);
if (key === null)
return null;
parts2.push(key);
}
return `a${parts2.length}:[${parts2.join(",")}]`;
}
const keys = Object.keys(value).sort();
const parts = [];
for (const k of keys) {
const key = canonicalKey(value[k], seen);
if (key === null)
return null;
parts.push(`${k.length}:${k}=${key}`);
}
return `o${parts.length}:{${parts.join(",")}}`;
} finally {
seen.delete(value);
}
}
var SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
"items",
"prefixItems",
"additionalItems",
"additionalProperties",
"contains",
"propertyNames",
"not",
"if",
"then",
"else",
"allOf",
"anyOf",
"oneOf",
"unevaluatedItems",
"unevaluatedProperties",
"contentSchema"
]);
var SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
"properties",
"patternProperties",
"dependentSchemas",
"dependencies",
"$defs",
"definitions"
]);
function containsRef(value) {
if (typeof value !== "object" || value === null)
return false;
if (Array.isArray(value))
return value.some(containsRef);
if (typeof value.$ref === "string")
return true;
return Object.entries(value).some(([key, sub]) => {
if (SCHEMA_KEYWORDS.has(key))
return containsRef(sub);
if (!SCHEMA_MAP_KEYWORDS.has(key) || typeof sub !== "object" || sub === null)
return false;
return Object.values(sub).some(containsRef);
});
}
function plural(n) {
return n === 1 ? "element" : "elements";
}
function checkArrayGuards(arraySchema, guards) {
const guard = z.transform((value) => value).check((payload) => {
const items = payload.value;
if (!Array.isArray(items))
return;
if (guards.uniqueItems === true) {
const firstSeen = /* @__PURE__ */ new Map();
for (let i = 0; i < items.length; i++) {
const key = canonicalKey(items[i], /* @__PURE__ */ new Set());
if (key === null)
continue;
const first = firstSeen.get(key);
if (first === void 0) {
firstSeen.set(key, i);
continue;
}
payload.issues.push({
code: "custom",
message: `Array items must be unique: element at index ${i} duplicates the one at index ${first}`,
input: items,
path: [i],
continue: true
});
}
}
if (guards.containsSchema) {
const minContains = guards.minContains ?? 1;
const ceiling = guards.maxContains !== void 0 ? guards.maxContains + 1 : Number.POSITIVE_INFINITY;
let matches = 0;
for (const item of items) {
if (guards.containsSchema.safeParse(item).success && ++matches >= ceiling)
break;
}
if (matches < minContains) {
payload.issues.push({
code: "custom",
message: `Array must contain at least ${minContains} matching ${plural(minContains)}; found ${matches}`,
input: items,
continue: true
});
}
if (guards.maxContains !== void 0 && matches > guards.maxContains) {
payload.issues.push({
code: "custom",
message: `Array must contain at most ${guards.maxContains} matching ${plural(guards.maxContains)}`,
input: items,
continue: true
});
}
}
});
return guard.pipe(arraySchema);
}
function getTupleRest(restSchema, ctx) {
if (restSchema === false) {
return void 0;
}
if (restSchema === void 0 || restSchema === true) {
return z.any();
}
return convertSchema(restSchema, ctx);
}
var fullTime = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
function convertBaseSchema(schema, ctx) {
if (schema.not !== void 0) {
if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
return z.never();
}
throw new Error("not is not supported in Zod (except { not: {} } for never)");
}
if (schema.unevaluatedItems !== void 0) {
throw new Error("unevaluatedItems is not supported");
}
if (schema.unevaluatedProperties !== void 0) {
throw new Error("unevaluatedProperties is not supported");
}
if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
throw new Error("Conditional schemas (if/then/else) are not supported");
}
if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
throw new Error("dependentSchemas and dependentRequired are not supported");
}
if (schema.$ref) {
const refPath = schema.$ref;
if (ctx.refs.has(refPath)) {
return ctx.refs.get(refPath);
}
if (ctx.processing.has(refPath)) {
return z.lazy(() => {
if (!ctx.refs.has(refPath)) {
throw new Error(`Circular reference not resolved: ${refPath}`);
}
return ctx.refs.get(refPath);
});
}
ctx.processing.add(refPath);
const resolved = resolveRef(refPath, ctx);
const zodSchema2 = convertSchema(resolved, ctx);
ctx.refs.set(refPath, zodSchema2);
ctx.processing.delete(refPath);
return zodSchema2;
}
if (schema.enum !== void 0) {
const enumValues = schema.enum;
if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
return z.null();
}
if (enumValues.length === 0) {
return z.never();
}
if (enumValues.length === 1) {
return z.literal(enumValues[0]);
}
if (enumValues.every((v) => typeof v === "string")) {
return z.enum(enumValues);
}
const literalSchemas = enumValues.map((v) => z.literal(v));
if (literalSchemas.length < 2) {
return literalSchemas[0];
}
return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
}
if (schema.const !== void 0) {
return z.literal(schema.const);
}
const type = schema.type;
if (Array.isArray(type)) {
const typeSchemas = type.map((t) => {
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({ offset: true }));
} else if (format === "date") {
stringSchema = stringSchema.check(z.iso.date());
} else if (format === "time") {
stringSchema = stringSchema.check(z.regex(fullTime));
} else if (format === "duration") {
stringSchema = stringSchema.check(z.iso.duration());
} else if (format === "hostname") {
stringSchema = stringSchema.check(z.hostname());
} 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 === "credit_card") {
stringSchema = stringSchema.check(z.creditCard());
} else if (format === "iban") {
stringSchema = stringSchema.check(z.iban());
} 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" && schema.exclusiveMinimum !== true) {
numberSchema = numberSchema.min(schema.minimum);
}
if (typeof schema.maximum === "number" && schema.exclusiveMaximum !== true) {
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 || []);
const additionalSchema = typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : void 0;
for (const [key, propSchema] of Object.entries(properties)) {
const propZodSchema = convertSchema(propSchema, ctx);
assignProp(shape, key, requiredSet.has(key) ? propZodSchema : propZodSchema.optional());
}
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;
}
if (schema.additionalProperties === false) {
const propertyKeys = Object.keys(shape);
const patterns = patternKeys.map((p) => new RegExp(p));
const basePatternSchema = zodSchema;
zodSchema = zodSchema.check((payload) => {
if (!isPlainObject(payload.value))
return;
const unrecognized = [];
for (const key of Object.keys(payload.value)) {
if (propertyKeys.includes(key))
continue;
if (patterns.some((regex) => regex.test(key)))
continue;
unrecognized.push(key);
}
if (unrecognized.length) {
payload.issues.push({
code: "unrecognized_keys",
keys: unrecognized,
input: payload.value,
inst: basePatternSchema
});
}
});
}
} else {
const objectSchema = z.object(shape);
if (schema.additionalProperties === false) {
zodSchema = objectSchema.strict();
} else if (additionalSchema) {
zodSchema = objectSchema.catchall(additionalSchema);
} else {
zodSchema = objectSchema.passthrough();
}
}
const hasKeyGuard = schema.propertyNames !== void 0 && schema.propertyNames !== true;
const minProperties = typeof schema.minProperties === "number" ? schema.minProperties : void 0;
const maxProperties = typeof schema.maxProperties === "number" ? schema.maxProperties : void 0;
if (hasKeyGuard || minProperties !== void 0 || maxProperties !== void 0) {
let keySchema;
if (hasKeyGuard) {
const keyJSONSchema = typeof schema.propertyNames === "object" && schema.propertyNames.type === void 0 ? { type: "string", ...schema.propertyNames } : schema.propertyNames;
keySchema = convertSchema(keyJSONSchema, ctx);
}
zodSchema = checkObjectGuards(zodSchema, { keySchema, minProperties, maxProperties });
}
break;
}
case "array": {
const prefixItems = schema.prefixItems;
const items = schema.items;
if (prefixItems && Array.isArray(prefixItems)) {
const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
const positionalItems = applyMinItems(tupleItems, minItems);
const rest = !Array.isArray(items) ? getTupleRest(items, ctx) : void 0;
const tupleSchema = z.tuple(positionalItems);
zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
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 minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
const tupleItems = items.map((item) => convertSchema(item, ctx));
const positionalItems = applyMinItems(tupleItems, minItems);
const rest = getTupleRest(schema.additionalItems, ctx);
const tupleSchema = z.tuple(positionalItems);
zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
if (typeof schema.minItems === "number") {
zodSchema = zodSchema.check(z.minLength(schema.minItems));
}
if (typeof schema.maxItems === "number") {
zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
}
} else if (items !== void 0) {
const element = convertSchema(items, ctx);
let arraySchema = z.array(element);
if (typeof schema.minItems === "number") {
arraySchema = arraySchema.min(schema.minItems);
}
if (typeof schema.maxItems === "number") {
arraySchema = arraySchema.max(schema.maxItems);
}
zodSchema = arraySchema;
} else {
zodSchema = z.array(z.any());
}
if (schema.uniqueItems === true || schema.contains !== void 0) {
zodSchema = checkArrayGuards(zodSchema, {
uniqueItems: schema.uniqueItems === true,
containsSchema: schema.contains !== void 0 ? convertSchema(schema.contains, ctx) : void 0,
minContains: typeof schema.minContains === "number" ? schema.minContains : void 0,
maxContains: typeof schema.maxContains === "number" ? schema.maxContains : void 0
});
}
break;
}
default:
throw new Error(`Unsupported type: ${type}`);
}
return zodSchema;
}
function convertSchema(schema, ctx) {
if (typeof schema === "boolean") {
return schema ? z.any() : z.never();
}
let baseSchema = convertBaseSchema(schema, ctx);
const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
if (schema.anyOf && Array.isArray(schema.anyOf)) {
const options = schema.anyOf.map((s) => convertSchema(s, ctx));
const anyOfUnion = z.union(options);
baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
}
if (schema.oneOf && Array.isArray(schema.oneOf)) {
const options = schema.oneOf.map((s) => convertSchema(s, ctx));
const oneOfUnion = z.xor(options);
baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
}
if (schema.allOf && Array.isArray(schema.allOf)) {
if (schema.allOf.length === 0) {
baseSchema = hasExplicitType ? baseSchema : z.any();
} else {
let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
const startIdx = hasExplicitType ? 0 : 1;
for (let i = startIdx; i < schema.allOf.length; i++) {
result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
}
baseSchema = result;
}
}
if (schema.nullable === true && ctx.version === "openapi-3.0") {
baseSchema = z.nullable(baseSchema);
}
if (schema.readOnly === true) {
baseSchema = z.readonly(baseSchema);
}
if (schema.default !== void 0) {
baseSchema = baseSchema.default(schema.default);
}
const extraMeta = {};
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];
}
}
if (schema.type === "object" && schema.$ref === void 0) {
if (schema.propertyNames !== void 0 && !containsRef(schema.propertyNames)) {
extraMeta.propertyNames = schema.propertyNames;
}
for (const key of ["minProperties", "maxProperties"]) {
if (schema[key] !== void 0)
extraMeta[key] = schema[key];
}
}
if (schema.type === "array" && schema.$ref === void 0) {
if (schema.contains !== void 0 && !containsRef(schema.contains)) {
extraMeta.contains = schema.contains;
}
for (const key of ["uniqueItems", "minContains", "maxContains"]) {
if (schema[key] !== void 0)
extraMeta[key] = schema[key];
}
}
for (const key of Object.keys(schema)) {
if (!RECOGNIZED_KEYS.has(key)) {
assignProp(extraMeta, key, schema[key]);
}
}
if (Object.keys(extraMeta).length > 0) {
ctx.registry.add(baseSchema, extraMeta);
}
if (schema.description) {
baseSchema = baseSchema.describe(schema.description);
}
return baseSchema;
}
function fromJSONSchema(schema, params) {
if (typeof schema === "boolean") {
return schema ? z.any() : z.never();
}
let normalized;
try {
normalized = JSON.parse(JSON.stringify(schema));
} catch {
throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
}
const version3 = detectVersion(normalized, params?.defaultTarget);
const defs = normalized.$defs || normalized.definitions || {};
const ctx = {
version: version3,
defs,
refs: /* @__PURE__ */ new Map(),
processing: /* @__PURE__ */ new Set(),
rootSchema: normalized,
registry: params?.registry ?? globalRegistry
};
return convertSchema(normalized, ctx);
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/visit.js
var RESOLVING = Symbol("z.visit/resolving");
function visit(schema, fnOrHandlers) {
const fn = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
const h = fnOrHandlers[node2._zod.def.type];
return h ? h(node2, rewritten) : node2;
};
const cache = /* @__PURE__ */ new Map();
function run(s) {
const cached2 = cache.get(s);
if (cached2 === RESOLVING) {
return new $ZodLazy({
type: "lazy",
getter: () => cache.get(s)
});
}
if (cached2 !== void 0)
return cached2;
cache.set(s, RESOLVING);
const inner = mapInner(s);
const mapped = fn(inner, inner !== s);
cache.set(s, mapped);
return mapped;
}
function mapInner(s) {
const def = s._zod.def;
const kind = def.type;
switch (kind) {
case "object": {
const oldShape = def.shape;
const keys = Object.keys(oldShape);
let changed = false;
const newShape = {};
for (const k of keys) {
const mapped = run(oldShape[k]);
if (mapped !== oldShape[k])
changed = true;
newShape[k] = mapped;
}
let newCatchall = def.catchall;
if (def.catchall) {
newCatchall = run(def.catchall);
if (newCatchall !== def.catchall)
changed = true;
}
return changed ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
}
case "array": {
const mapped = run(def.element);
return mapped === def.element ? s : clone(s, { ...def, element: mapped });
}
case "tuple": {
const oldItems = def.items;
let changed = false;
const newItems = [];
for (const item of oldItems) {
const mapped = run(item);
if (mapped !== item)
changed = true;
newItems.push(mapped);
}
let newRest = def.rest;
if (def.rest) {
newRest = run(def.rest);
if (newRest !== def.rest)
changed = true;
}
return changed ? clone(s, { ...def, items: newItems, rest: newRest }) : s;
}
case "record":
case "map": {
const newKey = run(def.keyType);
const newVal = run(def.valueType);
return newKey === def.keyType && newVal === def.valueType ? s : clone(s, { ...def, keyType: newKey, valueType: newVal });
}
case "set": {
const newVal = run(def.valueType);
return newVal === def.valueType ? s : clone(s, { ...def, valueType: newVal });
}
case "union": {
const oldOptions = def.options;
let changed = false;
const newOptions = [];
for (const opt of oldOptions) {
const mapped = run(opt);
if (mapped !== opt)
changed = true;
newOptions.push(mapped);
}
return changed ? clone(s, { ...def, options: newOptions }) : s;
}
case "intersection": {
const newLeft = run(def.left);
const newRight = run(def.right);
return newLeft === def.left && newRight === def.right ? s : clone(s, { ...def, left: newLeft, right: newRight });
}
case "optional":
case "nullable":
case "default":
case "prefault":
case "catch":
case "readonly":
case "nonoptional":
case "promise":
case "success": {
const newInner = run(def.innerType);
return newInner === def.innerType ? s : clone(s, { ...def, innerType: newInner });
}
case "pipe": {
const newIn = run(def.in);
const newOut = run(def.out);
return newIn === def.in && newOut === def.out ? s : clone(s, { ...def, in: newIn, out: newOut });
}
case "function": {
const newInput = run(def.input);
const newOutput = run(def.output);
return newInput === def.input && newOutput === def.output ? s : clone(s, { ...def, input: newInput, output: newOutput });
}
case "lazy": {
const original = def.getter;
const { _cachedInner, ...rest } = def;
return clone(s, { ...rest, getter: () => run(original()) });
}
// A leaf by choice: `parts` are regex fragments, not data positions.
case "template_literal":
// Leaves.
case "string":
case "number":
case "int":
case "boolean":
case "bigint":
case "symbol":
case "undefined":
case "null":
case "void":
case "never":
case "any":
case "unknown":
case "date":
case "nan":
case "enum":
case "literal":
case "file":
case "transform":
case "custom":
return s;
default: {
kind;
return s;
}
}
}
return run(schema);
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/deep-partial.js
function deepPartial(schema) {
return visit(schema, {
object: (s) => s.partial(),
// Every partialed option now admits `undefined`, which the constructor rejects as a duplicate.
union: (s) => {
const def = s._zod.def;
return def.discriminator === void 0 ? s : union(def.options);
}
});
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/in-out.js
function withChecks(side, checks) {
if (!checks?.length)
return side;
const def = side._zod.def;
return clone(side, mergeDefs(def, { checks: [...def.checks ?? [], ...checks] }), { parent: true });
}
function outSide(def) {
return withChecks(def.out, def.checks);
}
function inSide(def) {
return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
}
function input(schema) {
return visit(schema, {
pipe: (s) => inSide(s._zod.def),
// A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
default: (s, rewritten) => rewritten ? optional(s._zod.def.innerType) : s,
// A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
catch: (s, rewritten) => rewritten ? s._zod.def.innerType : s
});
}
function output(schema) {
return visit(schema, {
pipe: (s) => outSide(s._zod.def),
// A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
prefault: (s, rewritten) => rewritten ? s._zod.def.innerType : s
});
}
// node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/coerce.js
var coerce_exports = {};
__export(coerce_exports, {
bigint: () => bigint3,
boolean: () => boolean3,
date: () => date4,
number: () => number3,
string: () => string3
});
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/.pnpm/@modelcontextprotocol+core@2.4.0/node_modules/@modelcontextprotocol/core/dist/schemas-DscsoNZN.mjs
var LATEST_PROTOCOL_VERSION = "2025-11-25";
var SUPPORTED_PROTOCOL_VERSIONS = [
LATEST_PROTOCOL_VERSION,
"2025-06-18",
"2025-03-26",
"2024-11-05",
"2024-10-07"
];
var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
var PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
var CLIENT_INFO_META_KEY = "io.modelcontextprotocol/clientInfo";
var SERVER_INFO_META_KEY = "io.modelcontextprotocol/serverInfo";
var CLIENT_CAPABILITIES_META_KEY = "io.modelcontextprotocol/clientCapabilities";
var SUBSCRIPTION_ID_META_KEY = "io.modelcontextprotocol/subscriptionId";
var LOG_LEVEL_META_KEY = "io.modelcontextprotocol/logLevel";
var JSONRPC_VERSION = "2.0";
var JSONValueSchema = lazy(() => union([
string2(),
number2(),
boolean2(),
_null3(),
record(string2(), JSONValueSchema),
array(JSONValueSchema)
]));
var JSONObjectSchema = record(string2(), JSONValueSchema);
var JSONArraySchema = array(JSONValueSchema);
var ProgressTokenSchema = union([string2(), number2().int()]);
var CursorSchema = string2();
var TaskMetadataSchema = object({ ttl: number2().optional() });
var RelatedTaskMetadataSchema = object({ taskId: string2() });
var RequestMetaSchema = looseObject({
progressToken: ProgressTokenSchema.optional(),
[RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
});
var BaseRequestParamsSchema = object({ _meta: RequestMetaSchema.optional() });
var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({ task: TaskMetadataSchema.optional() });
var RequestSchema = object({
method: string2(),
params: BaseRequestParamsSchema.loose().optional()
});
var NotificationsParamsSchema = object({ _meta: RequestMetaSchema.optional() });
var NotificationSchema = object({
method: string2(),
params: NotificationsParamsSchema.loose().optional()
});
var ResultMetaObjectSchema = looseObject({ get [SERVER_INFO_META_KEY]() {
return ImplementationSchema.optional().catch(void 0);
} });
var ResultSchema = looseObject({ _meta: ResultMetaObjectSchema.optional() });
var RequestIdSchema = union([string2(), number2().int()]);
var JSONRPCRequestSchema = object({
jsonrpc: literal(JSONRPC_VERSION),
id: RequestIdSchema,
...RequestSchema.shape
}).strict();
var JSONRPCNotificationSchema = object({
jsonrpc: literal(JSONRPC_VERSION),
...NotificationSchema.shape
}).strict();
var JSONRPCResultResponseSchema = object({
jsonrpc: literal(JSONRPC_VERSION),
id: RequestIdSchema,
result: ResultSchema
}).strict();
var JSONRPCErrorResponseSchema = object({
jsonrpc: literal(JSONRPC_VERSION),
id: RequestIdSchema.optional(),
error: object({
code: number2().int(),
message: string2(),
data: unknown().optional()
})
}).strict();
var JSONRPCMessageSchema = union([
JSONRPCRequestSchema,
JSONRPCNotificationSchema,
JSONRPCResultResponseSchema,
JSONRPCErrorResponseSchema
]);
var JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
var EmptyResultSchema = ResultSchema.strict();
var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
requestId: RequestIdSchema.optional(),
reason: string2().optional()
});
var CancelledNotificationSchema = NotificationSchema.extend({
method: literal("notifications/cancelled"),
params: CancelledNotificationParamsSchema
});
var IconSchema = object({
src: string2(),
mimeType: string2().optional(),
sizes: array(string2()).optional(),
theme: _enum2(["light", "dark"]).optional()
});
var IconsSchema = object({ icons: array(IconSchema).optional() });
var BaseMetadataSchema = object({
name: string2(),
title: string2().optional()
});
var ImplementationSchema = BaseMetadataSchema.extend({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
version: string2(),
websiteUrl: string2().optional(),
description: string2().optional()
});
var FormElicitationCapabilitySchema = intersection(object({ applyDefaults: boolean2().optional() }), JSONObjectSchema);
var ElicitationCapabilitySchema = preprocess((value) => {
if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return { form: {} };
return value;
}, intersection(object({
form: FormElicitationCapabilitySchema.optional(),
url: JSONObjectSchema.optional()
}), JSONObjectSchema.optional()));
var ClientTasksCapabilitySchema = looseObject({
list: JSONObjectSchema.optional(),
cancel: JSONObjectSchema.optional(),
requests: looseObject({
sampling: looseObject({ createMessage: JSONObjectSchema.optional() }).optional(),
elicitation: looseObject({ create: JSONObjectSchema.optional() }).optional()
}).optional()
});
var ServerTasksCapabilitySchema = looseObject({
list: JSONObjectSchema.optional(),
cancel: JSONObjectSchema.optional(),
requests: looseObject({ tools: looseObject({ call: JSONObjectSchema.optional() }).optional() }).optional()
});
var ClientCapabilitiesSchema = object({
experimental: record(string2(), JSONObjectSchema).optional(),
sampling: object({
context: JSONObjectSchema.optional(),
tools: JSONObjectSchema.optional()
}).optional(),
elicitation: ElicitationCapabilitySchema.optional(),
roots: object({ listChanged: boolean2().optional() }).optional(),
tasks: ClientTasksCapabilitySchema.optional(),
extensions: record(string2(), JSONObjectSchema).optional()
});
var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
protocolVersion: string2(),
capabilities: ClientCapabilitiesSchema,
clientInfo: ImplementationSchema
});
var InitializeRequestSchema = RequestSchema.extend({
method: literal("initialize"),
params: InitializeRequestParamsSchema
});
var ServerCapabilitiesSchema = object({
experimental: record(string2(), JSONObjectSchema).optional(),
logging: JSONObjectSchema.optional(),
completions: JSONObjectSchema.optional(),
prompts: object({ listChanged: boolean2().optional() }).optional(),
resources: object({
subscribe: boolean2().optional(),
listChanged: boolean2().optional()
}).optional(),
tools: object({ listChanged: boolean2().optional() }).optional(),
tasks: ServerTasksCapabilitySchema.optional(),
extensions: record(string2(), JSONObjectSchema).optional()
});
var InitializeResultSchema = ResultSchema.extend({
protocolVersion: string2(),
capabilities: ServerCapabilitiesSchema,
serverInfo: ImplementationSchema,
instructions: string2().optional()
});
var InitializedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/initialized"),
params: NotificationsParamsSchema.optional()
});
var DiscoverRequestSchema = RequestSchema.extend({
method: literal("server/discover"),
params: BaseRequestParamsSchema.optional()
});
var DiscoverResultSchema = ResultSchema.extend({
supportedVersions: array(string2()),
capabilities: ServerCapabilitiesSchema,
instructions: string2().optional()
});
var PingRequestSchema = RequestSchema.extend({
method: literal("ping"),
params: BaseRequestParamsSchema.optional()
});
var ProgressSchema = object({
progress: number2(),
total: optional(number2()),
message: optional(string2())
});
var ProgressNotificationParamsSchema = object({
...NotificationsParamsSchema.shape,
...ProgressSchema.shape,
progressToken: ProgressTokenSchema
});
var ProgressNotificationSchema = NotificationSchema.extend({
method: literal("notifications/progress"),
params: ProgressNotificationParamsSchema
});
var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({ cursor: CursorSchema.optional() });
var PaginatedRequestSchema = RequestSchema.extend({ params: PaginatedRequestParamsSchema.optional() });
var PaginatedResultSchema = ResultSchema.extend({ nextCursor: CursorSchema.optional() });
var ResourceContentsSchema = object({
uri: string2(),
mimeType: optional(string2()),
_meta: record(string2(), unknown()).optional()
});
var TextResourceContentsSchema = ResourceContentsSchema.extend({ text: string2() });
var Base64Schema = string2().refine((val) => {
try {
atob(val);
return true;
} catch {
return false;
}
}, { message: "Invalid Base64 string" });
var BlobResourceContentsSchema = ResourceContentsSchema.extend({ blob: Base64Schema });
var RoleSchema = _enum2(["user", "assistant"]);
var AnnotationsSchema = object({
audience: array(RoleSchema).optional(),
priority: number2().min(0).max(1).optional(),
lastModified: iso_exports.datetime({ offset: true }).optional()
});
var ResourceSchema = object({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
uri: string2(),
description: optional(string2()),
mimeType: optional(string2()),
size: optional(number2()),
annotations: AnnotationsSchema.optional(),
_meta: optional(looseObject({}))
});
var ResourceTemplateSchema = object({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
uriTemplate: string2(),
description: optional(string2()),
mimeType: optional(string2()),
annotations: AnnotationsSchema.optional(),
_meta: optional(looseObject({}))
});
var ListResourcesRequestSchema = PaginatedRequestSchema.extend({ method: literal("resources/list") });
var ListResourcesResultSchema = PaginatedResultSchema.extend({ resources: array(ResourceSchema) });
var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({ method: literal("resources/templates/list") });
var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({ resourceTemplates: array(ResourceTemplateSchema) });
var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({ uri: string2() });
var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
var ReadResourceRequestSchema = RequestSchema.extend({
method: literal("resources/read"),
params: ReadResourceRequestParamsSchema
});
var ReadResourceResultSchema = ResultSchema.extend({ contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema])) });
var ResourceListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/resources/list_changed"),
params: NotificationsParamsSchema.optional()
});
var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
var SubscribeRequestSchema = RequestSchema.extend({
method: literal("resources/subscribe"),
params: SubscribeRequestParamsSchema
});
var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
var UnsubscribeRequestSchema = RequestSchema.extend({
method: literal("resources/unsubscribe"),
params: UnsubscribeRequestParamsSchema
});
var SubscriptionFilterSchema = object({
toolsListChanged: boolean2().optional(),
promptsListChanged: boolean2().optional(),
resourcesListChanged: boolean2().optional(),
resourceSubscriptions: array(string2()).optional()
});
var SubscriptionsListenRequestParamsSchema = BaseRequestParamsSchema.extend({ notifications: SubscriptionFilterSchema });
var SubscriptionsListenRequestSchema = RequestSchema.extend({
method: literal("subscriptions/listen"),
params: SubscriptionsListenRequestParamsSchema
});
var SubscriptionsAcknowledgedNotificationParamsSchema = NotificationsParamsSchema.extend({ notifications: SubscriptionFilterSchema });
var SubscriptionsAcknowledgedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/subscriptions/acknowledged"),
params: SubscriptionsAcknowledgedNotificationParamsSchema
});
var SubscriptionsListenResultMetaSchema = ResultMetaObjectSchema.extend({ [SUBSCRIPTION_ID_META_KEY]: RequestIdSchema });
var SubscriptionsListenResultSchema = ResultSchema.extend({ _meta: SubscriptionsListenResultMetaSchema });
var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({ uri: string2() });
var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/resources/updated"),
params: ResourceUpdatedNotificationParamsSchema
});
var PromptArgumentSchema = object({
name: string2(),
description: optional(string2()),
required: optional(boolean2())
});
var PromptSchema = object({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
description: optional(string2()),
arguments: optional(array(PromptArgumentSchema)),
_meta: optional(looseObject({}))
});
var ListPromptsRequestSchema = PaginatedRequestSchema.extend({ method: literal("prompts/list") });
var ListPromptsResultSchema = PaginatedResultSchema.extend({ prompts: array(PromptSchema) });
var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
name: string2(),
arguments: record(string2(), string2()).optional()
});
var GetPromptRequestSchema = RequestSchema.extend({
method: literal("prompts/get"),
params: GetPromptRequestParamsSchema
});
var TextContentSchema = object({
type: literal("text"),
text: string2(),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ImageContentSchema = object({
type: literal("image"),
data: Base64Schema,
mimeType: string2(),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var AudioContentSchema = object({
type: literal("audio"),
data: Base64Schema,
mimeType: string2(),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ToolUseContentSchema = object({
type: literal("tool_use"),
name: string2(),
id: string2(),
input: record(string2(), unknown()),
_meta: record(string2(), unknown()).optional()
});
var EmbeddedResourceSchema = object({
type: literal("resource"),
resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
annotations: AnnotationsSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ResourceLinkSchema = ResourceSchema.extend({ type: literal("resource_link") });
var ContentBlockSchema = union([
TextContentSchema,
ImageContentSchema,
AudioContentSchema,
ResourceLinkSchema,
EmbeddedResourceSchema
]);
var PromptMessageSchema = object({
role: RoleSchema,
content: ContentBlockSchema
});
var GetPromptResultSchema = ResultSchema.extend({
description: string2().optional(),
messages: array(PromptMessageSchema)
});
var PromptListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/prompts/list_changed"),
params: NotificationsParamsSchema.optional()
});
var ToolAnnotationsSchema = object({
title: string2().optional(),
readOnlyHint: boolean2().optional(),
destructiveHint: boolean2().optional(),
idempotentHint: boolean2().optional(),
openWorldHint: boolean2().optional()
});
var ToolExecutionSchema = object({ taskSupport: _enum2([
"required",
"optional",
"forbidden"
]).optional() });
var ToolSchema = object({
...BaseMetadataSchema.shape,
...IconsSchema.shape,
description: string2().optional(),
inputSchema: object({
type: literal("object"),
properties: record(string2(), JSONValueSchema).optional(),
required: array(string2()).optional()
}).catchall(unknown()),
outputSchema: looseObject({ $schema: string2().optional() }).optional(),
annotations: ToolAnnotationsSchema.optional(),
execution: ToolExecutionSchema.optional(),
_meta: record(string2(), unknown()).optional()
});
var ListToolsRequestSchema = PaginatedRequestSchema.extend({ method: literal("tools/list") });
var ListToolsResultSchema = PaginatedResultSchema.extend({ tools: array(ToolSchema) });
var CallToolResultSchema = ResultSchema.extend({
content: array(ContentBlockSchema).default([]),
structuredContent: unknown().optional(),
isError: boolean2().optional()
});
var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({ toolResult: unknown() }));
var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
name: string2(),
arguments: record(string2(), unknown()).optional()
});
var CallToolRequestSchema = RequestSchema.extend({
method: literal("tools/call"),
params: CallToolRequestParamsSchema
});
var ToolListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/tools/list_changed"),
params: NotificationsParamsSchema.optional()
});
var ListChangedOptionsBaseSchema = object({
autoRefresh: boolean2().default(true),
debounceMs: number2().int().nonnegative().default(300)
});
var LoggingLevelSchema = _enum2([
"debug",
"info",
"notice",
"warning",
"error",
"critical",
"alert",
"emergency"
]);
var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({ level: LoggingLevelSchema });
var SetLevelRequestSchema = RequestSchema.extend({
method: literal("logging/setLevel"),
params: SetLevelRequestParamsSchema
});
var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
level: LoggingLevelSchema,
logger: string2().optional(),
data: unknown()
});
var LoggingMessageNotificationSchema = NotificationSchema.extend({
method: literal("notifications/message"),
params: LoggingMessageNotificationParamsSchema
});
var ModelHintSchema = object({ name: string2().optional() });
var ModelPreferencesSchema = object({
hints: array(ModelHintSchema).optional(),
costPriority: number2().min(0).max(1).optional(),
speedPriority: number2().min(0).max(1).optional(),
intelligencePriority: number2().min(0).max(1).optional()
});
var ToolChoiceSchema = object({ mode: _enum2([
"auto",
"required",
"none"
]).optional() });
var ToolResultContentSchema = object({
type: literal("tool_result"),
toolUseId: string2().describe("The unique identifier for the corresponding tool call."),
content: array(ContentBlockSchema),
structuredContent: unknown().optional(),
isError: boolean2().optional(),
_meta: record(string2(), unknown()).optional()
});
var SamplingContentSchema = discriminatedUnion("type", [
TextContentSchema,
ImageContentSchema,
AudioContentSchema
]);
var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
TextContentSchema,
ImageContentSchema,
AudioContentSchema,
ToolUseContentSchema,
ToolResultContentSchema
]);
var SamplingMessageSchema = object({
role: RoleSchema,
content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]),
_meta: record(string2(), unknown()).optional()
});
var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
messages: array(SamplingMessageSchema),
modelPreferences: ModelPreferencesSchema.optional(),
systemPrompt: string2().optional(),
includeContext: _enum2([
"none",
"thisServer",
"allServers"
]).optional(),
temperature: number2().optional(),
maxTokens: number2().int(),
stopSequences: array(string2()).optional(),
metadata: JSONObjectSchema.optional(),
tools: array(ToolSchema).optional(),
toolChoice: ToolChoiceSchema.optional()
});
var CreateMessageRequestSchema = RequestSchema.extend({
method: literal("sampling/createMessage"),
params: CreateMessageRequestParamsSchema
});
var CreateMessageResultSchema = ResultSchema.extend({
model: string2(),
stopReason: optional(_enum2([
"endTurn",
"stopSequence",
"maxTokens"
]).or(string2())),
role: RoleSchema,
content: SamplingContentSchema
});
var CreateMessageResultWithToolsSchema = ResultSchema.extend({
model: string2(),
stopReason: optional(_enum2([
"endTurn",
"stopSequence",
"maxTokens",
"toolUse"
]).or(string2())),
role: RoleSchema,
content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
});
var BooleanSchemaSchema = object({
type: literal("boolean"),
title: string2().optional(),
description: string2().optional(),
default: boolean2().optional()
});
var StringSchemaSchema = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
minLength: number2().optional(),
maxLength: number2().optional(),
format: _enum2([
"email",
"uri",
"date",
"date-time"
]).optional(),
default: string2().optional()
});
var NumberSchemaSchema = object({
type: _enum2(["number", "integer"]),
title: string2().optional(),
description: string2().optional(),
minimum: number2().optional(),
maximum: number2().optional(),
default: number2().optional()
});
var UntitledSingleSelectEnumSchemaSchema = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
default: string2().optional()
});
var TitledSingleSelectEnumSchemaSchema = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
oneOf: array(object({
const: string2(),
title: string2()
})),
default: string2().optional()
});
var LegacyTitledEnumSchemaSchema = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
enumNames: array(string2()).optional(),
default: string2().optional()
});
var SingleSelectEnumSchemaSchema = union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
var UntitledMultiSelectEnumSchemaSchema = object({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object({
type: literal("string"),
enum: array(string2())
}),
default: array(string2()).optional()
});
var TitledMultiSelectEnumSchemaSchema = object({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object({ anyOf: array(object({
const: string2(),
title: string2()
})) }),
default: array(string2()).optional()
});
var MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
var EnumSchemaSchema = union([
LegacyTitledEnumSchemaSchema,
SingleSelectEnumSchemaSchema,
MultiSelectEnumSchemaSchema
]);
var PrimitiveSchemaDefinitionSchema = union([
EnumSchemaSchema,
BooleanSchemaSchema,
StringSchemaSchema,
NumberSchemaSchema
]);
var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
mode: literal("form").optional(),
message: string2(),
requestedSchema: object({
type: literal("object"),
properties: record(string2(), PrimitiveSchemaDefinitionSchema),
required: array(string2()).optional()
}).catchall(unknown())
});
var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
mode: literal("url"),
message: string2(),
elicitationId: string2(),
url: string2().url()
});
var ElicitRequestParamsSchema = union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
var ElicitRequestSchema = RequestSchema.extend({
method: literal("elicitation/create"),
params: ElicitRequestParamsSchema
});
var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({ elicitationId: string2() });
var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
method: literal("notifications/elicitation/complete"),
params: ElicitationCompleteNotificationParamsSchema
});
var ElicitResultSchema = ResultSchema.extend({
action: _enum2([
"accept",
"decline",
"cancel"
]),
content: preprocess((val) => val === null ? void 0 : val, record(string2(), union([
string2(),
number2(),
boolean2(),
array(string2())
])).optional())
});
var ResourceTemplateReferenceSchema = object({
type: literal("ref/resource"),
uri: string2()
});
var PromptReferenceSchema = object({
type: literal("ref/prompt"),
name: string2()
});
var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
argument: object({
name: string2(),
value: string2()
}),
context: object({ arguments: record(string2(), string2()).optional() }).optional()
});
var CompleteRequestSchema = RequestSchema.extend({
method: literal("completion/complete"),
params: CompleteRequestParamsSchema
});
var CompleteResultSchema = ResultSchema.extend({ completion: looseObject({
values: array(string2()).max(100),
total: optional(number2().int()),
hasMore: optional(boolean2())
}) });
var RootSchema = object({
uri: string2().startsWith("file://"),
name: string2().optional(),
_meta: record(string2(), unknown()).optional()
});
var ListRootsRequestSchema = RequestSchema.extend({
method: literal("roots/list"),
params: BaseRequestParamsSchema.optional()
});
var ListRootsResultSchema = ResultSchema.extend({ roots: array(RootSchema) });
var RootsListChangedNotificationSchema = NotificationSchema.extend({
method: literal("notifications/roots/list_changed"),
params: NotificationsParamsSchema.optional()
});
var TaskCreationParamsSchema = looseObject({
ttl: number2().optional(),
pollInterval: number2().optional()
});
var TaskStatusSchema = _enum2([
"working",
"input_required",
"completed",
"failed",
"cancelled"
]);
var TaskSchema = object({
taskId: string2(),
status: TaskStatusSchema,
ttl: union([number2(), _null3()]),
createdAt: string2(),
lastUpdatedAt: string2(),
pollInterval: optional(number2()),
statusMessage: optional(string2())
});
var CreateTaskResultSchema = ResultSchema.extend({ task: TaskSchema });
var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
var TaskStatusNotificationSchema = NotificationSchema.extend({
method: literal("notifications/tasks/status"),
params: TaskStatusNotificationParamsSchema
});
var GetTaskRequestSchema = RequestSchema.extend({
method: literal("tasks/get"),
params: BaseRequestParamsSchema.extend({ taskId: string2() })
});
var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
var GetTaskPayloadRequestSchema = RequestSchema.extend({
method: literal("tasks/result"),
params: BaseRequestParamsSchema.extend({ taskId: string2() })
});
var GetTaskPayloadResultSchema = ResultSchema.loose();
var ListTasksRequestSchema = PaginatedRequestSchema.extend({ method: literal("tasks/list") });
var ListTasksResultSchema = PaginatedResultSchema.extend({ tasks: array(TaskSchema) });
var CancelTaskRequestSchema = RequestSchema.extend({
method: literal("tasks/cancel"),
params: BaseRequestParamsSchema.extend({ taskId: string2() })
});
var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
var ClientRequestSchema = union([
PingRequestSchema,
InitializeRequestSchema,
DiscoverRequestSchema,
CompleteRequestSchema,
SetLevelRequestSchema,
GetPromptRequestSchema,
ListPromptsRequestSchema,
ListResourcesRequestSchema,
ListResourceTemplatesRequestSchema,
ReadResourceRequestSchema,
SubscribeRequestSchema,
UnsubscribeRequestSchema,
SubscriptionsListenRequestSchema,
CallToolRequestSchema,
ListToolsRequestSchema
]);
var ClientNotificationSchema = union([
CancelledNotificationSchema,
ProgressNotificationSchema,
InitializedNotificationSchema,
RootsListChangedNotificationSchema
]);
var ClientResultSchema = union([
EmptyResultSchema,
CreateMessageResultSchema,
CreateMessageResultWithToolsSchema,
ElicitResultSchema,
ListRootsResultSchema
]);
var ServerRequestSchema = union([
PingRequestSchema,
CreateMessageRequestSchema,
ElicitRequestSchema,
ListRootsRequestSchema
]);
var ServerNotificationSchema = union([
CancelledNotificationSchema,
ProgressNotificationSchema,
LoggingMessageNotificationSchema,
ResourceUpdatedNotificationSchema,
ResourceListChangedNotificationSchema,
ToolListChangedNotificationSchema,
PromptListChangedNotificationSchema,
SubscriptionsAcknowledgedNotificationSchema,
ElicitationCompleteNotificationSchema
]);
var ServerResultSchema = union([
EmptyResultSchema,
InitializeResultSchema,
DiscoverResultSchema,
CompleteResultSchema,
GetPromptResultSchema,
ListPromptsResultSchema,
ListResourcesResultSchema,
ListResourceTemplatesResultSchema,
ReadResourceResultSchema,
CallToolResultSchema,
ListToolsResultSchema,
SubscriptionsListenResultSchema
]);
// node_modules/.pnpm/@modelcontextprotocol+core@2.4.0/node_modules/@modelcontextprotocol/core/dist/auth-UMQCo-ad.mjs
var SafeUrlSchema = url().superRefine((val, ctx) => {
if (!URL.canParse(val)) {
ctx.addIssue({
code: ZodIssueCode.custom,
message: "URL must be parseable",
fatal: true
});
return NEVER;
}
}).refine((url2) => {
const u = new URL(url2);
return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
var OAuthProtectedResourceMetadataSchema = looseObject({
resource: string2().url(),
authorization_servers: array(SafeUrlSchema).optional(),
jwks_uri: string2().url().optional(),
scopes_supported: array(string2()).optional(),
bearer_methods_supported: array(string2()).optional(),
resource_signing_alg_values_supported: array(string2()).optional(),
resource_name: string2().optional(),
resource_documentation: string2().optional(),
resource_policy_uri: string2().url().optional(),
resource_tos_uri: string2().url().optional(),
tls_client_certificate_bound_access_tokens: boolean2().optional(),
authorization_details_types_supported: array(string2()).optional(),
dpop_signing_alg_values_supported: array(string2()).optional(),
dpop_bound_access_tokens_required: boolean2().optional()
});
var OAuthMetadataSchema = looseObject({
issuer: string2(),
authorization_endpoint: SafeUrlSchema,
token_endpoint: SafeUrlSchema,
registration_endpoint: SafeUrlSchema.optional(),
scopes_supported: array(string2()).optional(),
response_types_supported: array(string2()),
response_modes_supported: array(string2()).optional(),
grant_types_supported: array(string2()).optional(),
token_endpoint_auth_methods_supported: array(string2()).optional(),
token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
service_documentation: SafeUrlSchema.optional(),
revocation_endpoint: SafeUrlSchema.optional(),
revocation_endpoint_auth_methods_supported: array(string2()).optional(),
revocation_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
introspection_endpoint: string2().optional(),
introspection_endpoint_auth_methods_supported: array(string2()).optional(),
introspection_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
code_challenge_methods_supported: array(string2()).optional(),
client_id_metadata_document_supported: boolean2().optional(),
authorization_response_iss_parameter_supported: boolean2().optional().catch(void 0),
dpop_signing_alg_values_supported: array(string2()).optional()
});
var OpenIdProviderMetadataSchema = looseObject({
issuer: string2(),
authorization_endpoint: SafeUrlSchema,
token_endpoint: SafeUrlSchema,
userinfo_endpoint: SafeUrlSchema.optional(),
jwks_uri: SafeUrlSchema,
registration_endpoint: SafeUrlSchema.optional(),
scopes_supported: array(string2()).optional(),
response_types_supported: array(string2()),
response_modes_supported: array(string2()).optional(),
grant_types_supported: array(string2()).optional(),
acr_values_supported: array(string2()).optional(),
subject_types_supported: array(string2()),
id_token_signing_alg_values_supported: array(string2()),
id_token_encryption_alg_values_supported: array(string2()).optional(),
id_token_encryption_enc_values_supported: array(string2()).optional(),
userinfo_signing_alg_values_supported: array(string2()).optional(),
userinfo_encryption_alg_values_supported: array(string2()).optional(),
userinfo_encryption_enc_values_supported: array(string2()).optional(),
request_object_signing_alg_values_supported: array(string2()).optional(),
request_object_encryption_alg_values_supported: array(string2()).optional(),
request_object_encryption_enc_values_supported: array(string2()).optional(),
token_endpoint_auth_methods_supported: array(string2()).optional(),
token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
display_values_supported: array(string2()).optional(),
claim_types_supported: array(string2()).optional(),
claims_supported: array(string2()).optional(),
service_documentation: string2().optional(),
claims_locales_supported: array(string2()).optional(),
ui_locales_supported: array(string2()).optional(),
claims_parameter_supported: boolean2().optional(),
request_parameter_supported: boolean2().optional(),
request_uri_parameter_supported: boolean2().optional(),
require_request_uri_registration: boolean2().optional(),
op_policy_uri: SafeUrlSchema.optional(),
op_tos_uri: SafeUrlSchema.optional(),
client_id_metadata_document_supported: boolean2().optional(),
authorization_response_iss_parameter_supported: boolean2().optional().catch(void 0)
});
var OpenIdProviderDiscoveryMetadataSchema = object({
...OpenIdProviderMetadataSchema.shape,
...OAuthMetadataSchema.pick({ code_challenge_methods_supported: true }).shape
});
var OAuthTokensSchema = object({
access_token: string2(),
id_token: string2().optional(),
token_type: string2(),
expires_in: coerce_exports.number().optional(),
scope: string2().optional(),
refresh_token: string2().optional(),
issuer: string2().optional().catch(void 0)
}).strip();
var IdJagTokenExchangeResponseSchema = object({
issued_token_type: literal("urn:ietf:params:oauth:token-type:id-jag"),
access_token: string2(),
token_type: string2().optional(),
expires_in: number2().optional(),
scope: string2().optional()
}).strip();
var OAuthErrorResponseSchema = object({
error: string2(),
error_description: string2().optional(),
error_uri: string2().optional()
});
var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literal("").transform(() => void 0));
var OAuthClientMetadataSchema = object({
redirect_uris: array(SafeUrlSchema),
token_endpoint_auth_method: string2().optional(),
grant_types: array(string2()).optional(),
response_types: array(string2()).optional(),
application_type: string2().optional(),
client_name: string2().optional(),
client_uri: SafeUrlSchema.optional(),
logo_uri: OptionalSafeUrlSchema,
scope: string2().optional(),
contacts: array(string2()).optional(),
tos_uri: OptionalSafeUrlSchema,
policy_uri: string2().optional(),
jwks_uri: SafeUrlSchema.optional(),
jwks: any().optional(),
software_id: string2().optional(),
software_version: string2().optional(),
software_statement: string2().optional()
}).strip();
var OAuthClientInformationSchema = object({
client_id: string2(),
client_secret: string2().optional(),
client_id_issued_at: number2().optional(),
client_secret_expires_at: number2().optional(),
issuer: string2().optional().catch(void 0)
}).strip();
var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
var OAuthClientRegistrationErrorSchema = object({
error: string2(),
error_description: string2().optional()
}).strip();
var OAuthTokenRevocationRequestSchema = object({
token: string2(),
token_type_hint: string2().optional()
}).strip();
// node_modules/.pnpm/@modelcontextprotocol+client@2.4.0/node_modules/@modelcontextprotocol/client/dist/src-CeKsbNLO.mjs
var BRANDS = Symbol.for("mcp.sdk.errorBrands");
function stampErrorBrands(instance, ctor) {
const brands = /* @__PURE__ */ new Set();
let current = ctor;
while (typeof current === "function") {
const brand = current.mcpBrand;
if (Object.prototype.hasOwnProperty.call(current, "mcpBrand") && typeof brand === "string") brands.add(brand);
current = Object.getPrototypeOf(current);
}
if (brands.size === 0) return;
Object.defineProperty(instance, BRANDS, {
value: brands,
enumerable: false,
configurable: true
});
}
function brandedHasInstance(cls, value) {
try {
if (typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(cls, "mcpBrand") && typeof cls.mcpBrand === "string" && Object.prototype.hasOwnProperty.call(value, BRANDS)) {
const carried = value[BRANDS];
if (carried && typeof carried.has === "function" && carried.has(cls.mcpBrand)) return true;
}
} catch {
}
return Function.prototype[Symbol.hasInstance].call(cls, value);
}
var OAuthErrorCode = /* @__PURE__ */ function(OAuthErrorCode$1) {
OAuthErrorCode$1["InvalidRequest"] = "invalid_request";
OAuthErrorCode$1["InvalidClient"] = "invalid_client";
OAuthErrorCode$1["InvalidGrant"] = "invalid_grant";
OAuthErrorCode$1["UnauthorizedClient"] = "unauthorized_client";
OAuthErrorCode$1["UnsupportedGrantType"] = "unsupported_grant_type";
OAuthErrorCode$1["InvalidScope"] = "invalid_scope";
OAuthErrorCode$1["AccessDenied"] = "access_denied";
OAuthErrorCode$1["ServerError"] = "server_error";
OAuthErrorCode$1["TemporarilyUnavailable"] = "temporarily_unavailable";
OAuthErrorCode$1["UnsupportedResponseType"] = "unsupported_response_type";
OAuthErrorCode$1["UnsupportedTokenType"] = "unsupported_token_type";
OAuthErrorCode$1["InvalidToken"] = "invalid_token";
OAuthErrorCode$1["MethodNotAllowed"] = "method_not_allowed";
OAuthErrorCode$1["TooManyRequests"] = "too_many_requests";
OAuthErrorCode$1["InvalidClientMetadata"] = "invalid_client_metadata";
OAuthErrorCode$1["InvalidRedirectUri"] = "invalid_redirect_uri";
OAuthErrorCode$1["InsufficientScope"] = "insufficient_scope";
OAuthErrorCode$1["InvalidTarget"] = "invalid_target";
OAuthErrorCode$1["InvalidDpopProof"] = "invalid_dpop_proof";
OAuthErrorCode$1["UseDpopNonce"] = "use_dpop_nonce";
return OAuthErrorCode$1;
}({});
var OAuthError = class OAuthError2 extends Error {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.OAuthError" });
}
static [Symbol.hasInstance](value) {
return brandedHasInstance(this, value);
}
/**
* Brand-based type guard: equivalent to `value instanceof this`, as an
* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
* the caller's own brand via `this`, so every branded subclass gets a
* correctly-scoped guard by inheritance. Must be invoked on the class —
* in callback position write `v => SdkError.isInstance(v)`, not
* `.filter(SdkError.isInstance)` (detached calls throw rather than
* silently matching nothing).
*/
static isInstance(value) {
if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
return brandedHasInstance(this, value);
}
constructor(code, message, errorUri) {
super(message);
this.code = code;
this.errorUri = errorUri;
this.name = "OAuthError";
stampErrorBrands(this, new.target);
}
/**
* Converts the error to a standard OAuth error response object.
*/
toResponseObject() {
const response = {
error: this.code,
error_description: this.message
};
if (this.errorUri) response.error_uri = this.errorUri;
return response;
}
/**
* Creates an {@linkcode OAuthError} from an OAuth error response.
*/
static fromResponse(response) {
return new OAuthError2(response.error, response.error_description ?? response.error, response.error_uri);
}
};
var SdkErrorCode = /* @__PURE__ */ function(SdkErrorCode$1) {
SdkErrorCode$1["NotConnected"] = "NOT_CONNECTED";
SdkErrorCode$1["AlreadyConnected"] = "ALREADY_CONNECTED";
SdkErrorCode$1["NotInitialized"] = "NOT_INITIALIZED";
SdkErrorCode$1["CapabilityNotSupported"] = "CAPABILITY_NOT_SUPPORTED";
SdkErrorCode$1["RequestTimeout"] = "REQUEST_TIMEOUT";
SdkErrorCode$1["ConnectionClosed"] = "CONNECTION_CLOSED";
SdkErrorCode$1["SendFailed"] = "SEND_FAILED";
SdkErrorCode$1["InvalidResult"] = "INVALID_RESULT";
SdkErrorCode$1["UnsupportedResultType"] = "UNSUPPORTED_RESULT_TYPE";
SdkErrorCode$1["InputRequiredRoundsExceeded"] = "INPUT_REQUIRED_ROUNDS_EXCEEDED";
SdkErrorCode$1["ListPaginationExceeded"] = "LIST_PAGINATION_EXCEEDED";
SdkErrorCode$1["MethodNotSupportedByProtocolVersion"] = "METHOD_NOT_SUPPORTED_BY_PROTOCOL_VERSION";
SdkErrorCode$1["EraNegotiationFailed"] = "ERA_NEGOTIATION_FAILED";
SdkErrorCode$1["ClientHttpNotImplemented"] = "CLIENT_HTTP_NOT_IMPLEMENTED";
SdkErrorCode$1["ClientHttpAuthentication"] = "CLIENT_HTTP_AUTHENTICATION";
SdkErrorCode$1["ClientHttpForbidden"] = "CLIENT_HTTP_FORBIDDEN";
SdkErrorCode$1["ClientHttpUnexpectedContent"] = "CLIENT_HTTP_UNEXPECTED_CONTENT";
SdkErrorCode$1["ClientHttpFailedToOpenStream"] = "CLIENT_HTTP_FAILED_TO_OPEN_STREAM";
SdkErrorCode$1["ClientHttpFailedToTerminateSession"] = "CLIENT_HTTP_FAILED_TO_TERMINATE_SESSION";
return SdkErrorCode$1;
}({});
var SdkError = class extends Error {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkError" });
}
static [Symbol.hasInstance](value) {
return brandedHasInstance(this, value);
}
/**
* Brand-based type guard: equivalent to `value instanceof this`, as an
* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
* the caller's own brand via `this`, so every branded subclass gets a
* correctly-scoped guard by inheritance. Must be invoked on the class —
* in callback position write `v => SdkError.isInstance(v)`, not
* `.filter(SdkError.isInstance)` (detached calls throw rather than
* silently matching nothing).
*/
static isInstance(value) {
if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
return brandedHasInstance(this, value);
}
/**
* @param code - Stable string code identifying the failure ({@linkcode SdkErrorCode}).
* @param message - Human-readable description.
* @param data - Optional structured payload (for example the HTTP status carried by
* {@linkcode SdkHttpError}). Opaque to the SDK: a `cause` key inside `data` is not
* promoted to `Error.cause`.
* @param options - Standard `ErrorOptions`, forwarded to `Error`. Pass the underlying
* failure as `{ cause }` so it is reachable through the `Error.cause` chain that
* loggers and error trackers walk.
*/
constructor(code, message, data, options) {
super(message, options);
this.code = code;
this.data = data;
this.name = "SdkError";
stampErrorBrands(this, new.target);
}
};
var SdkHttpError = class extends SdkError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkHttpError" });
}
/**
* @param options - Standard `ErrorOptions`, forwarded to `Error` (see {@linkcode SdkError}).
*/
constructor(code, message, data, options) {
super(code, message, data, options);
this.name = "SdkHttpError";
}
get status() {
return this.data.status;
}
get statusText() {
return this.data.statusText;
}
};
function resourceUrlFromServerUrl(url2) {
const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href);
resourceURL.hash = "";
return resourceURL;
}
function withoutIssuer(body) {
if (typeof body !== "object" || body === null || Array.isArray(body)) return body;
const copy = { ...body };
delete copy.issuer;
return copy;
}
function checkResourceAllowed({ requestedResource, configuredResource }) {
const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
if (requested.origin !== configured.origin) return false;
if (requested.pathname.length < configured.pathname.length) return false;
const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
return requestedPath.startsWith(configuredPath);
}
var FIRST_MODERN_PROTOCOL_VERSION = "2026-07-28";
var SUPPORTED_MODERN_PROTOCOL_VERSIONS = [FIRST_MODERN_PROTOCOL_VERSION];
function isModernProtocolVersion(version3) {
return version3 >= FIRST_MODERN_PROTOCOL_VERSION;
}
function legacyProtocolVersions(versions) {
return versions.filter((version3) => !isModernProtocolVersion(version3));
}
function modernProtocolVersions(versions) {
return versions.filter((version3) => isModernProtocolVersion(version3));
}
function appendTextFallbackForNonObject(result) {
const sc = result.structuredContent;
if (sc === void 0) return result;
if (!(typeof sc !== "object" || sc === null || Array.isArray(sc))) return result;
if (result.content?.some((c) => c.type === "text") ?? false) return result;
return {
...result,
content: [...result.content ?? [], {
type: "text",
text: JSON.stringify(sc)
}]
};
}
var TOOL_RESULT_FOREIGN_FAMILY_KEYS = [
"task",
"inputRequests",
"requestState"
];
function normalizeContentlessToolResult(value) {
if (value === null || typeof value !== "object" || Array.isArray(value) || value.content !== void 0 || TOOL_RESULT_FOREIGN_FAMILY_KEYS.some((key) => key in value)) return value;
return {
...value,
content: []
};
}
function build$1() {
const JSONValueSchema$1 = lazy(() => union([
string2(),
number2(),
boolean2(),
_null3(),
record(string2(), JSONValueSchema$1),
array(JSONValueSchema$1)
]));
const JSONObjectSchema$1 = record(string2(), JSONValueSchema$1);
const ProgressTokenSchema$1 = union([string2(), number2().int()]);
const CursorSchema$1 = string2();
const TaskMetadataSchema$1 = object({ ttl: number2().optional() });
const RelatedTaskMetadataSchema$1 = object({ taskId: string2() });
const RequestMetaSchema$1 = looseObject({
progressToken: ProgressTokenSchema$1.optional(),
"io.modelcontextprotocol/related-task": RelatedTaskMetadataSchema$1.optional()
});
const BaseRequestParamsSchema$1 = object({ _meta: RequestMetaSchema$1.optional() });
const TaskAugmentedRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({ task: TaskMetadataSchema$1.optional() });
const RequestSchema$1 = object({
method: string2(),
params: BaseRequestParamsSchema$1.loose().optional()
});
const NotificationsParamsSchema$1 = object({ _meta: RequestMetaSchema$1.optional() });
const NotificationSchema$1 = object({
method: string2(),
params: NotificationsParamsSchema$1.loose().optional()
});
const ResultSchema$1 = looseObject({ _meta: RequestMetaSchema$1.optional() });
const RequestIdSchema$1 = union([string2(), number2().int()]);
const EmptyResultSchema$1 = ResultSchema$1.strict();
const CancelledNotificationParamsSchema$1 = NotificationsParamsSchema$1.extend({
requestId: RequestIdSchema$1.optional(),
reason: string2().optional()
});
const CancelledNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/cancelled"),
params: CancelledNotificationParamsSchema$1
});
const IconSchema$1 = object({
src: string2(),
mimeType: string2().optional(),
sizes: array(string2()).optional(),
theme: _enum2(["light", "dark"]).optional()
});
const IconsSchema$1 = object({ icons: array(IconSchema$1).optional() });
const BaseMetadataSchema$1 = object({
name: string2(),
title: string2().optional()
});
const ImplementationSchema$1 = BaseMetadataSchema$1.extend({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
version: string2(),
websiteUrl: string2().optional(),
description: string2().optional()
});
const FormElicitationCapabilitySchema2 = intersection(object({ applyDefaults: boolean2().optional() }), JSONObjectSchema$1);
const ElicitationCapabilitySchema2 = preprocess((value) => {
if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return { form: {} };
return value;
}, intersection(object({
form: FormElicitationCapabilitySchema2.optional(),
url: JSONObjectSchema$1.optional()
}), JSONObjectSchema$1.optional()));
const ClientTasksCapabilitySchema$1 = looseObject({
list: JSONObjectSchema$1.optional(),
cancel: JSONObjectSchema$1.optional(),
requests: looseObject({
sampling: looseObject({ createMessage: JSONObjectSchema$1.optional() }).optional(),
elicitation: looseObject({ create: JSONObjectSchema$1.optional() }).optional()
}).optional()
});
const ServerTasksCapabilitySchema$1 = looseObject({
list: JSONObjectSchema$1.optional(),
cancel: JSONObjectSchema$1.optional(),
requests: looseObject({ tools: looseObject({ call: JSONObjectSchema$1.optional() }).optional() }).optional()
});
const ClientCapabilitiesSchema$1 = object({
experimental: record(string2(), JSONObjectSchema$1).optional(),
sampling: object({
context: JSONObjectSchema$1.optional(),
tools: JSONObjectSchema$1.optional()
}).optional(),
elicitation: ElicitationCapabilitySchema2.optional(),
roots: object({ listChanged: boolean2().optional() }).optional(),
tasks: ClientTasksCapabilitySchema$1.optional(),
extensions: record(string2(), JSONObjectSchema$1).optional()
});
const InitializeRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({
protocolVersion: string2(),
capabilities: ClientCapabilitiesSchema$1,
clientInfo: ImplementationSchema$1
});
const InitializeRequestSchema$1 = RequestSchema$1.extend({
method: literal("initialize"),
params: InitializeRequestParamsSchema$1
});
const ServerCapabilitiesSchema$1 = object({
experimental: record(string2(), JSONObjectSchema$1).optional(),
logging: JSONObjectSchema$1.optional(),
completions: JSONObjectSchema$1.optional(),
prompts: object({ listChanged: boolean2().optional() }).optional(),
resources: object({
subscribe: boolean2().optional(),
listChanged: boolean2().optional()
}).optional(),
tools: object({ listChanged: boolean2().optional() }).optional(),
tasks: ServerTasksCapabilitySchema$1.optional(),
extensions: record(string2(), JSONObjectSchema$1).optional()
});
const InitializeResultSchema$1 = ResultSchema$1.extend({
protocolVersion: string2(),
capabilities: ServerCapabilitiesSchema$1,
serverInfo: ImplementationSchema$1,
instructions: string2().optional()
});
const InitializedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/initialized"),
params: NotificationsParamsSchema$1.optional()
});
const PingRequestSchema$1 = RequestSchema$1.extend({
method: literal("ping"),
params: BaseRequestParamsSchema$1.optional()
});
const ProgressSchema$1 = object({
progress: number2(),
total: optional(number2()),
message: optional(string2())
});
const ProgressNotificationParamsSchema$1 = object({
...NotificationsParamsSchema$1.shape,
...ProgressSchema$1.shape,
progressToken: ProgressTokenSchema$1
});
const ProgressNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/progress"),
params: ProgressNotificationParamsSchema$1
});
const PaginatedRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({ cursor: CursorSchema$1.optional() });
const PaginatedRequestSchema$1 = RequestSchema$1.extend({ params: PaginatedRequestParamsSchema$1.optional() });
const PaginatedResultSchema$1 = ResultSchema$1.extend({ nextCursor: CursorSchema$1.optional() });
const ResourceContentsSchema$1 = object({
uri: string2(),
mimeType: optional(string2()),
_meta: record(string2(), unknown()).optional()
});
const TextResourceContentsSchema$1 = ResourceContentsSchema$1.extend({ text: string2() });
const Base64Schema2 = string2().refine((val) => {
try {
atob(val);
return true;
} catch {
return false;
}
}, { message: "Invalid Base64 string" });
const BlobResourceContentsSchema$1 = ResourceContentsSchema$1.extend({ blob: Base64Schema2 });
const RoleSchema$1 = _enum2(["user", "assistant"]);
const AnnotationsSchema$1 = object({
audience: array(RoleSchema$1).optional(),
priority: number2().min(0).max(1).optional(),
lastModified: iso_exports.datetime({ offset: true }).optional()
});
const ResourceSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
uri: string2(),
description: optional(string2()),
mimeType: optional(string2()),
size: optional(number2()),
annotations: AnnotationsSchema$1.optional(),
_meta: optional(looseObject({}))
});
const ResourceTemplateSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
uriTemplate: string2(),
description: optional(string2()),
mimeType: optional(string2()),
annotations: AnnotationsSchema$1.optional(),
_meta: optional(looseObject({}))
});
const ListResourcesRequestSchema$1 = PaginatedRequestSchema$1.extend({ method: literal("resources/list") });
const ListResourcesResultSchema$1 = PaginatedResultSchema$1.extend({ resources: array(ResourceSchema$1) });
const ListResourceTemplatesRequestSchema$1 = PaginatedRequestSchema$1.extend({ method: literal("resources/templates/list") });
const ListResourceTemplatesResultSchema$1 = PaginatedResultSchema$1.extend({ resourceTemplates: array(ResourceTemplateSchema$1) });
const ResourceRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({ uri: string2() });
const ReadResourceRequestParamsSchema$1 = ResourceRequestParamsSchema$1;
const ReadResourceRequestSchema$1 = RequestSchema$1.extend({
method: literal("resources/read"),
params: ReadResourceRequestParamsSchema$1
});
const ReadResourceResultSchema$1 = ResultSchema$1.extend({ contents: array(union([TextResourceContentsSchema$1, BlobResourceContentsSchema$1])) });
const ResourceListChangedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/resources/list_changed"),
params: NotificationsParamsSchema$1.optional()
});
const SubscribeRequestParamsSchema$1 = ResourceRequestParamsSchema$1;
const SubscribeRequestSchema$1 = RequestSchema$1.extend({
method: literal("resources/subscribe"),
params: SubscribeRequestParamsSchema$1
});
const UnsubscribeRequestParamsSchema$1 = ResourceRequestParamsSchema$1;
const UnsubscribeRequestSchema$1 = RequestSchema$1.extend({
method: literal("resources/unsubscribe"),
params: UnsubscribeRequestParamsSchema$1
});
const ResourceUpdatedNotificationParamsSchema$1 = NotificationsParamsSchema$1.extend({ uri: string2() });
const ResourceUpdatedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/resources/updated"),
params: ResourceUpdatedNotificationParamsSchema$1
});
const PromptArgumentSchema$1 = object({
name: string2(),
description: optional(string2()),
required: optional(boolean2())
});
const PromptSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
description: optional(string2()),
arguments: optional(array(PromptArgumentSchema$1)),
_meta: optional(looseObject({}))
});
const ListPromptsRequestSchema$1 = PaginatedRequestSchema$1.extend({ method: literal("prompts/list") });
const ListPromptsResultSchema$1 = PaginatedResultSchema$1.extend({ prompts: array(PromptSchema$1) });
const GetPromptRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({
name: string2(),
arguments: record(string2(), string2()).optional()
});
const GetPromptRequestSchema$1 = RequestSchema$1.extend({
method: literal("prompts/get"),
params: GetPromptRequestParamsSchema$1
});
const TextContentSchema$1 = object({
type: literal("text"),
text: string2(),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ImageContentSchema$1 = object({
type: literal("image"),
data: Base64Schema2,
mimeType: string2(),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const AudioContentSchema$1 = object({
type: literal("audio"),
data: Base64Schema2,
mimeType: string2(),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ToolUseContentSchema$1 = object({
type: literal("tool_use"),
name: string2(),
id: string2(),
input: record(string2(), unknown()),
_meta: record(string2(), unknown()).optional()
});
const EmbeddedResourceSchema$1 = object({
type: literal("resource"),
resource: union([TextResourceContentsSchema$1, BlobResourceContentsSchema$1]),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ResourceLinkSchema$1 = ResourceSchema$1.extend({ type: literal("resource_link") });
const ContentBlockSchema$1 = union([
TextContentSchema$1,
ImageContentSchema$1,
AudioContentSchema$1,
ResourceLinkSchema$1,
EmbeddedResourceSchema$1
]);
const PromptMessageSchema$1 = object({
role: RoleSchema$1,
content: ContentBlockSchema$1
});
const GetPromptResultSchema$1 = ResultSchema$1.extend({
description: string2().optional(),
messages: array(PromptMessageSchema$1)
});
const PromptListChangedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/prompts/list_changed"),
params: NotificationsParamsSchema$1.optional()
});
const ToolAnnotationsSchema$1 = object({
title: string2().optional(),
readOnlyHint: boolean2().optional(),
destructiveHint: boolean2().optional(),
idempotentHint: boolean2().optional(),
openWorldHint: boolean2().optional()
});
const ToolExecutionSchema$1 = object({ taskSupport: _enum2([
"required",
"optional",
"forbidden"
]).optional() });
const ToolSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
description: string2().optional(),
inputSchema: object({
type: literal("object"),
properties: record(string2(), JSONValueSchema$1).optional(),
required: array(string2()).optional()
}).catchall(unknown()),
outputSchema: object({
type: literal("object"),
properties: record(string2(), JSONValueSchema$1).optional(),
required: array(string2()).optional()
}).catchall(unknown()).optional(),
annotations: ToolAnnotationsSchema$1.optional(),
execution: ToolExecutionSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ListToolsRequestSchema$1 = PaginatedRequestSchema$1.extend({ method: literal("tools/list") });
const ListToolsResultSchema$1 = PaginatedResultSchema$1.extend({ tools: array(ToolSchema$1) });
const CallToolResultSchema$1 = ResultSchema$1.extend({
content: array(ContentBlockSchema$1),
structuredContent: record(string2(), unknown()).optional(),
isError: boolean2().optional()
});
const CallToolRequestParamsSchema$1 = TaskAugmentedRequestParamsSchema$1.extend({
name: string2(),
arguments: record(string2(), unknown()).optional()
});
const CallToolRequestSchema$1 = RequestSchema$1.extend({
method: literal("tools/call"),
params: CallToolRequestParamsSchema$1
});
const ToolListChangedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/tools/list_changed"),
params: NotificationsParamsSchema$1.optional()
});
const LoggingLevelSchema$1 = _enum2([
"debug",
"info",
"notice",
"warning",
"error",
"critical",
"alert",
"emergency"
]);
const SetLevelRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({ level: LoggingLevelSchema$1 });
const SetLevelRequestSchema$1 = RequestSchema$1.extend({
method: literal("logging/setLevel"),
params: SetLevelRequestParamsSchema$1
});
const LoggingMessageNotificationParamsSchema$1 = NotificationsParamsSchema$1.extend({
level: LoggingLevelSchema$1,
logger: string2().optional(),
data: unknown()
});
const LoggingMessageNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/message"),
params: LoggingMessageNotificationParamsSchema$1
});
const ModelHintSchema$1 = object({ name: string2().optional() });
const ModelPreferencesSchema$1 = object({
hints: array(ModelHintSchema$1).optional(),
costPriority: number2().min(0).max(1).optional(),
speedPriority: number2().min(0).max(1).optional(),
intelligencePriority: number2().min(0).max(1).optional()
});
const ToolChoiceSchema$1 = object({ mode: _enum2([
"auto",
"required",
"none"
]).optional() });
const ToolResultContentSchema$1 = object({
type: literal("tool_result"),
toolUseId: string2().describe("The unique identifier for the corresponding tool call."),
content: array(ContentBlockSchema$1),
structuredContent: object({}).loose().optional(),
isError: boolean2().optional(),
_meta: record(string2(), unknown()).optional()
});
const SamplingContentSchema$1 = discriminatedUnion("type", [
TextContentSchema$1,
ImageContentSchema$1,
AudioContentSchema$1
]);
const SamplingMessageContentBlockSchema$1 = discriminatedUnion("type", [
TextContentSchema$1,
ImageContentSchema$1,
AudioContentSchema$1,
ToolUseContentSchema$1,
ToolResultContentSchema$1
]);
const SamplingMessageSchema$1 = object({
role: RoleSchema$1,
content: union([SamplingMessageContentBlockSchema$1, array(SamplingMessageContentBlockSchema$1)]),
_meta: record(string2(), unknown()).optional()
});
const CreateMessageRequestParamsSchema$1 = TaskAugmentedRequestParamsSchema$1.extend({
messages: array(SamplingMessageSchema$1),
modelPreferences: ModelPreferencesSchema$1.optional(),
systemPrompt: string2().optional(),
includeContext: _enum2([
"none",
"thisServer",
"allServers"
]).optional(),
temperature: number2().optional(),
maxTokens: number2().int(),
stopSequences: array(string2()).optional(),
metadata: JSONObjectSchema$1.optional(),
tools: array(ToolSchema$1).optional(),
toolChoice: ToolChoiceSchema$1.optional()
});
const CreateMessageRequestSchema$1 = RequestSchema$1.extend({
method: literal("sampling/createMessage"),
params: CreateMessageRequestParamsSchema$1
});
const CreateMessageResultSchema$1 = ResultSchema$1.extend({
model: string2(),
stopReason: optional(_enum2([
"endTurn",
"stopSequence",
"maxTokens"
]).or(string2())),
role: RoleSchema$1,
content: SamplingContentSchema$1
});
const CreateMessageResultWithToolsSchema$1 = ResultSchema$1.extend({
model: string2(),
stopReason: optional(_enum2([
"endTurn",
"stopSequence",
"maxTokens",
"toolUse"
]).or(string2())),
role: RoleSchema$1,
content: union([SamplingMessageContentBlockSchema$1, array(SamplingMessageContentBlockSchema$1)])
});
const BooleanSchemaSchema$1 = object({
type: literal("boolean"),
title: string2().optional(),
description: string2().optional(),
default: boolean2().optional()
});
const StringSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
minLength: number2().optional(),
maxLength: number2().optional(),
format: _enum2([
"email",
"uri",
"date",
"date-time"
]).optional(),
default: string2().optional()
});
const NumberSchemaSchema$1 = object({
type: _enum2(["number", "integer"]),
title: string2().optional(),
description: string2().optional(),
minimum: number2().optional(),
maximum: number2().optional(),
default: number2().optional()
});
const UntitledSingleSelectEnumSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
default: string2().optional()
});
const TitledSingleSelectEnumSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
oneOf: array(object({
const: string2(),
title: string2()
})),
default: string2().optional()
});
const LegacyTitledEnumSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
enumNames: array(string2()).optional(),
default: string2().optional()
});
const SingleSelectEnumSchemaSchema$1 = union([UntitledSingleSelectEnumSchemaSchema$1, TitledSingleSelectEnumSchemaSchema$1]);
const UntitledMultiSelectEnumSchemaSchema$1 = object({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object({
type: literal("string"),
enum: array(string2())
}),
default: array(string2()).optional()
});
const TitledMultiSelectEnumSchemaSchema$1 = object({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object({ anyOf: array(object({
const: string2(),
title: string2()
})) }),
default: array(string2()).optional()
});
const MultiSelectEnumSchemaSchema$1 = union([UntitledMultiSelectEnumSchemaSchema$1, TitledMultiSelectEnumSchemaSchema$1]);
const EnumSchemaSchema$1 = union([
LegacyTitledEnumSchemaSchema$1,
SingleSelectEnumSchemaSchema$1,
MultiSelectEnumSchemaSchema$1
]);
const PrimitiveSchemaDefinitionSchema$1 = union([
EnumSchemaSchema$1,
BooleanSchemaSchema$1,
StringSchemaSchema$1,
NumberSchemaSchema$1
]);
const ElicitRequestFormParamsSchema$1 = TaskAugmentedRequestParamsSchema$1.extend({
mode: literal("form").optional(),
message: string2(),
requestedSchema: object({
type: literal("object"),
properties: record(string2(), PrimitiveSchemaDefinitionSchema$1),
required: array(string2()).optional()
}).catchall(unknown())
});
const ElicitRequestURLParamsSchema$1 = TaskAugmentedRequestParamsSchema$1.extend({
mode: literal("url"),
message: string2(),
elicitationId: string2(),
url: string2().url()
});
const ElicitRequestParamsSchema$1 = union([ElicitRequestFormParamsSchema$1, ElicitRequestURLParamsSchema$1]);
const ElicitRequestSchema$1 = RequestSchema$1.extend({
method: literal("elicitation/create"),
params: ElicitRequestParamsSchema$1
});
const ElicitationCompleteNotificationParamsSchema$1 = NotificationsParamsSchema$1.extend({ elicitationId: string2() });
const ElicitationCompleteNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/elicitation/complete"),
params: ElicitationCompleteNotificationParamsSchema$1
});
const ElicitResultSchema$1 = ResultSchema$1.extend({
action: _enum2([
"accept",
"decline",
"cancel"
]),
content: preprocess((val) => val === null ? void 0 : val, record(string2(), union([
string2(),
number2(),
boolean2(),
array(string2())
])).optional())
});
const ResourceTemplateReferenceSchema$1 = object({
type: literal("ref/resource"),
uri: string2()
});
const PromptReferenceSchema$1 = object({
type: literal("ref/prompt"),
name: string2()
});
const CompleteRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({
ref: union([PromptReferenceSchema$1, ResourceTemplateReferenceSchema$1]),
argument: object({
name: string2(),
value: string2()
}),
context: object({ arguments: record(string2(), string2()).optional() }).optional()
});
const CompleteRequestSchema$1 = RequestSchema$1.extend({
method: literal("completion/complete"),
params: CompleteRequestParamsSchema$1
});
const CompleteResultSchema$1 = ResultSchema$1.extend({ completion: looseObject({
values: array(string2()).max(100),
total: optional(number2().int()),
hasMore: optional(boolean2())
}) });
const RootSchema$1 = object({
uri: string2().startsWith("file://"),
name: string2().optional(),
_meta: record(string2(), unknown()).optional()
});
const ListRootsRequestSchema$1 = RequestSchema$1.extend({
method: literal("roots/list"),
params: BaseRequestParamsSchema$1.optional()
});
const ListRootsResultSchema$1 = ResultSchema$1.extend({ roots: array(RootSchema$1) });
const RootsListChangedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/roots/list_changed"),
params: NotificationsParamsSchema$1.optional()
});
const TaskCreationParamsSchema$1 = looseObject({
ttl: number2().optional(),
pollInterval: number2().optional()
});
const TaskStatusSchema$1 = _enum2([
"working",
"input_required",
"completed",
"failed",
"cancelled"
]);
const TaskSchema$1 = object({
taskId: string2(),
status: TaskStatusSchema$1,
ttl: union([number2(), _null3()]),
createdAt: string2(),
lastUpdatedAt: string2(),
pollInterval: optional(number2()),
statusMessage: optional(string2())
});
const CreateTaskResultSchema$1 = ResultSchema$1.extend({ task: TaskSchema$1 });
const TaskStatusNotificationParamsSchema$1 = NotificationsParamsSchema$1.merge(TaskSchema$1);
const TaskStatusNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/tasks/status"),
params: TaskStatusNotificationParamsSchema$1
});
const GetTaskRequestSchema$1 = RequestSchema$1.extend({
method: literal("tasks/get"),
params: BaseRequestParamsSchema$1.extend({ taskId: string2() })
});
const GetTaskResultSchema$1 = ResultSchema$1.merge(TaskSchema$1);
const GetTaskPayloadRequestSchema$1 = RequestSchema$1.extend({
method: literal("tasks/result"),
params: BaseRequestParamsSchema$1.extend({ taskId: string2() })
});
const GetTaskPayloadResultSchema$1 = ResultSchema$1.loose();
const ListTasksRequestSchema$1 = PaginatedRequestSchema$1.extend({ method: literal("tasks/list") });
const ListTasksResultSchema$1 = PaginatedResultSchema$1.extend({ tasks: array(TaskSchema$1) });
const CancelTaskRequestSchema$1 = RequestSchema$1.extend({
method: literal("tasks/cancel"),
params: BaseRequestParamsSchema$1.extend({ taskId: string2() })
});
return {
JSONValueSchema: JSONValueSchema$1,
JSONObjectSchema: JSONObjectSchema$1,
ProgressTokenSchema: ProgressTokenSchema$1,
CursorSchema: CursorSchema$1,
TaskMetadataSchema: TaskMetadataSchema$1,
RelatedTaskMetadataSchema: RelatedTaskMetadataSchema$1,
RequestMetaSchema: RequestMetaSchema$1,
BaseRequestParamsSchema: BaseRequestParamsSchema$1,
TaskAugmentedRequestParamsSchema: TaskAugmentedRequestParamsSchema$1,
RequestSchema: RequestSchema$1,
NotificationsParamsSchema: NotificationsParamsSchema$1,
NotificationSchema: NotificationSchema$1,
ResultSchema: ResultSchema$1,
RequestIdSchema: RequestIdSchema$1,
EmptyResultSchema: EmptyResultSchema$1,
CancelledNotificationParamsSchema: CancelledNotificationParamsSchema$1,
CancelledNotificationSchema: CancelledNotificationSchema$1,
IconSchema: IconSchema$1,
IconsSchema: IconsSchema$1,
BaseMetadataSchema: BaseMetadataSchema$1,
ImplementationSchema: ImplementationSchema$1,
ClientTasksCapabilitySchema: ClientTasksCapabilitySchema$1,
ServerTasksCapabilitySchema: ServerTasksCapabilitySchema$1,
ClientCapabilitiesSchema: ClientCapabilitiesSchema$1,
InitializeRequestParamsSchema: InitializeRequestParamsSchema$1,
InitializeRequestSchema: InitializeRequestSchema$1,
ServerCapabilitiesSchema: ServerCapabilitiesSchema$1,
InitializeResultSchema: InitializeResultSchema$1,
InitializedNotificationSchema: InitializedNotificationSchema$1,
PingRequestSchema: PingRequestSchema$1,
ProgressSchema: ProgressSchema$1,
ProgressNotificationParamsSchema: ProgressNotificationParamsSchema$1,
ProgressNotificationSchema: ProgressNotificationSchema$1,
PaginatedRequestParamsSchema: PaginatedRequestParamsSchema$1,
PaginatedRequestSchema: PaginatedRequestSchema$1,
PaginatedResultSchema: PaginatedResultSchema$1,
ResourceContentsSchema: ResourceContentsSchema$1,
TextResourceContentsSchema: TextResourceContentsSchema$1,
BlobResourceContentsSchema: BlobResourceContentsSchema$1,
RoleSchema: RoleSchema$1,
AnnotationsSchema: AnnotationsSchema$1,
ResourceSchema: ResourceSchema$1,
ResourceTemplateSchema: ResourceTemplateSchema$1,
ListResourcesRequestSchema: ListResourcesRequestSchema$1,
ListResourcesResultSchema: ListResourcesResultSchema$1,
ListResourceTemplatesRequestSchema: ListResourceTemplatesRequestSchema$1,
ListResourceTemplatesResultSchema: ListResourceTemplatesResultSchema$1,
ResourceRequestParamsSchema: ResourceRequestParamsSchema$1,
ReadResourceRequestParamsSchema: ReadResourceRequestParamsSchema$1,
ReadResourceRequestSchema: ReadResourceRequestSchema$1,
ReadResourceResultSchema: ReadResourceResultSchema$1,
ResourceListChangedNotificationSchema: ResourceListChangedNotificationSchema$1,
SubscribeRequestParamsSchema: SubscribeRequestParamsSchema$1,
SubscribeRequestSchema: SubscribeRequestSchema$1,
UnsubscribeRequestParamsSchema: UnsubscribeRequestParamsSchema$1,
UnsubscribeRequestSchema: UnsubscribeRequestSchema$1,
ResourceUpdatedNotificationParamsSchema: ResourceUpdatedNotificationParamsSchema$1,
ResourceUpdatedNotificationSchema: ResourceUpdatedNotificationSchema$1,
PromptArgumentSchema: PromptArgumentSchema$1,
PromptSchema: PromptSchema$1,
ListPromptsRequestSchema: ListPromptsRequestSchema$1,
ListPromptsResultSchema: ListPromptsResultSchema$1,
GetPromptRequestParamsSchema: GetPromptRequestParamsSchema$1,
GetPromptRequestSchema: GetPromptRequestSchema$1,
TextContentSchema: TextContentSchema$1,
ImageContentSchema: ImageContentSchema$1,
AudioContentSchema: AudioContentSchema$1,
ToolUseContentSchema: ToolUseContentSchema$1,
EmbeddedResourceSchema: EmbeddedResourceSchema$1,
ResourceLinkSchema: ResourceLinkSchema$1,
ContentBlockSchema: ContentBlockSchema$1,
PromptMessageSchema: PromptMessageSchema$1,
GetPromptResultSchema: GetPromptResultSchema$1,
PromptListChangedNotificationSchema: PromptListChangedNotificationSchema$1,
ToolAnnotationsSchema: ToolAnnotationsSchema$1,
ToolExecutionSchema: ToolExecutionSchema$1,
ToolSchema: ToolSchema$1,
ListToolsRequestSchema: ListToolsRequestSchema$1,
ListToolsResultSchema: ListToolsResultSchema$1,
CallToolResultSchema: CallToolResultSchema$1,
CallToolRequestParamsSchema: CallToolRequestParamsSchema$1,
CallToolRequestSchema: CallToolRequestSchema$1,
ToolListChangedNotificationSchema: ToolListChangedNotificationSchema$1,
LoggingLevelSchema: LoggingLevelSchema$1,
SetLevelRequestParamsSchema: SetLevelRequestParamsSchema$1,
SetLevelRequestSchema: SetLevelRequestSchema$1,
LoggingMessageNotificationParamsSchema: LoggingMessageNotificationParamsSchema$1,
LoggingMessageNotificationSchema: LoggingMessageNotificationSchema$1,
ModelHintSchema: ModelHintSchema$1,
ModelPreferencesSchema: ModelPreferencesSchema$1,
ToolChoiceSchema: ToolChoiceSchema$1,
ToolResultContentSchema: ToolResultContentSchema$1,
SamplingContentSchema: SamplingContentSchema$1,
SamplingMessageContentBlockSchema: SamplingMessageContentBlockSchema$1,
SamplingMessageSchema: SamplingMessageSchema$1,
CreateMessageRequestParamsSchema: CreateMessageRequestParamsSchema$1,
CreateMessageRequestSchema: CreateMessageRequestSchema$1,
CreateMessageResultSchema: CreateMessageResultSchema$1,
CreateMessageResultWithToolsSchema: CreateMessageResultWithToolsSchema$1,
BooleanSchemaSchema: BooleanSchemaSchema$1,
StringSchemaSchema: StringSchemaSchema$1,
NumberSchemaSchema: NumberSchemaSchema$1,
UntitledSingleSelectEnumSchemaSchema: UntitledSingleSelectEnumSchemaSchema$1,
TitledSingleSelectEnumSchemaSchema: TitledSingleSelectEnumSchemaSchema$1,
LegacyTitledEnumSchemaSchema: LegacyTitledEnumSchemaSchema$1,
SingleSelectEnumSchemaSchema: SingleSelectEnumSchemaSchema$1,
UntitledMultiSelectEnumSchemaSchema: UntitledMultiSelectEnumSchemaSchema$1,
TitledMultiSelectEnumSchemaSchema: TitledMultiSelectEnumSchemaSchema$1,
MultiSelectEnumSchemaSchema: MultiSelectEnumSchemaSchema$1,
EnumSchemaSchema: EnumSchemaSchema$1,
PrimitiveSchemaDefinitionSchema: PrimitiveSchemaDefinitionSchema$1,
ElicitRequestFormParamsSchema: ElicitRequestFormParamsSchema$1,
ElicitRequestURLParamsSchema: ElicitRequestURLParamsSchema$1,
ElicitRequestParamsSchema: ElicitRequestParamsSchema$1,
ElicitRequestSchema: ElicitRequestSchema$1,
ElicitationCompleteNotificationParamsSchema: ElicitationCompleteNotificationParamsSchema$1,
ElicitationCompleteNotificationSchema: ElicitationCompleteNotificationSchema$1,
ElicitResultSchema: ElicitResultSchema$1,
ResourceTemplateReferenceSchema: ResourceTemplateReferenceSchema$1,
PromptReferenceSchema: PromptReferenceSchema$1,
CompleteRequestParamsSchema: CompleteRequestParamsSchema$1,
CompleteRequestSchema: CompleteRequestSchema$1,
CompleteResultSchema: CompleteResultSchema$1,
RootSchema: RootSchema$1,
ListRootsRequestSchema: ListRootsRequestSchema$1,
ListRootsResultSchema: ListRootsResultSchema$1,
RootsListChangedNotificationSchema: RootsListChangedNotificationSchema$1,
TaskCreationParamsSchema: TaskCreationParamsSchema$1,
TaskStatusSchema: TaskStatusSchema$1,
TaskSchema: TaskSchema$1,
CreateTaskResultSchema: CreateTaskResultSchema$1,
TaskStatusNotificationParamsSchema: TaskStatusNotificationParamsSchema$1,
TaskStatusNotificationSchema: TaskStatusNotificationSchema$1,
GetTaskRequestSchema: GetTaskRequestSchema$1,
GetTaskResultSchema: GetTaskResultSchema$1,
GetTaskPayloadRequestSchema: GetTaskPayloadRequestSchema$1,
GetTaskPayloadResultSchema: GetTaskPayloadResultSchema$1,
ListTasksRequestSchema: ListTasksRequestSchema$1,
ListTasksResultSchema: ListTasksResultSchema$1,
CancelTaskRequestSchema: CancelTaskRequestSchema$1,
CancelTaskResultSchema: ResultSchema$1.merge(TaskSchema$1),
ClientRequestSchema: union([
PingRequestSchema$1,
InitializeRequestSchema$1,
CompleteRequestSchema$1,
SetLevelRequestSchema$1,
GetPromptRequestSchema$1,
ListPromptsRequestSchema$1,
ListResourcesRequestSchema$1,
ListResourceTemplatesRequestSchema$1,
ReadResourceRequestSchema$1,
SubscribeRequestSchema$1,
UnsubscribeRequestSchema$1,
CallToolRequestSchema$1,
ListToolsRequestSchema$1,
GetTaskRequestSchema$1,
GetTaskPayloadRequestSchema$1,
ListTasksRequestSchema$1,
CancelTaskRequestSchema$1
]),
ClientNotificationSchema: union([
CancelledNotificationSchema$1,
ProgressNotificationSchema$1,
InitializedNotificationSchema$1,
RootsListChangedNotificationSchema$1,
TaskStatusNotificationSchema$1
]),
ClientResultSchema: union([
EmptyResultSchema$1,
CreateMessageResultSchema$1,
CreateMessageResultWithToolsSchema$1,
ElicitResultSchema$1,
ListRootsResultSchema$1,
GetTaskResultSchema$1,
ListTasksResultSchema$1,
CreateTaskResultSchema$1
]),
ServerRequestSchema: union([
PingRequestSchema$1,
CreateMessageRequestSchema$1,
ElicitRequestSchema$1,
ListRootsRequestSchema$1,
GetTaskRequestSchema$1,
GetTaskPayloadRequestSchema$1,
ListTasksRequestSchema$1,
CancelTaskRequestSchema$1
]),
ServerNotificationSchema: union([
CancelledNotificationSchema$1,
ProgressNotificationSchema$1,
LoggingMessageNotificationSchema$1,
ResourceUpdatedNotificationSchema$1,
ResourceListChangedNotificationSchema$1,
ToolListChangedNotificationSchema$1,
PromptListChangedNotificationSchema$1,
TaskStatusNotificationSchema$1,
ElicitationCompleteNotificationSchema$1
]),
ServerResultSchema: union([
EmptyResultSchema$1,
InitializeResultSchema$1,
CompleteResultSchema$1,
GetPromptResultSchema$1,
ListPromptsResultSchema$1,
ListResourcesResultSchema$1,
ListResourceTemplatesResultSchema$1,
ReadResourceResultSchema$1,
CallToolResultSchema$1,
ListToolsResultSchema$1,
GetTaskResultSchema$1,
ListTasksResultSchema$1,
CreateTaskResultSchema$1
]),
CallToolResultWireSchema: unknown().superRefine((value, ctx) => {
if (typeof value !== "object" || value === null || Array.isArray(value) || value.content !== void 0) return;
for (const key of TOOL_RESULT_FOREIGN_FAMILY_KEYS) if (key in value) {
ctx.addIssue({
code: "custom",
message: `content is required when the body carries '${key}' \u2014 another result family cannot default into an empty tools/call success`
});
return;
}
}).transform(normalizeContentlessToolResult).pipe(CallToolResultSchema$1)
};
}
var memo$1;
function buildSchemas2025() {
return memo$1 ??= build$1();
}
function isNonObjectJsonSchemaRoot(json2) {
return json2["type"] !== "object";
}
var REF_REWRITE_DATA_POSITION_KEYS = /* @__PURE__ */ new Set([
"const",
"enum",
"default",
"examples"
]);
var REF_REWRITE_NAME_MAP_KEYS = /* @__PURE__ */ new Set([
"properties",
"patternProperties",
"$defs",
"definitions",
"dependentSchemas",
"dependencies"
]);
function establishesNewBase(id) {
return id !== void 0 && !(typeof id === "string" && id.startsWith("#"));
}
function wrapOutputSchemaForLegacy(natural) {
const $schema = typeof natural["$schema"] === "string" ? natural["$schema"] : void 0;
if (establishesNewBase(natural["$id"])) return {
...$schema !== void 0 && { $schema },
type: "object",
properties: { result: natural },
required: ["result"]
};
const convertRecursiveRefs = declares2019Dialect(natural["$schema"]) && natural["$recursiveAnchor"] !== true;
const rewriteRefs = (node2, parentIsNameMap) => {
if (Array.isArray(node2)) return node2.map((item) => rewriteRefs(item, false));
if (node2 === null || typeof node2 !== "object") return node2;
if (!parentIsNameMap && establishesNewBase(node2["$id"])) return node2;
const out = {};
let convertedRecursion = false;
for (const [k, v] of Object.entries(node2)) if (parentIsNameMap) out[k] = rewriteRefs(v, false);
else if ((k === "$ref" || k === "$dynamicRef") && typeof v === "string") out[k] = v === "#" ? "#/properties/result" : v.startsWith("#/") ? `#/properties/result${v.slice(1)}` : v;
else if (k === "$recursiveRef" && v === "#" && convertRecursiveRefs) convertedRecursion = true;
else if (REF_REWRITE_DATA_POSITION_KEYS.has(k)) out[k] = v;
else if (REF_REWRITE_NAME_MAP_KEYS.has(k)) out[k] = rewriteRefs(v, true);
else out[k] = rewriteRefs(v, false);
if (convertedRecursion) if ("$ref" in out) out["allOf"] = [...Array.isArray(out["allOf"]) ? out["allOf"] : [], { $ref: "#/properties/result" }];
else out["$ref"] = "#/properties/result";
return out;
};
return {
...$schema !== void 0 && { $schema },
type: "object",
properties: { result: rewriteRefs(natural, false) },
required: ["result"]
};
}
var requestMethodKeys$1 = {
ping: null,
initialize: null,
"completion/complete": null,
"logging/setLevel": null,
"prompts/get": null,
"prompts/list": null,
"resources/list": null,
"resources/templates/list": null,
"resources/read": null,
"resources/subscribe": null,
"resources/unsubscribe": null,
"tools/call": null,
"tools/list": null,
"tasks/get": null,
"tasks/result": null,
"tasks/list": null,
"tasks/cancel": null,
"sampling/createMessage": null,
"elicitation/create": null,
"roots/list": null
};
var notificationMethodKeys$1 = {
"notifications/cancelled": null,
"notifications/progress": null,
"notifications/initialized": null,
"notifications/roots/list_changed": null,
"notifications/tasks/status": null,
"notifications/message": null,
"notifications/resources/updated": null,
"notifications/resources/list_changed": null,
"notifications/tools/list_changed": null,
"notifications/prompts/list_changed": null,
"notifications/elicitation/complete": null
};
var resultMethodKeys = {
ping: null,
initialize: null,
"completion/complete": null,
"logging/setLevel": null,
"prompts/get": null,
"prompts/list": null,
"resources/list": null,
"resources/templates/list": null,
"resources/read": null,
"resources/subscribe": null,
"resources/unsubscribe": null,
"tools/call": null,
"tools/list": null,
"sampling/createMessage": null,
"elicitation/create": null,
"roots/list": null
};
var maps$1;
function registryMaps() {
if (maps$1) return maps$1;
const s = buildSchemas2025();
maps$1 = {
requestSchemas: {
ping: s.PingRequestSchema,
initialize: s.InitializeRequestSchema,
"completion/complete": s.CompleteRequestSchema,
"logging/setLevel": s.SetLevelRequestSchema,
"prompts/get": s.GetPromptRequestSchema,
"prompts/list": s.ListPromptsRequestSchema,
"resources/list": s.ListResourcesRequestSchema,
"resources/templates/list": s.ListResourceTemplatesRequestSchema,
"resources/read": s.ReadResourceRequestSchema,
"resources/subscribe": s.SubscribeRequestSchema,
"resources/unsubscribe": s.UnsubscribeRequestSchema,
"tools/call": s.CallToolRequestSchema,
"tools/list": s.ListToolsRequestSchema,
"tasks/get": s.GetTaskRequestSchema,
"tasks/result": s.GetTaskPayloadRequestSchema,
"tasks/list": s.ListTasksRequestSchema,
"tasks/cancel": s.CancelTaskRequestSchema,
"sampling/createMessage": s.CreateMessageRequestSchema,
"elicitation/create": s.ElicitRequestSchema,
"roots/list": s.ListRootsRequestSchema
},
notificationSchemas: {
"notifications/cancelled": s.CancelledNotificationSchema,
"notifications/progress": s.ProgressNotificationSchema,
"notifications/initialized": s.InitializedNotificationSchema,
"notifications/roots/list_changed": s.RootsListChangedNotificationSchema,
"notifications/tasks/status": s.TaskStatusNotificationSchema,
"notifications/message": s.LoggingMessageNotificationSchema,
"notifications/resources/updated": s.ResourceUpdatedNotificationSchema,
"notifications/resources/list_changed": s.ResourceListChangedNotificationSchema,
"notifications/tools/list_changed": s.ToolListChangedNotificationSchema,
"notifications/prompts/list_changed": s.PromptListChangedNotificationSchema,
"notifications/elicitation/complete": s.ElicitationCompleteNotificationSchema
},
resultSchemas: {
ping: s.EmptyResultSchema,
initialize: s.InitializeResultSchema,
"completion/complete": s.CompleteResultSchema,
"logging/setLevel": s.EmptyResultSchema,
"prompts/get": s.GetPromptResultSchema,
"prompts/list": s.ListPromptsResultSchema,
"resources/list": s.ListResourcesResultSchema,
"resources/templates/list": s.ListResourceTemplatesResultSchema,
"resources/read": s.ReadResourceResultSchema,
"resources/subscribe": s.EmptyResultSchema,
"resources/unsubscribe": s.EmptyResultSchema,
"tools/call": s.CallToolResultWireSchema,
"tools/list": s.ListToolsResultSchema,
"sampling/createMessage": s.CreateMessageResultWithToolsSchema,
"elicitation/create": s.ElicitResultSchema,
"roots/list": s.ListRootsResultSchema
}
};
return maps$1;
}
function hasRequestMethod2025(method) {
return Object.prototype.hasOwnProperty.call(requestMethodKeys$1, method);
}
function hasNotificationMethod2025(method) {
return Object.prototype.hasOwnProperty.call(notificationMethodKeys$1, method);
}
function hasResultMethod(method) {
return Object.prototype.hasOwnProperty.call(resultMethodKeys, method);
}
function getResultSchema(method) {
return hasResultMethod(method) ? registryMaps().resultSchemas[method] : void 0;
}
function getRequestSchema(method) {
return hasRequestMethod2025(method) ? registryMaps().requestSchemas[method] : void 0;
}
function getNotificationSchema(method) {
return hasNotificationMethod2025(method) ? registryMaps().notificationSchemas[method] : void 0;
}
var rev2025RequestMethods = Object.keys(requestMethodKeys$1);
var rev2025NotificationMethods = Object.keys(notificationMethodKeys$1);
function isPlainObject$5(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function triState$1(schema, raw) {
if (schema === void 0) return {
ok: false,
reason: "not-in-era"
};
const parsed = schema.safeParse(raw);
return parsed.success ? {
ok: true,
value: parsed.data
} : {
ok: false,
reason: "invalid",
message: String(parsed.error)
};
}
var NOT_IN_ERA$1 = {
ok: false,
reason: "not-in-era"
};
function toolNeedsLegacyWrap(t) {
return isPlainObject$5(t) && isPlainObject$5(t["outputSchema"]) && isNonObjectJsonSchemaRoot(t["outputSchema"]);
}
function toNeutralResult(value) {
return value;
}
var rev2025Codec = {
era: "2025-11-25",
hasRequestMethod: hasRequestMethod2025,
hasNotificationMethod: hasNotificationMethod2025,
validateRequest: (method, raw) => triState$1(getRequestSchema(method), raw),
validateResult: (method, raw) => triState$1(getResultSchema(method), raw),
validateNotification: (method, raw) => triState$1(getNotificationSchema(method), raw),
hasInputRequestMethod: () => false,
validateInputRequest: () => NOT_IN_ERA$1,
validateInputResponse: () => NOT_IN_ERA$1,
samplingResultVariant: (hasTools, raw) => {
const s = buildSchemas2025();
return triState$1(hasTools ? s.CreateMessageResultWithToolsSchema : s.CreateMessageResultSchema, raw);
},
outboundEnvelope: (_material) => void 0,
validateEnvelopeMeta: (_meta) => [],
projectCallToolResult(result, advertisedOutputSchema) {
const withText = appendTextFallbackForNonObject(result);
const sc = withText.structuredContent;
if (sc === void 0) return withText;
const valueIsNonObject = typeof sc !== "object" || sc === null || Array.isArray(sc);
const schemaWrapped = advertisedOutputSchema !== void 0 && isNonObjectJsonSchemaRoot(advertisedOutputSchema);
if (!valueIsNonObject && !schemaWrapped) return withText;
return {
...withText,
structuredContent: { result: sc }
};
},
decodeResult(_method, raw) {
if (isPlainObject$5(raw) && "resultType" in raw) {
const stripped = { ...raw };
delete stripped["resultType"];
return {
kind: "complete",
result: toNeutralResult(stripped)
};
}
return {
kind: "complete",
result: toNeutralResult(raw)
};
},
encodeResult(method, result) {
if (method !== "tools/list") return result;
const tools = result.tools;
if (!Array.isArray(tools) || !tools.some((t) => toolNeedsLegacyWrap(t))) return result;
return {
...result,
tools: tools.map((t) => toolNeedsLegacyWrap(t) ? {
...t,
outputSchema: wrapOutputSchemaForLegacy(t.outputSchema)
} : t)
};
},
encodeErrorCode: (code) => code === -32002 ? -32602 : code,
checkInboundEnvelope: (_material) => void 0
};
function build() {
const JSONValueSchema$1 = lazy(() => union([
string2(),
number2(),
boolean2(),
_null3(),
record(string2(), JSONValueSchema$1),
array(JSONValueSchema$1)
]));
const JSONObjectSchema$1 = record(string2(), JSONValueSchema$1);
const ProgressTokenSchema$1 = union([string2(), number2().int()]);
const CursorSchema$1 = string2();
const RequestIdSchema$1 = union([string2(), number2().int()]);
const RoleSchema$1 = _enum2(["user", "assistant"]);
const LoggingLevelSchema$1 = _enum2([
"debug",
"info",
"notice",
"warning",
"error",
"critical",
"alert",
"emergency"
]);
const Base64Schema2 = string2().refine((val) => {
try {
atob(val);
return true;
} catch {
return false;
}
}, { message: "Invalid Base64 string" });
const TaskMetadataSchema$1 = object({ ttl: number2().optional() });
const RelatedTaskMetadataSchema$1 = object({ taskId: string2() });
const RequestMetaSchema$1 = looseObject({
progressToken: ProgressTokenSchema$1.optional(),
"io.modelcontextprotocol/related-task": RelatedTaskMetadataSchema$1.optional()
});
const BaseRequestParamsSchema$1 = object({ _meta: RequestMetaSchema$1.optional() });
const TaskAugmentedRequestParamsSchema$1 = BaseRequestParamsSchema$1.extend({ task: TaskMetadataSchema$1.optional() });
const NotificationsParamsSchema$1 = object({ _meta: RequestMetaSchema$1.optional() });
const NotificationSchema$1 = object({
method: string2(),
params: NotificationsParamsSchema$1.loose().optional()
});
const IconSchema$1 = object({
src: string2(),
mimeType: string2().optional(),
sizes: array(string2()).optional(),
theme: _enum2(["light", "dark"]).optional()
});
const IconsSchema$1 = object({ icons: array(IconSchema$1).optional() });
const BaseMetadataSchema$1 = object({
name: string2(),
title: string2().optional()
});
const ImplementationSchema$1 = BaseMetadataSchema$1.extend({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
version: string2(),
websiteUrl: string2().optional(),
description: string2().optional()
});
const FormElicitationCapabilitySchema2 = intersection(object({ applyDefaults: boolean2().optional() }), JSONObjectSchema$1);
const ElicitationCapabilitySchema2 = preprocess((value) => {
if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return { form: {} };
return value;
}, intersection(object({
form: FormElicitationCapabilitySchema2.optional(),
url: JSONObjectSchema$1.optional()
}), JSONObjectSchema$1.optional()));
const ClientTasksCapabilitySchema$1 = looseObject({
list: JSONObjectSchema$1.optional(),
cancel: JSONObjectSchema$1.optional(),
requests: looseObject({
sampling: looseObject({ createMessage: JSONObjectSchema$1.optional() }).optional(),
elicitation: looseObject({ create: JSONObjectSchema$1.optional() }).optional()
}).optional()
});
const ServerTasksCapabilitySchema$1 = looseObject({
list: JSONObjectSchema$1.optional(),
cancel: JSONObjectSchema$1.optional(),
requests: looseObject({ tools: looseObject({ call: JSONObjectSchema$1.optional() }).optional() }).optional()
});
const ClientCapabilitiesSchema$1 = object({
experimental: record(string2(), JSONObjectSchema$1).optional(),
sampling: object({
context: JSONObjectSchema$1.optional(),
tools: JSONObjectSchema$1.optional()
}).optional(),
elicitation: ElicitationCapabilitySchema2.optional(),
roots: object({ listChanged: boolean2().optional() }).optional(),
tasks: ClientTasksCapabilitySchema$1.optional(),
extensions: record(string2(), JSONObjectSchema$1).optional()
});
const ServerCapabilitiesSchema$1 = object({
experimental: record(string2(), JSONObjectSchema$1).optional(),
logging: JSONObjectSchema$1.optional(),
completions: JSONObjectSchema$1.optional(),
prompts: object({ listChanged: boolean2().optional() }).optional(),
resources: object({
subscribe: boolean2().optional(),
listChanged: boolean2().optional()
}).optional(),
tools: object({ listChanged: boolean2().optional() }).optional(),
tasks: ServerTasksCapabilitySchema$1.optional(),
extensions: record(string2(), JSONObjectSchema$1).optional()
});
const ProgressSchema$1 = object({
progress: number2(),
total: optional(number2()),
message: optional(string2())
});
const ProgressNotificationParamsSchema$1 = object({
...NotificationsParamsSchema$1.shape,
...ProgressSchema$1.shape,
progressToken: ProgressTokenSchema$1
});
const ProgressNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/progress"),
params: ProgressNotificationParamsSchema$1
});
const LoggingMessageNotificationParamsSchema$1 = NotificationsParamsSchema$1.extend({
level: LoggingLevelSchema$1,
logger: string2().optional(),
data: unknown()
});
const LoggingMessageNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/message"),
params: LoggingMessageNotificationParamsSchema$1
});
const ResourceContentsSchema$1 = object({
uri: string2(),
mimeType: optional(string2()),
_meta: record(string2(), unknown()).optional()
});
const TextResourceContentsSchema$1 = ResourceContentsSchema$1.extend({ text: string2() });
const BlobResourceContentsSchema$1 = ResourceContentsSchema$1.extend({ blob: Base64Schema2 });
const AnnotationsSchema$1 = object({
audience: array(RoleSchema$1).optional(),
priority: number2().min(0).max(1).optional(),
lastModified: iso_exports.datetime({ offset: true }).optional()
});
const ResourceSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
uri: string2(),
description: optional(string2()),
mimeType: optional(string2()),
size: optional(number2()),
annotations: AnnotationsSchema$1.optional(),
_meta: optional(looseObject({}))
});
const ResourceTemplateSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
uriTemplate: string2(),
description: optional(string2()),
mimeType: optional(string2()),
annotations: AnnotationsSchema$1.optional(),
_meta: optional(looseObject({}))
});
const ResourceListChangedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/resources/list_changed"),
params: NotificationsParamsSchema$1.optional()
});
const ResourceUpdatedNotificationParamsSchema$1 = NotificationsParamsSchema$1.extend({ uri: string2() });
const ResourceUpdatedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/resources/updated"),
params: ResourceUpdatedNotificationParamsSchema$1
});
const PromptArgumentSchema$1 = object({
name: string2(),
description: optional(string2()),
required: optional(boolean2())
});
const PromptSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
description: optional(string2()),
arguments: optional(array(PromptArgumentSchema$1)),
_meta: optional(looseObject({}))
});
const PromptListChangedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/prompts/list_changed"),
params: NotificationsParamsSchema$1.optional()
});
const TextContentSchema$1 = object({
type: literal("text"),
text: string2(),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ImageContentSchema$1 = object({
type: literal("image"),
data: Base64Schema2,
mimeType: string2(),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const AudioContentSchema$1 = object({
type: literal("audio"),
data: Base64Schema2,
mimeType: string2(),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ToolUseContentSchema$1 = object({
type: literal("tool_use"),
name: string2(),
id: string2(),
input: record(string2(), unknown()),
_meta: record(string2(), unknown()).optional()
});
const EmbeddedResourceSchema$1 = object({
type: literal("resource"),
resource: union([TextResourceContentsSchema$1, BlobResourceContentsSchema$1]),
annotations: AnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ResourceLinkSchema$1 = ResourceSchema$1.extend({ type: literal("resource_link") });
const ContentBlockSchema$1 = union([
TextContentSchema$1,
ImageContentSchema$1,
AudioContentSchema$1,
ResourceLinkSchema$1,
EmbeddedResourceSchema$1
]);
const PromptMessageSchema$1 = object({
role: RoleSchema$1,
content: ContentBlockSchema$1
});
const ToolAnnotationsSchema$1 = object({
title: string2().optional(),
readOnlyHint: boolean2().optional(),
destructiveHint: boolean2().optional(),
idempotentHint: boolean2().optional(),
openWorldHint: boolean2().optional()
});
const ToolListChangedNotificationSchema$1 = NotificationSchema$1.extend({
method: literal("notifications/tools/list_changed"),
params: NotificationsParamsSchema$1.optional()
});
const ModelHintSchema$1 = object({ name: string2().optional() });
const ModelPreferencesSchema$1 = object({
hints: array(ModelHintSchema$1).optional(),
costPriority: number2().min(0).max(1).optional(),
speedPriority: number2().min(0).max(1).optional(),
intelligencePriority: number2().min(0).max(1).optional()
});
const ToolChoiceSchema$1 = object({ mode: _enum2([
"auto",
"required",
"none"
]).optional() });
const BooleanSchemaSchema$1 = object({
type: literal("boolean"),
title: string2().optional(),
description: string2().optional(),
default: boolean2().optional()
});
const StringSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
minLength: number2().optional(),
maxLength: number2().optional(),
format: _enum2([
"email",
"uri",
"date",
"date-time"
]).optional(),
default: string2().optional()
});
const NumberSchemaSchema$1 = object({
type: _enum2(["number", "integer"]),
title: string2().optional(),
description: string2().optional(),
minimum: number2().optional(),
maximum: number2().optional(),
default: number2().optional()
});
const UntitledSingleSelectEnumSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
default: string2().optional()
});
const TitledSingleSelectEnumSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
oneOf: array(object({
const: string2(),
title: string2()
})),
default: string2().optional()
});
const LegacyTitledEnumSchemaSchema$1 = object({
type: literal("string"),
title: string2().optional(),
description: string2().optional(),
enum: array(string2()),
enumNames: array(string2()).optional(),
default: string2().optional()
});
const SingleSelectEnumSchemaSchema$1 = union([UntitledSingleSelectEnumSchemaSchema$1, TitledSingleSelectEnumSchemaSchema$1]);
const UntitledMultiSelectEnumSchemaSchema$1 = object({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object({
type: literal("string"),
enum: array(string2())
}),
default: array(string2()).optional()
});
const TitledMultiSelectEnumSchemaSchema$1 = object({
type: literal("array"),
title: string2().optional(),
description: string2().optional(),
minItems: number2().optional(),
maxItems: number2().optional(),
items: object({ anyOf: array(object({
const: string2(),
title: string2()
})) }),
default: array(string2()).optional()
});
const MultiSelectEnumSchemaSchema$1 = union([UntitledMultiSelectEnumSchemaSchema$1, TitledMultiSelectEnumSchemaSchema$1]);
const EnumSchemaSchema$1 = union([
LegacyTitledEnumSchemaSchema$1,
SingleSelectEnumSchemaSchema$1,
MultiSelectEnumSchemaSchema$1
]);
const PrimitiveSchemaDefinitionSchema$1 = union([
EnumSchemaSchema$1,
BooleanSchemaSchema$1,
StringSchemaSchema$1,
NumberSchemaSchema$1
]);
const ElicitRequestFormParamsSchema$1 = TaskAugmentedRequestParamsSchema$1.extend({
mode: literal("form").optional(),
message: string2(),
requestedSchema: object({
type: literal("object"),
properties: record(string2(), PrimitiveSchemaDefinitionSchema$1),
required: array(string2()).optional()
}).catchall(unknown())
});
const ResourceTemplateReferenceSchema$1 = object({
type: literal("ref/resource"),
uri: string2()
});
const PromptReferenceSchema$1 = object({
type: literal("ref/prompt"),
name: string2()
});
const RootSchema$1 = object({
uri: string2().startsWith("file://"),
name: string2().optional(),
_meta: record(string2(), unknown()).optional()
});
const sharedClientCapabilityShape = ClientCapabilitiesSchema$1.shape;
const ClientCapabilities2026Schema = object({
experimental: sharedClientCapabilityShape.experimental,
sampling: sharedClientCapabilityShape.sampling,
elicitation: sharedClientCapabilityShape.elicitation,
roots: sharedClientCapabilityShape.roots,
extensions: sharedClientCapabilityShape.extensions
});
const sharedServerCapabilityShape = ServerCapabilitiesSchema$1.shape;
const ServerCapabilities2026Schema = object({
experimental: sharedServerCapabilityShape.experimental,
logging: sharedServerCapabilityShape.logging,
completions: sharedServerCapabilityShape.completions,
prompts: sharedServerCapabilityShape.prompts,
resources: sharedServerCapabilityShape.resources,
tools: sharedServerCapabilityShape.tools,
extensions: sharedServerCapabilityShape.extensions
});
const RequestMetaEnvelopeSchema = looseObject({
progressToken: ProgressTokenSchema$1.optional(),
[PROTOCOL_VERSION_META_KEY]: string2(),
[CLIENT_INFO_META_KEY]: ImplementationSchema$1.optional(),
[CLIENT_CAPABILITIES_META_KEY]: ClientCapabilities2026Schema,
[LOG_LEVEL_META_KEY]: LoggingLevelSchema$1.optional()
});
const ToolSchema$1 = object({
...BaseMetadataSchema$1.shape,
...IconsSchema$1.shape,
description: string2().optional(),
inputSchema: looseObject({
$schema: string2().optional(),
type: literal("object")
}),
outputSchema: looseObject({ $schema: string2().optional() }).optional(),
annotations: ToolAnnotationsSchema$1.optional(),
_meta: record(string2(), unknown()).optional()
});
const ToolResultContentSchema$1 = object({
type: literal("tool_result"),
toolUseId: string2(),
content: array(ContentBlockSchema$1),
structuredContent: unknown().optional(),
isError: boolean2().optional(),
_meta: record(string2(), unknown()).optional()
});
const SamplingMessageContentBlockSchema$1 = union([
TextContentSchema$1,
ImageContentSchema$1,
AudioContentSchema$1,
ToolUseContentSchema$1,
ToolResultContentSchema$1
]);
const SamplingMessageSchema$1 = object({
role: RoleSchema$1,
content: union([SamplingMessageContentBlockSchema$1, array(SamplingMessageContentBlockSchema$1)]),
_meta: record(string2(), unknown()).optional()
});
const ResultTypeSchema = string2();
const ResultMetaSchema = looseObject({ [SERVER_INFO_META_KEY]: ImplementationSchema$1.optional().catch(void 0) });
const wireMeta = ResultMetaSchema.optional();
function wireResult(shape) {
return looseObject({
_meta: wireMeta,
resultType: ResultTypeSchema.default("complete"),
...shape
});
}
const ResultSchema$1 = wireResult({});
const PaginatedResultSchema$1 = wireResult({ nextCursor: CursorSchema$1.optional() });
const CallToolResultSchema$1 = wireResult({
content: array(ContentBlockSchema$1),
structuredContent: unknown().optional(),
isError: boolean2().optional()
});
const ListToolsResultSchema$1 = wireResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
tools: array(ToolSchema$1),
nextCursor: CursorSchema$1.optional()
});
const ListPromptsResultSchema$1 = wireResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
prompts: array(PromptSchema$1),
nextCursor: CursorSchema$1.optional()
});
const GetPromptResultSchema$1 = wireResult({
description: string2().optional(),
messages: array(PromptMessageSchema$1)
});
const ListResourcesResultSchema$1 = wireResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
resources: array(ResourceSchema$1),
nextCursor: CursorSchema$1.optional()
});
const ListResourceTemplatesResultSchema$1 = wireResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
resourceTemplates: array(ResourceTemplateSchema$1),
nextCursor: CursorSchema$1.optional()
});
const ReadResourceResultSchema$1 = wireResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
contents: array(union([TextResourceContentsSchema$1, BlobResourceContentsSchema$1]))
});
const CompleteResultSchema$1 = wireResult({ completion: object({
values: array(string2()).max(100),
total: number2().int().optional(),
hasMore: boolean2().optional()
}).loose() });
const CacheableResultSchema = wireResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"])
});
const DiscoverResultSchema$1 = wireResult({
ttlMs: number2().int().min(0).catch(0),
cacheScope: _enum2(["public", "private"]).catch("private"),
supportedVersions: array(string2()),
capabilities: ServerCapabilities2026Schema,
instructions: string2().optional()
});
const CreateMessageRequestParamsSchema$1 = object({
messages: array(SamplingMessageSchema$1),
modelPreferences: ModelPreferencesSchema$1.optional(),
systemPrompt: string2().optional(),
includeContext: _enum2([
"none",
"thisServer",
"allServers"
]).optional(),
temperature: number2().optional(),
maxTokens: number2().int(),
stopSequences: array(string2()).optional(),
metadata: JSONObjectSchema$1.optional(),
tools: array(ToolSchema$1).optional(),
toolChoice: ToolChoiceSchema$1.optional()
});
const CreateMessageRequestSchema$1 = object({
method: literal("sampling/createMessage"),
params: CreateMessageRequestParamsSchema$1
});
const ListRootsRequestSchema$1 = object({
method: literal("roots/list"),
params: object({ _meta: record(string2(), unknown()).optional() }).optional()
});
const CreateMessageResultSchema$1 = object({
...SamplingMessageSchema$1.shape,
model: string2(),
stopReason: string2().optional()
});
const ListRootsResultSchema$1 = object({ roots: array(RootSchema$1) });
const ElicitResultSchema$1 = object({
action: _enum2([
"accept",
"decline",
"cancel"
]),
content: record(string2(), union([
string2(),
number2(),
boolean2(),
array(string2())
])).optional()
});
const ElicitRequestURLParamsSchema$1 = object({
mode: literal("url"),
message: string2(),
url: string2().url()
});
const ElicitRequestParamsSchema$1 = union([ElicitRequestFormParamsSchema$1, ElicitRequestURLParamsSchema$1]);
const ElicitRequestSchema$1 = object({
method: literal("elicitation/create"),
params: ElicitRequestParamsSchema$1
});
const InputRequestSchema = union([
CreateMessageRequestSchema$1,
ListRootsRequestSchema$1,
ElicitRequestSchema$1
]);
const InputResponseSchema = union([
CreateMessageResultSchema$1,
ListRootsResultSchema$1,
ElicitResultSchema$1
]);
const InputRequestsSchema = record(string2(), InputRequestSchema);
const InputResponsesSchema = record(string2(), InputResponseSchema);
const InputRequiredResultSchema = wireResult({
inputRequests: InputRequestsSchema.optional(),
requestState: string2().optional()
});
const retryParamsShape = {
inputResponses: InputResponsesSchema.optional(),
requestState: string2().optional()
};
const InputResponseRequestParamsSchema = object({
_meta: RequestMetaEnvelopeSchema,
...retryParamsShape
});
const DispatchRequestMetaSchema = looseObject({ progressToken: ProgressTokenSchema$1.optional() });
function wireRequest(method, paramsShape) {
return object({
method: literal(method),
params: object({
_meta: RequestMetaEnvelopeSchema,
...paramsShape
})
});
}
function dispatchRequest(method, paramsShape) {
return object({
method: literal(method),
params: object({
_meta: DispatchRequestMetaSchema.optional(),
...paramsShape
}).optional()
});
}
const callToolParamsShape = {
name: string2(),
arguments: record(string2(), unknown()).optional(),
...retryParamsShape
};
const paginatedParamsShape = { cursor: CursorSchema$1.optional() };
const CallToolRequestSchema$1 = wireRequest("tools/call", callToolParamsShape);
const ListToolsRequestSchema$1 = wireRequest("tools/list", paginatedParamsShape);
const ListPromptsRequestSchema$1 = wireRequest("prompts/list", paginatedParamsShape);
const GetPromptRequestSchema$1 = wireRequest("prompts/get", {
name: string2(),
arguments: record(string2(), string2()).optional(),
...retryParamsShape
});
const ListResourcesRequestSchema$1 = wireRequest("resources/list", paginatedParamsShape);
const ListResourceTemplatesRequestSchema$1 = wireRequest("resources/templates/list", paginatedParamsShape);
const ReadResourceRequestSchema$1 = wireRequest("resources/read", {
uri: string2(),
...retryParamsShape
});
const completeParamsShape = {
ref: union([PromptReferenceSchema$1, ResourceTemplateReferenceSchema$1]),
argument: object({
name: string2(),
value: string2()
}),
context: object({ arguments: record(string2(), string2()).optional() }).optional()
};
const CompleteRequestSchema$1 = wireRequest("completion/complete", completeParamsShape);
const DiscoverRequestSchema$1 = wireRequest("server/discover", {});
const SubscriptionFilterSchema$1 = object({
toolsListChanged: boolean2().optional(),
promptsListChanged: boolean2().optional(),
resourcesListChanged: boolean2().optional(),
resourceSubscriptions: array(string2()).optional()
});
const subscriptionsListenParamsShape = { notifications: SubscriptionFilterSchema$1 };
const SubscriptionsListenRequestSchema$1 = wireRequest("subscriptions/listen", subscriptionsListenParamsShape);
const SubscriptionsListenResultMetaSchema$1 = ResultMetaSchema.extend({ "io.modelcontextprotocol/subscriptionId": RequestIdSchema$1 });
const SubscriptionsListenResultSchema$1 = looseObject({
_meta: SubscriptionsListenResultMetaSchema$1,
resultType: ResultTypeSchema.default("complete")
});
const dispatchRequestSchemas = {
"tools/call": dispatchRequest("tools/call", callToolParamsShape),
"tools/list": dispatchRequest("tools/list", paginatedParamsShape),
"prompts/get": dispatchRequest("prompts/get", {
name: string2(),
arguments: record(string2(), string2()).optional()
}),
"prompts/list": dispatchRequest("prompts/list", paginatedParamsShape),
"resources/list": dispatchRequest("resources/list", paginatedParamsShape),
"resources/templates/list": dispatchRequest("resources/templates/list", paginatedParamsShape),
"resources/read": dispatchRequest("resources/read", { uri: string2() }),
"completion/complete": dispatchRequest("completion/complete", completeParamsShape),
"server/discover": dispatchRequest("server/discover", {}),
"subscriptions/listen": dispatchRequest("subscriptions/listen", subscriptionsListenParamsShape)
};
function liftedResult(shape) {
return looseObject({
_meta: wireMeta,
...shape
});
}
const dispatchResultSchemas = {
"tools/call": liftedResult({
content: array(ContentBlockSchema$1),
structuredContent: unknown().optional(),
isError: boolean2().optional()
}),
"tools/list": liftedResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
tools: array(ToolSchema$1),
nextCursor: CursorSchema$1.optional()
}),
"prompts/get": liftedResult({
description: string2().optional(),
messages: array(PromptMessageSchema$1)
}),
"prompts/list": liftedResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
prompts: array(PromptSchema$1),
nextCursor: CursorSchema$1.optional()
}),
"resources/list": liftedResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
resources: array(ResourceSchema$1),
nextCursor: CursorSchema$1.optional()
}),
"resources/templates/list": liftedResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
resourceTemplates: array(ResourceTemplateSchema$1),
nextCursor: CursorSchema$1.optional()
}),
"resources/read": liftedResult({
ttlMs: number2().int().min(0),
cacheScope: _enum2(["public", "private"]),
contents: array(union([TextResourceContentsSchema$1, BlobResourceContentsSchema$1]))
}),
"completion/complete": liftedResult({ completion: object({
values: array(string2()).max(100),
total: number2().int().optional(),
hasMore: boolean2().optional()
}).loose() }),
"server/discover": liftedResult({
ttlMs: number2().int().min(0).catch(0),
cacheScope: _enum2(["public", "private"]).catch("private"),
supportedVersions: array(string2()),
capabilities: ServerCapabilities2026Schema,
instructions: string2().optional()
}),
"subscriptions/listen": liftedResult({})
};
const NotificationMetaSchema = looseObject({ "io.modelcontextprotocol/subscriptionId": RequestIdSchema$1.optional() });
const SubscriptionsAcknowledgedNotificationSchema$1 = object({
method: literal("notifications/subscriptions/acknowledged"),
params: object({
_meta: NotificationMetaSchema.optional(),
notifications: SubscriptionFilterSchema$1
})
});
const CancelledNotificationParamsSchema$1 = object({
_meta: NotificationMetaSchema.optional(),
requestId: RequestIdSchema$1,
reason: string2().optional()
});
const CancelledNotificationSchema$1 = object({
method: literal("notifications/cancelled"),
params: CancelledNotificationParamsSchema$1
});
const notificationSchemas2026 = {
"notifications/cancelled": CancelledNotificationSchema$1,
"notifications/progress": ProgressNotificationSchema$1,
"notifications/message": LoggingMessageNotificationSchema$1,
"notifications/resources/updated": ResourceUpdatedNotificationSchema$1,
"notifications/resources/list_changed": ResourceListChangedNotificationSchema$1,
"notifications/tools/list_changed": ToolListChangedNotificationSchema$1,
"notifications/prompts/list_changed": PromptListChangedNotificationSchema$1,
"notifications/subscriptions/acknowledged": SubscriptionsAcknowledgedNotificationSchema$1
};
const wireResultResponse = (result) => object({
jsonrpc: literal("2.0"),
id: union([string2(), number2().int()]),
result
}).strict();
return {
JSONValueSchema: JSONValueSchema$1,
JSONObjectSchema: JSONObjectSchema$1,
ProgressTokenSchema: ProgressTokenSchema$1,
CursorSchema: CursorSchema$1,
RequestIdSchema: RequestIdSchema$1,
RoleSchema: RoleSchema$1,
LoggingLevelSchema: LoggingLevelSchema$1,
TaskMetadataSchema: TaskMetadataSchema$1,
RelatedTaskMetadataSchema: RelatedTaskMetadataSchema$1,
RequestMetaSchema: RequestMetaSchema$1,
BaseRequestParamsSchema: BaseRequestParamsSchema$1,
TaskAugmentedRequestParamsSchema: TaskAugmentedRequestParamsSchema$1,
NotificationsParamsSchema: NotificationsParamsSchema$1,
NotificationSchema: NotificationSchema$1,
IconSchema: IconSchema$1,
IconsSchema: IconsSchema$1,
BaseMetadataSchema: BaseMetadataSchema$1,
ImplementationSchema: ImplementationSchema$1,
ClientTasksCapabilitySchema: ClientTasksCapabilitySchema$1,
ServerTasksCapabilitySchema: ServerTasksCapabilitySchema$1,
ClientCapabilitiesSchema: ClientCapabilitiesSchema$1,
ServerCapabilitiesSchema: ServerCapabilitiesSchema$1,
ProgressSchema: ProgressSchema$1,
ProgressNotificationParamsSchema: ProgressNotificationParamsSchema$1,
ProgressNotificationSchema: ProgressNotificationSchema$1,
LoggingMessageNotificationParamsSchema: LoggingMessageNotificationParamsSchema$1,
LoggingMessageNotificationSchema: LoggingMessageNotificationSchema$1,
ResourceContentsSchema: ResourceContentsSchema$1,
TextResourceContentsSchema: TextResourceContentsSchema$1,
BlobResourceContentsSchema: BlobResourceContentsSchema$1,
AnnotationsSchema: AnnotationsSchema$1,
ResourceSchema: ResourceSchema$1,
ResourceTemplateSchema: ResourceTemplateSchema$1,
ResourceListChangedNotificationSchema: ResourceListChangedNotificationSchema$1,
ResourceUpdatedNotificationParamsSchema: ResourceUpdatedNotificationParamsSchema$1,
ResourceUpdatedNotificationSchema: ResourceUpdatedNotificationSchema$1,
PromptArgumentSchema: PromptArgumentSchema$1,
PromptSchema: PromptSchema$1,
PromptListChangedNotificationSchema: PromptListChangedNotificationSchema$1,
TextContentSchema: TextContentSchema$1,
ImageContentSchema: ImageContentSchema$1,
AudioContentSchema: AudioContentSchema$1,
ToolUseContentSchema: ToolUseContentSchema$1,
EmbeddedResourceSchema: EmbeddedResourceSchema$1,
ResourceLinkSchema: ResourceLinkSchema$1,
ContentBlockSchema: ContentBlockSchema$1,
PromptMessageSchema: PromptMessageSchema$1,
ToolAnnotationsSchema: ToolAnnotationsSchema$1,
ToolListChangedNotificationSchema: ToolListChangedNotificationSchema$1,
ModelHintSchema: ModelHintSchema$1,
ModelPreferencesSchema: ModelPreferencesSchema$1,
ToolChoiceSchema: ToolChoiceSchema$1,
BooleanSchemaSchema: BooleanSchemaSchema$1,
StringSchemaSchema: StringSchemaSchema$1,
NumberSchemaSchema: NumberSchemaSchema$1,
UntitledSingleSelectEnumSchemaSchema: UntitledSingleSelectEnumSchemaSchema$1,
TitledSingleSelectEnumSchemaSchema: TitledSingleSelectEnumSchemaSchema$1,
LegacyTitledEnumSchemaSchema: LegacyTitledEnumSchemaSchema$1,
SingleSelectEnumSchemaSchema: SingleSelectEnumSchemaSchema$1,
UntitledMultiSelectEnumSchemaSchema: UntitledMultiSelectEnumSchemaSchema$1,
TitledMultiSelectEnumSchemaSchema: TitledMultiSelectEnumSchemaSchema$1,
MultiSelectEnumSchemaSchema: MultiSelectEnumSchemaSchema$1,
EnumSchemaSchema: EnumSchemaSchema$1,
PrimitiveSchemaDefinitionSchema: PrimitiveSchemaDefinitionSchema$1,
ElicitRequestFormParamsSchema: ElicitRequestFormParamsSchema$1,
ResourceTemplateReferenceSchema: ResourceTemplateReferenceSchema$1,
PromptReferenceSchema: PromptReferenceSchema$1,
RootSchema: RootSchema$1,
ClientCapabilities2026Schema,
ServerCapabilities2026Schema,
RequestMetaEnvelopeSchema,
ToolSchema: ToolSchema$1,
ToolResultContentSchema: ToolResultContentSchema$1,
SamplingMessageContentBlockSchema: SamplingMessageContentBlockSchema$1,
SamplingMessageSchema: SamplingMessageSchema$1,
ResultTypeSchema,
ResultMetaSchema,
ResultSchema: ResultSchema$1,
PaginatedResultSchema: PaginatedResultSchema$1,
CallToolResultSchema: CallToolResultSchema$1,
ListToolsResultSchema: ListToolsResultSchema$1,
ListPromptsResultSchema: ListPromptsResultSchema$1,
GetPromptResultSchema: GetPromptResultSchema$1,
ListResourcesResultSchema: ListResourcesResultSchema$1,
ListResourceTemplatesResultSchema: ListResourceTemplatesResultSchema$1,
ReadResourceResultSchema: ReadResourceResultSchema$1,
CompleteResultSchema: CompleteResultSchema$1,
CacheableResultSchema,
DiscoverResultSchema: DiscoverResultSchema$1,
CreateMessageRequestParamsSchema: CreateMessageRequestParamsSchema$1,
CreateMessageRequestSchema: CreateMessageRequestSchema$1,
ListRootsRequestSchema: ListRootsRequestSchema$1,
CreateMessageResultSchema: CreateMessageResultSchema$1,
ListRootsResultSchema: ListRootsResultSchema$1,
ElicitResultSchema: ElicitResultSchema$1,
ElicitRequestURLParamsSchema: ElicitRequestURLParamsSchema$1,
ElicitRequestParamsSchema: ElicitRequestParamsSchema$1,
ElicitRequestSchema: ElicitRequestSchema$1,
InputRequestSchema,
InputResponseSchema,
InputRequestsSchema,
InputResponsesSchema,
InputRequiredResultSchema,
InputResponseRequestParamsSchema,
CallToolRequestSchema: CallToolRequestSchema$1,
ListToolsRequestSchema: ListToolsRequestSchema$1,
ListPromptsRequestSchema: ListPromptsRequestSchema$1,
GetPromptRequestSchema: GetPromptRequestSchema$1,
ListResourcesRequestSchema: ListResourcesRequestSchema$1,
ListResourceTemplatesRequestSchema: ListResourceTemplatesRequestSchema$1,
ReadResourceRequestSchema: ReadResourceRequestSchema$1,
CompleteRequestSchema: CompleteRequestSchema$1,
DiscoverRequestSchema: DiscoverRequestSchema$1,
SubscriptionFilterSchema: SubscriptionFilterSchema$1,
SubscriptionsListenRequestSchema: SubscriptionsListenRequestSchema$1,
SubscriptionsListenResultMetaSchema: SubscriptionsListenResultMetaSchema$1,
SubscriptionsListenResultSchema: SubscriptionsListenResultSchema$1,
dispatchRequestSchemas,
dispatchResultSchemas,
NotificationMetaSchema,
SubscriptionsAcknowledgedNotificationSchema: SubscriptionsAcknowledgedNotificationSchema$1,
CancelledNotificationParamsSchema: CancelledNotificationParamsSchema$1,
CancelledNotificationSchema: CancelledNotificationSchema$1,
notificationSchemas2026,
JSONRPCResultResponseSchema: wireResultResponse(ResultSchema$1),
CallToolResultResponseSchema: wireResultResponse(union([CallToolResultSchema$1, InputRequiredResultSchema])),
ListToolsResultResponseSchema: wireResultResponse(ListToolsResultSchema$1),
ListPromptsResultResponseSchema: wireResultResponse(ListPromptsResultSchema$1),
GetPromptResultResponseSchema: wireResultResponse(union([GetPromptResultSchema$1, InputRequiredResultSchema])),
ListResourcesResultResponseSchema: wireResultResponse(ListResourcesResultSchema$1),
ListResourceTemplatesResultResponseSchema: wireResultResponse(ListResourceTemplatesResultSchema$1),
ReadResourceResultResponseSchema: wireResultResponse(union([ReadResourceResultSchema$1, InputRequiredResultSchema])),
CompleteResultResponseSchema: wireResultResponse(CompleteResultSchema$1),
DiscoverResultResponseSchema: wireResultResponse(DiscoverResultSchema$1),
SubscriptionsListenResultResponseSchema: wireResultResponse(SubscriptionsListenResultSchema$1)
};
}
var memo2;
function buildSchemas2026() {
return memo2 ??= build();
}
var CACHEABLE_RESULT_METHODS = [
"tools/list",
"prompts/list",
"resources/list",
"resources/templates/list",
"resources/read",
"server/discover"
];
function isCacheableResultMethod(method) {
return CACHEABLE_RESULT_METHODS.includes(method);
}
var RESULT_CACHE_HINT_FALLBACK = Symbol("modelcontextprotocol.resultCacheHintFallback");
function cacheHintFallbackOf(result) {
return result[RESULT_CACHE_HINT_FALLBACK];
}
function isValidCacheTtlMs(value) {
return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
}
function isValidCacheScope(value) {
return value === "public" || value === "private";
}
var ProtocolErrorCode = /* @__PURE__ */ function(ProtocolErrorCode$1) {
ProtocolErrorCode$1[ProtocolErrorCode$1["ParseError"] = -32700] = "ParseError";
ProtocolErrorCode$1[ProtocolErrorCode$1["InvalidRequest"] = -32600] = "InvalidRequest";
ProtocolErrorCode$1[ProtocolErrorCode$1["MethodNotFound"] = -32601] = "MethodNotFound";
ProtocolErrorCode$1[ProtocolErrorCode$1["InvalidParams"] = -32602] = "InvalidParams";
ProtocolErrorCode$1[ProtocolErrorCode$1["InternalError"] = -32603] = "InternalError";
ProtocolErrorCode$1[ProtocolErrorCode$1["ResourceNotFound"] = -32002] = "ResourceNotFound";
ProtocolErrorCode$1[ProtocolErrorCode$1["MissingRequiredClientCapability"] = -32021] = "MissingRequiredClientCapability";
ProtocolErrorCode$1[ProtocolErrorCode$1["UnsupportedProtocolVersion"] = -32022] = "UnsupportedProtocolVersion";
ProtocolErrorCode$1[ProtocolErrorCode$1["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
return ProtocolErrorCode$1;
}({});
var ProtocolError = class ProtocolError2 extends Error {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.ProtocolError" });
}
static [Symbol.hasInstance](value) {
return brandedHasInstance(this, value);
}
/**
* Brand-based type guard: equivalent to `value instanceof this`, as an
* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
* the caller's own brand via `this`, so every branded subclass gets a
* correctly-scoped guard by inheritance. Must be invoked on the class —
* in callback position write `v => SdkError.isInstance(v)`, not
* `.filter(SdkError.isInstance)` (detached calls throw rather than
* silently matching nothing).
*/
static isInstance(value) {
if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
return brandedHasInstance(this, value);
}
constructor(code, message, data) {
super(message);
this.code = code;
this.data = data;
this.name = "ProtocolError";
stampErrorBrands(this, new.target);
}
/**
* Factory method to create the appropriate error type based on the error code and data
*/
static fromError(code, message, data) {
if (code === ProtocolErrorCode.UrlElicitationRequired && data) {
const errorData = data;
if (errorData.elicitations) return new UrlElicitationRequiredError(errorData.elicitations, message);
}
if (code === ProtocolErrorCode.UnsupportedProtocolVersion && data) {
const errorData = data;
if (Array.isArray(errorData.supported) && typeof errorData.requested === "string") return new UnsupportedProtocolVersionError({
supported: errorData.supported,
requested: errorData.requested
}, message);
}
if (code === ProtocolErrorCode.InvalidParams || code === ProtocolErrorCode.ResourceNotFound) {
const errorData = data;
if (typeof errorData?.uri === "string" && (code === ProtocolErrorCode.ResourceNotFound || Object.keys(errorData).length === 1)) return new ResourceNotFoundError(errorData.uri, message);
}
if (code === ProtocolErrorCode.MissingRequiredClientCapability && data) {
const errorData = data;
if (errorData.requiredCapabilities !== null && typeof errorData.requiredCapabilities === "object" && !Array.isArray(errorData.requiredCapabilities)) return new MissingRequiredClientCapabilityError({ requiredCapabilities: errorData.requiredCapabilities }, message);
}
return new ProtocolError2(code, message, data);
}
};
var ResourceNotFoundError = class extends ProtocolError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.ResourceNotFoundError" });
}
constructor(uri, message = `Resource not found: ${uri}`) {
super(ProtocolErrorCode.InvalidParams, message, { uri });
}
/** The URI that was requested and not found. */
get uri() {
return this.data.uri;
}
};
var UrlElicitationRequiredError = class extends ProtocolError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.UrlElicitationRequiredError" });
}
constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) {
super(ProtocolErrorCode.UrlElicitationRequired, message, { elicitations });
}
get elicitations() {
return this.data?.elicitations ?? [];
}
};
var UnsupportedProtocolVersionError = class extends ProtocolError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.UnsupportedProtocolVersionError" });
}
constructor(data, message = `Unsupported protocol version: ${data.requested}`) {
super(ProtocolErrorCode.UnsupportedProtocolVersion, message, data);
}
/**
* Protocol versions the receiver supports.
*/
get supported() {
return this.data.supported;
}
/**
* The protocol version that was requested.
*/
get requested() {
return this.data.requested;
}
};
var MissingRequiredClientCapabilityError = class extends ProtocolError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.MissingRequiredClientCapabilityError" });
}
constructor(data, message = `Missing required client capabilities: ${Object.keys(data.requiredCapabilities).join(", ")}`) {
super(ProtocolErrorCode.MissingRequiredClientCapability, message, data);
}
/**
* The capabilities the server requires from the client to process the
* request (only the missing capabilities are listed).
*/
get requiredCapabilities() {
return this.data.requiredCapabilities;
}
};
var DEFAULT_CACHE_TTL_MS = 0;
var DEFAULT_CACHE_SCOPE = "private";
var EXTENDED_RESULT_TYPE_METHODS = [
"tools/call",
"prompts/get",
"resources/read"
];
function stampResultType(method, result) {
const provided = result["resultType"];
if (provided === void 0) return {
...result,
resultType: "complete"
};
if (provided === "complete") return result;
if (EXTENDED_RESULT_TYPE_METHODS.includes(method)) return result;
throw new ProtocolError(ProtocolErrorCode.InternalError, `Handler for ${method} returned resultType '${String(provided)}', but results of ${method} only support 'complete' on protocol revision 2026-07-28`);
}
function fillCacheFields(method, result) {
const fallback = cacheHintFallbackOf(result);
if (result["resultType"] !== "complete" || !isCacheableResultMethod(method)) return fallback === void 0 ? result : stripCacheHintFallback(result);
const provided = result;
const ttlMs = isValidCacheTtlMs(provided["ttlMs"]) ? provided["ttlMs"] : resolveTtlMs(fallback);
const cacheScope = isValidCacheScope(provided["cacheScope"]) ? provided["cacheScope"] : resolveCacheScope(fallback);
const filled = {
...provided,
ttlMs,
cacheScope
};
delete filled[RESULT_CACHE_HINT_FALLBACK];
return filled;
}
function isPlainObject$4(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function stampServerInfoMeta(result, serverInfo) {
if (serverInfo === void 0) return result;
const meta3 = result["_meta"];
if (meta3 === void 0) return {
...result,
_meta: { [SERVER_INFO_META_KEY]: serverInfo }
};
if (!isPlainObject$4(meta3)) return result;
if (meta3[SERVER_INFO_META_KEY] !== void 0) return result;
return {
...result,
_meta: {
...meta3,
[SERVER_INFO_META_KEY]: serverInfo
}
};
}
function resolveTtlMs(fallback) {
return fallback !== void 0 && isValidCacheTtlMs(fallback.ttlMs) ? fallback.ttlMs : DEFAULT_CACHE_TTL_MS;
}
function resolveCacheScope(fallback) {
return fallback !== void 0 && isValidCacheScope(fallback.cacheScope) ? fallback.cacheScope : DEFAULT_CACHE_SCOPE;
}
function stripCacheHintFallback(result) {
const copy = { ...result };
delete copy[RESULT_CACHE_HINT_FALLBACK];
return copy;
}
var INPUT_REQUEST_METHODS_2026 = [
"elicitation/create",
"sampling/createMessage",
"roots/list"
];
var maps;
function inputSchemaMaps() {
if (maps) return maps;
const s = buildSchemas2026();
maps = {
request: {
"elicitation/create": object({
method: literal("elicitation/create"),
params: s.ElicitRequestParamsSchema
}),
"sampling/createMessage": object({
method: literal("sampling/createMessage"),
params: s.CreateMessageRequestParamsSchema
}),
"roots/list": object({
method: literal("roots/list"),
params: looseObject({}).optional()
})
},
response: {
"elicitation/create": s.ElicitResultSchema,
"sampling/createMessage": s.CreateMessageResultSchema,
"roots/list": s.ListRootsResultSchema
}
};
return maps;
}
function isInputRequestMethod2026(method) {
return INPUT_REQUEST_METHODS_2026.includes(method);
}
function getInputRequestSchema2026(method) {
return isInputRequestMethod2026(method) ? inputSchemaMaps().request[method] : void 0;
}
function getInputResponseSchema2026(method) {
return isInputRequestMethod2026(method) ? inputSchemaMaps().response[method] : void 0;
}
var requestMethodKeys = {
"tools/call": null,
"tools/list": null,
"prompts/get": null,
"prompts/list": null,
"resources/list": null,
"resources/templates/list": null,
"resources/read": null,
"completion/complete": null,
"server/discover": null,
"subscriptions/listen": null
};
var notificationMethodKeys = {
"notifications/cancelled": null,
"notifications/progress": null,
"notifications/message": null,
"notifications/resources/updated": null,
"notifications/resources/list_changed": null,
"notifications/tools/list_changed": null,
"notifications/prompts/list_changed": null,
"notifications/subscriptions/acknowledged": null
};
function hasRequestMethod2026(method) {
return Object.prototype.hasOwnProperty.call(requestMethodKeys, method);
}
function hasNotificationMethod2026(method) {
return Object.prototype.hasOwnProperty.call(notificationMethodKeys, method);
}
function hasResultMethod2026(method) {
return Object.prototype.hasOwnProperty.call(requestMethodKeys, method);
}
function getRequestSchema2026(method) {
return hasRequestMethod2026(method) ? buildSchemas2026().dispatchRequestSchemas[method] : void 0;
}
function getResultSchema2026(method) {
return hasResultMethod2026(method) ? buildSchemas2026().dispatchResultSchemas[method] : void 0;
}
function getNotificationSchema2026(method) {
return hasNotificationMethod2026(method) ? buildSchemas2026().notificationSchemas2026[method] : void 0;
}
var rev2026RequestMethods = Object.keys(requestMethodKeys);
var rev2026NotificationMethods = Object.keys(notificationMethodKeys);
function isPlainObject$3(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function triState(schema, raw) {
if (schema === void 0) return {
ok: false,
reason: "not-in-era"
};
const parsed = schema.safeParse(raw);
return parsed.success ? {
ok: true,
value: parsed.data
} : {
ok: false,
reason: "invalid",
message: String(parsed.error)
};
}
var NOT_IN_ERA = {
ok: false,
reason: "not-in-era"
};
var REQUIRED_ENVELOPE_KEYS = [PROTOCOL_VERSION_META_KEY, CLIENT_CAPABILITIES_META_KEY];
function enforceDeletedFields(method, result) {
let next = result;
let copied = false;
const copy = () => {
if (!copied) {
next = { ...next };
copied = true;
}
return next;
};
const tools = result.tools;
if (method === "tools/list" && Array.isArray(tools) && tools.some((tool) => isPlainObject$3(tool) && "execution" in tool)) copy().tools = tools.map((tool) => {
if (!isPlainObject$3(tool) || !("execution" in tool)) return tool;
const rest = { ...tool };
delete rest["execution"];
return rest;
});
const capabilities = result.capabilities;
if (isPlainObject$3(capabilities) && "tasks" in capabilities) {
const rest = { ...capabilities };
delete rest["tasks"];
copy().capabilities = rest;
}
return next;
}
var rev2026Codec = {
era: "2026-07-28",
hasRequestMethod: hasRequestMethod2026,
hasNotificationMethod: hasNotificationMethod2026,
hasInputRequestMethod: (method) => getInputRequestSchema2026(method) !== void 0,
validateRequest: (method, raw) => triState(getRequestSchema2026(method), raw),
validateResult: (method, raw) => triState(getResultSchema2026(method), raw),
validateNotification: (method, raw) => triState(getNotificationSchema2026(method), raw),
validateInputRequest: (method, raw) => triState(getInputRequestSchema2026(method), raw),
validateInputResponse: (method, raw) => triState(getInputResponseSchema2026(method), raw),
samplingResultVariant: () => NOT_IN_ERA,
outboundEnvelope(material) {
return {
[PROTOCOL_VERSION_META_KEY]: material.protocolVersion,
[CLIENT_INFO_META_KEY]: material.clientInfo,
[CLIENT_CAPABILITIES_META_KEY]: material.clientCapabilities,
...material.logLevel !== void 0 && { [LOG_LEVEL_META_KEY]: material.logLevel }
};
},
validateEnvelopeMeta(meta3) {
const issues = [];
for (const key of REQUIRED_ENVELOPE_KEYS) if (!(key in meta3)) issues.push({
key,
problem: "missing"
});
const parsed = buildSchemas2026().RequestMetaEnvelopeSchema.safeParse(meta3);
if (!parsed.success) for (const issue2 of parsed.error.issues) {
const path3 = issue2.path.map(String);
const key = path3.length > 0 ? path3.join(".") : "_meta";
if (path3.length === 1 && issues.some((existing) => existing.key === key && existing.problem === "missing")) continue;
issues.push({
key,
problem: issue2.message
});
}
return issues;
},
projectCallToolResult: (result) => appendTextFallbackForNonObject(result),
inputRequestSchema: getInputRequestSchema2026,
decodeResult(method, raw) {
if (!isPlainObject$3(raw)) return {
kind: "invalid",
error: new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${method}: not an object`, { method })
};
const rawResultType = raw["resultType"];
if (rawResultType === void 0) return {
kind: "invalid",
error: new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${method}: missing required resultType \u2014 servers implementing protocol revision 2026-07-28 MUST include it (the absent-means-complete bridge applies only to earlier-revision servers)`, {
method,
violation: "missing-resultType"
})
};
if (typeof rawResultType !== "string") return {
kind: "invalid",
error: new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${method}: non-string resultType`, {
method,
resultType: rawResultType
})
};
if (rawResultType === "input_required") {
const rawInputRequests = raw["inputRequests"];
const inputRequests = isPlainObject$3(rawInputRequests) ? rawInputRequests : {};
const requestState = raw["requestState"];
const metaParse = raw["_meta"] === void 0 ? void 0 : buildSchemas2026().ResultMetaSchema.safeParse(raw["_meta"]);
const meta3 = metaParse?.success ? metaParse.data : void 0;
if (Object.keys(inputRequests).length === 0 && typeof requestState !== "string") return {
kind: "invalid",
error: new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${method}: input_required carries neither inputRequests nor requestState (every input_required result must include at least one of the two)`, {
method,
violation: "input-required-missing-both"
})
};
return {
kind: "input_required",
inputRequests,
...typeof requestState === "string" && { requestState },
...meta3 !== void 0 && { _meta: meta3 }
};
}
if (rawResultType !== "complete") return {
kind: "invalid",
error: new SdkError(SdkErrorCode.UnsupportedResultType, `Unsupported result type '${rawResultType}' for ${method}`, {
resultType: rawResultType,
method
})
};
const wireResultSchemas = getWireResultSchemas();
const wireSchema = Object.hasOwn(wireResultSchemas, method) ? wireResultSchemas[method] : void 0;
if (wireSchema !== void 0) {
const parsed = wireSchema.safeParse(raw);
if (!parsed.success) return {
kind: "invalid",
error: new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${method}: ${parsed.error}`, { method })
};
}
const lifted = { ...raw };
delete lifted["resultType"];
return {
kind: "complete",
result: lifted
};
},
encodeResult(method, result, serverInfo) {
return stampServerInfoMeta(fillCacheFields(method, stampResultType(method, enforceDeletedFields(method, result))), serverInfo);
},
encodeErrorCode: (code) => code === -32002 ? -32602 : code,
checkInboundEnvelope(material) {
if (material.envelope === void 0) return "Request is missing the required _meta envelope for protocol revision 2026-07-28 (io.modelcontextprotocol/protocolVersion, io.modelcontextprotocol/clientCapabilities)";
const parsed = buildSchemas2026().RequestMetaEnvelopeSchema.safeParse(material.envelope);
if (!parsed.success) return `Invalid _meta envelope for protocol revision 2026-07-28: ${parsed.error.issues.map((issue2) => issue2.message).join("; ")}`;
}
};
var wireResultSchemasMemo;
function getWireResultSchemas() {
if (wireResultSchemasMemo) return wireResultSchemasMemo;
const s = buildSchemas2026();
wireResultSchemasMemo = {
"tools/call": s.CallToolResultSchema,
"tools/list": s.ListToolsResultSchema,
"prompts/get": s.GetPromptResultSchema,
"prompts/list": s.ListPromptsResultSchema,
"resources/list": s.ListResourcesResultSchema,
"resources/templates/list": s.ListResourceTemplatesResultSchema,
"resources/read": s.ReadResourceResultSchema,
"completion/complete": s.CompleteResultSchema,
"server/discover": s.DiscoverResultSchema
};
return wireResultSchemasMemo;
}
var MODERN_WIRE_REVISION = "2026-07-28";
function codecForVersion(version3) {
return version3 !== void 0 && isModernProtocolVersion(version3) ? rev2026Codec : rev2025Codec;
}
function classifiedWireEra(classification) {
if (classification.revision !== void 0) return codecForVersion(classification.revision).era;
return classification.era === "modern" ? rev2026Codec.era : rev2025Codec.era;
}
function isSpecRequestMethod(method) {
return ALL_CODECS.some((codec2) => codec2.hasRequestMethod(method));
}
function isSpecNotificationMethod(method) {
return ALL_CODECS.some((codec2) => codec2.hasNotificationMethod(method));
}
function isExtensionReusedRequestMethod(method) {
return method === "tasks/get" || method === "tasks/cancel";
}
var ALL_CODECS = [rev2025Codec, rev2026Codec];
var schemas_exports3 = /* @__PURE__ */ __exportAll({
AnnotationsSchema: () => AnnotationsSchema,
AudioContentSchema: () => AudioContentSchema,
BaseMetadataSchema: () => BaseMetadataSchema,
BaseRequestParamsSchema: () => BaseRequestParamsSchema,
BlobResourceContentsSchema: () => BlobResourceContentsSchema,
BooleanSchemaSchema: () => BooleanSchemaSchema,
CallToolRequestParamsSchema: () => CallToolRequestParamsSchema,
CallToolRequestSchema: () => CallToolRequestSchema,
CallToolResultSchema: () => CallToolResultSchema,
CancelTaskRequestSchema: () => CancelTaskRequestSchema,
CancelTaskResultSchema: () => CancelTaskResultSchema,
CancelledNotificationParamsSchema: () => CancelledNotificationParamsSchema,
CancelledNotificationSchema: () => CancelledNotificationSchema,
ClientCapabilitiesSchema: () => ClientCapabilitiesSchema,
ClientNotificationSchema: () => ClientNotificationSchema,
ClientRequestSchema: () => ClientRequestSchema,
ClientResultSchema: () => ClientResultSchema,
ClientTasksCapabilitySchema: () => ClientTasksCapabilitySchema,
CompatibilityCallToolResultSchema: () => CompatibilityCallToolResultSchema,
CompleteRequestParamsSchema: () => CompleteRequestParamsSchema,
CompleteRequestSchema: () => CompleteRequestSchema,
CompleteResultSchema: () => CompleteResultSchema,
ContentBlockSchema: () => ContentBlockSchema,
CreateMessageRequestParamsSchema: () => CreateMessageRequestParamsSchema,
CreateMessageRequestSchema: () => CreateMessageRequestSchema,
CreateMessageResultSchema: () => CreateMessageResultSchema,
CreateMessageResultWithToolsSchema: () => CreateMessageResultWithToolsSchema,
CreateTaskResultSchema: () => CreateTaskResultSchema,
CursorSchema: () => CursorSchema,
DiscoverRequestSchema: () => DiscoverRequestSchema,
DiscoverResultSchema: () => DiscoverResultSchema,
ElicitRequestFormParamsSchema: () => ElicitRequestFormParamsSchema,
ElicitRequestParamsSchema: () => ElicitRequestParamsSchema,
ElicitRequestSchema: () => ElicitRequestSchema,
ElicitRequestURLParamsSchema: () => ElicitRequestURLParamsSchema,
ElicitResultSchema: () => ElicitResultSchema,
ElicitationCompleteNotificationParamsSchema: () => ElicitationCompleteNotificationParamsSchema,
ElicitationCompleteNotificationSchema: () => ElicitationCompleteNotificationSchema,
EmbeddedResourceSchema: () => EmbeddedResourceSchema,
EmptyResultSchema: () => EmptyResultSchema,
EnumSchemaSchema: () => EnumSchemaSchema,
GetPromptRequestParamsSchema: () => GetPromptRequestParamsSchema,
GetPromptRequestSchema: () => GetPromptRequestSchema,
GetPromptResultSchema: () => GetPromptResultSchema,
GetTaskPayloadRequestSchema: () => GetTaskPayloadRequestSchema,
GetTaskPayloadResultSchema: () => GetTaskPayloadResultSchema,
GetTaskRequestSchema: () => GetTaskRequestSchema,
GetTaskResultSchema: () => GetTaskResultSchema,
IconSchema: () => IconSchema,
IconsSchema: () => IconsSchema,
ImageContentSchema: () => ImageContentSchema,
ImplementationSchema: () => ImplementationSchema,
InitializeRequestParamsSchema: () => InitializeRequestParamsSchema,
InitializeRequestSchema: () => InitializeRequestSchema,
InitializeResultSchema: () => InitializeResultSchema,
InitializedNotificationSchema: () => InitializedNotificationSchema,
JSONArraySchema: () => JSONArraySchema,
JSONObjectSchema: () => JSONObjectSchema,
JSONRPCErrorResponseSchema: () => JSONRPCErrorResponseSchema,
JSONRPCMessageSchema: () => JSONRPCMessageSchema,
JSONRPCNotificationSchema: () => JSONRPCNotificationSchema,
JSONRPCRequestSchema: () => JSONRPCRequestSchema,
JSONRPCResponseSchema: () => JSONRPCResponseSchema,
JSONRPCResultResponseSchema: () => JSONRPCResultResponseSchema,
JSONValueSchema: () => JSONValueSchema,
LegacyTitledEnumSchemaSchema: () => LegacyTitledEnumSchemaSchema,
ListChangedOptionsBaseSchema: () => ListChangedOptionsBaseSchema,
ListPromptsRequestSchema: () => ListPromptsRequestSchema,
ListPromptsResultSchema: () => ListPromptsResultSchema,
ListResourceTemplatesRequestSchema: () => ListResourceTemplatesRequestSchema,
ListResourceTemplatesResultSchema: () => ListResourceTemplatesResultSchema,
ListResourcesRequestSchema: () => ListResourcesRequestSchema,
ListResourcesResultSchema: () => ListResourcesResultSchema,
ListRootsRequestSchema: () => ListRootsRequestSchema,
ListRootsResultSchema: () => ListRootsResultSchema,
ListTasksRequestSchema: () => ListTasksRequestSchema,
ListTasksResultSchema: () => ListTasksResultSchema,
ListToolsRequestSchema: () => ListToolsRequestSchema,
ListToolsResultSchema: () => ListToolsResultSchema,
LoggingLevelSchema: () => LoggingLevelSchema,
LoggingMessageNotificationParamsSchema: () => LoggingMessageNotificationParamsSchema,
LoggingMessageNotificationSchema: () => LoggingMessageNotificationSchema,
ModelHintSchema: () => ModelHintSchema,
ModelPreferencesSchema: () => ModelPreferencesSchema,
MultiSelectEnumSchemaSchema: () => MultiSelectEnumSchemaSchema,
NotificationSchema: () => NotificationSchema,
NotificationsParamsSchema: () => NotificationsParamsSchema,
NumberSchemaSchema: () => NumberSchemaSchema,
PaginatedRequestParamsSchema: () => PaginatedRequestParamsSchema,
PaginatedRequestSchema: () => PaginatedRequestSchema,
PaginatedResultSchema: () => PaginatedResultSchema,
PingRequestSchema: () => PingRequestSchema,
PrimitiveSchemaDefinitionSchema: () => PrimitiveSchemaDefinitionSchema,
ProgressNotificationParamsSchema: () => ProgressNotificationParamsSchema,
ProgressNotificationSchema: () => ProgressNotificationSchema,
ProgressSchema: () => ProgressSchema,
ProgressTokenSchema: () => ProgressTokenSchema,
PromptArgumentSchema: () => PromptArgumentSchema,
PromptListChangedNotificationSchema: () => PromptListChangedNotificationSchema,
PromptMessageSchema: () => PromptMessageSchema,
PromptReferenceSchema: () => PromptReferenceSchema,
PromptSchema: () => PromptSchema,
ReadResourceRequestParamsSchema: () => ReadResourceRequestParamsSchema,
ReadResourceRequestSchema: () => ReadResourceRequestSchema,
ReadResourceResultSchema: () => ReadResourceResultSchema,
RelatedTaskMetadataSchema: () => RelatedTaskMetadataSchema,
RequestIdSchema: () => RequestIdSchema,
RequestMetaSchema: () => RequestMetaSchema,
RequestSchema: () => RequestSchema,
ResourceContentsSchema: () => ResourceContentsSchema,
ResourceLinkSchema: () => ResourceLinkSchema,
ResourceListChangedNotificationSchema: () => ResourceListChangedNotificationSchema,
ResourceRequestParamsSchema: () => ResourceRequestParamsSchema,
ResourceSchema: () => ResourceSchema,
ResourceTemplateReferenceSchema: () => ResourceTemplateReferenceSchema,
ResourceTemplateSchema: () => ResourceTemplateSchema,
ResourceUpdatedNotificationParamsSchema: () => ResourceUpdatedNotificationParamsSchema,
ResourceUpdatedNotificationSchema: () => ResourceUpdatedNotificationSchema,
ResultMetaObjectSchema: () => ResultMetaObjectSchema,
ResultSchema: () => ResultSchema,
RoleSchema: () => RoleSchema,
RootSchema: () => RootSchema,
RootsListChangedNotificationSchema: () => RootsListChangedNotificationSchema,
SamplingContentSchema: () => SamplingContentSchema,
SamplingMessageContentBlockSchema: () => SamplingMessageContentBlockSchema,
SamplingMessageSchema: () => SamplingMessageSchema,
ServerCapabilitiesSchema: () => ServerCapabilitiesSchema,
ServerNotificationSchema: () => ServerNotificationSchema,
ServerRequestSchema: () => ServerRequestSchema,
ServerResultSchema: () => ServerResultSchema,
ServerTasksCapabilitySchema: () => ServerTasksCapabilitySchema,
SetLevelRequestParamsSchema: () => SetLevelRequestParamsSchema,
SetLevelRequestSchema: () => SetLevelRequestSchema,
SingleSelectEnumSchemaSchema: () => SingleSelectEnumSchemaSchema,
StringSchemaSchema: () => StringSchemaSchema,
SubscribeRequestParamsSchema: () => SubscribeRequestParamsSchema,
SubscribeRequestSchema: () => SubscribeRequestSchema,
SubscriptionFilterSchema: () => SubscriptionFilterSchema,
SubscriptionsAcknowledgedNotificationParamsSchema: () => SubscriptionsAcknowledgedNotificationParamsSchema,
SubscriptionsAcknowledgedNotificationSchema: () => SubscriptionsAcknowledgedNotificationSchema,
SubscriptionsListenRequestParamsSchema: () => SubscriptionsListenRequestParamsSchema,
SubscriptionsListenRequestSchema: () => SubscriptionsListenRequestSchema,
SubscriptionsListenResultMetaSchema: () => SubscriptionsListenResultMetaSchema,
SubscriptionsListenResultSchema: () => SubscriptionsListenResultSchema,
TaskAugmentedRequestParamsSchema: () => TaskAugmentedRequestParamsSchema,
TaskCreationParamsSchema: () => TaskCreationParamsSchema,
TaskMetadataSchema: () => TaskMetadataSchema,
TaskSchema: () => TaskSchema,
TaskStatusNotificationParamsSchema: () => TaskStatusNotificationParamsSchema,
TaskStatusNotificationSchema: () => TaskStatusNotificationSchema,
TaskStatusSchema: () => TaskStatusSchema,
TextContentSchema: () => TextContentSchema,
TextResourceContentsSchema: () => TextResourceContentsSchema,
TitledMultiSelectEnumSchemaSchema: () => TitledMultiSelectEnumSchemaSchema,
TitledSingleSelectEnumSchemaSchema: () => TitledSingleSelectEnumSchemaSchema,
ToolAnnotationsSchema: () => ToolAnnotationsSchema,
ToolChoiceSchema: () => ToolChoiceSchema,
ToolExecutionSchema: () => ToolExecutionSchema,
ToolListChangedNotificationSchema: () => ToolListChangedNotificationSchema,
ToolResultContentSchema: () => ToolResultContentSchema,
ToolSchema: () => ToolSchema,
ToolUseContentSchema: () => ToolUseContentSchema,
UnsubscribeRequestParamsSchema: () => UnsubscribeRequestParamsSchema,
UnsubscribeRequestSchema: () => UnsubscribeRequestSchema,
UntitledMultiSelectEnumSchemaSchema: () => UntitledMultiSelectEnumSchemaSchema,
UntitledSingleSelectEnumSchemaSchema: () => UntitledSingleSelectEnumSchemaSchema
});
var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
var isInputRequiredResult = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && value.resultType === "input_required";
var isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
var isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
var MCP_PARAM_HEADER_PREFIX = "Mcp-Param-";
var X_MCP_HEADER_KEY = "x-mcp-header";
var RFC9110_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
var PERMITTED_X_MCP_HEADER_TYPES = /* @__PURE__ */ new Set([
"string",
"integer",
"boolean"
]);
function scanXMcpHeaderDeclarations(inputSchema) {
const declarations = [];
const seenLower = /* @__PURE__ */ new Map();
let numberFault;
const visit2 = (node2, path3, reachable) => {
if (node2 === null || typeof node2 !== "object") return void 0;
const schema = node2;
if (X_MCP_HEADER_KEY in schema) {
if (!reachable || path3.length === 0) return `${pathName(path3)}: x-mcp-header is only permitted on properties statically reachable via a chain of 'properties' keys (not under items, additionalProperties, oneOf/anyOf/allOf/not, if/then/else, or $ref)`;
const raw = schema[X_MCP_HEADER_KEY];
if (typeof raw !== "string" || raw.length === 0) return `${pathName(path3)}: x-mcp-header MUST be a non-empty string`;
if (!RFC9110_TOKEN.test(raw)) return `${pathName(path3)}: x-mcp-header '${raw}' is not a valid RFC 9110 token (no spaces, control characters or HTTP delimiters)`;
const type = typeof schema.type === "string" ? schema.type : void 0;
if (type === void 0 || !PERMITTED_X_MCP_HEADER_TYPES.has(type)) {
const fault$1 = `${pathName(path3)}: x-mcp-header is only permitted on primitive-typed properties (string, integer, boolean); got ${type ?? "<none>"}`;
if (type !== "number") return fault$1;
numberFault ??= fault$1;
}
const lower = raw.toLowerCase();
const prior = seenLower.get(lower);
if (prior !== void 0) return `x-mcp-header '${raw}' is not case-insensitively unique (also declared as '${prior}')`;
seenLower.set(lower, raw);
declarations.push({
path: path3,
headerName: raw,
type
});
}
const properties = schema.properties;
if (properties !== null && typeof properties === "object") for (const [key, child] of Object.entries(properties)) {
const fault$1 = visit2(child, [...path3, key], reachable);
if (fault$1 !== void 0) return fault$1;
}
for (const k of NON_REACHABLE_SUBSCHEMA_KEYWORDS) {
const sub = schema[k];
if (sub === void 0) continue;
const branches = Array.isArray(sub) ? sub : sub !== null && typeof sub === "object" && OBJECT_VALUED_SUBSCHEMA_KEYWORDS.has(k) ? Object.values(sub) : [sub];
for (const branch of branches) {
const fault$1 = visit2(branch, [...path3, `<${k}>`], false);
if (fault$1 !== void 0) return fault$1;
}
}
};
const fault = visit2(inputSchema, [], true);
if (fault !== void 0) return {
valid: false,
reason: numberFault ?? fault
};
return numberFault === void 0 ? {
valid: true,
declarations
} : {
valid: false,
reason: numberFault,
declarations
};
}
var NON_REACHABLE_SUBSCHEMA_KEYWORDS = [
"items",
"prefixItems",
"contains",
"additionalProperties",
"unevaluatedProperties",
"unevaluatedItems",
"propertyNames",
"patternProperties",
"dependentSchemas",
"oneOf",
"anyOf",
"allOf",
"not",
"if",
"then",
"else",
"$defs",
"definitions"
];
var OBJECT_VALUED_SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
"patternProperties",
"dependentSchemas",
"$defs",
"definitions"
]);
function pathName(path3) {
return path3.length === 0 ? "<root>" : path3.join(".");
}
var BASE64_SENTINEL_PREFIX = "=?base64?";
var BASE64_SENTINEL_SUFFIX = "?=";
function mcpParamPrimitiveToString(value) {
if (typeof value === "string") return value;
if (typeof value === "boolean") return value ? "true" : "false";
if (typeof value === "number") {
if (!Number.isFinite(value)) return void 0;
if (Number.isInteger(value) && !Number.isSafeInteger(value)) return void 0;
return String(value);
}
}
function needsBase64(s) {
if (s.length === 0) return true;
if (s.startsWith(BASE64_SENTINEL_PREFIX) && s.endsWith(BASE64_SENTINEL_SUFFIX)) return true;
if (s !== s.trim()) return true;
for (let i = 0; i < s.length; i++) {
const c = s.codePointAt(i);
if (c === 9 || c >= 32 && c <= 126) continue;
return true;
}
return false;
}
function utf8ToBase64(s) {
const bytes = new TextEncoder().encode(s);
let bin = "";
for (const b of bytes) bin += String.fromCodePoint(b);
return btoa(bin);
}
function encodeMcpParamValue(value) {
return needsBase64(value) ? `${BASE64_SENTINEL_PREFIX}${utf8ToBase64(value)}${BASE64_SENTINEL_SUFFIX}` : value;
}
function valueAtPath(root, path3) {
let node2 = root;
for (const key of path3) {
if (node2 === null || typeof node2 !== "object") return void 0;
node2 = node2[key];
}
return node2;
}
function buildMcpParamHeaders(declarations, args) {
const out = {};
for (const decl of declarations) {
const raw = valueAtPath(args, decl.path);
if (raw === void 0 || raw === null) continue;
const stringValue = mcpParamPrimitiveToString(raw);
if (stringValue === void 0) continue;
out[`${MCP_PARAM_HEADER_PREFIX}${decl.headerName}`] = encodeMcpParamValue(stringValue);
}
return out;
}
var HEADER_MISMATCH_ERROR_CODE = -32020;
var INBOUND_VALIDATION_LADDER = [
{
rung: "http-method",
order: 1,
evaluatedAt: "edge",
codes: [-32e3],
conformance: [],
rationale: "The modern era is POST-only; GET/DELETE are body-less 2025-era session operations and are method-routed to legacy serving (405 when legacy serving is not configured), before any body is read."
},
{
rung: "jsonrpc-shape",
order: 2,
evaluatedAt: "edge",
codes: [ProtocolErrorCode.InvalidRequest],
conformance: ["server-stateless"],
rationale: "The body must be a JSON-RPC request or notification: posted responses and batch arrays containing a modern or invalid element are rejected before classification (element-wise batch rule); all-legacy arrays stay legacy traffic."
},
{
rung: "era-classification",
order: 3,
evaluatedAt: "edge",
codes: [HEADER_MISMATCH_ERROR_CODE, ProtocolErrorCode.UnsupportedProtocolVersion],
conformance: [
"server-stateless",
"http-header-validation",
"http-custom-header-server-validation"
],
rationale: "Body-primary era classification with the protocol-version header as a cross-check; a header/body disagreement is rejected with -32020 (HeaderMismatch), and an envelope-less request on a modern-only endpoint is answered with the unsupported-protocol-version error naming the supported revisions."
},
{
rung: "envelope",
order: 4,
evaluatedAt: "edge",
codes: [ProtocolErrorCode.InvalidParams],
conformance: ["server-stateless"],
rationale: "A present envelope claim with a malformed envelope \u2014 and a missing envelope on a request whose protocol-version header names a modern revision \u2014 is an invalid-params rejection naming the offending or missing key(s); never a silent fall back to legacy handling. This is the only place an invalid-params rejection maps to HTTP 400."
},
{
rung: "method-registry",
order: 5,
evaluatedAt: "dispatch",
codes: [ProtocolErrorCode.MethodNotFound],
conformance: ["server-stateless"],
rationale: "Method existence outranks parameter validity: a method absent from the negotiated revision\u2019s registry (or with no handler installed) answers method-not-found before params or capabilities are looked at."
},
{
rung: "request-params",
order: 6,
evaluatedAt: "dispatch",
codes: [ProtocolErrorCode.InvalidParams],
conformance: [],
rationale: "Per-method params validation; emitted in-band by the dispatch layer (HTTP 200), never via the ladder status table."
},
{
rung: "standard-header-validation",
order: 7,
evaluatedAt: "pre-dispatch",
codes: [HEADER_MISMATCH_ERROR_CODE],
conformance: ["http-header-validation"],
rationale: "SEP-2243 standard `MCP-Protocol-Version` / `Mcp-Method` / `Mcp-Name` headers \u2014 presence, sentinel decoding, and `Mcp-Name` \u2194 body cross-check \u2014 are validated by the HTTP entry on a modern-classified request after the supported-revision gate and before dispatch. The spec requires `MCP-Protocol-Version` and `Mcp-Method` on every modern *request* POST (`Mcp-Name` only for the methods that mirror `params.name` / `params.uri` / `params.taskId`, see `MCP_NAME_HEADER_SOURCE`) and names them in that order, so a request missing several is answered by the earliest. Notification POSTs are exempt: the presence half runs on requests only, so a modern-enveloped notification is dispatched even with no standard headers at all. The classifier\u2019s own header-mismatch cells (protocol-version, `Mcp-Method` mismatch) stay on the edge `era-classification` rung; this rung carries the entry-layer presence/`Mcp-Name` half \u2014 including the missing `MCP-Protocol-Version` cell, which cannot live on the edge rung without breaking body-primary classification. Evaluated before the capability gate, the factory call, and the `Mcp-Param-*` rung so a request that fails several rungs is answered by the standard-header rung first. The documented order (after method-registry 5 and request-params 6) is NOT the observed precedence: serveModern evaluates this rung immediately after the supported-revision gate, so a request that also fails a dispatch rung is answered here before the dispatch rungs (5\u20136) are consulted."
},
{
rung: "client-capabilities",
order: 8,
evaluatedAt: "pre-dispatch",
codes: [ProtocolErrorCode.MissingRequiredClientCapability],
conformance: ["server-stateless"],
rationale: "The capability requirement is checked by the HTTP entry, pre-dispatch, against the validated envelope the classifier produced \u2014 pinning the spec-mandated HTTP 400 independently of how dispatch- and handler-produced errors are mapped. The documented order (after method resolution and params validation) is preserved observably only while the requirement table is empty: once a served method gains a requirement entry, a request that is missing the capability and would also fail a dispatch rung is answered by this gate first, so the entry must consult the method registry before the gate if the documented precedence is to stay observable."
},
{
rung: "param-header-validation",
order: 9,
evaluatedAt: "pre-dispatch",
codes: [HEADER_MISMATCH_ERROR_CODE],
conformance: ["http-custom-header-server-validation"],
rationale: "SEP-2243 `Mcp-Param-*` headers are validated against the named tool\u2019s `x-mcp-header` declarations and the body `arguments` after the tool registry is known and before dispatch reaches the handler; a missing/disagreeing/malformed header is rejected 400 / -32020 with the same shape as the standard-header cross-checks. The documented order (after method resolution and params validation) is preserved observably only when the body `arguments` would otherwise validate: the check runs pre-dispatch, so a `tools/call` that fails BOTH this rung and a dispatch-time rung (e.g. order-6 `request-params`, -32602) is answered by this gate first with 400 / -32020, not by the earlier-ordered rung."
}
];
var LADDER_ERROR_HTTP_STATUS = {
[ProtocolErrorCode.ParseError]: 400,
[ProtocolErrorCode.InvalidRequest]: 400,
[ProtocolErrorCode.MethodNotFound]: 404,
[ProtocolErrorCode.UnsupportedProtocolVersion]: 400,
[ProtocolErrorCode.MissingRequiredClientCapability]: 400,
[HEADER_MISMATCH_ERROR_CODE]: 400
};
var MCP_NAME_HEADER_SOURCE = {
"tools/call": "name",
"prompts/get": "name",
"resources/read": "uri",
"tasks/get": "taskId",
"tasks/update": "taskId",
"tasks/cancel": "taskId"
};
function mcpNameSource(method, params) {
const field = Object.hasOwn(MCP_NAME_HEADER_SOURCE, method) ? MCP_NAME_HEADER_SOURCE[method] : void 0;
if (field === void 0) return;
const raw = isPlainObject$2(params) ? params[field] : void 0;
return {
field,
value: typeof raw === "string" ? raw : void 0
};
}
function isPlainObject$2(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function parseSchema(schema, data) {
return safeParse2(schema, data);
}
function shapeKeys(schemas) {
return new Set(schemas.flatMap((schema) => Object.keys(schema.shape)));
}
function isStandardSchema(schema) {
if (schema == null) return false;
const schemaType = typeof schema;
if (schemaType !== "object" && schemaType !== "function") return false;
if (!("~standard" in schema)) return false;
return typeof schema["~standard"]?.validate === "function";
}
var warnedZodFallback = false;
var JSON_SCHEMA_CONVERSION_TARGET = "draft-2020-12";
function standardSchemaToJsonSchema(schema, io = "input") {
const std = schema["~standard"];
let result;
if (std.jsonSchema) result = std.jsonSchema[io]({ target: JSON_SCHEMA_CONVERSION_TARGET });
else if (std.vendor === "zod") {
if (!("_zod" in schema)) throw new Error("Schema appears to be from zod 3, which the SDK cannot convert to JSON Schema. Upgrade to zod >=4.2.0, or wrap your JSON Schema with fromJsonSchema().");
if (!warnedZodFallback) {
warnedZodFallback = true;
console.warn("[mcp-sdk] Your zod version does not implement `~standard.jsonSchema` (added in zod 4.2.0). Falling back to z.toJSONSchema(). Upgrade to zod >=4.2.0 to silence this warning.");
}
result = toJSONSchema(schema, {
target: JSON_SCHEMA_CONVERSION_TARGET,
io
});
} else throw new Error(`Schema library "${std.vendor}" does not implement StandardJSONSchemaV1 (\`~standard.jsonSchema\`). Upgrade to a version that does, or wrap your JSON Schema with fromJsonSchema().`);
if (io === "output") {
if (result.type !== void 0) return result;
return isProvablyObjectShapedRoot(result) ? {
type: "object",
...result
} : result;
}
if (result.type !== void 0 && result.type !== "object") throw new Error(`MCP tool and prompt schemas must describe objects (got type: ${JSON.stringify(result.type)}). Wrap your schema in z.object({...}) or equivalent.`);
return {
type: "object",
...result
};
}
var LOCAL_DEFINITION_REF = /^#\/(\$defs|definitions)\/([^/~%]+)$/;
function isProvablyObjectShapedRoot(schema, root = schema) {
if ("properties" in schema || "patternProperties" in schema || "additionalProperties" in schema || "required" in schema) return true;
const ref = typeof schema.$ref === "string" && LOCAL_DEFINITION_REF.exec(schema.$ref);
if (ref && root[ref[1]]?.[ref[2]]?.type === "object") return true;
for (const key of [
"oneOf",
"anyOf",
"allOf"
]) {
const members2 = schema[key];
if (Array.isArray(members2) && members2.length > 0) return members2.every((m) => m !== null && typeof m === "object" && (m.type === "object" || isProvablyObjectShapedRoot(m, "$id" in m ? {} : root)));
}
return false;
}
function formatIssue(issue2) {
if (!issue2.path?.length) return issue2.message;
return `${issue2.path.map((p) => String(typeof p === "object" ? p.key : p)).join(".")}: ${issue2.message}`;
}
async function validateStandardSchema(schema, data) {
const result = await schema["~standard"].validate(data);
if (result.issues && result.issues.length > 0) return {
success: false,
error: result.issues.map((i) => formatIssue(i)).join(", ")
};
return {
success: true,
data: result.value
};
}
function zodEmittedPattern(schema) {
const jsonSchema = toJSONSchema(schema, {
target: JSON_SCHEMA_CONVERSION_TARGET,
io: "input"
});
return typeof jsonSchema.pattern === "string" ? jsonSchema.pattern : void 0;
}
var DATETIME_FRACTION_DIGITS = /\\\.\\d\{(\d+)\}/;
function datetimeReferenceSchemas(pattern) {
const fractionDigits = DATETIME_FRACTION_DIGITS.exec(pattern);
const precisions = [
void 0,
-1,
0
];
if (fractionDigits) precisions.push(Number(fractionDigits[1]));
return [false, true].flatMap((local) => [false, true].flatMap((offset) => precisions.map((precision) => iso_exports.datetime({
local,
offset,
precision
}))));
}
function referencePatternsForFormat(format, pattern) {
let referenceSchemas;
switch (format) {
case "email":
referenceSchemas = [email2()];
break;
case "uri":
referenceSchemas = [url()];
break;
case "date":
referenceSchemas = [iso_exports.date()];
break;
case "date-time":
referenceSchemas = datetimeReferenceSchemas(pattern);
break;
}
return new Set(referenceSchemas.map((schema) => zodEmittedPattern(schema)).filter((emitted) => emitted !== void 0));
}
function isLibraryFormatPattern(format, pattern, vendor) {
if (vendor !== "zod") return true;
return referencePatternsForFormat(format, pattern).has(pattern);
}
function isJsonObject(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function convertStandardElicitationSchema(schema) {
try {
return standardSchemaToJsonSchema(schema, "input");
} catch (error62) {
const detail = error62 instanceof Error ? error62.message : String(error62);
throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Elicitation requestedSchema must describe an object with flat primitive properties: ${detail}`);
}
}
var ANNOTATION_ONLY_JSON_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
"$comment",
"deprecated",
"description",
"examples",
"readOnly",
"title",
"writeOnly"
]);
function isAnnotationOnlyJsonSchemaKeyword(key) {
return ANNOTATION_ONLY_JSON_SCHEMA_KEYWORDS.has(key) || key.startsWith("x-");
}
var ROOT_KEYS = /* @__PURE__ */ new Set(["$schema", ...Object.keys(ElicitRequestFormParamsSchema.shape.requestedSchema.shape)]);
var PROPERTY_KEYS_BY_TYPE = {
string: shapeKeys([
StringSchemaSchema,
UntitledSingleSelectEnumSchemaSchema,
TitledSingleSelectEnumSchemaSchema,
LegacyTitledEnumSchemaSchema
]),
number: shapeKeys([NumberSchemaSchema]),
integer: shapeKeys([NumberSchemaSchema]),
boolean: shapeKeys([BooleanSchemaSchema]),
array: shapeKeys([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema])
};
var SUPPORTED_STRING_FORMATS = new Set(StringSchemaSchema.shape.format.unwrap().options);
function walkProperty(node2, path3, vendor, unsupported) {
if (!isJsonObject(node2)) return node2;
const allowedKeys = typeof node2.type === "string" && Object.hasOwn(PROPERTY_KEYS_BY_TYPE, node2.type) ? PROPERTY_KEYS_BY_TYPE[node2.type] : void 0;
if (allowedKeys === void 0) return node2;
const pruned = {};
for (const [key, value] of Object.entries(node2)) if (allowedKeys.has(key) || isAnnotationOnlyJsonSchemaKeyword(key)) pruned[key] = value;
else if (key === "pattern" && node2.type === "string" && typeof node2.format === "string") {
if (!SUPPORTED_STRING_FORMATS.has(node2.format)) pruned[key] = value;
else if (typeof value !== "string" || !isLibraryFormatPattern(node2.format, value, vendor)) unsupported.push(`${path3}.${key}`);
} else unsupported.push(`${path3}.${key}`);
return pruned;
}
function walkRequestedSchema(converted, vendor) {
const pruned = {};
const unsupported = [];
for (const [key, value] of Object.entries(converted)) if (key === "properties" && isJsonObject(value)) pruned[key] = Object.fromEntries(Object.entries(value).map(([name, node2]) => [name, walkProperty(node2, `properties.${name}`, vendor, unsupported)]));
else if (ROOT_KEYS.has(key)) pruned[key] = value;
else if (!isAnnotationOnlyJsonSchemaKeyword(key)) unsupported.push(key);
if (unsupported.length > 0) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Elicitation requestedSchema contains unsupported JSON Schema constraint(s) after Standard Schema conversion: ${unsupported.join(", ")}`);
return pruned;
}
function describeUnsupportedProperties(pruned, fallback) {
if (!isJsonObject(pruned.properties)) return fallback;
const offenders = Object.entries(pruned.properties).filter(([, node2]) => !parseSchema(PrimitiveSchemaDefinitionSchema, node2).success).map(([name]) => `properties.${name}`);
return offenders.length > 0 ? offenders.join(", ") : fallback;
}
function findDroppedConstraintPaths(original, parsed, path3 = "") {
if (Array.isArray(original) && Array.isArray(parsed)) return original.flatMap((item, index) => findDroppedConstraintPaths(item, parsed[index], `${path3}[${index}]`));
if (!isJsonObject(original) || !isJsonObject(parsed)) return [];
return Object.entries(original).flatMap(([key, value]) => {
const childPath = path3 ? `${path3}.${key}` : key;
if (!Object.prototype.hasOwnProperty.call(parsed, key)) return isAnnotationOnlyJsonSchemaKeyword(key) ? [] : [childPath];
return findDroppedConstraintPaths(value, parsed[key], childPath);
});
}
function normalizeElicitInputParams(input2) {
if (!isStandardSchema(input2.requestedSchema)) return {
...input2,
mode: "form",
requestedSchema: input2.requestedSchema
};
const vendor = input2.requestedSchema["~standard"].vendor;
const pruned = walkRequestedSchema(convertStandardElicitationSchema(input2.requestedSchema), vendor);
const parsed = parseSchema(ElicitRequestFormParamsSchema.shape.requestedSchema, pruned);
if (!parsed.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Elicitation requestedSchema only supports flat primitive properties (string, number, integer, boolean, and string enums): ${describeUnsupportedProperties(pruned, parsed.error.message)}`);
const droppedConstraints = findDroppedConstraintPaths(pruned, parsed.data);
if (droppedConstraints.length > 0) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Elicitation requestedSchema contains unsupported JSON Schema constraint(s) after Standard Schema conversion: ${droppedConstraints.join(", ")}`);
const danglingRequired = (parsed.data.required ?? []).filter((key) => !Object.prototype.hasOwnProperty.call(parsed.data.properties, key));
if (danglingRequired.length > 0) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Elicitation requestedSchema lists required properties that are not defined in properties: ${danglingRequired.join(", ")}`);
return {
...input2,
mode: "form",
requestedSchema: parsed.data
};
}
function buildInputRequired(spec) {
const hasInputRequests = spec.inputRequests !== void 0 && Object.keys(spec.inputRequests).length > 0;
const hasRequestState = typeof spec.requestState === "string";
if (!hasInputRequests && !hasRequestState) throw new TypeError("inputRequired() requires at least one of inputRequests (with at least one entry) or requestState (spec: every InputRequiredResult MUST include at least one of the two)");
return {
resultType: "input_required",
...spec.inputRequests !== void 0 && { inputRequests: spec.inputRequests },
...spec.requestState !== void 0 && { requestState: spec.requestState }
};
}
var inputRequired = Object.assign(buildInputRequired, {
elicit(params) {
try {
return {
method: "elicitation/create",
params: normalizeElicitInputParams(params)
};
} catch (error62) {
throw error62 instanceof ProtocolError ? new TypeError(error62.message, { cause: error62 }) : error62;
}
},
elicitUrl(params) {
return {
method: "elicitation/create",
params: {
...params,
mode: "url"
}
};
},
createMessage(params) {
return {
method: "sampling/createMessage",
params
};
},
listRoots() {
return { method: "roots/list" };
}
});
var DEFAULT_INPUT_REQUIRED_AUTO_FULFILL = true;
var DEFAULT_INPUT_REQUIRED_MAX_ROUNDS = 10;
var REQUEST_STATE_ONLY_LEG_PACING_MS = 250;
function resolveInputRequiredDriverConfig(options) {
return {
autoFulfill: options?.autoFulfill ?? DEFAULT_INPUT_REQUIRED_AUTO_FULFILL,
maxRounds: options?.maxRounds ?? DEFAULT_INPUT_REQUIRED_MAX_ROUNDS
};
}
function buildInputRequiredRetryParams(originalParams, responses, requestState) {
const hasResponses = responses !== void 0 && Object.keys(responses).length > 0;
if (!hasResponses && requestState === void 0) return originalParams;
return {
...originalParams,
...hasResponses && { inputResponses: responses },
...requestState !== void 0 && { requestState }
};
}
function inputRequiredRoundsExceededMessage(method, maxRounds) {
return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
}
function sleep(ms, signal) {
return new Promise((resolve, reject) => {
if (signal?.aborted) {
reject(signal.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal.reason)));
return;
}
const timer = setTimeout(() => {
signal?.removeEventListener("abort", onAbort);
resolve();
}, ms);
const onAbort = () => {
clearTimeout(timer);
reject(signal?.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal?.reason)));
};
signal?.addEventListener("abort", onAbort, { once: true });
});
}
function linkedRoundAbort(outer) {
const controller = new AbortController();
const onOuterAbort = () => controller.abort(outer?.reason);
outer?.addEventListener("abort", onOuterAbort, { once: true });
if (outer?.aborted) controller.abort(outer.reason);
return {
signal: controller.signal,
abort: (reason) => controller.abort(reason),
dispose: () => outer?.removeEventListener("abort", onOuterAbort)
};
}
async function runInputRequiredDriver(args) {
const { config: config2, method, originalParams, requestOptions, hooks, signal } = args;
const startedAt = args.flowStartedAt ?? Date.now();
let payload = args.firstPayload;
let round = 0;
while (true) {
round += 1;
if (round > config2.maxRounds) throw new SdkError(SdkErrorCode.InputRequiredRoundsExceeded, inputRequiredRoundsExceededMessage(method, config2.maxRounds), {
rounds: config2.maxRounds,
lastResult: {
inputRequests: payload.inputRequests,
...payload.requestState !== void 0 && { requestState: payload.requestState }
}
});
requestOptions.onprogress?.({
progress: round,
message: `Fulfilling input required by '${method}' (round ${round})`
});
const entries = Object.entries(payload.inputRequests ?? {});
let responses;
if (entries.length > 0) {
const round$1 = linkedRoundAbort(signal);
try {
const fulfilled = await Promise.all(entries.map(async ([key, entry]) => {
try {
return [key, await hooks.dispatchInputRequest(key, entry, round$1.signal)];
} catch (error62) {
round$1.abort(error62);
throw error62;
}
}));
responses = Object.fromEntries(fulfilled);
} finally {
round$1.dispose();
}
} else await sleep(REQUEST_STATE_ONLY_LEG_PACING_MS, signal);
const legOptions = { ...requestOptions.timeout !== void 0 && { timeout: requestOptions.timeout } };
if (requestOptions.maxTotalTimeout !== void 0) {
const totalElapsed = Date.now() - startedAt;
const remaining = requestOptions.maxTotalTimeout - totalElapsed;
if (remaining <= 0) throw new SdkError(SdkErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
maxTotalTimeout: requestOptions.maxTotalTimeout,
totalElapsed
});
legOptions.maxTotalTimeout = remaining;
}
const result = await hooks.retry(buildInputRequiredRetryParams(originalParams, responses, payload.requestState), legOptions);
if (isInputRequiredResult(result)) {
payload = {
inputRequests: result.inputRequests ?? {},
...result.requestState !== void 0 && { requestState: result.requestState }
};
continue;
}
return result;
}
}
var SPEC_SCHEMA_KEYS = [
"AnnotationsSchema",
"AudioContentSchema",
"BaseMetadataSchema",
"BlobResourceContentsSchema",
"BooleanSchemaSchema",
"CallToolRequestSchema",
"CallToolRequestParamsSchema",
"CallToolResultSchema",
"CancelledNotificationSchema",
"CancelledNotificationParamsSchema",
"CancelTaskRequestSchema",
"CancelTaskResultSchema",
"ClientCapabilitiesSchema",
"ClientNotificationSchema",
"ClientRequestSchema",
"ClientResultSchema",
"CompatibilityCallToolResultSchema",
"CompleteRequestSchema",
"CompleteRequestParamsSchema",
"CompleteResultSchema",
"ContentBlockSchema",
"CreateMessageRequestSchema",
"CreateMessageRequestParamsSchema",
"CreateMessageResultSchema",
"CreateMessageResultWithToolsSchema",
"CreateTaskResultSchema",
"CursorSchema",
"DiscoverRequestSchema",
"DiscoverResultSchema",
"ElicitationCompleteNotificationSchema",
"ElicitationCompleteNotificationParamsSchema",
"ElicitRequestSchema",
"ElicitRequestFormParamsSchema",
"ElicitRequestParamsSchema",
"ElicitRequestURLParamsSchema",
"ElicitResultSchema",
"EmbeddedResourceSchema",
"EmptyResultSchema",
"EnumSchemaSchema",
"GetPromptRequestSchema",
"GetPromptRequestParamsSchema",
"GetPromptResultSchema",
"GetTaskPayloadRequestSchema",
"GetTaskPayloadResultSchema",
"GetTaskRequestSchema",
"GetTaskResultSchema",
"IconSchema",
"IconsSchema",
"ImageContentSchema",
"ImplementationSchema",
"InitializedNotificationSchema",
"InitializeRequestSchema",
"InitializeRequestParamsSchema",
"InitializeResultSchema",
"JSONArraySchema",
"JSONObjectSchema",
"JSONRPCErrorResponseSchema",
"JSONRPCMessageSchema",
"JSONRPCNotificationSchema",
"JSONRPCRequestSchema",
"JSONRPCResponseSchema",
"JSONRPCResultResponseSchema",
"JSONValueSchema",
"LegacyTitledEnumSchemaSchema",
"ListPromptsRequestSchema",
"ListPromptsResultSchema",
"ListResourcesRequestSchema",
"ListResourcesResultSchema",
"ListResourceTemplatesRequestSchema",
"ListResourceTemplatesResultSchema",
"ListRootsRequestSchema",
"ListRootsResultSchema",
"ListTasksRequestSchema",
"ListTasksResultSchema",
"ListToolsRequestSchema",
"ListToolsResultSchema",
"LoggingLevelSchema",
"LoggingMessageNotificationSchema",
"LoggingMessageNotificationParamsSchema",
"ModelHintSchema",
"ModelPreferencesSchema",
"MultiSelectEnumSchemaSchema",
"NotificationSchema",
"NumberSchemaSchema",
"PaginatedRequestSchema",
"PaginatedRequestParamsSchema",
"PaginatedResultSchema",
"PingRequestSchema",
"PrimitiveSchemaDefinitionSchema",
"ProgressSchema",
"ProgressNotificationSchema",
"ProgressNotificationParamsSchema",
"ProgressTokenSchema",
"PromptSchema",
"PromptArgumentSchema",
"PromptListChangedNotificationSchema",
"PromptMessageSchema",
"PromptReferenceSchema",
"ReadResourceRequestSchema",
"ReadResourceRequestParamsSchema",
"ReadResourceResultSchema",
"RelatedTaskMetadataSchema",
"RequestSchema",
"RequestIdSchema",
"RequestMetaSchema",
"ResourceSchema",
"ResourceContentsSchema",
"ResourceLinkSchema",
"ResourceListChangedNotificationSchema",
"ResourceRequestParamsSchema",
"ResourceTemplateSchema",
"ResourceTemplateReferenceSchema",
"ResourceUpdatedNotificationSchema",
"ResourceUpdatedNotificationParamsSchema",
"ResultMetaObjectSchema",
"ResultSchema",
"RoleSchema",
"RootSchema",
"RootsListChangedNotificationSchema",
"SamplingContentSchema",
"SamplingMessageSchema",
"SamplingMessageContentBlockSchema",
"ServerCapabilitiesSchema",
"ServerNotificationSchema",
"ServerRequestSchema",
"ServerResultSchema",
"SetLevelRequestSchema",
"SetLevelRequestParamsSchema",
"SingleSelectEnumSchemaSchema",
"StringSchemaSchema",
"SubscribeRequestSchema",
"SubscribeRequestParamsSchema",
"SubscriptionFilterSchema",
"SubscriptionsAcknowledgedNotificationSchema",
"SubscriptionsAcknowledgedNotificationParamsSchema",
"SubscriptionsListenRequestSchema",
"SubscriptionsListenRequestParamsSchema",
"SubscriptionsListenResultSchema",
"SubscriptionsListenResultMetaSchema",
"TaskAugmentedRequestParamsSchema",
"TaskCreationParamsSchema",
"TaskMetadataSchema",
"TaskSchema",
"TaskStatusSchema",
"TaskStatusNotificationSchema",
"TaskStatusNotificationParamsSchema",
"TextContentSchema",
"TextResourceContentsSchema",
"TitledMultiSelectEnumSchemaSchema",
"TitledSingleSelectEnumSchemaSchema",
"ToolSchema",
"ToolAnnotationsSchema",
"ToolChoiceSchema",
"ToolExecutionSchema",
"ToolListChangedNotificationSchema",
"ToolResultContentSchema",
"ToolUseContentSchema",
"UnsubscribeRequestSchema",
"UnsubscribeRequestParamsSchema",
"UntitledMultiSelectEnumSchemaSchema",
"UntitledSingleSelectEnumSchemaSchema"
];
var authSchemas = {
IdJagTokenExchangeResponseSchema,
OAuthClientInformationFullSchema,
OAuthClientInformationSchema,
OAuthClientMetadataSchema,
OAuthClientRegistrationErrorSchema,
OAuthErrorResponseSchema,
OAuthMetadataSchema,
OAuthProtectedResourceMetadataSchema,
OAuthTokenRevocationRequestSchema,
OAuthTokensSchema,
OpenIdProviderDiscoveryMetadataSchema,
OpenIdProviderMetadataSchema
};
var _specTypeSchemas = {};
var _isSpecType = {};
function register(key, schema) {
const name = key.slice(0, -6);
_specTypeSchemas[name] = schema;
_isSpecType[name] = (v) => schema.safeParse(v).success;
}
for (const key of SPEC_SCHEMA_KEYS) register(key, schemas_exports3[key]);
for (const [key, schema] of Object.entries(authSchemas)) register(key, schema);
var specTypeSchemas = Object.freeze(_specTypeSchemas);
var isSpecType = Object.freeze(_isSpecType);
function bootstrapOutboundCodec(method) {
switch (method) {
case "initialize":
case "notifications/initialized":
return codecForVersion(void 0);
case "server/discover":
return codecForVersion(MODERN_WIRE_REVISION);
default:
return;
}
}
var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
var RESERVED_ENVELOPE_META_KEYS = [
PROTOCOL_VERSION_META_KEY,
CLIENT_INFO_META_KEY,
CLIENT_CAPABILITIES_META_KEY,
LOG_LEVEL_META_KEY
];
var RETRY_PARAMS_KEYS = ["inputResponses", "requestState"];
function liftWireOnlyMaterial(message, kind) {
const params = message.params;
if (!isPlainObject$1(params)) return {
message,
lifted: {}
};
const meta3 = params._meta;
const envelopeKeys = isPlainObject$1(meta3) ? RESERVED_ENVELOPE_META_KEYS.filter((key) => key in meta3) : [];
const retryKeys = kind === "request" ? RETRY_PARAMS_KEYS.filter((key) => key in params) : [];
if (envelopeKeys.length === 0 && retryKeys.length === 0) return {
message,
lifted: {}
};
const lifted = {};
const nextParams = { ...params };
if (envelopeKeys.length > 0 && isPlainObject$1(meta3)) {
const envelope = {};
const nextMeta = { ...meta3 };
for (const key of envelopeKeys) {
envelope[key] = meta3[key];
delete nextMeta[key];
}
lifted.envelope = envelope;
if (Object.keys(nextMeta).length > 0) nextParams._meta = nextMeta;
else delete nextParams._meta;
}
for (const key of retryKeys) {
if (key === "inputResponses") lifted.inputResponses = nextParams[key];
if (key === "requestState") lifted.requestState = nextParams[key];
delete nextParams[key];
}
return {
message: {
...message,
params: nextParams
},
lifted
};
}
function codecResultValidator(codec2, method) {
const probe = codec2.validateResult(method, void 0);
if (!probe.ok && probe.reason === "not-in-era") return void 0;
return { "~standard": {
version: 1,
vendor: "mcp-wire-codec",
validate(value) {
const outcome = codec2.validateResult(method, value);
if (outcome.ok) return { value: outcome.value };
return { issues: [{ message: outcome.reason === "invalid" ? outcome.message : `not-in-era: ${method}` }] };
}
} };
}
function requestStateAccessor(value) {
return () => value;
}
var NO_REQUEST_STATE = requestStateAccessor(void 0);
var writeNegotiatedProtocolVersion;
var Protocol = class {
_transport;
_requestMessageId = 0;
_requestHandlers = /* @__PURE__ */ new Map();
/** Methods registered with an explicit schema; the era gate in `_onrequest` reads it for the Tasks extension names. */
_customSchemaRequestMethods = /* @__PURE__ */ new Set();
_requestHandlerAbortControllers = /* @__PURE__ */ new Map();
_notificationHandlers = /* @__PURE__ */ new Map();
_responseHandlers = /* @__PURE__ */ new Map();
_progressHandlers = /* @__PURE__ */ new Map();
_timeoutInfo = /* @__PURE__ */ new Map();
_pendingDebouncedNotifications = /* @__PURE__ */ new Set();
/**
* The protocol version negotiated for the current connection (`undefined`
* before negotiation completes), which determines the wire era this
* instance speaks. Set by the SDK's negotiation and initialize paths
* (`Client.connect`, `Server._oninitialize`).
*/
_negotiatedProtocolVersion;
static {
writeNegotiatedProtocolVersion = (instance, version3) => {
instance._negotiatedProtocolVersion = version3;
};
}
_supportedProtocolVersions;
/**
* Callback for when the connection is closed for any reason.
*
* This is invoked when {@linkcode Protocol.close | close()} is called as well.
*/
onclose;
/**
* Callback for when an error occurs.
*
* Note that errors are not necessarily fatal; they are used for reporting any kind of exceptional condition out of band.
*/
onerror;
/**
* A handler to invoke for any request types that do not have their own handler installed.
*/
fallbackRequestHandler;
/**
* A handler to invoke for any notification types that do not have their own handler installed.
*/
fallbackNotificationHandler;
constructor(_options) {
this._options = _options;
this._supportedProtocolVersions = _options?.supportedProtocolVersions ?? SUPPORTED_PROTOCOL_VERSIONS;
this.setNotificationHandler("notifications/cancelled", (notification) => {
this._oncancel(notification);
});
this.setNotificationHandler("notifications/progress", (notification) => {
this._onprogress(notification);
});
this.setRequestHandler("ping", (_request) => ({}));
}
/**
* Drop consult for inbound messages whose transport did not classify them
* at the edge — long-lived channels such as stdio, where a role class may
* need to decline traffic the negotiated era has no answer for (the
* client-side inbound-request drop on modern-era connections: the
* 2026-07-28 era has no server→client request channel, and on stdio the
* client must never write JSON-RPC responses).
*
* Consulted ONLY when the transport supplied no
* {@linkcode MessageExtraInfo.classification}: edge-classified traffic
* never reaches the hook. Returning `'drop'` discards the message without
* writing any response (requests are surfaced via `onerror`). The base
* implementation returns `undefined`: unclassified traffic keeps today's
* dispatch path unchanged. Era selection never happens here — era is
* instance state, owned by the serving entry that constructed and
* connected the instance.
*/
_shouldDropInbound(_message) {
}
/**
* The per-request `_meta` envelope this instance attaches to every outgoing
* request and notification, when one applies. The base implementation
* returns `undefined` (no envelope — the 2025-era posture, so legacy-era
* outbound traffic is byte-identical to a build without this seam).
* `Client` overrides it on a connection that negotiated a modern (2026-07-28+)
* era to return the reserved protocol-version / client-info /
* client-capabilities keys. User-supplied `_meta` keys take precedence over
* the auto-attached ones.
*/
_outboundMetaEnvelope() {
}
/**
* Attach this instance's outbound `_meta` envelope (when one is configured)
* to a request or notification. A no-op when the seam returns `undefined`
* — the message returns by reference, so the legacy-era wire stays
* byte-identical. User-supplied `_meta` keys are spread last so they win
* over the auto-attached envelope keys.
*/
_envelopeOutbound(message) {
const envelope = this._outboundMetaEnvelope();
if (envelope === void 0) return message;
const params = message.params ?? {};
return {
...message,
params: {
...params,
_meta: {
...envelope,
...params._meta
}
}
};
}
/**
* Extension point for non-`complete` decoded results in the response
* funnel: a result the wire codec discriminated into a kind other than
* `'complete'` or `'invalid'` is handed here for the role class to
* resolve. The base default surfaces it as a typed
* {@linkcode SdkErrorCode.UnsupportedResultType} error (no retry).
*
* Intended consumers (named so the seam stays accountable):
* - the `Client`'s multi-round-trip auto-fulfilment engine, which fulfils
* `'input_required'` results through the registered
* elicitation/sampling/roots handlers and retries via `flow.retry`;
* - a future client-side terminal-result handler for
* `subscriptions/listen`, when the spec defines one.
*
* `Server` instances never receive `input_required` responses on their
* outbound legs and leave the base behavior in place.
*/
_resolveNonCompleteResult(decoded, flow) {
return Promise.reject(new SdkError(SdkErrorCode.UnsupportedResultType, `Unsupported result type '${decoded.kind}' for ${flow.request.method}`, {
resultType: decoded.kind,
method: flow.request.method
}));
}
/**
* Protected accessor for a registered request handler. Used by role
* classes that dispatch synthesized requests through the same stored
* handler chain (e.g. the `Client` fulfilling an embedded multi-round-trip
* input request).
*/
_getRequestHandler(method) {
return this._requestHandlers.get(method);
}
async _oncancel(notification) {
if (notification.params.requestId === void 0) return;
this._requestHandlerAbortControllers.get(notification.params.requestId)?.abort(notification.params.reason);
}
_setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
this._timeoutInfo.set(messageId, {
timeoutId: setTimeout(onTimeout, timeout),
startTime: Date.now(),
timeout,
maxTotalTimeout,
resetTimeoutOnProgress,
onTimeout
});
}
_resetTimeout(messageId) {
const info = this._timeoutInfo.get(messageId);
if (!info) return false;
const totalElapsed = Date.now() - info.startTime;
if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
this._timeoutInfo.delete(messageId);
throw new SdkError(SdkErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
maxTotalTimeout: info.maxTotalTimeout,
totalElapsed
});
}
clearTimeout(info.timeoutId);
info.timeoutId = setTimeout(info.onTimeout, info.timeout);
return true;
}
_cleanupTimeout(messageId) {
const info = this._timeoutInfo.get(messageId);
if (info) {
clearTimeout(info.timeoutId);
this._timeoutInfo.delete(messageId);
}
}
/**
* Attaches to the given transport, starts it, and starts listening for messages.
*
* The caller assumes ownership of the {@linkcode Transport}, replacing any callbacks that have already been set, and expects that it is the only user of the {@linkcode Transport} instance going forward.
*/
async connect(transport) {
this._transport = transport;
const _onclose = this.transport?.onclose;
this._transport.onclose = () => {
try {
_onclose?.();
} finally {
this._onclose();
}
};
const _onerror = this.transport?.onerror;
this._transport.onerror = (error62) => {
_onerror?.(error62);
this._onerror(error62);
};
const _onmessage = this._transport?.onmessage;
this._transport.onmessage = (message, extra) => {
_onmessage?.(message, extra);
if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) this._onresponse(message);
else if (isJSONRPCRequest(message)) this._onrequest(message, extra);
else if (isJSONRPCNotification(message)) this._onnotification(message, extra);
else this._onerror(/* @__PURE__ */ new Error(`Unknown message type: ${JSON.stringify(message)}`));
};
transport.setSupportedProtocolVersions?.(this._supportedProtocolVersions);
await this._transport.start();
}
/**
* Transport-close hook. Subclass overrides MUST call `super._onclose()`
* after their own cleanup — base teardown (response-handler settlement,
* timeout clearing, in-flight request abort) does not run otherwise.
*/
_onclose() {
const responseHandlers = this._responseHandlers;
this._responseHandlers = /* @__PURE__ */ new Map();
this._progressHandlers.clear();
this._pendingDebouncedNotifications.clear();
for (const info of this._timeoutInfo.values()) clearTimeout(info.timeoutId);
this._timeoutInfo.clear();
const requestHandlerAbortControllers = this._requestHandlerAbortControllers;
this._requestHandlerAbortControllers = /* @__PURE__ */ new Map();
const error62 = new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed");
this._transport = void 0;
try {
this.onclose?.();
} finally {
for (const handler of responseHandlers.values()) handler(error62);
for (const controller of requestHandlerAbortControllers.values()) controller.abort(error62);
}
}
_onerror(error62) {
this.onerror?.(error62);
}
/**
* Inbound-notification dispatch. Subclass overrides MUST delegate
* unmatched traffic to `super._onnotification(rawNotification, extra)` —
* an override that consumes only what it owns and falls through to base
* dispatch for everything else.
*/
_onnotification(rawNotification, extra) {
const { message: notification } = liftWireOnlyMaterial(rawNotification, "notification");
const codec2 = this._negotiatedWireCodec();
if (extra?.classification === void 0 && this._shouldDropInbound(rawNotification) === "drop") return;
if (extra?.classification !== void 0) {
const classified = classifiedWireEra(extra.classification);
if (classified !== codec2.era) {
this._onerror(/* @__PURE__ */ new Error(`Era mismatch on inbound notification '${notification.method}': classified as ${classified} but this instance serves ${codec2.era}`));
return;
}
}
if (isSpecNotificationMethod(notification.method) && !codec2.hasNotificationMethod(notification.method)) return;
const handler = this._notificationHandlers.get(notification.method);
const fallback = this.fallbackNotificationHandler;
if (handler === void 0 && fallback === void 0) return;
Promise.resolve().then(() => handler === void 0 ? fallback(notification) : handler(notification, codec2)).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Uncaught error in notification handler: ${error62}`)));
}
_onrequest(rawRequest, extra) {
const { message: request, lifted } = liftWireOnlyMaterial(rawRequest, "request");
const codec2 = this._negotiatedWireCodec();
if (extra?.classification === void 0 && this._shouldDropInbound(rawRequest) === "drop") {
this._onerror(/* @__PURE__ */ new Error(`Dropped inbound request '${rawRequest.method}': not servable on this connection's protocol era`));
return;
}
const capturedTransport = this._transport;
const sendErrorResponse = (code, message, data) => {
const errorResponse = {
jsonrpc: "2.0",
id: request.id,
error: {
code,
message,
...data !== void 0 && { data }
}
};
capturedTransport?.send(errorResponse).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send an error response: ${error62}`)));
};
if (extra?.classification !== void 0) {
const classified = classifiedWireEra(extra.classification);
if (classified !== codec2.era) {
this._onerror(/* @__PURE__ */ new Error(`Era mismatch on inbound request '${request.method}': classified as ${classified} but this instance serves ${codec2.era}`));
const requested = extra.classification.revision ?? classified;
sendErrorResponse(ProtocolErrorCode.UnsupportedProtocolVersion, `Unsupported protocol version: ${requested}`, {
supported: this._supportedProtocolVersions,
requested
});
return;
}
}
if (isSpecRequestMethod(request.method) && !codec2.hasRequestMethod(request.method) && !(isExtensionReusedRequestMethod(request.method) && this._customSchemaRequestMethods.has(request.method))) {
sendErrorResponse(ProtocolErrorCode.MethodNotFound, "Method not found");
return;
}
const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
if (handler === void 0) {
sendErrorResponse(ProtocolErrorCode.MethodNotFound, "Method not found");
return;
}
const envelopeError = codec2.checkInboundEnvelope(lifted);
if (envelopeError !== void 0) {
sendErrorResponse(ProtocolErrorCode.InvalidParams, envelopeError);
return;
}
const sendNotification = (notification, options) => this._notificationViaCodec(this._resolveOutboundCodec(notification.method), notification, {
...options,
relatedRequestId: request.id
});
const sendRequest = (r, resultSchema, options) => this._requestWithSchemaViaCodec(this._resolveOutboundCodec(r.method), r, resultSchema, {
...options,
relatedRequestId: request.id
});
const abortController = new AbortController();
this._requestHandlerAbortControllers.set(request.id, abortController);
const partitionedInputResponses = lifted.inputResponses === void 0 ? void 0 : partitionInputResponses(lifted.inputResponses);
const baseCtx = {
sessionId: capturedTransport?.sessionId,
mcpReq: {
id: request.id,
method: request.method,
_meta: request.params?._meta,
...lifted.envelope !== void 0 && { envelope: lifted.envelope },
...partitionedInputResponses !== void 0 && { inputResponses: partitionedInputResponses.accepted },
...partitionedInputResponses !== void 0 && partitionedInputResponses.droppedKeys.length > 0 && { droppedInputResponseKeys: partitionedInputResponses.droppedKeys },
requestState: lifted.requestState === void 0 ? NO_REQUEST_STATE : requestStateAccessor(lifted.requestState),
signal: abortController.signal,
send: (r, schemaOrOptions, maybeOptions) => {
const sendCodec = this._resolveOutboundCodec(r.method);
this._assertOutboundRequestInEra(sendCodec, r.method);
if (isStandardSchema(schemaOrOptions)) return sendRequest(r, schemaOrOptions, maybeOptions);
const validate2 = codecResultValidator(sendCodec, r.method);
if (validate2 === void 0) throw new TypeError(`'${r.method}' is not a spec method; pass a result schema as the second argument to ctx.mcpReq.send().`);
return sendRequest(r, validate2, schemaOrOptions);
},
notify: sendNotification
},
http: extra?.authInfo ? { authInfo: extra.authInfo } : void 0
};
const ctx = this.buildContext(baseCtx, extra);
Promise.resolve().then(() => handler(request, ctx)).then(async (result) => {
if (abortController.signal.aborted) return;
let encoded;
try {
encoded = codec2.encodeResult(request.method, result, this._outboundServerInfo());
} catch (error62) {
this._onerror(/* @__PURE__ */ new Error(`Failed to encode result for ${request.method}: ${error62}`));
sendErrorResponse(ProtocolErrorCode.InternalError, "Internal error");
return;
}
const response = {
result: encoded,
jsonrpc: "2.0",
id: request.id
};
await capturedTransport?.send(response);
}, async (error62) => {
if (abortController.signal.aborted) return;
const thrownCode = Number.isSafeInteger(error62["code"]) ? error62["code"] : ProtocolErrorCode.InternalError;
const errorResponse = {
jsonrpc: "2.0",
id: request.id,
error: {
code: codec2.encodeErrorCode(thrownCode),
message: error62.message ?? "Internal error",
...error62["data"] !== void 0 && { data: error62["data"] }
}
};
await capturedTransport?.send(errorResponse);
}).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send response: ${error62}`))).finally(() => {
if (this._requestHandlerAbortControllers.get(request.id) === abortController) this._requestHandlerAbortControllers.delete(request.id);
});
}
_onprogress(notification) {
const { progressToken, ...params } = notification.params;
const messageId = Number(progressToken);
const handler = this._progressHandlers.get(messageId);
if (!handler) {
this._onerror(/* @__PURE__ */ new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
return;
}
const responseHandler = this._responseHandlers.get(messageId);
const timeoutInfo = this._timeoutInfo.get(messageId);
if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) try {
this._resetTimeout(messageId);
} catch (error62) {
this._responseHandlers.delete(messageId);
this._progressHandlers.delete(messageId);
this._cleanupTimeout(messageId);
responseHandler(error62);
return;
}
handler(params);
}
/**
* Inbound-response dispatch. Subclass overrides MUST delegate unmatched
* traffic to `super._onresponse(response)` — an override that consumes
* only what it owns and falls through to base dispatch for everything
* else.
*/
_onresponse(response) {
const messageId = Number(response.id);
const handler = this._responseHandlers.get(messageId);
if (handler === void 0) {
this._onerror(/* @__PURE__ */ new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
return;
}
this._responseHandlers.delete(messageId);
this._cleanupTimeout(messageId);
this._progressHandlers.delete(messageId);
if (isJSONRPCResultResponse(response)) handler(response);
else handler(ProtocolError.fromError(response.error.code, response.error.message, response.error.data));
}
get transport() {
return this._transport;
}
/**
* Closes the connection.
*/
async close() {
await this._transport?.close();
}
request(request, schemaOrOptions, maybeOptions) {
const codec2 = this._resolveOutboundCodec(request.method);
if (isStandardSchema(schemaOrOptions)) {
if (!isExtensionReusedRequestMethod(request.method)) this._assertOutboundRequestInEra(codec2, request.method);
return this._requestWithSchemaViaCodec(codec2, request, schemaOrOptions, maybeOptions);
}
this._assertOutboundRequestInEra(codec2, request.method);
const validate2 = codecResultValidator(codec2, request.method);
if (validate2 === void 0) throw new TypeError(`'${request.method}' is not a spec method; pass a result schema as the second argument to request().`);
return this._requestWithSchemaViaCodec(codec2, request, validate2, schemaOrOptions);
}
/**
* The wire codec for this instance's negotiated era — the phase-2 truth:
* everything an established connection sends and receives resolves
* through it. Legacy until a version has been negotiated.
*/
_negotiatedWireCodec() {
return codecForVersion(this._negotiatedProtocolVersion);
}
/**
* Protected accessor for the instance's negotiated wire codec, for role
* classes (Client/Server/McpServer) routing era-dependent behavior
* through the codec's function-only surface — `samplingResultVariant`,
* `outboundEnvelope`, `projectCallToolResult` — instead of branching on
* the protocol version themselves.
*/
_wireCodec() {
return this._negotiatedWireCodec();
}
/**
* Outbound codec resolution: while the negotiated version is still unset
* (the negotiation window), lifecycle messages are bootstrap-pinned BY
* METHOD — they self-identify their era (`initialize` IS the legacy
* handshake, `server/discover` IS the modern probe). Once a version has
* been negotiated, the instance era is authoritative for everything — a
* negotiated session never re-routes a method onto the other era.
*/
_resolveOutboundCodec(method) {
if (this._negotiatedProtocolVersion === void 0) {
const pinned = bootstrapOutboundCodec(method);
if (pinned) return pinned;
}
return this._negotiatedWireCodec();
}
/**
* Era gate for outbound requests — deletions are physical in BOTH
* directions: sending a spec method that the resolved era does not define
* dies locally with a typed error before anything reaches the transport.
* Methods outside the spec universe are consumer-owned extension methods
* and stay era-blind.
*/
_assertOutboundRequestInEra(codec2, method) {
if (isSpecRequestMethod(method) && !codec2.hasRequestMethod(method)) throw new SdkError(SdkErrorCode.MethodNotSupportedByProtocolVersion, `Method '${method}' is not supported by the negotiated protocol version (wire era ${codec2.era})`, {
method,
era: codec2.era
});
}
/**
* Sends a request and waits for a response, using the provided schema for
* validation instead of the era registry's method-keyed entry.
*
* This is the internal implementation used by SDK methods whose result
* schema cannot be expressed as a method-keyed registry entry — the one
* surviving case is `server.createMessage`, whose result schema depends
* on the REQUEST params (tools vs no tools) — and by callers passing
* explicit compatibility schemas. Spec methods are still era-gated here:
* an explicit schema never smuggles a deleted method onto the wire.
*/
_requestWithSchema(request, resultSchema, options) {
const codec2 = this._resolveOutboundCodec(request.method);
this._assertOutboundRequestInEra(codec2, request.method);
return this._requestWithSchemaViaCodec(codec2, request, resultSchema, options);
}
/**
* The request funnel proper, keyed by the resolved era codec: the codec
* owns result decoding (raw-first `resultType` discrimination — V-1 —
* and the era's lift posture) before the schema validation step.
*/
_requestWithSchemaViaCodec(codec2, request, resultSchema, options) {
const { relatedRequestId, resumptionToken, onresumptiontoken, headers } = options ?? {};
const flowStartedAt = Date.now();
let onAbort;
let cleanupMessageId;
return new Promise((resolve, reject) => {
const earlyReject = (error62) => {
reject(error62);
};
if (!this._transport) {
earlyReject(/* @__PURE__ */ new Error("Not connected"));
return;
}
if (this._options?.enforceStrictCapabilities === true) try {
this.assertCapabilityForMethod(request.method);
} catch (error62) {
earlyReject(error62);
return;
}
if (options?.signal?.aborted) {
const reason = options.signal.reason;
throw reason instanceof SdkError ? reason : new SdkError(SdkErrorCode.RequestTimeout, String(reason));
}
const requestAbort = codec2.era === MODERN_WIRE_REVISION && this._transport.hasPerRequestStream === true ? new AbortController() : void 0;
const messageId = this._requestMessageId++;
cleanupMessageId = messageId;
const jsonrpcRequest = {
...request,
jsonrpc: "2.0",
id: messageId
};
if (options?.onprogress) {
this._progressHandlers.set(messageId, options.onprogress);
jsonrpcRequest.params = {
...request.params,
_meta: {
...request.params?._meta,
progressToken: messageId
}
};
}
const outbound = this._envelopeOutbound(jsonrpcRequest);
let responseReceived = false;
const cancel = (reason) => {
if (responseReceived) return;
this._progressHandlers.delete(messageId);
if (requestAbort === void 0) {
if (request.method !== "initialize") this._transport?.send(this._envelopeOutbound({
jsonrpc: "2.0",
method: "notifications/cancelled",
params: {
requestId: messageId,
reason: String(reason)
}
}), {
relatedRequestId,
resumptionToken,
onresumptiontoken
}).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error62}`)));
} else requestAbort.abort();
reject(reason instanceof SdkError ? reason : new SdkError(SdkErrorCode.RequestTimeout, String(reason)));
};
this._responseHandlers.set(messageId, (response) => {
if (options?.signal?.aborted) return;
responseReceived = true;
if (response instanceof Error) return reject(response);
let decoded;
try {
decoded = codec2.decodeResult(request.method, response.result);
} catch (error62) {
return reject(error62 instanceof Error ? error62 : new Error(String(error62)));
}
if (decoded.kind === "invalid") return reject(decoded.error);
if (decoded.kind === "input_required") {
if (options?.allowInputRequired === true) return resolve(manualInputRequiredValue(decoded));
const flow = {
codec: codec2,
request,
resultSchema,
options,
flowStartedAt,
retry: (params, legOptions) => this._requestWithSchemaViaCodec(codec2, params === void 0 ? { method: request.method } : {
method: request.method,
params
}, resultSchema, legOptions)
};
return resolve(this._resolveNonCompleteResult(decoded, flow));
}
const result = decoded.result;
validateStandardSchema(resultSchema, result).then((parseResult) => {
if (parseResult.success) resolve(parseResult.data);
else reject(new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${request.method}: ${parseResult.error}`));
}, reject);
});
onAbort = () => cancel(options?.signal?.reason);
options?.signal?.addEventListener("abort", onAbort, { once: true });
const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
const timeoutHandler = () => cancel(new SdkError(SdkErrorCode.RequestTimeout, "Request timed out", { timeout }));
this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
this._transport.send(outbound, {
relatedRequestId,
resumptionToken,
onresumptiontoken,
headers,
requestSignal: requestAbort?.signal
}).catch((error62) => {
this._progressHandlers.delete(messageId);
reject(error62);
});
}).finally(() => {
if (onAbort) options?.signal?.removeEventListener("abort", onAbort);
if (cleanupMessageId !== void 0) {
this._responseHandlers.delete(cleanupMessageId);
this._cleanupTimeout(cleanupMessageId);
}
});
}
/**
* Emits a notification, which is a one-way message that does not expect a response.
*/
async notification(notification, options) {
return await this._notificationViaCodec(this._resolveOutboundCodec(notification.method), notification, options);
}
/**
* The notification funnel proper, keyed by the resolved era codec —
* direct sends and related notifications (`ctx.mcpReq.notify`) alike
* resolve through the instance's negotiated era at send time.
*/
async _notificationViaCodec(codec2, notification, options) {
if (!this._transport) throw new SdkError(SdkErrorCode.NotConnected, "Not connected");
if (isSpecNotificationMethod(notification.method) && !codec2.hasNotificationMethod(notification.method)) throw new SdkError(SdkErrorCode.MethodNotSupportedByProtocolVersion, `Notification '${notification.method}' is not supported by the negotiated protocol version (wire era ${codec2.era})`, {
method: notification.method,
era: codec2.era
});
this.assertNotificationCapability(notification.method);
const jsonrpcNotification = this._envelopeOutbound({
jsonrpc: "2.0",
...notification
});
if ((this._options?.debouncedNotificationMethods ?? []).includes(notification.method) && !notification.params && options?.relatedRequestId === void 0) {
if (this._pendingDebouncedNotifications.has(notification.method)) return;
this._pendingDebouncedNotifications.add(notification.method);
Promise.resolve().then(() => {
this._pendingDebouncedNotifications.delete(notification.method);
if (!this._transport) return;
this._transport?.send(jsonrpcNotification, options).catch((error62) => this._onerror(error62));
});
return;
}
await this._transport.send(jsonrpcNotification, options);
}
setRequestHandler(method, schemasOrHandler, maybeHandler) {
this.assertRequestHandlerCapability(method);
let stored;
if (typeof schemasOrHandler === "function") {
if (!isSpecRequestMethod(method)) throw new TypeError(`'${method}' is not a spec request method; pass schemas as the second argument to setRequestHandler().`);
stored = (request, ctx) => {
const dispatchCodec = this._negotiatedWireCodec();
let outcome = dispatchCodec.validateRequest(method, request);
if (!outcome.ok && outcome.reason === "not-in-era") outcome = dispatchCodec.validateInputRequest(method, request);
if (!outcome.ok) {
if (outcome.reason === "not-in-era") throw new ProtocolError(ProtocolErrorCode.InternalError, `No wire schema for ${method} in the resolved era`);
throw new Error(outcome.message);
}
return Promise.resolve(schemasOrHandler(outcome.value, ctx));
};
} else if (maybeHandler) stored = async (request, ctx) => {
const parsed = await validateStandardSchema(schemasOrHandler.params, { ...request.params });
if (!parsed.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid params for ${method}: ${parsed.error}`);
return maybeHandler(parsed.data, ctx);
};
else throw new TypeError("setRequestHandler: handler is required");
if (typeof schemasOrHandler === "function") this._customSchemaRequestMethods.delete(method);
else this._customSchemaRequestMethods.add(method);
this._requestHandlers.set(method, this._wrapHandler(method, stored));
}
/**
* Hook for subclasses to wrap a registered request handler with role-specific
* validation or behavior (e.g. `Server` validates `tools/call` results, `Client`
* validates `elicitation/create` mode and result). Runs for both the 2-arg and
* 3-arg registration paths. The default implementation is identity.
*
* Subclasses overriding this hook avoid redeclaring `setRequestHandler`'s overload set.
*/
_wrapHandler(_method, handler) {
return handler;
}
/**
* Hook for subclasses to supply the implementation identity the 2026-era
* encode seam stamps into outbound result `_meta` under
* `io.modelcontextprotocol/serverInfo` (spec PR #3002: servers SHOULD
* identify themselves on every response). The default is `undefined` — no
* stamp. Only `Server` overrides this: the key identifies the software
* producing a response, and the 2025-era codec never stamps anything
* regardless (the never-stamp guarantee).
*/
_outboundServerInfo() {
}
/**
* Removes the request handler for the given method.
*/
removeRequestHandler(method) {
this._requestHandlers.delete(method);
this._customSchemaRequestMethods.delete(method);
}
/**
* Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
*/
assertCanSetRequestHandler(method) {
if (this._requestHandlers.has(method)) throw new Error(`A request handler for ${method} already exists, which would be overridden`);
}
setNotificationHandler(method, schemasOrHandler, maybeHandler) {
if (typeof schemasOrHandler === "function") {
if (!isSpecNotificationMethod(method)) throw new TypeError(`'${method}' is not a spec notification method; pass schemas as the second argument to setNotificationHandler().`);
this._notificationHandlers.set(method, (notification, codec2) => {
const outcome = codec2.validateNotification(method, notification);
if (!outcome.ok) {
if (outcome.reason === "not-in-era") throw new ProtocolError(ProtocolErrorCode.InternalError, `No wire schema for ${method} in the resolved era`);
throw new Error(outcome.message);
}
return Promise.resolve(schemasOrHandler(outcome.value));
});
return;
}
if (!maybeHandler) throw new TypeError("setNotificationHandler: handler is required");
this._notificationHandlers.set(method, async (notification) => {
const parsed = await validateStandardSchema(schemasOrHandler.params, { ...notification.params });
if (!parsed.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid params for notification ${method}: ${parsed.error}`);
await maybeHandler(parsed.data, notification);
});
}
/**
* Removes the notification handler for the given method.
*/
removeNotificationHandler(method) {
this._notificationHandlers.delete(method);
}
};
function isPlainObject$1(value) {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function mergeCapabilities(base, additional) {
const result = { ...base };
for (const key in additional) {
const k = key;
const addValue = additional[k];
if (addValue === void 0) continue;
const baseValue = result[k];
result[k] = isPlainObject$1(baseValue) && isPlainObject$1(addValue) ? {
...baseValue,
...addValue
} : addValue;
}
return result;
}
function isPlainObject2(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function partitionInputResponses(inputResponses) {
const accepted = {};
const droppedKeys = [];
if (!isPlainObject2(inputResponses)) return {
accepted,
droppedKeys
};
for (const [key, entry] of Object.entries(inputResponses)) {
if (!isPlainObject2(entry) || "method" in entry || "result" in entry) {
droppedKeys.push(key);
continue;
}
accepted[key] = entry;
}
return {
accepted,
droppedKeys
};
}
function relatedMessagingUnavailable(member) {
throw new SdkError(SdkErrorCode.SendFailed, `ctx.mcpReq.${member} is not available while fulfilling an embedded input request: the request is fulfilled locally and has no related peer request`);
}
function synthesizeInputRequestContext(key, method, params, signal, sessionId) {
return {
sessionId,
mcpReq: {
id: key,
method,
_meta: params?.["_meta"],
requestState: requestStateAccessor(void 0),
signal,
send: () => relatedMessagingUnavailable("send"),
notify: () => relatedMessagingUnavailable("notify")
}
};
}
async function dispatchInputRequest(host, codec2, key, entry, signal) {
if (!isPlainObject2(entry) || typeof entry["method"] !== "string") throw new SdkError(SdkErrorCode.InvalidResult, `Invalid input request '${key}': each inputRequests entry must be an embedded request object with a method`, { key });
const method = entry["method"];
if (!codec2.hasInputRequestMethod(method)) throw new SdkError(SdkErrorCode.InvalidResult, `Invalid input request '${key}': '${method}' is not an embedded request the ${codec2.era} revision defines (expected elicitation/create, sampling/createMessage, or roots/list)`, {
key,
method
});
const handler = host.getRequestHandler(method);
if (handler === void 0) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Cannot fulfil input request '${key}': no handler is registered for '${method}' on this client. Declare the corresponding capability and register a handler, or handle input_required results manually.`, {
key,
method
});
const params = isPlainObject2(entry["params"]) ? entry["params"] : void 0;
return await handler({
jsonrpc: "2.0",
id: key,
method,
...params !== void 0 && { params }
}, host.buildContext(synthesizeInputRequestContext(key, method, params, signal, host.sessionId)));
}
function buildRetryLegRequestOptions(options, legOptions) {
return {
...options?.signal !== void 0 && { signal: options.signal },
...options?.onprogress !== void 0 && { onprogress: options.onprogress },
...options?.resetTimeoutOnProgress !== void 0 && { resetTimeoutOnProgress: options.resetTimeoutOnProgress },
...options?.headers !== void 0 && { headers: options.headers },
...legOptions.timeout !== void 0 && { timeout: legOptions.timeout },
...legOptions.maxTotalTimeout !== void 0 && { maxTotalTimeout: legOptions.maxTotalTimeout },
allowInputRequired: true
};
}
function runInputRequiredFlow(host, config2, decoded, flow) {
const { codec: codec2, request, options, flowStartedAt } = flow;
const firstPayload = {
inputRequests: decoded.inputRequests,
...decoded.requestState !== void 0 && { requestState: decoded.requestState }
};
const hooks = {
dispatchInputRequest: (key, entry, signal) => dispatchInputRequest(host, codec2, key, entry, signal),
retry: (params, legOptions) => flow.retry(params, buildRetryLegRequestOptions(options, legOptions))
};
return runInputRequiredDriver({
config: config2,
method: request.method,
originalParams: request.params,
firstPayload,
flowStartedAt,
signal: options?.signal,
requestOptions: {
...options?.timeout !== void 0 && { timeout: options.timeout },
...options?.maxTotalTimeout !== void 0 && { maxTotalTimeout: options.maxTotalTimeout },
...options?.onprogress !== void 0 && { onprogress: options.onprogress }
},
hooks
});
}
function manualInputRequiredValue(decoded) {
return {
resultType: "input_required",
inputRequests: decoded.inputRequests,
...decoded.requestState !== void 0 && { requestState: decoded.requestState },
...decoded._meta !== void 0 && { _meta: decoded._meta }
};
}
var require_content_type = /* @__PURE__ */ __commonJSMin((exports) => {
var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
exports.parse = parse3;
function parse3(string4) {
if (!string4) throw new TypeError("argument string is required");
var header = typeof string4 === "object" ? getcontenttype(string4) : string4;
if (typeof header !== "string") throw new TypeError("argument string is required to be a string");
var index = header.indexOf(";");
var type = index !== -1 ? header.slice(0, index).trim() : header.trim();
if (!TYPE_REGEXP.test(type)) throw new TypeError("invalid media type");
var obj = new ContentType(type.toLowerCase());
if (index !== -1) {
var key;
var match;
var value;
PARAM_REGEXP.lastIndex = index;
while (match = PARAM_REGEXP.exec(header)) {
if (match.index !== index) throw new TypeError("invalid parameter format");
index += match[0].length;
key = match[1].toLowerCase();
value = match[2];
if (value.charCodeAt(0) === 34) {
value = value.slice(1, -1);
if (value.indexOf("\\") !== -1) value = value.replace(QESC_REGEXP, "$1");
}
obj.parameters[key] = value;
}
if (index !== header.length) throw new TypeError("invalid parameter format");
}
return obj;
}
function getcontenttype(obj) {
var header;
if (typeof obj.getHeader === "function") header = obj.getHeader("content-type");
else if (typeof obj.headers === "object") header = obj.headers && obj.headers["content-type"];
if (typeof header !== "string") throw new TypeError("content-type header is missing from object");
return header;
}
function ContentType(type) {
this.parameters = /* @__PURE__ */ Object.create(null);
this.type = type;
}
});
var import_content_type = /* @__PURE__ */ __toESM(require_content_type(), 1);
function mediaTypeEssence(header) {
if (!header) return;
try {
return import_content_type.parse(header).type;
} catch {
const essence = (header.split(";", 1)[0] ?? "").trim().toLowerCase();
if (essence === "" || header.slice(essence.length).includes(",")) return;
return essence;
}
}
var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
function normalizeHeaders(headers) {
if (!headers) return {};
if (headers instanceof Headers) return Object.fromEntries(headers.entries());
if (Array.isArray(headers)) return Object.fromEntries(headers);
return { ...headers };
}
function createFetchWithInit(baseFetch = fetch, baseInit) {
if (!baseInit) return baseFetch;
return async (url2, init) => {
return baseFetch(url2, {
...baseInit,
...init,
headers: init?.headers ? {
...normalizeHeaders(baseInit.headers),
...normalizeHeaders(init.headers)
} : baseInit.headers
});
};
}
var REDIRECT_STATUSES = /* @__PURE__ */ new Set([
301,
302,
303,
307,
308
]);
var MAX_REDIRECTS = 5;
function isWithinOrigin(from, to) {
if (from.protocol === to.protocol && from.host === to.host) return true;
return from.protocol === "http:" && to.protocol === "https:" && from.hostname === to.hostname && !from.port && !to.port;
}
function redirectTarget(url2, response) {
const location = REDIRECT_STATUSES.has(response.status) ? response.headers?.get("location") : void 0;
if (!location) return void 0;
try {
return new URL(location, url2);
} catch {
return;
}
}
var leftToFetch = /* @__PURE__ */ new WeakSet();
function fetchLeavingRedirects(baseFetch) {
const copy = (url2, init) => baseFetch(url2, init);
leftToFetch.add(copy);
return copy;
}
function fetchWithinOrigin(baseFetch) {
if (leftToFetch.has(baseFetch)) return baseFetch;
return async (url2, init) => {
if (init?.redirect === "error" || init?.redirect === "manual") return baseFetch(url2, init);
const method = (init?.method ?? "GET").toUpperCase();
let current = url2;
for (let followed = 0; ; followed++) {
const response = await baseFetch(current, {
...init,
redirect: "manual"
});
const target = redirectTarget(current, response);
if (!target || followed === MAX_REDIRECTS) return response;
const from = new URL(current);
const keepsMethod = method === "GET" || response.status === 307 || response.status === 308;
const keepsUserinfo = !(target.username || target.password) || target.username === from.username && target.password === from.password;
if (!keepsMethod || !keepsUserinfo || !isWithinOrigin(from, target)) return response;
await response.text?.().catch(() => {
});
current = target;
}
};
}
function unfollowedRedirect(url2, response) {
if (response.type === "opaqueredirect") return "Redirect not followed: this runtime does not expose where it points";
const target = redirectTarget(response.url || url2, response);
if (!target) return void 0;
target.username = target.password = target.search = target.hash = "";
if (target.protocol === "http:" && new URL(response.url || url2).protocol === "https:") {
target.protocol = "https:";
return `Redirect from https to plain http not followed; try ${target.href} as the endpoint`;
}
return `Redirect to ${target.href} not followed; use that URL as the endpoint if it is the intended server`;
}
// node_modules/.pnpm/@modelcontextprotocol+client@2.4.0/node_modules/@modelcontextprotocol/client/dist/ajvProvider-BIwGVY6G.mjs
var require_code$1 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0;
var _CodeOrName = class {
};
exports._CodeOrName = _CodeOrName;
exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
var Name = class extends _CodeOrName {
constructor(s) {
super();
if (!exports.IDENTIFIER.test(s)) throw new Error("CodeGen: name must be a valid identifier");
this.str = s;
}
toString() {
return this.str;
}
emptyStr() {
return false;
}
get names() {
return { [this.str]: 1 };
}
};
exports.Name = Name;
var _Code = class extends _CodeOrName {
constructor(code) {
super();
this._items = typeof code === "string" ? [code] : code;
}
toString() {
return this.str;
}
emptyStr() {
if (this._items.length > 1) return false;
const item = this._items[0];
return item === "" || item === '""';
}
get str() {
var _a3;
return (_a3 = this._str) !== null && _a3 !== void 0 ? _a3 : this._str = this._items.reduce((s, c) => `${s}${c}`, "");
}
get names() {
var _a3;
return (_a3 = this._names) !== null && _a3 !== void 0 ? _a3 : this._names = this._items.reduce((names, c) => {
if (c instanceof Name) names[c.str] = (names[c.str] || 0) + 1;
return names;
}, {});
}
};
exports._Code = _Code;
exports.nil = new _Code("");
function _(strs, ...args) {
const code = [strs[0]];
let i = 0;
while (i < args.length) {
addCodeArg(code, args[i]);
code.push(strs[++i]);
}
return new _Code(code);
}
exports._ = _;
const plus = new _Code("+");
function str(strs, ...args) {
const expr = [safeStringify(strs[0])];
let i = 0;
while (i < args.length) {
expr.push(plus);
addCodeArg(expr, args[i]);
expr.push(plus, safeStringify(strs[++i]));
}
optimize(expr);
return new _Code(expr);
}
exports.str = str;
function addCodeArg(code, arg) {
if (arg instanceof _Code) code.push(...arg._items);
else if (arg instanceof Name) code.push(arg);
else code.push(interpolate(arg));
}
exports.addCodeArg = addCodeArg;
function optimize(expr) {
let i = 1;
while (i < expr.length - 1) {
if (expr[i] === plus) {
const res = mergeExprItems(expr[i - 1], expr[i + 1]);
if (res !== void 0) {
expr.splice(i - 1, 3, res);
continue;
}
expr[i++] = "+";
}
i++;
}
}
function mergeExprItems(a, b) {
if (b === '""') return a;
if (a === '""') return b;
if (typeof a == "string") {
if (b instanceof Name || a[a.length - 1] !== '"') return;
if (typeof b != "string") return `${a.slice(0, -1)}${b}"`;
if (b[0] === '"') return a.slice(0, -1) + b.slice(1);
return;
}
if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) return `"${a}${b.slice(1)}`;
}
function strConcat(c1, c2) {
return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
}
exports.strConcat = strConcat;
function interpolate(x) {
return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x);
}
function stringify(x) {
return new _Code(safeStringify(x));
}
exports.stringify = stringify;
function safeStringify(x) {
return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
}
exports.safeStringify = safeStringify;
function getProperty(key) {
return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
}
exports.getProperty = getProperty;
function getEsmExportName(key) {
if (typeof key == "string" && exports.IDENTIFIER.test(key)) return new _Code(`${key}`);
throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
}
exports.getEsmExportName = getEsmExportName;
function regexpCode(rx) {
return new _Code(rx.toString());
}
exports.regexpCode = regexpCode;
});
var require_scope = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
const code_1 = require_code$1();
var ValueError = class extends Error {
constructor(name) {
super(`CodeGen: "code" for ${name} not defined`);
this.value = name.value;
}
};
var UsedValueState;
(function(UsedValueState2) {
UsedValueState2[UsedValueState2["Started"] = 0] = "Started";
UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed";
})(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
exports.varKinds = {
const: new code_1.Name("const"),
let: new code_1.Name("let"),
var: new code_1.Name("var")
};
var Scope = class {
constructor({ prefixes, parent } = {}) {
this._names = {};
this._prefixes = prefixes;
this._parent = parent;
}
toName(nameOrPrefix) {
return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
}
name(prefix) {
return new code_1.Name(this._newName(prefix));
}
_newName(prefix) {
const ng = this._names[prefix] || this._nameGroup(prefix);
return `${prefix}${ng.index++}`;
}
_nameGroup(prefix) {
var _a3, _b;
if (((_b = (_a3 = this._parent) === null || _a3 === void 0 ? void 0 : _a3._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
return this._names[prefix] = {
prefix,
index: 0
};
}
};
exports.Scope = Scope;
var ValueScopeName = class extends code_1.Name {
constructor(prefix, nameStr) {
super(nameStr);
this.prefix = prefix;
}
setValue(value, { property, itemIndex }) {
this.value = value;
this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
}
};
exports.ValueScopeName = ValueScopeName;
const line = (0, code_1._)`\n`;
var ValueScope = class extends Scope {
constructor(opts) {
super(opts);
this._values = {};
this._scope = opts.scope;
this.opts = {
...opts,
_n: opts.lines ? line : code_1.nil
};
}
get() {
return this._scope;
}
name(prefix) {
return new ValueScopeName(prefix, this._newName(prefix));
}
value(nameOrPrefix, value) {
var _a3;
if (value.ref === void 0) throw new Error("CodeGen: ref must be passed in value");
const name = this.toName(nameOrPrefix);
const { prefix } = name;
const valueKey = (_a3 = value.key) !== null && _a3 !== void 0 ? _a3 : value.ref;
let vs = this._values[prefix];
if (vs) {
const _name = vs.get(valueKey);
if (_name) return _name;
} else vs = this._values[prefix] = /* @__PURE__ */ new Map();
vs.set(valueKey, name);
const s = this._scope[prefix] || (this._scope[prefix] = []);
const itemIndex = s.length;
s[itemIndex] = value.ref;
name.setValue(value, {
property: prefix,
itemIndex
});
return name;
}
getValue(prefix, keyOrRef) {
const vs = this._values[prefix];
if (!vs) return;
return vs.get(keyOrRef);
}
scopeRefs(scopeName, values = this._values) {
return this._reduceValues(values, (name) => {
if (name.scopePath === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
return (0, code_1._)`${scopeName}${name.scopePath}`;
});
}
scopeCode(values = this._values, usedValues, getCode) {
return this._reduceValues(values, (name) => {
if (name.value === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
return name.value.code;
}, usedValues, getCode);
}
_reduceValues(values, valueCode, usedValues = {}, getCode) {
let code = code_1.nil;
for (const prefix in values) {
const vs = values[prefix];
if (!vs) continue;
const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map();
vs.forEach((name) => {
if (nameSet.has(name)) return;
nameSet.set(name, UsedValueState.Started);
let c = valueCode(name);
if (c) {
const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
} else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) code = (0, code_1._)`${code}${c}${this.opts._n}`;
else throw new ValueError(name);
nameSet.set(name, UsedValueState.Completed);
});
}
return code;
}
};
exports.ValueScope = ValueScope;
});
var require_codegen = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
const code_1 = require_code$1();
const scope_1 = require_scope();
var code_2 = require_code$1();
Object.defineProperty(exports, "_", {
enumerable: true,
get: function() {
return code_2._;
}
});
Object.defineProperty(exports, "str", {
enumerable: true,
get: function() {
return code_2.str;
}
});
Object.defineProperty(exports, "strConcat", {
enumerable: true,
get: function() {
return code_2.strConcat;
}
});
Object.defineProperty(exports, "nil", {
enumerable: true,
get: function() {
return code_2.nil;
}
});
Object.defineProperty(exports, "getProperty", {
enumerable: true,
get: function() {
return code_2.getProperty;
}
});
Object.defineProperty(exports, "stringify", {
enumerable: true,
get: function() {
return code_2.stringify;
}
});
Object.defineProperty(exports, "regexpCode", {
enumerable: true,
get: function() {
return code_2.regexpCode;
}
});
Object.defineProperty(exports, "Name", {
enumerable: true,
get: function() {
return code_2.Name;
}
});
var scope_2 = require_scope();
Object.defineProperty(exports, "Scope", {
enumerable: true,
get: function() {
return scope_2.Scope;
}
});
Object.defineProperty(exports, "ValueScope", {
enumerable: true,
get: function() {
return scope_2.ValueScope;
}
});
Object.defineProperty(exports, "ValueScopeName", {
enumerable: true,
get: function() {
return scope_2.ValueScopeName;
}
});
Object.defineProperty(exports, "varKinds", {
enumerable: true,
get: function() {
return scope_2.varKinds;
}
});
exports.operators = {
GT: new code_1._Code(">"),
GTE: new code_1._Code(">="),
LT: new code_1._Code("<"),
LTE: new code_1._Code("<="),
EQ: new code_1._Code("==="),
NEQ: new code_1._Code("!=="),
NOT: new code_1._Code("!"),
OR: new code_1._Code("||"),
AND: new code_1._Code("&&"),
ADD: new code_1._Code("+")
};
var Node = class {
optimizeNodes() {
return this;
}
optimizeNames(_names, _constants) {
return this;
}
};
var Def = class extends Node {
constructor(varKind, name, rhs) {
super();
this.varKind = varKind;
this.name = name;
this.rhs = rhs;
}
render({ es5, _n }) {
const varKind = es5 ? scope_1.varKinds.var : this.varKind;
const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
return `${varKind} ${this.name}${rhs};` + _n;
}
optimizeNames(names, constants) {
if (!names[this.name.str]) return;
if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants);
return this;
}
get names() {
return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
}
};
var Assign = class extends Node {
constructor(lhs, rhs, sideEffects) {
super();
this.lhs = lhs;
this.rhs = rhs;
this.sideEffects = sideEffects;
}
render({ _n }) {
return `${this.lhs} = ${this.rhs};` + _n;
}
optimizeNames(names, constants) {
if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) return;
this.rhs = optimizeExpr(this.rhs, names, constants);
return this;
}
get names() {
return addExprNames(this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names }, this.rhs);
}
};
var AssignOp = class extends Assign {
constructor(lhs, op, rhs, sideEffects) {
super(lhs, rhs, sideEffects);
this.op = op;
}
render({ _n }) {
return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
}
};
var Label = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
return `${this.label}:` + _n;
}
};
var Break = class extends Node {
constructor(label) {
super();
this.label = label;
this.names = {};
}
render({ _n }) {
return `break${this.label ? ` ${this.label}` : ""};` + _n;
}
};
var Throw = class extends Node {
constructor(error62) {
super();
this.error = error62;
}
render({ _n }) {
return `throw ${this.error};` + _n;
}
get names() {
return this.error.names;
}
};
var AnyCode = class extends Node {
constructor(code) {
super();
this.code = code;
}
render({ _n }) {
return `${this.code};` + _n;
}
optimizeNodes() {
return `${this.code}` ? this : void 0;
}
optimizeNames(names, constants) {
this.code = optimizeExpr(this.code, names, constants);
return this;
}
get names() {
return this.code instanceof code_1._CodeOrName ? this.code.names : {};
}
};
var ParentNode = class extends Node {
constructor(nodes = []) {
super();
this.nodes = nodes;
}
render(opts) {
return this.nodes.reduce((code, n) => code + n.render(opts), "");
}
optimizeNodes() {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i].optimizeNodes();
if (Array.isArray(n)) nodes.splice(i, 1, ...n);
else if (n) nodes[i] = n;
else nodes.splice(i, 1);
}
return nodes.length > 0 ? this : void 0;
}
optimizeNames(names, constants) {
const { nodes } = this;
let i = nodes.length;
while (i--) {
const n = nodes[i];
if (n.optimizeNames(names, constants)) continue;
subtractNames(names, n.names);
nodes.splice(i, 1);
}
return nodes.length > 0 ? this : void 0;
}
get names() {
return this.nodes.reduce((names, n) => addNames(names, n.names), {});
}
};
var BlockNode = class extends ParentNode {
render(opts) {
return "{" + opts._n + super.render(opts) + "}" + opts._n;
}
};
var Root = class extends ParentNode {
};
var Else = class extends BlockNode {
};
Else.kind = "else";
var If = class If2 extends BlockNode {
constructor(condition, nodes) {
super(nodes);
this.condition = condition;
}
render(opts) {
let code = `if(${this.condition})` + super.render(opts);
if (this.else) code += "else " + this.else.render(opts);
return code;
}
optimizeNodes() {
super.optimizeNodes();
const cond = this.condition;
if (cond === true) return this.nodes;
let e = this.else;
if (e) {
const ns = e.optimizeNodes();
e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
}
if (e) {
if (cond === false) return e instanceof If2 ? e : e.nodes;
if (this.nodes.length) return this;
return new If2(not(cond), e instanceof If2 ? [e] : e.nodes);
}
if (cond === false || !this.nodes.length) return void 0;
return this;
}
optimizeNames(names, constants) {
var _a3;
this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants);
if (!(super.optimizeNames(names, constants) || this.else)) return;
this.condition = optimizeExpr(this.condition, names, constants);
return this;
}
get names() {
const names = super.names;
addExprNames(names, this.condition);
if (this.else) addNames(names, this.else.names);
return names;
}
};
If.kind = "if";
var For = class extends BlockNode {
};
For.kind = "for";
var ForLoop = class extends For {
constructor(iteration) {
super();
this.iteration = iteration;
}
render(opts) {
return `for(${this.iteration})` + super.render(opts);
}
optimizeNames(names, constants) {
if (!super.optimizeNames(names, constants)) return;
this.iteration = optimizeExpr(this.iteration, names, constants);
return this;
}
get names() {
return addNames(super.names, this.iteration.names);
}
};
var ForRange = class extends For {
constructor(varKind, name, from, to) {
super();
this.varKind = varKind;
this.name = name;
this.from = from;
this.to = to;
}
render(opts) {
const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
const { name, from, to } = this;
return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
}
get names() {
return addExprNames(addExprNames(super.names, this.from), this.to);
}
};
var ForIter = class extends For {
constructor(loop, varKind, name, iterable) {
super();
this.loop = loop;
this.varKind = varKind;
this.name = name;
this.iterable = iterable;
}
render(opts) {
return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
}
optimizeNames(names, constants) {
if (!super.optimizeNames(names, constants)) return;
this.iterable = optimizeExpr(this.iterable, names, constants);
return this;
}
get names() {
return addNames(super.names, this.iterable.names);
}
};
var Func = class extends BlockNode {
constructor(name, args, async) {
super();
this.name = name;
this.args = args;
this.async = async;
}
render(opts) {
return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(opts);
}
};
Func.kind = "func";
var Return = class extends ParentNode {
render(opts) {
return "return " + super.render(opts);
}
};
Return.kind = "return";
var Try = class extends BlockNode {
render(opts) {
let code = "try" + super.render(opts);
if (this.catch) code += this.catch.render(opts);
if (this.finally) code += this.finally.render(opts);
return code;
}
optimizeNodes() {
var _a3, _b;
super.optimizeNodes();
(_a3 = this.catch) === null || _a3 === void 0 || _a3.optimizeNodes();
(_b = this.finally) === null || _b === void 0 || _b.optimizeNodes();
return this;
}
optimizeNames(names, constants) {
var _a3, _b;
super.optimizeNames(names, constants);
(_a3 = this.catch) === null || _a3 === void 0 || _a3.optimizeNames(names, constants);
(_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants);
return this;
}
get names() {
const names = super.names;
if (this.catch) addNames(names, this.catch.names);
if (this.finally) addNames(names, this.finally.names);
return names;
}
};
var Catch = class extends BlockNode {
constructor(error62) {
super();
this.error = error62;
}
render(opts) {
return `catch(${this.error})` + super.render(opts);
}
};
Catch.kind = "catch";
var Finally = class extends BlockNode {
render(opts) {
return "finally" + super.render(opts);
}
};
Finally.kind = "finally";
var CodeGen = class {
constructor(extScope, opts = {}) {
this._values = {};
this._blockStarts = [];
this._constants = {};
this.opts = {
...opts,
_n: opts.lines ? "\n" : ""
};
this._extScope = extScope;
this._scope = new scope_1.Scope({ parent: extScope });
this._nodes = [new Root()];
}
toString() {
return this._root.render(this.opts);
}
name(prefix) {
return this._scope.name(prefix);
}
scopeName(prefix) {
return this._extScope.name(prefix);
}
scopeValue(prefixOrName, value) {
const name = this._extScope.value(prefixOrName, value);
(this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set())).add(name);
return name;
}
getScopeValue(prefix, keyOrRef) {
return this._extScope.getValue(prefix, keyOrRef);
}
scopeRefs(scopeName) {
return this._extScope.scopeRefs(scopeName, this._values);
}
scopeCode() {
return this._extScope.scopeCode(this._values);
}
_def(varKind, nameOrPrefix, rhs, constant) {
const name = this._scope.toName(nameOrPrefix);
if (rhs !== void 0 && constant) this._constants[name.str] = rhs;
this._leafNode(new Def(varKind, name, rhs));
return name;
}
const(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
}
let(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
}
var(nameOrPrefix, rhs, _constant) {
return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
}
assign(lhs, rhs, sideEffects) {
return this._leafNode(new Assign(lhs, rhs, sideEffects));
}
add(lhs, rhs) {
return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
}
code(c) {
if (typeof c == "function") c();
else if (c !== code_1.nil) this._leafNode(new AnyCode(c));
return this;
}
object(...keyValues) {
const code = ["{"];
for (const [key, value] of keyValues) {
if (code.length > 1) code.push(",");
code.push(key);
if (key !== value || this.opts.es5) {
code.push(":");
(0, code_1.addCodeArg)(code, value);
}
}
code.push("}");
return new code_1._Code(code);
}
if(condition, thenBody, elseBody) {
this._blockNode(new If(condition));
if (thenBody && elseBody) this.code(thenBody).else().code(elseBody).endIf();
else if (thenBody) this.code(thenBody).endIf();
else if (elseBody) throw new Error('CodeGen: "else" body without "then" body');
return this;
}
elseIf(condition) {
return this._elseNode(new If(condition));
}
else() {
return this._elseNode(new Else());
}
endIf() {
return this._endBlockNode(If, Else);
}
_for(node2, forBody) {
this._blockNode(node2);
if (forBody) this.code(forBody).endFor();
return this;
}
for(iteration, forBody) {
return this._for(new ForLoop(iteration), forBody);
}
forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
const name = this._scope.toName(nameOrPrefix);
return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
}
forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
const name = this._scope.toName(nameOrPrefix);
if (this.opts.es5) {
const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
this.var(name, (0, code_1._)`${arr}[${i}]`);
forBody(name);
});
}
return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
}
forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
if (this.opts.ownProperties) return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
const name = this._scope.toName(nameOrPrefix);
return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
}
endFor() {
return this._endBlockNode(For);
}
label(label) {
return this._leafNode(new Label(label));
}
break(label) {
return this._leafNode(new Break(label));
}
return(value) {
const node2 = new Return();
this._blockNode(node2);
this.code(value);
if (node2.nodes.length !== 1) throw new Error('CodeGen: "return" should have one node');
return this._endBlockNode(Return);
}
try(tryBody, catchCode, finallyCode) {
if (!catchCode && !finallyCode) throw new Error('CodeGen: "try" without "catch" and "finally"');
const node2 = new Try();
this._blockNode(node2);
this.code(tryBody);
if (catchCode) {
const error62 = this.name("e");
this._currNode = node2.catch = new Catch(error62);
catchCode(error62);
}
if (finallyCode) {
this._currNode = node2.finally = new Finally();
this.code(finallyCode);
}
return this._endBlockNode(Catch, Finally);
}
throw(error62) {
return this._leafNode(new Throw(error62));
}
block(body, nodeCount) {
this._blockStarts.push(this._nodes.length);
if (body) this.code(body).endBlock(nodeCount);
return this;
}
endBlock(nodeCount) {
const len = this._blockStarts.pop();
if (len === void 0) throw new Error("CodeGen: not in self-balancing block");
const toClose = this._nodes.length - len;
if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
this._nodes.length = len;
return this;
}
func(name, args = code_1.nil, async, funcBody) {
this._blockNode(new Func(name, args, async));
if (funcBody) this.code(funcBody).endFunc();
return this;
}
endFunc() {
return this._endBlockNode(Func);
}
optimize(n = 1) {
while (n-- > 0) {
this._root.optimizeNodes();
this._root.optimizeNames(this._root.names, this._constants);
}
}
_leafNode(node2) {
this._currNode.nodes.push(node2);
return this;
}
_blockNode(node2) {
this._currNode.nodes.push(node2);
this._nodes.push(node2);
}
_endBlockNode(N1, N2) {
const n = this._currNode;
if (n instanceof N1 || N2 && n instanceof N2) {
this._nodes.pop();
return this;
}
throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
}
_elseNode(node2) {
const n = this._currNode;
if (!(n instanceof If)) throw new Error('CodeGen: "else" without "if"');
this._currNode = n.else = node2;
return this;
}
get _root() {
return this._nodes[0];
}
get _currNode() {
const ns = this._nodes;
return ns[ns.length - 1];
}
set _currNode(node2) {
const ns = this._nodes;
ns[ns.length - 1] = node2;
}
};
exports.CodeGen = CodeGen;
function addNames(names, from) {
for (const n in from) names[n] = (names[n] || 0) + (from[n] || 0);
return names;
}
function addExprNames(names, from) {
return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
}
function optimizeExpr(expr, names, constants) {
if (expr instanceof code_1.Name) return replaceName(expr);
if (!canOptimize(expr)) return expr;
return new code_1._Code(expr._items.reduce((items, c) => {
if (c instanceof code_1.Name) c = replaceName(c);
if (c instanceof code_1._Code) items.push(...c._items);
else items.push(c);
return items;
}, []));
function replaceName(n) {
const c = constants[n.str];
if (c === void 0 || names[n.str] !== 1) return n;
delete names[n.str];
return c;
}
function canOptimize(e) {
return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0);
}
}
function subtractNames(names, from) {
for (const n in from) names[n] = (names[n] || 0) - (from[n] || 0);
}
function not(x) {
return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`;
}
exports.not = not;
const andCode = mappend(exports.operators.AND);
function and(...args) {
return args.reduce(andCode);
}
exports.and = and;
const orCode = mappend(exports.operators.OR);
function or(...args) {
return args.reduce(orCode);
}
exports.or = or;
function mappend(op) {
return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
}
function par(x) {
return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
}
});
var require_util = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
const codegen_1 = require_codegen();
const code_1 = require_code$1();
function toHash(arr) {
const hash2 = {};
for (const item of arr) hash2[item] = true;
return hash2;
}
exports.toHash = toHash;
function alwaysValidSchema(it, schema) {
if (typeof schema == "boolean") return schema;
if (Object.keys(schema).length === 0) return true;
checkUnknownRules(it, schema);
return !schemaHasRules(schema, it.self.RULES.all);
}
exports.alwaysValidSchema = alwaysValidSchema;
function checkUnknownRules(it, schema = it.schema) {
const { opts, self } = it;
if (!opts.strictSchema) return;
if (typeof schema === "boolean") return;
const rules = self.RULES.keywords;
for (const key in schema) if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`);
}
exports.checkUnknownRules = checkUnknownRules;
function schemaHasRules(schema, rules) {
if (typeof schema == "boolean") return !schema;
for (const key in schema) if (rules[key]) return true;
return false;
}
exports.schemaHasRules = schemaHasRules;
function schemaHasRulesButRef(schema, RULES) {
if (typeof schema == "boolean") return !schema;
for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true;
return false;
}
exports.schemaHasRulesButRef = schemaHasRulesButRef;
function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
if (!$data) {
if (typeof schema == "number" || typeof schema == "boolean") return schema;
if (typeof schema == "string") return (0, codegen_1._)`${schema}`;
}
return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
}
exports.schemaRefOrVal = schemaRefOrVal;
function unescapeFragment(str) {
return unescapeJsonPointer(decodeURIComponent(str));
}
exports.unescapeFragment = unescapeFragment;
function escapeFragment(str) {
return encodeURIComponent(escapeJsonPointer(str));
}
exports.escapeFragment = escapeFragment;
function escapeJsonPointer(str) {
if (typeof str == "number") return `${str}`;
return str.replace(/~/g, "~0").replace(/\//g, "~1");
}
exports.escapeJsonPointer = escapeJsonPointer;
function unescapeJsonPointer(str) {
return str.replace(/~1/g, "/").replace(/~0/g, "~");
}
exports.unescapeJsonPointer = unescapeJsonPointer;
function eachItem(xs, f) {
if (Array.isArray(xs)) for (const x of xs) f(x);
else f(xs);
}
exports.eachItem = eachItem;
function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues2, resultToName }) {
return (gen, from, to, toName) => {
const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues2(from, to);
return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
};
}
exports.mergeEvaluated = {
props: makeMergeEvaluated({
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`));
}),
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
if (from === true) gen.assign(to, true);
else {
gen.assign(to, (0, codegen_1._)`${to} || {}`);
setEvaluated(gen, to, from);
}
}),
mergeValues: (from, to) => from === true ? true : {
...from,
...to
},
resultToName: evaluatedPropsToName
}),
items: makeMergeEvaluated({
mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
mergeValues: (from, to) => from === true ? true : Math.max(from, to),
resultToName: (gen, items) => gen.var("items", items)
})
};
function evaluatedPropsToName(gen, ps) {
if (ps === true) return gen.var("props", true);
const props = gen.var("props", (0, codegen_1._)`{}`);
if (ps !== void 0) setEvaluated(gen, props, ps);
return props;
}
exports.evaluatedPropsToName = evaluatedPropsToName;
function setEvaluated(gen, props, ps) {
Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
}
exports.setEvaluated = setEvaluated;
const snippets = {};
function useFunc(gen, f) {
return gen.scopeValue("func", {
ref: f,
code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code))
});
}
exports.useFunc = useFunc;
var Type;
(function(Type2) {
Type2[Type2["Num"] = 0] = "Num";
Type2[Type2["Str"] = 1] = "Str";
})(Type || (exports.Type = Type = {}));
function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
if (dataProp instanceof codegen_1.Name) {
const isNumber = dataPropType === Type.Num;
return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
}
return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
}
exports.getErrorPath = getErrorPath;
function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
if (!mode) return;
msg = `strict mode: ${msg}`;
if (mode === true) throw new Error(msg);
it.self.logger.warn(msg);
}
exports.checkStrictMode = checkStrictMode;
});
var require_names = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const names = {
data: new codegen_1.Name("data"),
valCxt: new codegen_1.Name("valCxt"),
instancePath: new codegen_1.Name("instancePath"),
parentData: new codegen_1.Name("parentData"),
parentDataProperty: new codegen_1.Name("parentDataProperty"),
rootData: new codegen_1.Name("rootData"),
dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
vErrors: new codegen_1.Name("vErrors"),
errors: new codegen_1.Name("errors"),
this: new codegen_1.Name("this"),
self: new codegen_1.Name("self"),
scope: new codegen_1.Name("scope"),
json: new codegen_1.Name("json"),
jsonPos: new codegen_1.Name("jsonPos"),
jsonLen: new codegen_1.Name("jsonLen"),
jsonPart: new codegen_1.Name("jsonPart")
};
exports.default = names;
});
var require_errors = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
const codegen_1 = require_codegen();
const util_1 = require_util();
const names_1 = require_names();
exports.keywordError = { message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation` };
exports.keyword$DataError = { message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)` };
function reportError(cxt, error62 = exports.keywordError, errorPaths, overrideAllErrors) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
const errObj = errorObjectCode(cxt, error62, errorPaths);
if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) addError(gen, errObj);
else returnErrors(it, (0, codegen_1._)`[${errObj}]`);
}
exports.reportError = reportError;
function reportExtraError(cxt, error62 = exports.keywordError, errorPaths) {
const { it } = cxt;
const { gen, compositeRule, allErrors } = it;
addError(gen, errorObjectCode(cxt, error62, errorPaths));
if (!(compositeRule || allErrors)) returnErrors(it, names_1.default.vErrors);
}
exports.reportExtraError = reportExtraError;
function resetErrorsCount(gen, errsCount) {
gen.assign(names_1.default.errors, errsCount);
gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
}
exports.resetErrorsCount = resetErrorsCount;
function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
if (errsCount === void 0) throw new Error("ajv implementation error");
const err = gen.name("err");
gen.forRange("i", errsCount, names_1.default.errors, (i) => {
gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
if (it.opts.verbose) {
gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
gen.assign((0, codegen_1._)`${err}.data`, data);
}
});
}
exports.extendErrors = extendErrors;
function addError(gen, errObj) {
const err = gen.const("err", errObj);
gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
gen.code((0, codegen_1._)`${names_1.default.errors}++`);
}
function returnErrors(it, errs) {
const { gen, validateName, schemaEnv } = it;
if (schemaEnv.$async) gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`);
else {
gen.assign((0, codegen_1._)`${validateName}.errors`, errs);
gen.return(false);
}
}
const E = {
keyword: new codegen_1.Name("keyword"),
schemaPath: new codegen_1.Name("schemaPath"),
params: new codegen_1.Name("params"),
propertyName: new codegen_1.Name("propertyName"),
message: new codegen_1.Name("message"),
schema: new codegen_1.Name("schema"),
parentSchema: new codegen_1.Name("parentSchema")
};
function errorObjectCode(cxt, error62, errorPaths) {
const { createErrors } = cxt.it;
if (createErrors === false) return (0, codegen_1._)`{}`;
return errorObject(cxt, error62, errorPaths);
}
function errorObject(cxt, error62, errorPaths = {}) {
const { gen, it } = cxt;
const keyValues = [errorInstancePath(it, errorPaths), errorSchemaPath(cxt, errorPaths)];
extraErrorProps(cxt, error62, keyValues);
return gen.object(...keyValues);
}
function errorInstancePath({ errorPath }, { instancePath }) {
const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath;
return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
}
function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
if (schemaPath) schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
return [E.schemaPath, schPath];
}
function extraErrorProps(cxt, { params, message }, keyValues) {
const { keyword, data, schemaValue, it } = cxt;
const { opts, propertyName, topSchemaRef, schemaPath } = it;
keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]);
if (opts.messages) keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
if (opts.verbose) keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
if (propertyName) keyValues.push([E.propertyName, propertyName]);
}
});
var require_boolSchema = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
const errors_1 = require_errors();
const codegen_1 = require_codegen();
const names_1 = require_names();
const boolError = { message: "boolean schema is false" };
function topBoolOrEmptySchema(it) {
const { gen, schema, validateName } = it;
if (schema === false) falseSchemaError(it, false);
else if (typeof schema == "object" && schema.$async === true) gen.return(names_1.default.data);
else {
gen.assign((0, codegen_1._)`${validateName}.errors`, null);
gen.return(true);
}
}
exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
function boolOrEmptySchema(it, valid) {
const { gen, schema } = it;
if (schema === false) {
gen.var(valid, false);
falseSchemaError(it);
} else gen.var(valid, true);
}
exports.boolOrEmptySchema = boolOrEmptySchema;
function falseSchemaError(it, overrideAllErrors) {
const { gen, data } = it;
const cxt = {
gen,
keyword: "false schema",
data,
schema: false,
schemaCode: false,
schemaValue: false,
params: {},
it
};
(0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
}
});
var require_rules = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRules = exports.isJSONType = void 0;
const jsonTypes = /* @__PURE__ */ new Set([
"string",
"number",
"integer",
"boolean",
"null",
"object",
"array"
]);
function isJSONType(x) {
return typeof x == "string" && jsonTypes.has(x);
}
exports.isJSONType = isJSONType;
function getRules() {
const groups = {
number: {
type: "number",
rules: []
},
string: {
type: "string",
rules: []
},
array: {
type: "array",
rules: []
},
object: {
type: "object",
rules: []
}
};
return {
types: {
...groups,
integer: true,
boolean: true,
null: true
},
rules: [
{ rules: [] },
groups.number,
groups.string,
groups.array,
groups.object
],
post: { rules: [] },
all: {},
keywords: {}
};
}
exports.getRules = getRules;
});
var require_applicability = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
function schemaHasRulesForType({ schema, self }, type) {
const group = self.RULES.types[type];
return group && group !== true && shouldUseGroup(schema, group);
}
exports.schemaHasRulesForType = schemaHasRulesForType;
function shouldUseGroup(schema, group) {
return group.rules.some((rule) => shouldUseRule(schema, rule));
}
exports.shouldUseGroup = shouldUseGroup;
function shouldUseRule(schema, rule) {
var _a3;
return schema[rule.keyword] !== void 0 || ((_a3 = rule.definition.implements) === null || _a3 === void 0 ? void 0 : _a3.some((kwd) => schema[kwd] !== void 0));
}
exports.shouldUseRule = shouldUseRule;
});
var require_dataType = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
const rules_1 = require_rules();
const applicability_1 = require_applicability();
const errors_1 = require_errors();
const codegen_1 = require_codegen();
const util_1 = require_util();
var DataType;
(function(DataType2) {
DataType2[DataType2["Correct"] = 0] = "Correct";
DataType2[DataType2["Wrong"] = 1] = "Wrong";
})(DataType || (exports.DataType = DataType = {}));
function getSchemaTypes(schema) {
const types = getJSONTypes(schema.type);
if (types.includes("null")) {
if (schema.nullable === false) throw new Error("type: null contradicts nullable: false");
} else {
if (!types.length && schema.nullable !== void 0) throw new Error('"nullable" cannot be used without "type"');
if (schema.nullable === true) types.push("null");
}
return types;
}
exports.getSchemaTypes = getSchemaTypes;
function getJSONTypes(ts) {
const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
if (types.every(rules_1.isJSONType)) return types;
throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
}
exports.getJSONTypes = getJSONTypes;
function coerceAndCheckDataType(it, types) {
const { gen, data, opts } = it;
const coerceTo = coerceToTypes(types, opts.coerceTypes);
const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
if (checkTypes) {
const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
gen.if(wrongType, () => {
if (coerceTo.length) coerceData(it, types, coerceTo);
else reportTypeError(it);
});
}
return checkTypes;
}
exports.coerceAndCheckDataType = coerceAndCheckDataType;
const COERCIBLE = /* @__PURE__ */ new Set([
"string",
"number",
"integer",
"boolean",
"null"
]);
function coerceToTypes(types, coerceTypes) {
return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
}
function coerceData(it, types, coerceTo) {
const { gen, data, opts } = it;
const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
if (opts.coerceTypes === "array") gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
gen.if((0, codegen_1._)`${coerced} !== undefined`);
for (const t of coerceTo) if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") coerceSpecificType(t);
gen.else();
reportTypeError(it);
gen.endIf();
gen.if((0, codegen_1._)`${coerced} !== undefined`, () => {
gen.assign(data, coerced);
assignParentData(it, coerced);
});
function coerceSpecificType(t) {
switch (t) {
case "string":
gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
return;
case "number":
gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null
|| (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`);
return;
case "integer":
gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null
|| (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`);
return;
case "boolean":
gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
return;
case "null":
gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`);
gen.assign(coerced, null);
return;
case "array":
gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number"
|| ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`);
}
}
}
function assignParentData({ gen, parentData, parentDataProperty }, expr) {
gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr));
}
function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
let cond;
switch (dataType) {
case "null":
return (0, codegen_1._)`${data} ${EQ} null`;
case "array":
cond = (0, codegen_1._)`Array.isArray(${data})`;
break;
case "object":
cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
break;
case "integer":
cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`);
break;
case "number":
cond = numCond();
break;
default:
return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`;
}
return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
function numCond(_cond = codegen_1.nil) {
return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil);
}
}
exports.checkDataType = checkDataType;
function checkDataTypes(dataTypes, data, strictNums, correct) {
if (dataTypes.length === 1) return checkDataType(dataTypes[0], data, strictNums, correct);
let cond;
const types = (0, util_1.toHash)(dataTypes);
if (types.array && types.object) {
const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
delete types.null;
delete types.array;
delete types.object;
} else cond = codegen_1.nil;
if (types.number) delete types.integer;
for (const t in types) cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
return cond;
}
exports.checkDataTypes = checkDataTypes;
const typeError = {
message: ({ schema }) => `must be ${schema}`,
params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
};
function reportTypeError(it) {
const cxt = getTypeErrorContext(it);
(0, errors_1.reportError)(cxt, typeError);
}
exports.reportTypeError = reportTypeError;
function getTypeErrorContext(it) {
const { gen, data, schema } = it;
const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
return {
gen,
keyword: "type",
data,
schema: schema.type,
schemaCode,
schemaValue: schemaCode,
parentSchema: schema,
params: {},
it
};
}
});
var require_defaults = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.assignDefaults = void 0;
const codegen_1 = require_codegen();
const util_1 = require_util();
function assignDefaults(it, ty) {
const { properties, items } = it.schema;
if (ty === "object" && properties) for (const key in properties) assignDefault(it, key, properties[key].default);
else if (ty === "array" && Array.isArray(items)) items.forEach((sch, i) => assignDefault(it, i, sch.default));
}
exports.assignDefaults = assignDefaults;
function assignDefault(it, prop, defaultValue) {
const { gen, compositeRule, data, opts } = it;
if (defaultValue === void 0) return;
const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
if (compositeRule) {
(0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
return;
}
let condition = (0, codegen_1._)`${childData} === undefined`;
if (opts.useDefaults === "empty") condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
}
});
var require_code = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
const codegen_1 = require_codegen();
const util_1 = require_util();
const names_1 = require_names();
const util_2 = require_util();
function checkReportMissingProp(cxt, prop) {
const { gen, data, it } = cxt;
gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
cxt.error();
});
}
exports.checkReportMissingProp = checkReportMissingProp;
function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
}
exports.checkMissingProp = checkMissingProp;
function reportMissingProp(cxt, missing) {
cxt.setParams({ missingProperty: missing }, true);
cxt.error();
}
exports.reportMissingProp = reportMissingProp;
function hasPropFunc(gen) {
return gen.scopeValue("func", {
ref: Object.prototype.hasOwnProperty,
code: (0, codegen_1._)`Object.prototype.hasOwnProperty`
});
}
exports.hasPropFunc = hasPropFunc;
function isOwnProperty(gen, data, property) {
return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
}
exports.isOwnProperty = isOwnProperty;
function propertyInData(gen, data, property, ownProperties) {
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
}
exports.propertyInData = propertyInData;
function noPropertyInData(gen, data, property, ownProperties) {
const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
}
exports.noPropertyInData = noPropertyInData;
function allSchemaProperties(schemaMap) {
return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
}
exports.allSchemaProperties = allSchemaProperties;
function schemaProperties(it, schemaMap) {
return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
}
exports.schemaProperties = schemaProperties;
function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
const valCxt = [
[names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
[names_1.default.parentData, it.parentData],
[names_1.default.parentDataProperty, it.parentDataProperty],
[names_1.default.rootData, names_1.default.rootData]
];
if (it.opts.dynamicRef) valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
}
exports.callValidateCode = callValidateCode;
const newRegExp = (0, codegen_1._)`new RegExp`;
function usePattern({ gen, it: { opts } }, pattern) {
const u = opts.unicodeRegExp ? "u" : "";
const { regExp } = opts.code;
const rx = regExp(pattern, u);
return gen.scopeValue("pattern", {
key: rx.toString(),
ref: rx,
code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
});
}
exports.usePattern = usePattern;
function validateArray(cxt) {
const { gen, data, keyword, it } = cxt;
const valid = gen.name("valid");
if (it.allErrors) {
const validArr = gen.let("valid", true);
validateItems(() => gen.assign(validArr, false));
return validArr;
}
gen.var(valid, true);
validateItems(() => gen.break());
return valid;
function validateItems(notValid) {
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
gen.forRange("i", 0, len, (i) => {
cxt.subschema({
keyword,
dataProp: i,
dataPropType: util_1.Type.Num
}, valid);
gen.if((0, codegen_1.not)(valid), notValid);
});
}
}
exports.validateArray = validateArray;
function validateUnion(cxt) {
const { gen, schema, keyword, it } = cxt;
if (!Array.isArray(schema)) throw new Error("ajv implementation error");
if (schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)) && !it.opts.unevaluated) return;
const valid = gen.let("valid", false);
const schValid = gen.name("_valid");
gen.block(() => schema.forEach((_sch, i) => {
const schCxt = cxt.subschema({
keyword,
schemaProp: i,
compositeRule: true
}, schValid);
gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
if (!cxt.mergeValidEvaluated(schCxt, schValid)) gen.if((0, codegen_1.not)(valid));
}));
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
}
exports.validateUnion = validateUnion;
});
var require_keyword = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
const codegen_1 = require_codegen();
const names_1 = require_names();
const code_1 = require_code();
const errors_1 = require_errors();
function macroKeywordCode(cxt, def) {
const { gen, keyword, schema, parentSchema, it } = cxt;
const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
const schemaRef = useKeyword(gen, keyword, macroSchema);
if (it.opts.validateSchema !== false) it.self.validateSchema(macroSchema, true);
const valid = gen.name("valid");
cxt.subschema({
schema: macroSchema,
schemaPath: codegen_1.nil,
errSchemaPath: `${it.errSchemaPath}/${keyword}`,
topSchemaRef: schemaRef,
compositeRule: true
}, valid);
cxt.pass(valid, () => cxt.error(true));
}
exports.macroKeywordCode = macroKeywordCode;
function funcKeywordCode(cxt, def) {
var _a3;
const { gen, keyword, schema, parentSchema, $data, it } = cxt;
checkAsyncKeyword(it, def);
const validateRef = useKeyword(gen, keyword, !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate);
const valid = gen.let("valid");
cxt.block$data(valid, validateKeyword);
cxt.ok((_a3 = def.valid) !== null && _a3 !== void 0 ? _a3 : valid);
function validateKeyword() {
if (def.errors === false) {
assignValid();
if (def.modifying) modifyData(cxt);
reportErrs(() => cxt.error());
} else {
const ruleErrs = def.async ? validateAsync3() : validateSync();
if (def.modifying) modifyData(cxt);
reportErrs(() => addErrs(cxt, ruleErrs));
}
}
function validateAsync3() {
const ruleErrs = gen.let("ruleErrs", null);
gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e)));
return ruleErrs;
}
function validateSync() {
const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
gen.assign(validateErrs, null);
assignValid(codegen_1.nil);
return validateErrs;
}
function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
const passSchema = !("compile" in def && !$data || def.schema === false);
gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
}
function reportErrs(errors) {
var _a$1;
gen.if((0, codegen_1.not)((_a$1 = def.valid) !== null && _a$1 !== void 0 ? _a$1 : valid), errors);
}
}
exports.funcKeywordCode = funcKeywordCode;
function modifyData(cxt) {
const { gen, data, it } = cxt;
gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`));
}
function addErrs(cxt, errs) {
const { gen } = cxt;
gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => {
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
(0, errors_1.extendErrors)(cxt);
}, () => cxt.error());
}
function checkAsyncKeyword({ schemaEnv }, def) {
if (def.async && !schemaEnv.$async) throw new Error("async keyword in sync schema");
}
function useKeyword(gen, keyword, result) {
if (result === void 0) throw new Error(`keyword "${keyword}" failed to compile`);
return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : {
ref: result,
code: (0, codegen_1.stringify)(result)
});
}
function validSchemaType(schema, schemaType, allowUndefined = false) {
return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
}
exports.validSchemaType = validSchemaType;
function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {
if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) throw new Error("ajv implementation error");
const deps = def.dependencies;
if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
if (def.validateSchema) {
if (!def.validateSchema(schema[keyword])) {
const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors);
if (opts.validateSchema === "log") self.logger.error(msg);
else throw new Error(msg);
}
}
}
exports.validateKeywordUsage = validateKeywordUsage;
});
var require_subschema = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
const codegen_1 = require_codegen();
const util_1 = require_util();
function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
if (keyword !== void 0 && schema !== void 0) throw new Error('both "keyword" and "schema" passed, only one allowed');
if (keyword !== void 0) {
const sch = it.schema[keyword];
return schemaProp === void 0 ? {
schema: sch,
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
errSchemaPath: `${it.errSchemaPath}/${keyword}`
} : {
schema: sch[schemaProp],
schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
};
}
if (schema !== void 0) {
if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
return {
schema,
schemaPath,
topSchemaRef,
errSchemaPath
};
}
throw new Error('either "keyword" or "schema" must be passed');
}
exports.getSubschema = getSubschema;
function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
if (data !== void 0 && dataProp !== void 0) throw new Error('both "data" and "dataProp" passed, only one allowed');
const { gen } = it;
if (dataProp !== void 0) {
const { errorPath, dataPathArr, opts } = it;
dataContextProps(gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true));
subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
}
if (data !== void 0) {
dataContextProps(data instanceof codegen_1.Name ? data : gen.let("data", data, true));
if (propertyName !== void 0) subschema.propertyName = propertyName;
}
if (dataTypes) subschema.dataTypes = dataTypes;
function dataContextProps(_nextData) {
subschema.data = _nextData;
subschema.dataLevel = it.dataLevel + 1;
subschema.dataTypes = [];
it.definedProperties = /* @__PURE__ */ new Set();
subschema.parentData = it.data;
subschema.dataNames = [...it.dataNames, _nextData];
}
}
exports.extendSubschemaData = extendSubschemaData;
function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
if (compositeRule !== void 0) subschema.compositeRule = compositeRule;
if (createErrors !== void 0) subschema.createErrors = createErrors;
if (allErrors !== void 0) subschema.allErrors = allErrors;
subschema.jtdDiscriminator = jtdDiscriminator;
subschema.jtdMetadata = jtdMetadata;
}
exports.extendSubschemaMode = extendSubschemaMode;
});
var require_fast_deep_equal = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = function equal(a, b) {
if (a === b) return true;
if (a && b && typeof a == "object" && typeof b == "object") {
if (a.constructor !== b.constructor) return false;
var length, i, keys;
if (Array.isArray(a)) {
length = a.length;
if (length != b.length) return false;
for (i = length; i-- !== 0; ) if (!equal(a[i], b[i])) return false;
return true;
}
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length) return false;
for (i = length; i-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
for (i = length; i-- !== 0; ) {
var key = keys[i];
if (!equal(a[key], b[key])) return false;
}
return true;
}
return a !== a && b !== b;
};
});
var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin((exports, module) => {
var traverse = module.exports = function(schema, opts, cb) {
if (typeof opts == "function") {
cb = opts;
opts = {};
}
cb = opts.cb || cb;
var pre = typeof cb == "function" ? cb : cb.pre || function() {
};
var post = cb.post || function() {
};
_traverse(opts, pre, post, schema, "", schema);
};
traverse.keywords = {
additionalItems: true,
items: true,
contains: true,
additionalProperties: true,
propertyNames: true,
not: true,
if: true,
then: true,
else: true
};
traverse.arrayKeywords = {
items: true,
allOf: true,
anyOf: true,
oneOf: true
};
traverse.propsKeywords = {
$defs: true,
definitions: true,
properties: true,
patternProperties: true,
dependencies: true
};
traverse.skipKeywords = {
default: true,
enum: true,
const: true,
required: true,
maximum: true,
minimum: true,
exclusiveMaximum: true,
exclusiveMinimum: true,
multipleOf: true,
maxLength: true,
minLength: true,
pattern: true,
format: true,
maxItems: true,
minItems: true,
uniqueItems: true,
maxProperties: true,
minProperties: true
};
function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
if (schema && typeof schema == "object" && !Array.isArray(schema)) {
pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
for (var key in schema) {
var sch = schema[key];
if (Array.isArray(sch)) {
if (key in traverse.arrayKeywords) for (var i = 0; i < sch.length; i++) _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
} else if (key in traverse.propsKeywords) {
if (sch && typeof sch == "object") for (var prop in sch) _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
}
post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
}
}
function escapeJsonPtr(str) {
return str.replace(/~/g, "~0").replace(/\//g, "~1");
}
});
var require_resolve = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
const util_1 = require_util();
const equal = require_fast_deep_equal();
const traverse = require_json_schema_traverse();
const SIMPLE_INLINED = /* @__PURE__ */ new Set([
"type",
"format",
"pattern",
"maxLength",
"minLength",
"maxProperties",
"minProperties",
"maxItems",
"minItems",
"maximum",
"minimum",
"uniqueItems",
"multipleOf",
"required",
"enum",
"const"
]);
function inlineRef(schema, limit = true) {
if (typeof schema == "boolean") return true;
if (limit === true) return !hasRef(schema);
if (!limit) return false;
return countKeys(schema) <= limit;
}
exports.inlineRef = inlineRef;
const REF_KEYWORDS = /* @__PURE__ */ new Set([
"$ref",
"$recursiveRef",
"$recursiveAnchor",
"$dynamicRef",
"$dynamicAnchor"
]);
function hasRef(schema) {
for (const key in schema) {
if (REF_KEYWORDS.has(key)) return true;
const sch = schema[key];
if (Array.isArray(sch) && sch.some(hasRef)) return true;
if (typeof sch == "object" && hasRef(sch)) return true;
}
return false;
}
function countKeys(schema) {
let count = 0;
for (const key in schema) {
if (key === "$ref") return Infinity;
count++;
if (SIMPLE_INLINED.has(key)) continue;
if (typeof schema[key] == "object") (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
if (count === Infinity) return Infinity;
}
return count;
}
function getFullPath(resolver, id = "", normalize) {
if (normalize !== false) id = normalizeId(id);
return _getFullPath(resolver, resolver.parse(id));
}
exports.getFullPath = getFullPath;
function _getFullPath(resolver, p) {
return resolver.serialize(p).split("#")[0] + "#";
}
exports._getFullPath = _getFullPath;
const TRAILING_SLASH_HASH = /#\/?$/;
function normalizeId(id) {
return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
}
exports.normalizeId = normalizeId;
function resolveUrl(resolver, baseId, id) {
id = normalizeId(id);
return resolver.resolve(baseId, id);
}
exports.resolveUrl = resolveUrl;
const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
function getSchemaRefs(schema, baseId) {
if (typeof schema == "boolean") return {};
const { schemaId, uriResolver } = this.opts;
const schId = normalizeId(schema[schemaId] || baseId);
const baseIds = { "": schId };
const pathPrefix = getFullPath(uriResolver, schId, false);
const localRefs = {};
const schemaRefs = /* @__PURE__ */ new Set();
traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
if (parentJsonPtr === void 0) return;
const fullPath = pathPrefix + jsonPtr;
let innerBaseId = baseIds[parentJsonPtr];
if (typeof sch[schemaId] == "string") innerBaseId = addRef.call(this, sch[schemaId]);
addAnchor.call(this, sch.$anchor);
addAnchor.call(this, sch.$dynamicAnchor);
baseIds[jsonPtr] = innerBaseId;
function addRef(ref) {
const _resolve = this.opts.uriResolver.resolve;
ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
if (schemaRefs.has(ref)) throw ambiguos(ref);
schemaRefs.add(ref);
let schOrRef = this.refs[ref];
if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef];
if (typeof schOrRef == "object") checkAmbiguosRef(sch, schOrRef.schema, ref);
else if (ref !== normalizeId(fullPath)) if (ref[0] === "#") {
checkAmbiguosRef(sch, localRefs[ref], ref);
localRefs[ref] = sch;
} else this.refs[ref] = fullPath;
return ref;
}
function addAnchor(anchor2) {
if (typeof anchor2 == "string") {
if (!ANCHOR.test(anchor2)) throw new Error(`invalid anchor "${anchor2}"`);
addRef.call(this, `#${anchor2}`);
}
}
});
return localRefs;
function checkAmbiguosRef(sch1, sch2, ref) {
if (sch2 !== void 0 && !equal(sch1, sch2)) throw ambiguos(ref);
}
function ambiguos(ref) {
return /* @__PURE__ */ new Error(`reference "${ref}" resolves to more than one schema`);
}
}
exports.getSchemaRefs = getSchemaRefs;
});
var require_validate = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
const boolSchema_1 = require_boolSchema();
const dataType_1 = require_dataType();
const applicability_1 = require_applicability();
const dataType_2 = require_dataType();
const defaults_1 = require_defaults();
const keyword_1 = require_keyword();
const subschema_1 = require_subschema();
const codegen_1 = require_codegen();
const names_1 = require_names();
const resolve_1 = require_resolve();
const util_1 = require_util();
const errors_1 = require_errors();
function validateFunctionCode(it) {
if (isSchemaObj(it)) {
checkKeywords(it);
if (schemaCxtHasRules(it)) {
topSchemaObjCode(it);
return;
}
}
validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
}
exports.validateFunctionCode = validateFunctionCode;
function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
if (opts.code.es5) gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
destructureValCxtES5(gen, opts);
gen.code(body);
});
else gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
}
function destructureValCxt(opts) {
return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
}
function destructureValCxtES5(gen, opts) {
gen.if(names_1.default.valCxt, () => {
gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`);
gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`);
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);
gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`);
if (opts.dynamicRef) gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);
}, () => {
gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
gen.var(names_1.default.rootData, names_1.default.data);
if (opts.dynamicRef) gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
});
}
function topSchemaObjCode(it) {
const { schema, opts, gen } = it;
validateFunction(it, () => {
if (opts.$comment && schema.$comment) commentKeyword(it);
checkNoDefault(it);
gen.let(names_1.default.vErrors, null);
gen.let(names_1.default.errors, 0);
if (opts.unevaluated) resetEvaluated(it);
typeAndKeywords(it);
returnResults(it);
});
}
function resetEvaluated(it) {
const { gen, validateName } = it;
it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
}
function funcSourceUrl(schema, opts) {
const schId = typeof schema == "object" && schema[opts.schemaId];
return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
}
function subschemaCode(it, valid) {
if (isSchemaObj(it)) {
checkKeywords(it);
if (schemaCxtHasRules(it)) {
subSchemaObjCode(it, valid);
return;
}
}
(0, boolSchema_1.boolOrEmptySchema)(it, valid);
}
function schemaCxtHasRules({ schema, self }) {
if (typeof schema == "boolean") return !schema;
for (const key in schema) if (self.RULES.all[key]) return true;
return false;
}
function isSchemaObj(it) {
return typeof it.schema != "boolean";
}
function subSchemaObjCode(it, valid) {
const { schema, gen, opts } = it;
if (opts.$comment && schema.$comment) commentKeyword(it);
updateContext(it);
checkAsyncSchema(it);
const errsCount = gen.const("_errs", names_1.default.errors);
typeAndKeywords(it, errsCount);
gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
}
function checkKeywords(it) {
(0, util_1.checkUnknownRules)(it);
checkRefsAndKeywords(it);
}
function typeAndKeywords(it, errsCount) {
if (it.opts.jtd) return schemaKeywords(it, [], false, errsCount);
const types = (0, dataType_1.getSchemaTypes)(it.schema);
schemaKeywords(it, types, !(0, dataType_1.coerceAndCheckDataType)(it, types), errsCount);
}
function checkRefsAndKeywords(it) {
const { schema, errSchemaPath, opts, self } = it;
if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
}
function checkNoDefault(it) {
const { schema, opts } = it;
if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
}
function updateContext(it) {
const schId = it.schema[it.opts.schemaId];
if (schId) it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
}
function checkAsyncSchema(it) {
if (it.schema.$async && !it.schemaEnv.$async) throw new Error("async schema in sync schema");
}
function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
const msg = schema.$comment;
if (opts.$comment === true) gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
else if (typeof opts.$comment == "function") {
const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
}
}
function returnResults(it) {
const { gen, schemaEnv, validateName, ValidationError, opts } = it;
if (schemaEnv.$async) gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
else {
gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
if (opts.unevaluated) assignEvaluated(it);
gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
}
}
function assignEvaluated({ gen, evaluated, props, items }) {
if (props instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.props`, props);
if (items instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.items`, items);
}
function schemaKeywords(it, types, typeErrors, errsCount) {
const { gen, schema, data, allErrors, opts, self } = it;
const { RULES } = self;
if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
return;
}
if (!opts.jtd) checkStrictTypes(it, types);
gen.block(() => {
for (const group of RULES.rules) groupKeywords(group);
groupKeywords(RULES.post);
});
function groupKeywords(group) {
if (!(0, applicability_1.shouldUseGroup)(schema, group)) return;
if (group.type) {
gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
iterateKeywords(it, group);
if (types.length === 1 && types[0] === group.type && typeErrors) {
gen.else();
(0, dataType_2.reportTypeError)(it);
}
gen.endIf();
} else iterateKeywords(it, group);
if (!allErrors) gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
}
}
function iterateKeywords(it, group) {
const { gen, schema, opts: { useDefaults } } = it;
if (useDefaults) (0, defaults_1.assignDefaults)(it, group.type);
gen.block(() => {
for (const rule of group.rules) if ((0, applicability_1.shouldUseRule)(schema, rule)) keywordCode(it, rule.keyword, rule.definition, group.type);
});
}
function checkStrictTypes(it, types) {
if (it.schemaEnv.meta || !it.opts.strictTypes) return;
checkContextTypes(it, types);
if (!it.opts.allowUnionTypes) checkMultipleTypes(it, types);
checkKeywordTypes(it, it.dataTypes);
}
function checkContextTypes(it, types) {
if (!types.length) return;
if (!it.dataTypes.length) {
it.dataTypes = types;
return;
}
types.forEach((t) => {
if (!includesType(it.dataTypes, t)) strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
});
narrowSchemaTypes(it, types);
}
function checkMultipleTypes(it, ts) {
if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) strictTypesError(it, "use allowUnionTypes to allow union type keyword");
}
function checkKeywordTypes(it, ts) {
const rules = it.self.RULES.all;
for (const keyword in rules) {
const rule = rules[keyword];
if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
const { type } = rule.definition;
if (type.length && !type.some((t) => hasApplicableType(ts, t))) strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
}
}
}
function hasApplicableType(schTs, kwdT) {
return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
}
function includesType(ts, t) {
return ts.includes(t) || t === "integer" && ts.includes("number");
}
function narrowSchemaTypes(it, withTypes) {
const ts = [];
for (const t of it.dataTypes) if (includesType(withTypes, t)) ts.push(t);
else if (withTypes.includes("integer") && t === "number") ts.push("integer");
it.dataTypes = ts;
}
function strictTypesError(it, msg) {
const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
msg += ` at "${schemaPath}" (strictTypes)`;
(0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
}
var KeywordCxt = class {
constructor(it, def, keyword) {
(0, keyword_1.validateKeywordUsage)(it, def, keyword);
this.gen = it.gen;
this.allErrors = it.allErrors;
this.keyword = keyword;
this.data = it.data;
this.schema = it.schema[keyword];
this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
this.schemaType = def.schemaType;
this.parentSchema = it.schema;
this.params = {};
this.it = it;
this.def = def;
if (this.$data) this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
else {
this.schemaCode = this.schemaValue;
if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
}
if ("code" in def ? def.trackErrors : def.errors !== false) this.errsCount = it.gen.const("_errs", names_1.default.errors);
}
result(condition, successAction, failAction) {
this.failResult((0, codegen_1.not)(condition), successAction, failAction);
}
failResult(condition, successAction, failAction) {
this.gen.if(condition);
if (failAction) failAction();
else this.error();
if (successAction) {
this.gen.else();
successAction();
if (this.allErrors) this.gen.endIf();
} else if (this.allErrors) this.gen.endIf();
else this.gen.else();
}
pass(condition, failAction) {
this.failResult((0, codegen_1.not)(condition), void 0, failAction);
}
fail(condition) {
if (condition === void 0) {
this.error();
if (!this.allErrors) this.gen.if(false);
return;
}
this.gen.if(condition);
this.error();
if (this.allErrors) this.gen.endIf();
else this.gen.else();
}
fail$data(condition) {
if (!this.$data) return this.fail(condition);
const { schemaCode } = this;
this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
}
error(append, errorParams, errorPaths) {
if (errorParams) {
this.setParams(errorParams);
this._error(append, errorPaths);
this.setParams({});
return;
}
this._error(append, errorPaths);
}
_error(append, errorPaths) {
(append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
}
$dataError() {
(0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
}
reset() {
if (this.errsCount === void 0) throw new Error('add "trackErrors" to keyword definition');
(0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
}
ok(cond) {
if (!this.allErrors) this.gen.if(cond);
}
setParams(obj, assign) {
if (assign) Object.assign(this.params, obj);
else this.params = obj;
}
block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
this.gen.block(() => {
this.check$data(valid, $dataValid);
codeBlock();
});
}
check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
if (!this.$data) return;
const { gen, schemaCode, schemaType, def } = this;
gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
if (valid !== codegen_1.nil) gen.assign(valid, true);
if (schemaType.length || def.validateSchema) {
gen.elseIf(this.invalid$data());
this.$dataError();
if (valid !== codegen_1.nil) gen.assign(valid, false);
}
gen.else();
}
invalid$data() {
const { gen, schemaCode, schemaType, def, it } = this;
return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
function wrong$DataType() {
if (schemaType.length) {
if (!(schemaCode instanceof codegen_1.Name)) throw new Error("ajv implementation error");
const st = Array.isArray(schemaType) ? schemaType : [schemaType];
return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
}
return codegen_1.nil;
}
function invalid$DataSchema() {
if (def.validateSchema) {
const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema });
return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`;
}
return codegen_1.nil;
}
}
subschema(appl, valid) {
const subschema = (0, subschema_1.getSubschema)(this.it, appl);
(0, subschema_1.extendSubschemaData)(subschema, this.it, appl);
(0, subschema_1.extendSubschemaMode)(subschema, appl);
const nextContext = {
...this.it,
...subschema,
items: void 0,
props: void 0
};
subschemaCode(nextContext, valid);
return nextContext;
}
mergeEvaluated(schemaCxt, toName) {
const { it, gen } = this;
if (!it.opts.unevaluated) return;
if (it.props !== true && schemaCxt.props !== void 0) it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
if (it.items !== true && schemaCxt.items !== void 0) it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
}
mergeValidEvaluated(schemaCxt, valid) {
const { it, gen } = this;
if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));
return true;
}
}
};
exports.KeywordCxt = KeywordCxt;
function keywordCode(it, keyword, def, ruleType) {
const cxt = new KeywordCxt(it, def, keyword);
if ("code" in def) def.code(cxt, ruleType);
else if (cxt.$data && def.validate) (0, keyword_1.funcKeywordCode)(cxt, def);
else if ("macro" in def) (0, keyword_1.macroKeywordCode)(cxt, def);
else if (def.compile || def.validate) (0, keyword_1.funcKeywordCode)(cxt, def);
}
const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
const RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
function getData($data, { dataLevel, dataNames, dataPathArr }) {
let jsonPointer;
let data;
if ($data === "") return names_1.default.rootData;
if ($data[0] === "/") {
if (!JSON_POINTER.test($data)) throw new Error(`Invalid JSON-pointer: ${$data}`);
jsonPointer = $data;
data = names_1.default.rootData;
} else {
const matches = RELATIVE_JSON_POINTER.exec($data);
if (!matches) throw new Error(`Invalid JSON-pointer: ${$data}`);
const up = +matches[1];
jsonPointer = matches[2];
if (jsonPointer === "#") {
if (up >= dataLevel) throw new Error(errorMsg("property/index", up));
return dataPathArr[dataLevel - up];
}
if (up > dataLevel) throw new Error(errorMsg("data", up));
data = dataNames[dataLevel - up];
if (!jsonPointer) return data;
}
let expr = data;
const segments = jsonPointer.split("/");
for (const segment of segments) if (segment) {
data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
expr = (0, codegen_1._)`${expr} && ${data}`;
}
return expr;
function errorMsg(pointerType, up) {
return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
}
}
exports.getData = getData;
});
var require_validation_error = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
var ValidationError = class extends Error {
constructor(errors) {
super("validation failed");
this.errors = errors;
this.ajv = this.validation = true;
}
};
exports.default = ValidationError;
});
var require_ref_error = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const resolve_1 = require_resolve();
var MissingRefError = class extends Error {
constructor(resolver, baseId, ref, msg) {
super(msg || `can't resolve reference ${ref} from id ${baseId}`);
this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
}
};
exports.default = MissingRefError;
});
var require_compile = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
const codegen_1 = require_codegen();
const validation_error_1 = require_validation_error();
const names_1 = require_names();
const resolve_1 = require_resolve();
const util_1 = require_util();
const validate_1 = require_validate();
var SchemaEnv = class {
constructor(env) {
var _a3;
this.refs = {};
this.dynamicAnchors = {};
let schema;
if (typeof env.schema == "object") schema = env.schema;
this.schema = env.schema;
this.schemaId = env.schemaId;
this.root = env.root || this;
this.baseId = (_a3 = env.baseId) !== null && _a3 !== void 0 ? _a3 : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
this.schemaPath = env.schemaPath;
this.localRefs = env.localRefs;
this.meta = env.meta;
this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
this.refs = {};
}
};
exports.SchemaEnv = SchemaEnv;
function compileSchema(sch) {
const _sch = getCompilingSchema.call(this, sch);
if (_sch) return _sch;
const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
const { es5, lines } = this.opts.code;
const { ownProperties } = this.opts;
const gen = new codegen_1.CodeGen(this.scope, {
es5,
lines,
ownProperties
});
let _ValidationError;
if (sch.$async) _ValidationError = gen.scopeValue("Error", {
ref: validation_error_1.default,
code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
});
const validateName = gen.scopeName("validate");
sch.validateName = validateName;
const schemaCxt = {
gen,
allErrors: this.opts.allErrors,
data: names_1.default.data,
parentData: names_1.default.parentData,
parentDataProperty: names_1.default.parentDataProperty,
dataNames: [names_1.default.data],
dataPathArr: [codegen_1.nil],
dataLevel: 0,
dataTypes: [],
definedProperties: /* @__PURE__ */ new Set(),
topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? {
ref: sch.schema,
code: (0, codegen_1.stringify)(sch.schema)
} : { ref: sch.schema }),
validateName,
ValidationError: _ValidationError,
schema: sch.schema,
schemaEnv: sch,
rootId,
baseId: sch.baseId || rootId,
schemaPath: codegen_1.nil,
errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
errorPath: (0, codegen_1._)`""`,
opts: this.opts,
self: this
};
let sourceCode;
try {
this._compilations.add(sch);
(0, validate_1.validateFunctionCode)(schemaCxt);
gen.optimize(this.opts.code.optimize);
const validateCode = gen.toString();
sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
if (this.opts.code.process) sourceCode = this.opts.code.process(sourceCode, sch);
const validate2 = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode)(this, this.scope.get());
this.scope.value(validateName, { ref: validate2 });
validate2.errors = null;
validate2.schema = sch.schema;
validate2.schemaEnv = sch;
if (sch.$async) validate2.$async = true;
if (this.opts.code.source === true) validate2.source = {
validateName,
validateCode,
scopeValues: gen._values
};
if (this.opts.unevaluated) {
const { props, items } = schemaCxt;
validate2.evaluated = {
props: props instanceof codegen_1.Name ? void 0 : props,
items: items instanceof codegen_1.Name ? void 0 : items,
dynamicProps: props instanceof codegen_1.Name,
dynamicItems: items instanceof codegen_1.Name
};
if (validate2.source) validate2.source.evaluated = (0, codegen_1.stringify)(validate2.evaluated);
}
sch.validate = validate2;
return sch;
} catch (e) {
delete sch.validate;
delete sch.validateName;
if (sourceCode) this.logger.error("Error compiling schema, function code:", sourceCode);
throw e;
} finally {
this._compilations.delete(sch);
}
}
exports.compileSchema = compileSchema;
function resolveRef2(root, baseId, ref) {
var _a3;
ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
const schOrFunc = root.refs[ref];
if (schOrFunc) return schOrFunc;
let _sch = resolve.call(this, root, ref);
if (_sch === void 0) {
const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
const { schemaId } = this.opts;
if (schema) _sch = new SchemaEnv({
schema,
schemaId,
root,
baseId
});
}
if (_sch === void 0) return;
return root.refs[ref] = inlineOrCompile.call(this, _sch);
}
exports.resolveRef = resolveRef2;
function inlineOrCompile(sch) {
if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs)) return sch.schema;
return sch.validate ? sch : compileSchema.call(this, sch);
}
function getCompilingSchema(schEnv) {
for (const sch of this._compilations) if (sameSchemaEnv(sch, schEnv)) return sch;
}
exports.getCompilingSchema = getCompilingSchema;
function sameSchemaEnv(s1, s2) {
return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
}
function resolve(root, ref) {
let sch;
while (typeof (sch = this.refs[ref]) == "string") ref = sch;
return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
}
function resolveSchema(root, ref) {
const p = this.opts.uriResolver.parse(ref);
const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
if (Object.keys(root.schema).length > 0 && refPath === baseId) return getJsonPointer.call(this, p, root);
const id = (0, resolve_1.normalizeId)(refPath);
const schOrRef = this.refs[id] || this.schemas[id];
if (typeof schOrRef == "string") {
const sch = resolveSchema.call(this, root, schOrRef);
if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") return;
return getJsonPointer.call(this, p, sch);
}
if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object") return;
if (!schOrRef.validate) compileSchema.call(this, schOrRef);
if (id === (0, resolve_1.normalizeId)(ref)) {
const { schema } = schOrRef;
const { schemaId } = this.opts;
const schId = schema[schemaId];
if (schId) baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
return new SchemaEnv({
schema,
schemaId,
root,
baseId
});
}
return getJsonPointer.call(this, p, schOrRef);
}
exports.resolveSchema = resolveSchema;
const PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([
"properties",
"patternProperties",
"enum",
"dependencies",
"definitions"
]);
function getJsonPointer(parsedRef, { baseId, schema, root }) {
var _a3;
if (((_a3 = parsedRef.fragment) === null || _a3 === void 0 ? void 0 : _a3[0]) !== "/") return;
for (const part of parsedRef.fragment.slice(1).split("/")) {
if (typeof schema === "boolean") return;
const partSchema = schema[(0, util_1.unescapeFragment)(part)];
if (partSchema === void 0) return;
schema = partSchema;
const schId = typeof schema === "object" && schema[this.opts.schemaId];
if (!PREVENT_SCOPE_CHANGE.has(part) && schId) baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
}
let env;
if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
env = resolveSchema.call(this, root, $ref);
}
const { schemaId } = this.opts;
env = env || new SchemaEnv({
schema,
schemaId,
root,
baseId
});
if (env.schema !== env.root.schema) return env;
}
});
var require_data = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$id": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
"description": "Meta-schema for $data reference (JSON AnySchema extension proposal)",
"type": "object",
"required": ["$data"],
"properties": { "$data": {
"type": "string",
"anyOf": [{ "format": "relative-json-pointer" }, { "format": "json-pointer" }]
} },
"additionalProperties": false
};
});
var require_utils = /* @__PURE__ */ __commonJSMin((exports, module) => {
const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
const isPort = RegExp.prototype.test.bind(/^\d*$/u);
const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
const isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
const isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
const isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
const BYTE_HEX = new Array(256);
{
const HEX_DIGITS = "0123456789ABCDEF";
for (let i = 0; i < 256; i++) BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
}
function percentEncodeNonAscii(cp) {
if (cp < 2048) return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
if (cp < 65536) return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
}
function stringArrayToHexStripped(input2) {
let acc = "";
let code = 0;
let i = 0;
for (i = 0; i < input2.length; i++) {
code = input2[i].charCodeAt(0);
if (code === 48) continue;
if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
acc += input2[i];
break;
}
for (i += 1; i < input2.length; i++) {
code = input2[i].charCodeAt(0);
if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
acc += input2[i];
}
return acc;
}
const isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
const isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
const isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
function isZoneIdentifier(zone) {
if (zone.length === 0) return false;
for (let i = 0; i < zone.length; i++) {
if (isZoneCharacter(zone[i])) continue;
if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
i += 2;
continue;
}
return false;
}
return true;
}
function compressIPv6ZeroRun(hextets) {
let bestStart = -1;
let bestLength = 0;
let runStart = -1;
let runLength = 0;
for (let i = 0; i < hextets.length; i++) if (hextets[i] === "0") {
if (runStart === -1) runStart = i;
runLength++;
if (runLength > bestLength) {
bestLength = runLength;
bestStart = runStart;
}
} else {
runStart = -1;
runLength = 0;
}
if (bestLength < 2) return hextets.join(":");
const head = hextets.slice(0, bestStart).join(":");
const tail = hextets.slice(bestStart + bestLength).join(":");
return head + "::" + tail;
}
function normalizeIPv6Address(input2) {
const compression = input2.indexOf("::");
if (compression !== -1 && input2.indexOf("::", compression + 1) !== -1) return void 0;
const left = compression === -1 ? input2.split(":") : input2.slice(0, compression).split(":");
const right = compression === -1 ? [] : input2.slice(compression + 2).split(":");
if (compression !== -1) {
if (left.length === 1 && left[0] === "") left.length = 0;
if (right.length === 1 && right[0] === "") right.length = 0;
}
const parts = left.concat(right);
let hextetCount = 0;
for (let i = 0; i < parts.length; i++) {
const part = parts[i];
if (part === "") return void 0;
if (part.indexOf(".") !== -1) {
if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
hextetCount += 2;
continue;
}
if (!isHextet(part)) return void 0;
parts[i] = parseInt(part, 16).toString(16);
hextetCount++;
}
if (compression === -1) {
if (hextetCount !== 8) return void 0;
return compressIPv6ZeroRun(parts);
}
if (hextetCount >= 8) return void 0;
const expanded = parts.slice(0, left.length);
for (let i = hextetCount; i < 8; i++) expanded.push("0");
for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
return compressIPv6ZeroRun(expanded);
}
function normalizeIPv6(host) {
const bracketed = host[0] === "[" && host[host.length - 1] === "]";
if ((host[0] === "[" || host[host.length - 1] === "]") && !bracketed) return {
host,
isIPV6: false,
error: true
};
let input2 = bracketed ? host.slice(1, -1) : host;
if (bracketed && isIPvFuture(input2)) {
input2 = input2.toLowerCase();
return {
host: `[${input2}]`,
escapedHost: input2,
isIPV6: false,
isIPVFuture: true
};
}
if (findToken(input2, ":") < 2) return {
host,
isIPV6: false,
error: bracketed
};
let zoneIdentifier = "";
const zoneSeparator = input2.indexOf("%");
if (zoneSeparator !== -1) {
const separatorLength = input2.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
zoneIdentifier = input2.slice(zoneSeparator + separatorLength);
if (!isZoneIdentifier(zoneIdentifier)) return {
host,
isIPV6: false,
error: true
};
input2 = input2.slice(0, zoneSeparator);
}
const address = normalizeIPv6Address(input2);
if (address === void 0) return {
host,
isIPV6: false,
error: true
};
return {
host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
isIPV6: true
};
}
function findToken(str, token) {
let ind = 0;
for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
return ind;
}
function removeDotSegments(path3) {
let input2 = path3;
const output2 = [];
let nextSlash = -1;
let len = 0;
while (len = input2.length) {
if (len === 1) if (input2 === ".") break;
else if (input2 === "/") {
output2.push("/");
break;
} else {
output2.push(input2);
break;
}
else if (len === 2) {
if (input2[0] === ".") {
if (input2[1] === ".") break;
else if (input2[1] === "/") {
input2 = input2.slice(2);
continue;
}
} else if (input2[0] === "/") {
if (input2[1] === "." || input2[1] === "/") {
output2.push("/");
break;
}
}
} else if (len === 3) {
if (input2 === "/..") {
if (output2.length !== 0) output2.pop();
output2.push("/");
break;
}
}
if (input2[0] === ".") {
if (input2[1] === ".") {
if (input2[2] === "/") {
input2 = input2.slice(3);
continue;
}
} else if (input2[1] === "/") {
input2 = input2.slice(2);
continue;
}
} else if (input2[0] === "/") {
if (input2[1] === ".") {
if (input2[2] === "/") {
input2 = input2.slice(2);
continue;
} else if (input2[2] === ".") {
if (input2[3] === "/") {
input2 = input2.slice(3);
if (output2.length !== 0) output2.pop();
continue;
}
}
}
}
if ((nextSlash = input2.indexOf("/", 1)) === -1) {
output2.push(input2);
break;
} else {
output2.push(input2.slice(0, nextSlash));
input2 = input2.slice(nextSlash);
}
}
return output2.join("");
}
const HOST_DELIMS = {
"@": "%40",
"/": "%2F",
"?": "%3F",
"#": "%23",
":": "%3A"
};
const HOST_DELIM_RE = /[@/?#:]/g;
const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
function reescapeHostDelimiters(host, isIP) {
const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
re.lastIndex = 0;
return host.replace(re, (ch) => HOST_DELIMS[ch]);
}
function normalizePercentEncoding(input2, decodeUnreserved = false) {
if (input2.indexOf("%") === -1) return input2;
let output2 = "";
for (let i = 0; i < input2.length; i++) {
if (input2[i] === "%" && i + 2 < input2.length) {
const hex3 = input2.slice(i + 1, i + 3);
if (isHexPair(hex3)) {
const normalizedHex = hex3.toUpperCase();
const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
if (decodeUnreserved && isUnreserved(decoded)) output2 += decoded;
else output2 += "%" + normalizedHex;
i += 2;
continue;
}
}
output2 += input2[i];
}
return output2;
}
function normalizePathEncoding(input2) {
let output2 = "";
for (let i = 0; i < input2.length; i++) {
const ch = input2[i];
if (ch === "%" && i + 2 < input2.length) {
const hex3 = input2.slice(i + 1, i + 3);
if (isHexPair(hex3)) {
const normalizedHex = hex3.toUpperCase();
const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
if (decoded !== "." && isUnreserved(decoded)) output2 += decoded;
else output2 += "%" + normalizedHex;
i += 2;
continue;
}
}
if (isPathCharacter(ch)) output2 += ch;
else {
const code = input2.charCodeAt(i);
if (code < 128) output2 += isEscapeSafe(code) ? ch : BYTE_HEX[code];
else if (code < 55296 || code > 57343) output2 += percentEncodeNonAscii(code);
else if (code <= 56319 && i + 1 < input2.length) {
const low = input2.charCodeAt(i + 1);
if (low >= 56320 && low <= 57343) {
output2 += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
i++;
} else output2 += percentEncodeNonAscii(65533);
} else output2 += percentEncodeNonAscii(65533);
}
}
return output2;
}
function serializePathEncoding(input2, pathNoScheme = false) {
let output2 = "";
let firstSegment = pathNoScheme && input2[0] !== "/";
for (let i = 0; i < input2.length; i++) {
const ch = input2[i];
if (ch === "%" && i + 2 < input2.length) {
const hex3 = input2.slice(i + 1, i + 3);
if (isHexPair(hex3)) {
output2 += "%" + hex3.toUpperCase();
i += 2;
continue;
}
}
if (ch === "/") firstSegment = false;
if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) output2 += ch;
else {
const code = input2.charCodeAt(i);
if (code < 128) output2 += BYTE_HEX[code];
else if (code < 55296 || code > 57343) output2 += percentEncodeNonAscii(code);
else if (code <= 56319 && i + 1 < input2.length) {
const low = input2.charCodeAt(i + 1);
if (low >= 56320 && low <= 57343) {
output2 += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
i++;
} else output2 += percentEncodeNonAscii(65533);
} else output2 += percentEncodeNonAscii(65533);
}
}
return output2;
}
function encodeComponent(input2, isAllowed) {
let output2 = "";
for (let i = 0; i < input2.length; i++) {
const ch = input2[i];
if (ch === "%" && i + 2 < input2.length) {
const hex3 = input2.slice(i + 1, i + 3);
if (isHexPair(hex3)) {
output2 += "%" + hex3.toUpperCase();
i += 2;
continue;
}
}
if (isAllowed(ch)) output2 += ch;
else {
const code = input2.charCodeAt(i);
if (code < 128) output2 += BYTE_HEX[code];
else if (code < 55296 || code > 57343) output2 += percentEncodeNonAscii(code);
else if (code <= 56319 && i + 1 < input2.length) {
const low = input2.charCodeAt(i + 1);
if (low >= 56320 && low <= 57343) {
output2 += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
i++;
} else output2 += percentEncodeNonAscii(65533);
} else output2 += percentEncodeNonAscii(65533);
}
}
return output2;
}
function encodeUserinfo(input2) {
return encodeComponent(input2, isUserinfoCharacter);
}
function encodeQuery(input2) {
return encodeComponent(input2, isQueryFragmentCharacter);
}
function encodeFragment(input2) {
return encodeComponent(input2, isQueryFragmentCharacter);
}
function isEscapeSafe(cp) {
return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
}
function normalizeQueryFragmentEncoding(input2) {
let output2 = "";
for (let i = 0; i < input2.length; i++) {
const ch = input2[i];
if (ch === "%" && i + 2 < input2.length) {
const hex3 = input2.slice(i + 1, i + 3);
if (isHexPair(hex3)) {
const normalizedHex = hex3.toUpperCase();
const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
if (isUnreserved(decoded)) output2 += decoded;
else output2 += "%" + normalizedHex;
i += 2;
continue;
}
}
if (isQueryFragmentCharacter(ch)) output2 += ch;
else {
const code = input2.charCodeAt(i);
if (code < 128) output2 += isEscapeSafe(code) ? ch : BYTE_HEX[code];
else if (code < 55296 || code > 57343) output2 += percentEncodeNonAscii(code);
else if (code <= 56319 && i + 1 < input2.length) {
const low = input2.charCodeAt(i + 1);
if (low >= 56320 && low <= 57343) {
output2 += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
i++;
} else output2 += percentEncodeNonAscii(65533);
} else output2 += percentEncodeNonAscii(65533);
}
}
return output2;
}
function escapePreservingEscapes(input2) {
let output2 = "";
for (let i = 0; i < input2.length; i++) {
if (input2[i] === "%" && i + 2 < input2.length) {
const hex3 = input2.slice(i + 1, i + 3);
if (isHexPair(hex3)) {
output2 += "%" + hex3.toUpperCase();
i += 2;
continue;
}
}
output2 += escape(input2[i]);
}
return output2;
}
function recomposeAuthority(component) {
const uriTokens = [];
if (component.userinfo !== void 0) {
uriTokens.push(encodeUserinfo(component.userinfo));
uriTokens.push("@");
}
if (component.host !== void 0) {
let host = component.host;
if (!isIPv4(host)) {
let ipV6res = normalizeIPv6(host);
if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
host = normalizePercentEncoding(host, true);
ipV6res = normalizeIPv6(host);
}
if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) host = `[${ipV6res.escapedHost}]`;
else host = reescapeHostDelimiters(host, false);
}
uriTokens.push(host);
}
if (typeof component.port === "number" || typeof component.port === "string") {
const port = String(component.port);
if (!isPort(port)) throw new TypeError("URI port is malformed.");
uriTokens.push(":");
uriTokens.push(port);
}
return uriTokens.length ? uriTokens.join("") : void 0;
}
module.exports = {
nonSimpleDomain,
recomposeAuthority,
reescapeHostDelimiters,
normalizePercentEncoding,
normalizePathEncoding,
serializePathEncoding,
normalizeQueryFragmentEncoding,
encodeUserinfo,
encodeQuery,
encodeFragment,
escapePreservingEscapes,
removeDotSegments,
isIPv4,
isUUID,
normalizeIPv6,
stringArrayToHexStripped
};
});
var require_schemes = /* @__PURE__ */ __commonJSMin((exports, module) => {
const { isUUID } = require_utils();
const URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
const supportedSchemeNames = [
"http",
"https",
"ws",
"wss",
"urn",
"urn:uuid"
];
function isValidSchemeName(name) {
return supportedSchemeNames.indexOf(name) !== -1;
}
function wsIsSecure(wsComponent) {
if (wsComponent.secure === true) return true;
else if (wsComponent.secure === false) return false;
else if (wsComponent.scheme) return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
else return false;
}
function httpParse(component) {
if (!component.host) component.error = component.error || "HTTP URIs must have a host.";
return component;
}
function httpSerialize(component) {
const secure = String(component.scheme).toLowerCase() === "https";
if (component.port === (secure ? 443 : 80) || component.port === "") component.port = void 0;
if (!component.path) component.path = "/";
return component;
}
function wsParse(wsComponent) {
wsComponent.secure = wsIsSecure(wsComponent);
wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
wsComponent.path = void 0;
wsComponent.query = void 0;
return wsComponent;
}
function wsSerialize(wsComponent) {
if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") wsComponent.port = void 0;
if (typeof wsComponent.secure === "boolean") {
wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
wsComponent.secure = void 0;
}
if (wsComponent.resourceName) {
const queryIndex = wsComponent.resourceName.indexOf("?");
const path3 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
wsComponent.resourceName = void 0;
}
wsComponent.fragment = void 0;
return wsComponent;
}
function urnParse(urnComponent, options) {
if (!urnComponent.path) {
urnComponent.error = "URN can not be parsed";
return urnComponent;
}
const matches = urnComponent.path.match(URN_REG);
if (matches && matches[0] === urnComponent.path) {
const scheme = options.scheme || urnComponent.scheme || "urn";
urnComponent.nid = matches[1].toLowerCase();
urnComponent.nss = matches[2];
const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || urnComponent.nid}`);
urnComponent.path = void 0;
if (schemeHandler) urnComponent = schemeHandler.parse(urnComponent, options);
} else urnComponent.error = urnComponent.error || "URN can not be parsed.";
return urnComponent;
}
function urnSerialize(urnComponent, options) {
if (urnComponent.nid === void 0) throw new Error("URN without nid cannot be serialized");
const scheme = options.scheme || urnComponent.scheme || "urn";
const nid = urnComponent.nid.toLowerCase();
const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || nid}`);
if (schemeHandler) urnComponent = schemeHandler.serialize(urnComponent, options);
const uriComponent = urnComponent;
const nss = urnComponent.nss;
uriComponent.path = `${nid || options.nid}:${nss}`;
options.skipEscape = true;
return uriComponent;
}
function urnuuidParse(urnComponent, options) {
const uuidComponent = urnComponent;
uuidComponent.uuid = uuidComponent.nss;
uuidComponent.nss = void 0;
if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) uuidComponent.error = uuidComponent.error || "UUID is not valid.";
return uuidComponent;
}
function urnuuidSerialize(uuidComponent) {
const urnComponent = uuidComponent;
urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
return urnComponent;
}
const http = {
scheme: "http",
domainHost: true,
parse: httpParse,
serialize: httpSerialize
};
const https = {
scheme: "https",
domainHost: http.domainHost,
parse: httpParse,
serialize: httpSerialize
};
const ws = {
scheme: "ws",
domainHost: true,
parse: wsParse,
serialize: wsSerialize
};
const wss = {
scheme: "wss",
domainHost: ws.domainHost,
parse: ws.parse,
serialize: ws.serialize
};
const urn = {
scheme: "urn",
parse: urnParse,
serialize: urnSerialize,
skipNormalize: true
};
const urnuuid = {
scheme: "urn:uuid",
parse: urnuuidParse,
serialize: urnuuidSerialize,
skipNormalize: true
};
const SCHEMES = {
http,
https,
ws,
wss,
urn,
"urn:uuid": urnuuid
};
Object.setPrototypeOf(SCHEMES, null);
function getSchemeHandler(scheme) {
return scheme && (SCHEMES[scheme] || SCHEMES[scheme.toLowerCase()]) || void 0;
}
module.exports = {
wsIsSecure,
SCHEMES,
isValidSchemeName,
getSchemeHandler
};
});
var require_fast_uri = /* @__PURE__ */ __commonJSMin((exports, module) => {
const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
const { SCHEMES, getSchemeHandler } = require_schemes();
const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
const MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
function decodeValidScheme(scheme) {
const decodedScheme = unescape(String(scheme));
if (!VALID_SCHEME.test(decodedScheme)) throw new TypeError(MALFORMED_SCHEME_ERROR);
return decodedScheme;
}
function normalize(uri, options) {
if (typeof uri === "string") uri = normalizeString(uri, options);
else if (typeof uri === "object") uri = parse3(serialize(uri, options), options);
return uri;
}
function resolve(baseURI, relativeURI, options) {
const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed, malformedPercentEncoding: baseMalformedPercentEncoding, malformedSchemeSpecific: baseMalformedSchemeSpecific, malformedHost: baseMalformedHost, malformedScheme: baseMalformedScheme } = parseWithStatus(baseURI, schemelessOptions);
const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed, malformedPercentEncoding: relativeMalformedPercentEncoding, malformedSchemeSpecific: relativeMalformedSchemeSpecific, malformedHost: relativeMalformedHost, malformedScheme: relativeMalformedScheme } = parseWithStatus(relativeURI, schemelessOptions);
if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
const resolvedHost = resolved.host;
const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
if (resolved.error && !encodedASCIIHost) throw new Error(resolved.error);
schemelessOptions.skipEscape = true;
return serialize(resolved, schemelessOptions);
}
function resolveComponent(base, relative, options, skipNormalization) {
const target = {};
if (!skipNormalization) {
base = parse3(serialize(base, options), options);
relative = parse3(serialize(relative, options), options);
}
options = options || {};
if (!options.tolerant && relative.scheme) {
target.scheme = relative.scheme;
target.userinfo = relative.userinfo;
target.host = relative.host;
target.port = relative.port;
target.path = removeDotSegments(relative.path || "");
target.query = relative.query;
} else {
if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
target.userinfo = relative.userinfo;
target.host = relative.host;
target.port = relative.port;
target.path = removeDotSegments(relative.path || "");
target.query = relative.query;
} else {
if (!relative.path) {
target.path = base.path;
if (relative.query !== void 0) target.query = relative.query;
else target.query = base.query;
} else {
if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
else {
if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative.path;
else if (!base.path) target.path = relative.path;
else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
target.path = removeDotSegments(target.path);
}
target.query = relative.query;
}
target.userinfo = base.userinfo;
target.host = base.host;
target.port = base.port;
}
target.scheme = base.scheme;
}
target.fragment = relative.fragment;
return target;
}
function equal(uriA, uriB, options) {
const normalizedA = normalizeComparableURI(uriA, options);
const normalizedB = normalizeComparableURI(uriB, options);
return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
}
function serialize(cmpts, opts) {
const component = {
host: cmpts.host,
scheme: cmpts.scheme,
userinfo: cmpts.userinfo,
port: cmpts.port,
path: cmpts.path,
query: cmpts.query,
nid: cmpts.nid,
nss: cmpts.nss,
uuid: cmpts.uuid,
fragment: cmpts.fragment,
reference: cmpts.reference,
resourceName: cmpts.resourceName,
secure: cmpts.secure,
error: ""
};
const options = Object.assign({}, opts);
const uriTokens = [];
if (component.scheme) component.scheme = decodeValidScheme(component.scheme);
const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
if (component.path !== void 0) if (!options.skipEscape) component.path = serializePathEncoding(component.path, pathNoScheme);
else component.path = normalizePercentEncoding(component.path);
if (options.reference !== "suffix" && component.scheme) {
component.scheme = decodeValidScheme(component.scheme);
uriTokens.push(component.scheme, ":");
}
const authority = recomposeAuthority(component);
if (authority !== void 0) {
if (options.reference !== "suffix") uriTokens.push("//");
uriTokens.push(authority);
if (component.path && component.path[0] !== "/") uriTokens.push("/");
}
if (component.path !== void 0) {
let s = component.path;
if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) s = removeDotSegments(s);
if (pathNoScheme) s = serializePathEncoding(s, true);
if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
uriTokens.push(s);
}
if (component.query !== void 0) uriTokens.push("?", encodeQuery(component.query));
if (component.fragment !== void 0) uriTokens.push("#", encodeFragment(component.fragment));
return uriTokens.join("");
}
const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
const AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
function getParseError(parsed, matches) {
if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") return 'URI path must start with "/" when authority is present.';
if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) return "URI port is malformed.";
}
function hasMalformedPercentEncoding(component) {
if (component === void 0) return false;
let percent = component.indexOf("%");
while (percent !== -1) {
if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) return true;
percent = component.indexOf("%", percent + 3);
}
return false;
}
function isIPLiteral(host) {
return host[0] === "[" && host[host.length - 1] === "]";
}
function hasMalformedComponentPercentEncoding(matches) {
const host = matches[4];
return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
}
function canonicalizeHost(parsed, options, schemeHandler, isIP) {
if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
parsed.host = new URL("http://" + parsed.host).hostname;
} catch (e) {
parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
return true;
}
return false;
}
function parseWithStatus(uri, opts) {
const options = Object.assign({}, opts);
const parsed = {
scheme: void 0,
userinfo: void 0,
host: "",
port: void 0,
path: "",
query: void 0,
fragment: void 0
};
let malformedAuthorityOrPort = false;
let malformedPercentEncoding = false;
let malformedSchemeSpecific = false;
let malformedHost = false;
let malformedIPLiteral = false;
let malformedScheme = false;
let isIP = false;
if (options.reference === "suffix") if (options.scheme) uri = options.scheme + ":" + uri;
else uri = "//" + uri;
const authorityMatch = uri.match(AUTHORITY_PREFIX);
if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
parsed.error = "URI authority must not contain a literal backslash.";
malformedAuthorityOrPort = true;
}
const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
if (introducerMatch !== null) {
const region = introducerMatch[1];
const normalizedRegion = region.replace(/[\t\n\r]/g, "");
if (normalizedRegion.length >= 2) {
if (normalizedRegion.slice(0, 2) !== "//") {
parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
malformedAuthorityOrPort = true;
} else if (region.length !== normalizedRegion.length) {
parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
malformedAuthorityOrPort = true;
}
}
}
const matches = uri.match(URI_PARSE);
if (matches) {
parsed.scheme = matches[1];
parsed.userinfo = matches[3];
parsed.host = matches[4];
parsed.port = parseInt(matches[5], 10);
parsed.path = matches[6] || "";
parsed.query = matches[7];
parsed.fragment = matches[8];
if (parsed.scheme !== void 0) {
const decodedScheme = unescape(parsed.scheme);
if (VALID_SCHEME.test(decodedScheme)) parsed.scheme = decodedScheme.toLowerCase();
else {
parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
malformedScheme = true;
}
}
malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
if (malformedPercentEncoding) parsed.error = parsed.error || "URI contains malformed percent-encoding.";
if (isNaN(parsed.port)) parsed.port = matches[5];
const parseError = getParseError(parsed, matches);
if (parseError !== void 0) {
parsed.error = parsed.error || parseError;
malformedAuthorityOrPort = true;
}
if (parsed.host) if (isIPv4(parsed.host) === false) {
const bracketedIPLiteral = isIPLiteral(parsed.host);
const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
const ipv6result = normalizeIPv6(parsed.host);
isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
if (malformedIPLiteral) {
parsed.error = parsed.error || "URI host is malformed.";
malformedAuthorityOrPort = true;
}
} else isIP = true;
if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) parsed.reference = "same-document";
else if (parsed.scheme === void 0) parsed.reference = "relative";
else if (parsed.fragment === void 0) parsed.reference = "absolute";
else parsed.reference = "uri";
if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
if (!malformedIPLiteral) malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
if (!isIP) host = normalizePercentEncoding(host.toLowerCase());
parsed.host = reescapeHostDelimiters(host, isIP);
}
if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
if (parsed.path) parsed.path = normalizePathEncoding(parsed.path);
if (parsed.query) parsed.query = normalizeQueryFragmentEncoding(parsed.query);
if (parsed.fragment) parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
}
if (schemeHandler && schemeHandler.parse) {
schemeHandler.parse(parsed, options);
if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) malformedSchemeSpecific = true;
}
} else parsed.error = parsed.error || "URI can not be parsed.";
return {
parsed,
malformedAuthorityOrPort,
malformedPercentEncoding,
malformedSchemeSpecific,
malformedHost,
malformedScheme
};
}
function parse3(uri, opts) {
return parseWithStatus(uri, opts).parsed;
}
function normalizeString(uri, opts) {
return normalizeStringWithStatus(uri, opts).normalized;
}
function normalizeStringWithStatus(uri, opts) {
const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
return {
normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
malformedAuthorityOrPort,
malformedPercentEncoding,
malformedSchemeSpecific,
malformedHost,
malformedScheme
};
}
function normalizeComparableURI(uri, opts) {
if (typeof uri !== "string" && typeof uri !== "object") return;
let value;
try {
value = typeof uri === "string" ? uri : serialize(uri, opts);
} catch {
return;
}
const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
}
const fastUri = {
SCHEMES,
normalize,
resolve,
resolveComponent,
equal,
serialize,
parse: parse3
};
module.exports = fastUri;
module.exports.default = fastUri;
module.exports.fastUri = fastUri;
});
var require_uri = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const uri = require_fast_uri();
uri.code = 'require("ajv/dist/runtime/uri").default';
exports.default = uri;
});
var require_core$3 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", {
enumerable: true,
get: function() {
return validate_1.KeywordCxt;
}
});
var codegen_1 = require_codegen();
Object.defineProperty(exports, "_", {
enumerable: true,
get: function() {
return codegen_1._;
}
});
Object.defineProperty(exports, "str", {
enumerable: true,
get: function() {
return codegen_1.str;
}
});
Object.defineProperty(exports, "stringify", {
enumerable: true,
get: function() {
return codegen_1.stringify;
}
});
Object.defineProperty(exports, "nil", {
enumerable: true,
get: function() {
return codegen_1.nil;
}
});
Object.defineProperty(exports, "Name", {
enumerable: true,
get: function() {
return codegen_1.Name;
}
});
Object.defineProperty(exports, "CodeGen", {
enumerable: true,
get: function() {
return codegen_1.CodeGen;
}
});
const validation_error_1 = require_validation_error();
const ref_error_1 = require_ref_error();
const rules_1 = require_rules();
const compile_1 = require_compile();
const codegen_2 = require_codegen();
const resolve_1 = require_resolve();
const dataType_1 = require_dataType();
const util_1 = require_util();
const $dataRefSchema = require_data();
const uri_1 = require_uri();
const defaultRegExp = (str, flags) => new RegExp(str, flags);
defaultRegExp.code = "new RegExp";
const META_IGNORE_OPTIONS = [
"removeAdditional",
"useDefaults",
"coerceTypes"
];
const EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
"validate",
"serialize",
"parse",
"wrapper",
"root",
"schema",
"keyword",
"pattern",
"formats",
"validate$data",
"func",
"obj",
"Error"
]);
const removedOptions = {
errorDataPath: "",
format: "`validateFormats: false` can be used instead.",
nullable: '"nullable" keyword is supported by default.',
jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
sourceCode: "Use option `code: {source: true}`",
strictDefaults: "It is default now, see option `strict`.",
strictKeywords: "It is default now, see option `strict`.",
uniqueItems: '"uniqueItems" keyword is always validated.',
unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
cache: "Map is used as cache, schema object as key.",
serialize: "Map is used as cache, schema object as key.",
ajvErrors: "It is default now."
};
const deprecatedOptions = {
ignoreKeywordsWithRef: "",
jsPropertySyntax: "",
unicode: '"minLength"/"maxLength" account for unicode characters by default.'
};
const MAX_EXPRESSION = 200;
function requiredOptions(o) {
var _a3, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
const s = o.strict;
const _optz = (_a3 = o.code) === null || _a3 === void 0 ? void 0 : _a3.optimize;
const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0;
const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp;
const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default;
return {
strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true,
strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true,
strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log",
strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log",
strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false,
code: o.code ? {
...o.code,
optimize,
regExp
} : {
optimize,
regExp
},
loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION,
loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION,
meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true,
messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true,
inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true,
schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id",
addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true,
validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true,
validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true,
unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true,
int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true,
uriResolver
};
}
var Ajv2 = class {
constructor(opts = {}) {
this.schemas = {};
this.refs = {};
this.formats = {};
this._compilations = /* @__PURE__ */ new Set();
this._loading = {};
this._cache = /* @__PURE__ */ new Map();
opts = this.opts = {
...opts,
...requiredOptions(opts)
};
const { es5, lines } = this.opts.code;
this.scope = new codegen_2.ValueScope({
scope: {},
prefixes: EXT_SCOPE_NAMES,
es5,
lines
});
this.logger = getLogger(opts.logger);
const formatOpt = opts.validateFormats;
opts.validateFormats = false;
this.RULES = (0, rules_1.getRules)();
checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED");
checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn");
this._metaOpts = getMetaSchemaOptions.call(this);
if (opts.formats) addInitialFormats.call(this);
this._addVocabularies();
this._addDefaultMetaSchema();
if (opts.keywords) addInitialKeywords.call(this, opts.keywords);
if (typeof opts.meta == "object") this.addMetaSchema(opts.meta);
addInitialSchemas.call(this);
opts.validateFormats = formatOpt;
}
_addVocabularies() {
this.addKeyword("$async");
}
_addDefaultMetaSchema() {
const { $data, meta: meta3, schemaId } = this.opts;
let _dataRefSchema = $dataRefSchema;
if (schemaId === "id") {
_dataRefSchema = { ...$dataRefSchema };
_dataRefSchema.id = _dataRefSchema.$id;
delete _dataRefSchema.$id;
}
if (meta3 && $data) this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false);
}
defaultMeta() {
const { meta: meta3, schemaId } = this.opts;
return this.opts.defaultMeta = typeof meta3 == "object" ? meta3[schemaId] || meta3 : void 0;
}
validate(schemaKeyRef, data) {
let v;
if (typeof schemaKeyRef == "string") {
v = this.getSchema(schemaKeyRef);
if (!v) throw new Error(`no schema with key or ref "${schemaKeyRef}"`);
} else v = this.compile(schemaKeyRef);
const valid = v(data);
if (!("$async" in v)) this.errors = v.errors;
return valid;
}
compile(schema, _meta) {
const sch = this._addSchema(schema, _meta);
return sch.validate || this._compileSchemaEnv(sch);
}
compileAsync(schema, meta3) {
if (typeof this.opts.loadSchema != "function") throw new Error("options.loadSchema should be a function");
const { loadSchema } = this.opts;
return runCompileAsync.call(this, schema, meta3);
async function runCompileAsync(_schema, _meta) {
await loadMetaSchema.call(this, _schema.$schema);
const sch = this._addSchema(_schema, _meta);
return sch.validate || _compileAsync.call(this, sch);
}
async function loadMetaSchema($ref) {
if ($ref && !this.getSchema($ref)) await runCompileAsync.call(this, { $ref }, true);
}
async function _compileAsync(sch) {
try {
return this._compileSchemaEnv(sch);
} catch (e) {
if (!(e instanceof ref_error_1.default)) throw e;
checkLoaded.call(this, e);
await loadMissingSchema.call(this, e.missingSchema);
return _compileAsync.call(this, sch);
}
}
function checkLoaded({ missingSchema: ref, missingRef }) {
if (this.refs[ref]) throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`);
}
async function loadMissingSchema(ref) {
const _schema = await _loadSchema.call(this, ref);
if (!this.refs[ref]) await loadMetaSchema.call(this, _schema.$schema);
if (!this.refs[ref]) this.addSchema(_schema, ref, meta3);
}
async function _loadSchema(ref) {
const p = this._loading[ref];
if (p) return p;
try {
return await (this._loading[ref] = loadSchema(ref));
} finally {
delete this._loading[ref];
}
}
}
addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
if (Array.isArray(schema)) {
for (const sch of schema) this.addSchema(sch, void 0, _meta, _validateSchema);
return this;
}
let id;
if (typeof schema === "object") {
const { schemaId } = this.opts;
id = schema[schemaId];
if (id !== void 0 && typeof id != "string") throw new Error(`schema ${schemaId} must be string`);
}
key = (0, resolve_1.normalizeId)(key || id);
this._checkUnique(key);
this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
return this;
}
addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
this.addSchema(schema, key, true, _validateSchema);
return this;
}
validateSchema(schema, throwOrLogError) {
if (typeof schema == "boolean") return true;
let $schema;
$schema = schema.$schema;
if ($schema !== void 0 && typeof $schema != "string") throw new Error("$schema must be a string");
$schema = $schema || this.opts.defaultMeta || this.defaultMeta();
if (!$schema) {
this.logger.warn("meta-schema not available");
this.errors = null;
return true;
}
const valid = this.validate($schema, schema);
if (!valid && throwOrLogError) {
const message = "schema is invalid: " + this.errorsText();
if (this.opts.validateSchema === "log") this.logger.error(message);
else throw new Error(message);
}
return valid;
}
getSchema(keyRef) {
let sch;
while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") keyRef = sch;
if (sch === void 0) {
const { schemaId } = this.opts;
const root = new compile_1.SchemaEnv({
schema: {},
schemaId
});
sch = compile_1.resolveSchema.call(this, root, keyRef);
if (!sch) return;
this.refs[keyRef] = sch;
}
return sch.validate || this._compileSchemaEnv(sch);
}
removeSchema(schemaKeyRef) {
if (schemaKeyRef instanceof RegExp) {
this._removeAllSchemas(this.schemas, schemaKeyRef);
this._removeAllSchemas(this.refs, schemaKeyRef);
return this;
}
switch (typeof schemaKeyRef) {
case "undefined":
this._removeAllSchemas(this.schemas);
this._removeAllSchemas(this.refs);
this._cache.clear();
return this;
case "string": {
const sch = getSchEnv.call(this, schemaKeyRef);
if (typeof sch == "object") this._cache.delete(sch.schema);
delete this.schemas[schemaKeyRef];
delete this.refs[schemaKeyRef];
return this;
}
case "object": {
const cacheKey = schemaKeyRef;
this._cache.delete(cacheKey);
let id = schemaKeyRef[this.opts.schemaId];
if (id) {
id = (0, resolve_1.normalizeId)(id);
delete this.schemas[id];
delete this.refs[id];
}
return this;
}
default:
throw new Error("ajv.removeSchema: invalid parameter");
}
}
addVocabulary(definitions) {
for (const def of definitions) this.addKeyword(def);
return this;
}
addKeyword(kwdOrDef, def) {
let keyword;
if (typeof kwdOrDef == "string") {
keyword = kwdOrDef;
if (typeof def == "object") {
this.logger.warn("these parameters are deprecated, see docs for addKeyword");
def.keyword = keyword;
}
} else if (typeof kwdOrDef == "object" && def === void 0) {
def = kwdOrDef;
keyword = def.keyword;
if (Array.isArray(keyword) && !keyword.length) throw new Error("addKeywords: keyword must be string or non-empty array");
} else throw new Error("invalid addKeywords parameters");
checkKeyword.call(this, keyword, def);
if (!def) {
(0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd));
return this;
}
keywordMetaschema.call(this, def);
const definition = {
...def,
type: (0, dataType_1.getJSONTypes)(def.type),
schemaType: (0, dataType_1.getJSONTypes)(def.schemaType)
};
(0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t)));
return this;
}
getKeyword(keyword) {
const rule = this.RULES.all[keyword];
return typeof rule == "object" ? rule.definition : !!rule;
}
removeKeyword(keyword) {
const { RULES } = this;
delete RULES.keywords[keyword];
delete RULES.all[keyword];
for (const group of RULES.rules) {
const i = group.rules.findIndex((rule) => rule.keyword === keyword);
if (i >= 0) group.rules.splice(i, 1);
}
return this;
}
addFormat(name, format) {
if (typeof format == "string") format = new RegExp(format);
this.formats[name] = format;
return this;
}
errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
if (!errors || errors.length === 0) return "No errors";
return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
}
$dataMetaSchema(metaSchema, keywordsJsonPointers) {
const rules = this.RULES.all;
metaSchema = JSON.parse(JSON.stringify(metaSchema));
for (const jsonPointer of keywordsJsonPointers) {
const segments = jsonPointer.split("/").slice(1);
let keywords = metaSchema;
for (const seg of segments) keywords = keywords[seg];
for (const key in rules) {
const rule = rules[key];
if (typeof rule != "object") continue;
const { $data } = rule.definition;
const schema = keywords[key];
if ($data && schema) keywords[key] = schemaOrData(schema);
}
}
return metaSchema;
}
_removeAllSchemas(schemas, regex) {
for (const keyRef in schemas) {
const sch = schemas[keyRef];
if (!regex || regex.test(keyRef)) {
if (typeof sch == "string") delete schemas[keyRef];
else if (sch && !sch.meta) {
this._cache.delete(sch.schema);
delete schemas[keyRef];
}
}
}
}
_addSchema(schema, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
let id;
const { schemaId } = this.opts;
if (typeof schema == "object") id = schema[schemaId];
else if (this.opts.jtd) throw new Error("schema must be object");
else if (typeof schema != "boolean") throw new Error("schema must be object or boolean");
let sch = this._cache.get(schema);
if (sch !== void 0) return sch;
baseId = (0, resolve_1.normalizeId)(id || baseId);
const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
sch = new compile_1.SchemaEnv({
schema,
schemaId,
meta: meta3,
baseId,
localRefs
});
this._cache.set(sch.schema, sch);
if (addSchema && !baseId.startsWith("#")) {
if (baseId) this._checkUnique(baseId);
this.refs[baseId] = sch;
}
if (validateSchema) this.validateSchema(schema, true);
return sch;
}
_checkUnique(id) {
if (this.schemas[id] || this.refs[id]) throw new Error(`schema with key or id "${id}" already exists`);
}
_compileSchemaEnv(sch) {
if (sch.meta) this._compileMetaSchema(sch);
else compile_1.compileSchema.call(this, sch);
if (!sch.validate) throw new Error("ajv implementation error");
return sch.validate;
}
_compileMetaSchema(sch) {
const currentOpts = this.opts;
this.opts = this._metaOpts;
try {
compile_1.compileSchema.call(this, sch);
} finally {
this.opts = currentOpts;
}
}
};
Ajv2.ValidationError = validation_error_1.default;
Ajv2.MissingRefError = ref_error_1.default;
exports.default = Ajv2;
function checkOptions(checkOpts, options, msg, log2 = "error") {
for (const key in checkOpts) {
const opt = key;
if (opt in options) this.logger[log2](`${msg}: option ${key}. ${checkOpts[opt]}`);
}
}
function getSchEnv(keyRef) {
keyRef = (0, resolve_1.normalizeId)(keyRef);
return this.schemas[keyRef] || this.refs[keyRef];
}
function addInitialSchemas() {
const optsSchemas = this.opts.schemas;
if (!optsSchemas) return;
if (Array.isArray(optsSchemas)) this.addSchema(optsSchemas);
else for (const key in optsSchemas) this.addSchema(optsSchemas[key], key);
}
function addInitialFormats() {
for (const name in this.opts.formats) {
const format = this.opts.formats[name];
if (format) this.addFormat(name, format);
}
}
function addInitialKeywords(defs) {
if (Array.isArray(defs)) {
this.addVocabulary(defs);
return;
}
this.logger.warn("keywords option as map is deprecated, pass array");
for (const keyword in defs) {
const def = defs[keyword];
if (!def.keyword) def.keyword = keyword;
this.addKeyword(def);
}
}
function getMetaSchemaOptions() {
const metaOpts = { ...this.opts };
for (const opt of META_IGNORE_OPTIONS) delete metaOpts[opt];
return metaOpts;
}
const noLogs = {
log() {
},
warn() {
},
error() {
}
};
function getLogger(logger) {
if (logger === false) return noLogs;
if (logger === void 0) return console;
if (logger.log && logger.warn && logger.error) return logger;
throw new Error("logger must implement log, warn and error methods");
}
const KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
function checkKeyword(keyword, def) {
const { RULES } = this;
(0, util_1.eachItem)(keyword, (kwd) => {
if (RULES.keywords[kwd]) throw new Error(`Keyword ${kwd} is already defined`);
if (!KEYWORD_NAME.test(kwd)) throw new Error(`Keyword ${kwd} has invalid name`);
});
if (!def) return;
if (def.$data && !("code" in def || "validate" in def)) throw new Error('$data keyword must have "code" or "validate" function');
}
function addRule(keyword, definition, dataType) {
var _a3;
const post = definition === null || definition === void 0 ? void 0 : definition.post;
if (dataType && post) throw new Error('keyword with "post" flag cannot have "type"');
const { RULES } = this;
let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType);
if (!ruleGroup) {
ruleGroup = {
type: dataType,
rules: []
};
RULES.rules.push(ruleGroup);
}
RULES.keywords[keyword] = true;
if (!definition) return;
const rule = {
keyword,
definition: {
...definition,
type: (0, dataType_1.getJSONTypes)(definition.type),
schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType)
}
};
if (definition.before) addBeforeRule.call(this, ruleGroup, rule, definition.before);
else ruleGroup.rules.push(rule);
RULES.all[keyword] = rule;
(_a3 = definition.implements) === null || _a3 === void 0 || _a3.forEach((kwd) => this.addKeyword(kwd));
}
function addBeforeRule(ruleGroup, rule, before) {
const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
if (i >= 0) ruleGroup.rules.splice(i, 0, rule);
else {
ruleGroup.rules.push(rule);
this.logger.warn(`rule ${before} is not defined`);
}
}
function keywordMetaschema(def) {
let { metaSchema } = def;
if (metaSchema === void 0) return;
if (def.$data && this.opts.$data) metaSchema = schemaOrData(metaSchema);
def.validateSchema = this.compile(metaSchema, true);
}
const $dataRef = { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" };
function schemaOrData(schema) {
return { anyOf: [schema, $dataRef] };
}
});
var require_id = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const def = {
keyword: "id",
code() {
throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
}
};
exports.default = def;
});
var require_ref = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.callRef = exports.getValidate = void 0;
const ref_error_1 = require_ref_error();
const code_1 = require_code();
const codegen_1 = require_codegen();
const names_1 = require_names();
const compile_1 = require_compile();
const util_1 = require_util();
const def = {
keyword: "$ref",
schemaType: "string",
code(cxt) {
const { gen, schema: $ref, it } = cxt;
const { baseId, schemaEnv: env, validateName, opts, self } = it;
const { root } = env;
if (($ref === "#" || $ref === "#/") && baseId === root.baseId) return callRootRef();
const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
if (schOrEnv === void 0) throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
if (schOrEnv instanceof compile_1.SchemaEnv) return callValidate(schOrEnv);
return inlineRefSchema(schOrEnv);
function callRootRef() {
if (env === root) return callRef(cxt, validateName, env, env.$async);
const rootName = gen.scopeValue("root", { ref: root });
return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
}
function callValidate(sch) {
callRef(cxt, getValidate(cxt, sch), sch, sch.$async);
}
function inlineRefSchema(sch) {
const schName = gen.scopeValue("schema", opts.code.source === true ? {
ref: sch,
code: (0, codegen_1.stringify)(sch)
} : { ref: sch });
const valid = gen.name("valid");
const schCxt = cxt.subschema({
schema: sch,
dataTypes: [],
schemaPath: codegen_1.nil,
topSchemaRef: schName,
errSchemaPath: $ref
}, valid);
cxt.mergeEvaluated(schCxt);
cxt.ok(valid);
}
}
};
function getValidate(cxt, sch) {
const { gen } = cxt;
return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
}
exports.getValidate = getValidate;
function callRef(cxt, v, sch, $async) {
const { gen, it } = cxt;
const { allErrors, schemaEnv: env, opts } = it;
const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
if ($async) callAsyncRef();
else callSyncRef();
function callAsyncRef() {
if (!env.$async) throw new Error("async schema referenced by sync schema");
const valid = gen.let("valid");
gen.try(() => {
gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
addEvaluatedFrom(v);
if (!allErrors) gen.assign(valid, true);
}, (e) => {
gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
addErrorsFrom(e);
if (!allErrors) gen.assign(valid, false);
});
cxt.ok(valid);
}
function callSyncRef() {
cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
}
function addErrorsFrom(source) {
const errs = (0, codegen_1._)`${source}.errors`;
gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
}
function addEvaluatedFrom(source) {
var _a3;
if (!it.opts.unevaluated) return;
const schEvaluated = (_a3 = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a3 === void 0 ? void 0 : _a3.evaluated;
if (it.props !== true) if (schEvaluated && !schEvaluated.dynamicProps) {
if (schEvaluated.props !== void 0) it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
} else {
const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
}
if (it.items !== true) if (schEvaluated && !schEvaluated.dynamicItems) {
if (schEvaluated.items !== void 0) it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
} else {
const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
}
}
}
exports.callRef = callRef;
exports.default = def;
});
var require_core$2 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const id_1 = require_id();
const ref_1 = require_ref();
const core = [
"$schema",
"$id",
"$defs",
"$vocabulary",
{ keyword: "$comment" },
"definitions",
id_1.default,
ref_1.default
];
exports.default = core;
});
var require_limitNumber = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const ops = codegen_1.operators;
const KWDs = {
maximum: {
okStr: "<=",
ok: ops.LTE,
fail: ops.GT
},
minimum: {
okStr: ">=",
ok: ops.GTE,
fail: ops.LT
},
exclusiveMaximum: {
okStr: "<",
ok: ops.LT,
fail: ops.GTE
},
exclusiveMinimum: {
okStr: ">",
ok: ops.GT,
fail: ops.LTE
}
};
const def = {
keyword: Object.keys(KWDs),
type: "number",
schemaType: "number",
$data: true,
error: {
message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
},
code(cxt) {
const { keyword, data, schemaCode } = cxt;
cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
}
};
exports.default = def;
});
var require_multipleOf = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const def = {
keyword: "multipleOf",
type: "number",
schemaType: "number",
$data: true,
error: {
message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
},
code(cxt) {
const { gen, data, schemaCode, it } = cxt;
const prec = it.opts.multipleOfPrecision;
const res = gen.let("res");
const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
}
};
exports.default = def;
});
var require_ucs2length = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
function ucs2length(str) {
const len = str.length;
let length = 0;
let pos = 0;
let value;
while (pos < len) {
length++;
value = str.charCodeAt(pos++);
if (value >= 55296 && value <= 56319 && pos < len) {
value = str.charCodeAt(pos);
if ((value & 64512) === 56320) pos++;
}
}
return length;
}
exports.default = ucs2length;
ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
});
var require_limitLength = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const ucs2length_1 = require_ucs2length();
const def = {
keyword: ["maxLength", "minLength"],
type: "string",
schemaType: "number",
$data: true,
error: {
message({ keyword, schemaCode }) {
const comp = keyword === "maxLength" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
},
code(cxt) {
const { keyword, data, schemaCode, it } = cxt;
const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
}
};
exports.default = def;
});
var require_pattern = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const code_1 = require_code();
const util_1 = require_util();
const codegen_1 = require_codegen();
const def = {
keyword: "pattern",
type: "string",
schemaType: "string",
$data: true,
error: {
message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
},
code(cxt) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const u = it.opts.unicodeRegExp ? "u" : "";
if ($data) {
const { regExp } = it.opts.code;
const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
const valid = gen.let("valid");
gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
cxt.fail$data((0, codegen_1._)`!${valid}`);
} else {
const regExp = (0, code_1.usePattern)(cxt, schema);
cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
}
}
};
exports.default = def;
});
var require_limitProperties = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const def = {
keyword: ["maxProperties", "minProperties"],
type: "object",
schemaType: "number",
$data: true,
error: {
message({ keyword, schemaCode }) {
const comp = keyword === "maxProperties" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
},
code(cxt) {
const { keyword, data, schemaCode } = cxt;
const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
}
};
exports.default = def;
});
var require_required = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const code_1 = require_code();
const codegen_1 = require_codegen();
const util_1 = require_util();
const def = {
keyword: "required",
type: "object",
schemaType: "array",
$data: true,
error: {
message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
},
code(cxt) {
const { gen, schema, schemaCode, data, $data, it } = cxt;
const { opts } = it;
if (!$data && schema.length === 0) return;
const useLoop = schema.length >= opts.loopRequired;
if (it.allErrors) allErrorsMode();
else exitOnErrorMode();
if (opts.strictRequired) {
const props = cxt.parentSchema.properties;
const { definedProperties } = cxt.it;
for (const requiredKey of schema) if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
const msg = `required property "${requiredKey}" is not defined at "${it.schemaEnv.baseId + it.errSchemaPath}" (strictRequired)`;
(0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
}
}
function allErrorsMode() {
if (useLoop || $data) cxt.block$data(codegen_1.nil, loopAllRequired);
else for (const prop of schema) (0, code_1.checkReportMissingProp)(cxt, prop);
}
function exitOnErrorMode() {
const missing = gen.let("missing");
if (useLoop || $data) {
const valid = gen.let("valid", true);
cxt.block$data(valid, () => loopUntilMissing(missing, valid));
cxt.ok(valid);
} else {
gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
(0, code_1.reportMissingProp)(cxt, missing);
gen.else();
}
}
function loopAllRequired() {
gen.forOf("prop", schemaCode, (prop) => {
cxt.setParams({ missingProperty: prop });
gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
});
}
function loopUntilMissing(missing, valid) {
cxt.setParams({ missingProperty: missing });
gen.forOf(missing, schemaCode, () => {
gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
gen.if((0, codegen_1.not)(valid), () => {
cxt.error();
gen.break();
});
}, codegen_1.nil);
}
}
};
exports.default = def;
});
var require_limitItems = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const def = {
keyword: ["maxItems", "minItems"],
type: "array",
schemaType: "number",
$data: true,
error: {
message({ keyword, schemaCode }) {
const comp = keyword === "maxItems" ? "more" : "fewer";
return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
},
params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
},
code(cxt) {
const { keyword, data, schemaCode } = cxt;
const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
}
};
exports.default = def;
});
var require_equal = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const equal = require_fast_deep_equal();
equal.code = 'require("ajv/dist/runtime/equal").default';
exports.default = equal;
});
var require_uniqueItems = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const dataType_1 = require_dataType();
const codegen_1 = require_codegen();
const util_1 = require_util();
const equal_1 = require_equal();
const def = {
keyword: "uniqueItems",
type: "array",
schemaType: "boolean",
$data: true,
error: {
message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
},
code(cxt) {
const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
if (!$data && !schema) return;
const valid = gen.let("valid");
const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
cxt.ok(valid);
function validateUniqueItems() {
const i = gen.let("i", (0, codegen_1._)`${data}.length`);
const j = gen.let("j");
cxt.setParams({
i,
j
});
gen.assign(valid, true);
gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
}
function canOptimize() {
return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
}
function loopN(i, j) {
const item = gen.name("item");
const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
const indices = gen.const("indices", (0, codegen_1._)`{}`);
gen.for((0, codegen_1._)`;${i}--;`, () => {
gen.let(item, (0, codegen_1._)`${data}[${i}]`);
gen.if(wrongType, (0, codegen_1._)`continue`);
if (itemTypes.length > 1) gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
cxt.error();
gen.assign(valid, false).break();
}).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
});
}
function loopN2(i, j) {
const eql = (0, util_1.useFunc)(gen, equal_1.default);
const outer = gen.name("outer");
gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
cxt.error();
gen.assign(valid, false).break(outer);
})));
}
}
};
exports.default = def;
});
var require_const = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const equal_1 = require_equal();
const def = {
keyword: "const",
$data: true,
error: {
message: "must be equal to constant",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
},
code(cxt) {
const { gen, data, $data, schemaCode, schema } = cxt;
if ($data || schema && typeof schema == "object") cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
else cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
}
};
exports.default = def;
});
var require_enum = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const equal_1 = require_equal();
const def = {
keyword: "enum",
schemaType: "array",
$data: true,
error: {
message: "must be equal to one of the allowed values",
params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
},
code(cxt) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
if (!$data && schema.length === 0) throw new Error("enum must have non-empty array");
const useLoop = schema.length >= it.opts.loopEnum;
let eql;
const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
let valid;
if (useLoop || $data) {
valid = gen.let("valid");
cxt.block$data(valid, loopEnum);
} else {
if (!Array.isArray(schema)) throw new Error("ajv implementation error");
const vSchema = gen.const("vSchema", schemaCode);
valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
}
cxt.pass(valid);
function loopEnum() {
gen.assign(valid, false);
gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
}
function equalCode(vSchema, i) {
const sch = schema[i];
return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
}
}
};
exports.default = def;
});
var require_validation$2 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const limitNumber_1 = require_limitNumber();
const multipleOf_1 = require_multipleOf();
const limitLength_1 = require_limitLength();
const pattern_1 = require_pattern();
const limitProperties_1 = require_limitProperties();
const required_1 = require_required();
const limitItems_1 = require_limitItems();
const uniqueItems_1 = require_uniqueItems();
const const_1 = require_const();
const enum_1 = require_enum();
const validation = [
limitNumber_1.default,
multipleOf_1.default,
limitLength_1.default,
pattern_1.default,
limitProperties_1.default,
required_1.default,
limitItems_1.default,
uniqueItems_1.default,
{
keyword: "type",
schemaType: ["string", "array"]
},
{
keyword: "nullable",
schemaType: "boolean"
},
const_1.default,
enum_1.default
];
exports.default = validation;
});
var require_additionalItems = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAdditionalItems = void 0;
const codegen_1 = require_codegen();
const util_1 = require_util();
const def = {
keyword: "additionalItems",
type: "array",
schemaType: ["boolean", "object"],
before: "uniqueItems",
error: {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
},
code(cxt) {
const { parentSchema, it } = cxt;
const { items } = parentSchema;
if (!Array.isArray(items)) {
(0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
return;
}
validateAdditionalItems(cxt, items);
}
};
function validateAdditionalItems(cxt, items) {
const { gen, schema, data, keyword, it } = cxt;
it.items = true;
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
if (schema === false) {
cxt.setParams({ len: items.length });
cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
cxt.ok(valid);
}
function validateItems(valid) {
gen.forRange("i", items.length, len, (i) => {
cxt.subschema({
keyword,
dataProp: i,
dataPropType: util_1.Type.Num
}, valid);
if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
});
}
}
exports.validateAdditionalItems = validateAdditionalItems;
exports.default = def;
});
var require_items = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateTuple = void 0;
const codegen_1 = require_codegen();
const util_1 = require_util();
const code_1 = require_code();
const def = {
keyword: "items",
type: "array",
schemaType: [
"object",
"array",
"boolean"
],
before: "uniqueItems",
code(cxt) {
const { schema, it } = cxt;
if (Array.isArray(schema)) return validateTuple(cxt, "additionalItems", schema);
it.items = true;
if ((0, util_1.alwaysValidSchema)(it, schema)) return;
cxt.ok((0, code_1.validateArray)(cxt));
}
};
function validateTuple(cxt, extraItems, schArr = cxt.schema) {
const { gen, parentSchema, data, keyword, it } = cxt;
checkStrictTuple(parentSchema);
if (it.opts.unevaluated && schArr.length && it.items !== true) it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
const valid = gen.name("valid");
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
schArr.forEach((sch, i) => {
if ((0, util_1.alwaysValidSchema)(it, sch)) return;
gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
keyword,
schemaProp: i,
dataProp: i
}, valid));
cxt.ok(valid);
});
function checkStrictTuple(sch) {
const { opts, errSchemaPath } = it;
const l = schArr.length;
const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
if (opts.strictTuples && !fullTuple) {
const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
(0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
}
}
}
exports.validateTuple = validateTuple;
exports.default = def;
});
var require_prefixItems = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const items_1 = require_items();
const def = {
keyword: "prefixItems",
type: "array",
schemaType: ["array"],
before: "uniqueItems",
code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
};
exports.default = def;
});
var require_items2020 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const code_1 = require_code();
const additionalItems_1 = require_additionalItems();
const def = {
keyword: "items",
type: "array",
schemaType: ["object", "boolean"],
before: "uniqueItems",
error: {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
},
code(cxt) {
const { schema, parentSchema, it } = cxt;
const { prefixItems } = parentSchema;
it.items = true;
if ((0, util_1.alwaysValidSchema)(it, schema)) return;
if (prefixItems) (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
else cxt.ok((0, code_1.validateArray)(cxt));
}
};
exports.default = def;
});
var require_contains = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const def = {
keyword: "contains",
type: "array",
schemaType: ["object", "boolean"],
before: "uniqueItems",
trackErrors: true,
error: {
message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
},
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
let min;
let max;
const { minContains, maxContains } = parentSchema;
if (it.opts.next) {
min = minContains === void 0 ? 1 : minContains;
max = maxContains;
} else min = 1;
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
cxt.setParams({
min,
max
});
if (max === void 0 && min === 0) {
(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
return;
}
if (max !== void 0 && min > max) {
(0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
cxt.fail();
return;
}
if ((0, util_1.alwaysValidSchema)(it, schema)) {
let cond = (0, codegen_1._)`${len} >= ${min}`;
if (max !== void 0) cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
cxt.pass(cond);
return;
}
it.items = true;
const valid = gen.name("valid");
if (max === void 0 && min === 1) validateItems(valid, () => gen.if(valid, () => gen.break()));
else if (min === 0) {
gen.let(valid, true);
if (max !== void 0) gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
} else {
gen.let(valid, false);
validateItemsWithCount();
}
cxt.result(valid, () => cxt.reset());
function validateItemsWithCount() {
const schValid = gen.name("_valid");
const count = gen.let("count", 0);
validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
}
function validateItems(_valid, block) {
gen.forRange("i", 0, len, (i) => {
cxt.subschema({
keyword: "contains",
dataProp: i,
dataPropType: util_1.Type.Num,
compositeRule: true
}, _valid);
block();
});
}
function checkLimits(count) {
gen.code((0, codegen_1._)`${count}++`);
if (max === void 0) gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
else {
gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
if (min === 1) gen.assign(valid, true);
else gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
}
}
}
};
exports.default = def;
});
var require_dependencies = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
const codegen_1 = require_codegen();
const util_1 = require_util();
const code_1 = require_code();
exports.error = {
message: ({ params: { property, depsCount, deps } }) => {
const property_ies = depsCount === 1 ? "property" : "properties";
return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
},
params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
missingProperty: ${missingProperty},
depsCount: ${depsCount},
deps: ${deps}}`
};
const def = {
keyword: "dependencies",
type: "object",
schemaType: "object",
error: exports.error,
code(cxt) {
const [propDeps, schDeps] = splitDependencies(cxt);
validatePropertyDeps(cxt, propDeps);
validateSchemaDeps(cxt, schDeps);
}
};
function splitDependencies({ schema }) {
const propertyDeps = {};
const schemaDeps = {};
for (const key in schema) {
if (key === "__proto__") continue;
const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
deps[key] = schema[key];
}
return [propertyDeps, schemaDeps];
}
function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
const { gen, data, it } = cxt;
if (Object.keys(propertyDeps).length === 0) return;
const missing = gen.let("missing");
for (const prop in propertyDeps) {
const deps = propertyDeps[prop];
if (deps.length === 0) continue;
const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
cxt.setParams({
property: prop,
depsCount: deps.length,
deps: deps.join(", ")
});
if (it.allErrors) gen.if(hasProperty, () => {
for (const depProp of deps) (0, code_1.checkReportMissingProp)(cxt, depProp);
});
else {
gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
(0, code_1.reportMissingProp)(cxt, missing);
gen.else();
}
}
}
exports.validatePropertyDeps = validatePropertyDeps;
function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
const { gen, data, keyword, it } = cxt;
const valid = gen.name("valid");
for (const prop in schemaDeps) {
if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) continue;
gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => {
const schCxt = cxt.subschema({
keyword,
schemaProp: prop
}, valid);
cxt.mergeValidEvaluated(schCxt, valid);
}, () => gen.var(valid, true));
cxt.ok(valid);
}
}
exports.validateSchemaDeps = validateSchemaDeps;
exports.default = def;
});
var require_propertyNames = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const def = {
keyword: "propertyNames",
type: "object",
schemaType: ["object", "boolean"],
error: {
message: "property name must be valid",
params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
},
code(cxt) {
const { gen, schema, data, it } = cxt;
if ((0, util_1.alwaysValidSchema)(it, schema)) return;
const valid = gen.name("valid");
gen.forIn("key", data, (key) => {
cxt.setParams({ propertyName: key });
cxt.subschema({
keyword: "propertyNames",
data: key,
dataTypes: ["string"],
propertyName: key,
compositeRule: true
}, valid);
gen.if((0, codegen_1.not)(valid), () => {
cxt.error(true);
if (!it.allErrors) gen.break();
});
});
cxt.ok(valid);
}
};
exports.default = def;
});
var require_additionalProperties = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const code_1 = require_code();
const codegen_1 = require_codegen();
const names_1 = require_names();
const util_1 = require_util();
const def = {
keyword: "additionalProperties",
type: ["object"],
schemaType: ["boolean", "object"],
allowUndefined: true,
trackErrors: true,
error: {
message: "must NOT have additional properties",
params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
},
code(cxt) {
const { gen, schema, parentSchema, data, errsCount, it } = cxt;
if (!errsCount) throw new Error("ajv implementation error");
const { allErrors, opts } = it;
it.props = true;
if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema)) return;
const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
checkAdditionalProperties();
cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
function checkAdditionalProperties() {
gen.forIn("key", data, (key) => {
if (!props.length && !patProps.length) additionalPropertyCode(key);
else gen.if(isAdditional(key), () => additionalPropertyCode(key));
});
}
function isAdditional(key) {
let definedProp;
if (props.length > 8) {
const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
} else if (props.length) definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
else definedProp = codegen_1.nil;
if (patProps.length) definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
return (0, codegen_1.not)(definedProp);
}
function deleteAdditional(key) {
gen.code((0, codegen_1._)`delete ${data}[${key}]`);
}
function additionalPropertyCode(key) {
if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
deleteAdditional(key);
return;
}
if (schema === false) {
cxt.setParams({ additionalProperty: key });
cxt.error();
if (!allErrors) gen.break();
return;
}
if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.name("valid");
if (opts.removeAdditional === "failing") {
applyAdditionalSchema(key, valid, false);
gen.if((0, codegen_1.not)(valid), () => {
cxt.reset();
deleteAdditional(key);
});
} else {
applyAdditionalSchema(key, valid);
if (!allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
}
}
}
function applyAdditionalSchema(key, valid, errors) {
const subschema = {
keyword: "additionalProperties",
dataProp: key,
dataPropType: util_1.Type.Str
};
if (errors === false) Object.assign(subschema, {
compositeRule: true,
createErrors: false,
allErrors: false
});
cxt.subschema(subschema, valid);
}
}
};
exports.default = def;
});
var require_properties = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const validate_1 = require_validate();
const code_1 = require_code();
const util_1 = require_util();
const additionalProperties_1 = require_additionalProperties();
const def = {
keyword: "properties",
type: "object",
schemaType: "object",
code(cxt) {
const { gen, schema, parentSchema, data, it } = cxt;
if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
const allProps = (0, code_1.allSchemaProperties)(schema);
for (const prop of allProps) it.definedProperties.add(prop);
if (it.opts.unevaluated && allProps.length && it.props !== true) it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
if (properties.length === 0) return;
const valid = gen.name("valid");
for (const prop of properties) {
if (hasDefault(prop)) applyPropertySchema(prop);
else {
gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
applyPropertySchema(prop);
if (!it.allErrors) gen.else().var(valid, true);
gen.endIf();
}
cxt.it.definedProperties.add(prop);
cxt.ok(valid);
}
function hasDefault(prop) {
return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0;
}
function applyPropertySchema(prop) {
cxt.subschema({
keyword: "properties",
schemaProp: prop,
dataProp: prop
}, valid);
}
}
};
exports.default = def;
});
var require_patternProperties = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const code_1 = require_code();
const codegen_1 = require_codegen();
const util_1 = require_util();
const util_2 = require_util();
const def = {
keyword: "patternProperties",
type: "object",
schemaType: "object",
code(cxt) {
const { gen, schema, data, parentSchema, it } = cxt;
const { opts } = it;
const patterns = (0, code_1.allSchemaProperties)(schema);
const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) return;
const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
const valid = gen.name("valid");
if (it.props !== true && !(it.props instanceof codegen_1.Name)) it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
const { props } = it;
validatePatternProperties();
function validatePatternProperties() {
for (const pat of patterns) {
if (checkProperties) checkMatchingProperties(pat);
if (it.allErrors) validateProperties(pat);
else {
gen.var(valid, true);
validateProperties(pat);
gen.if(valid);
}
}
}
function checkMatchingProperties(pat) {
for (const prop in checkProperties) if (new RegExp(pat).test(prop)) (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
}
function validateProperties(pat) {
gen.forIn("key", data, (key) => {
gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
const alwaysValid = alwaysValidPatterns.includes(pat);
if (!alwaysValid) cxt.subschema({
keyword: "patternProperties",
schemaProp: pat,
dataProp: key,
dataPropType: util_2.Type.Str
}, valid);
if (it.opts.unevaluated && props !== true) gen.assign((0, codegen_1._)`${props}[${key}]`, true);
else if (!alwaysValid && !it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
});
});
}
}
};
exports.default = def;
});
var require_not = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require_util();
const def = {
keyword: "not",
schemaType: ["object", "boolean"],
trackErrors: true,
code(cxt) {
const { gen, schema, it } = cxt;
if ((0, util_1.alwaysValidSchema)(it, schema)) {
cxt.fail();
return;
}
const valid = gen.name("valid");
cxt.subschema({
keyword: "not",
compositeRule: true,
createErrors: false,
allErrors: false
}, valid);
cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
},
error: { message: "must NOT be valid" }
};
exports.default = def;
});
var require_anyOf = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const def = {
keyword: "anyOf",
schemaType: "array",
trackErrors: true,
code: require_code().validateUnion,
error: { message: "must match a schema in anyOf" }
};
exports.default = def;
});
var require_oneOf = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const def = {
keyword: "oneOf",
schemaType: "array",
trackErrors: true,
error: {
message: "must match exactly one schema in oneOf",
params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
},
code(cxt) {
const { gen, schema, parentSchema, it } = cxt;
if (!Array.isArray(schema)) throw new Error("ajv implementation error");
if (it.opts.discriminator && parentSchema.discriminator) return;
const schArr = schema;
const valid = gen.let("valid", false);
const passing = gen.let("passing", null);
const schValid = gen.name("_valid");
cxt.setParams({ passing });
gen.block(validateOneOf);
cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
function validateOneOf() {
schArr.forEach((sch, i) => {
let schCxt;
if ((0, util_1.alwaysValidSchema)(it, sch)) gen.var(schValid, true);
else schCxt = cxt.subschema({
keyword: "oneOf",
schemaProp: i,
compositeRule: true
}, schValid);
if (i > 0) gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
gen.if(schValid, () => {
gen.assign(valid, true);
gen.assign(passing, i);
if (schCxt) cxt.mergeEvaluated(schCxt, codegen_1.Name);
});
});
}
}
};
exports.default = def;
});
var require_allOf = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require_util();
const def = {
keyword: "allOf",
schemaType: "array",
code(cxt) {
const { gen, schema, it } = cxt;
if (!Array.isArray(schema)) throw new Error("ajv implementation error");
const valid = gen.name("valid");
schema.forEach((sch, i) => {
if ((0, util_1.alwaysValidSchema)(it, sch)) return;
const schCxt = cxt.subschema({
keyword: "allOf",
schemaProp: i
}, valid);
cxt.ok(valid);
cxt.mergeEvaluated(schCxt);
});
}
};
exports.default = def;
});
var require_if = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const def = {
keyword: "if",
schemaType: ["object", "boolean"],
trackErrors: true,
error: {
message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
},
code(cxt) {
const { gen, parentSchema, it } = cxt;
if (parentSchema.then === void 0 && parentSchema.else === void 0) (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored');
const hasThen = hasSchema(it, "then");
const hasElse = hasSchema(it, "else");
if (!hasThen && !hasElse) return;
const valid = gen.let("valid", true);
const schValid = gen.name("_valid");
validateIf();
cxt.reset();
if (hasThen && hasElse) {
const ifClause = gen.let("ifClause");
cxt.setParams({ ifClause });
gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
} else if (hasThen) gen.if(schValid, validateClause("then"));
else gen.if((0, codegen_1.not)(schValid), validateClause("else"));
cxt.pass(valid, () => cxt.error(true));
function validateIf() {
const schCxt = cxt.subschema({
keyword: "if",
compositeRule: true,
createErrors: false,
allErrors: false
}, schValid);
cxt.mergeEvaluated(schCxt);
}
function validateClause(keyword, ifClause) {
return () => {
const schCxt = cxt.subschema({ keyword }, schValid);
gen.assign(valid, schValid);
cxt.mergeValidEvaluated(schCxt, valid);
if (ifClause) gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
else cxt.setParams({ ifClause: keyword });
};
}
}
};
function hasSchema(it, keyword) {
const schema = it.schema[keyword];
return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
}
exports.default = def;
});
var require_thenElse = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require_util();
const def = {
keyword: ["then", "else"],
schemaType: ["object", "boolean"],
code({ keyword, parentSchema, it }) {
if (parentSchema.if === void 0) (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
}
};
exports.default = def;
});
var require_applicator$2 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const additionalItems_1 = require_additionalItems();
const prefixItems_1 = require_prefixItems();
const items_1 = require_items();
const items2020_1 = require_items2020();
const contains_1 = require_contains();
const dependencies_1 = require_dependencies();
const propertyNames_1 = require_propertyNames();
const additionalProperties_1 = require_additionalProperties();
const properties_1 = require_properties();
const patternProperties_1 = require_patternProperties();
const not_1 = require_not();
const anyOf_1 = require_anyOf();
const oneOf_1 = require_oneOf();
const allOf_1 = require_allOf();
const if_1 = require_if();
const thenElse_1 = require_thenElse();
function getApplicator(draft2020 = false) {
const applicator = [
not_1.default,
anyOf_1.default,
oneOf_1.default,
allOf_1.default,
if_1.default,
thenElse_1.default,
propertyNames_1.default,
additionalProperties_1.default,
dependencies_1.default,
properties_1.default,
patternProperties_1.default
];
if (draft2020) applicator.push(prefixItems_1.default, items2020_1.default);
else applicator.push(additionalItems_1.default, items_1.default);
applicator.push(contains_1.default);
return applicator;
}
exports.default = getApplicator;
});
var require_format$2 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const def = {
keyword: "format",
type: ["number", "string"],
schemaType: "string",
$data: true,
error: {
message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
},
code(cxt, ruleType) {
const { gen, data, $data, schema, schemaCode, it } = cxt;
const { opts, errSchemaPath, schemaEnv, self } = it;
if (!opts.validateFormats) return;
if ($data) validate$DataFormat();
else validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self.formats,
code: opts.code.formats
});
const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
const fType = gen.let("fType");
const format = gen.let("format");
gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef));
cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
function unknownFmt() {
if (opts.strictSchema === false) return codegen_1.nil;
return (0, codegen_1._)`${schemaCode} && !${format}`;
}
function invalidFmt() {
const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
}
}
function validateFormat() {
const formatDef = self.formats[schema];
if (!formatDef) {
unknownFormat();
return;
}
if (formatDef === true) return;
const [fmtType, format, fmtRef] = getFormat(formatDef);
if (fmtType === ruleType) cxt.pass(validCondition());
function unknownFormat() {
if (opts.strictSchema === false) {
self.logger.warn(unknownMsg());
return;
}
throw new Error(unknownMsg());
function unknownMsg() {
return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
}
}
function getFormat(fmtDef) {
const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0;
const fmt = gen.scopeValue("formats", {
key: schema,
ref: fmtDef,
code
});
if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) return [
fmtDef.type || "string",
fmtDef.validate,
(0, codegen_1._)`${fmt}.validate`
];
return [
"string",
fmtDef,
fmt
];
}
function validCondition() {
if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
if (!schemaEnv.$async) throw new Error("async format in sync schema");
return (0, codegen_1._)`await ${fmtRef}(${data})`;
}
return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
}
}
}
};
exports.default = def;
});
var require_format$1 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const format = [require_format$2().default];
exports.default = format;
});
var require_metadata = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.contentVocabulary = exports.metadataVocabulary = void 0;
exports.metadataVocabulary = [
"title",
"description",
"default",
"deprecated",
"readOnly",
"writeOnly",
"examples"
];
exports.contentVocabulary = [
"contentMediaType",
"contentEncoding",
"contentSchema"
];
});
var require_draft7 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require_core$2();
const validation_1 = require_validation$2();
const applicator_1 = require_applicator$2();
const format_1 = require_format$1();
const metadata_1 = require_metadata();
const draft7Vocabularies = [
core_1.default,
validation_1.default,
(0, applicator_1.default)(),
format_1.default,
metadata_1.metadataVocabulary,
metadata_1.contentVocabulary
];
exports.default = draft7Vocabularies;
});
var require_types = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.DiscrError = void 0;
var DiscrError;
(function(DiscrError2) {
DiscrError2["Tag"] = "tag";
DiscrError2["Mapping"] = "mapping";
})(DiscrError || (exports.DiscrError = DiscrError = {}));
});
var require_discriminator = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const types_1 = require_types();
const compile_1 = require_compile();
const ref_error_1 = require_ref_error();
const util_1 = require_util();
const def = {
keyword: "discriminator",
type: "object",
schemaType: "object",
error: {
message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
},
code(cxt) {
const { gen, data, schema, parentSchema, it } = cxt;
const { oneOf } = parentSchema;
if (!it.opts.discriminator) throw new Error("discriminator: requires discriminator option");
const tagName = schema.propertyName;
if (typeof tagName != "string") throw new Error("discriminator: requires propertyName");
if (schema.mapping) throw new Error("discriminator: mapping is not supported");
if (!oneOf) throw new Error("discriminator: requires oneOf keyword");
const valid = gen.let("valid", false);
const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, {
discrError: types_1.DiscrError.Tag,
tag,
tagName
}));
cxt.ok(valid);
function validateMapping() {
const mapping = getMapping();
gen.if(false);
for (const tagValue in mapping) {
gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
gen.assign(valid, applyTagSchema(mapping[tagValue]));
}
gen.else();
cxt.error(false, {
discrError: types_1.DiscrError.Mapping,
tag,
tagName
});
gen.endIf();
}
function applyTagSchema(schemaProp) {
const _valid = gen.name("valid");
const schCxt = cxt.subschema({
keyword: "oneOf",
schemaProp
}, _valid);
cxt.mergeEvaluated(schCxt, codegen_1.Name);
return _valid;
}
function getMapping() {
var _a3;
const oneOfMapping = {};
const topRequired = hasRequired(parentSchema);
let tagRequired = true;
for (let i = 0; i < oneOf.length; i++) {
let sch = oneOf[i];
if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
const ref = sch.$ref;
sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
if (sch instanceof compile_1.SchemaEnv) sch = sch.schema;
if (sch === void 0) throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
}
const propSch = (_a3 = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a3 === void 0 ? void 0 : _a3[tagName];
if (typeof propSch != "object") throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
tagRequired = tagRequired && (topRequired || hasRequired(sch));
addMappings(propSch, i);
}
if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`);
return oneOfMapping;
function hasRequired({ required: required2 }) {
return Array.isArray(required2) && required2.includes(tagName);
}
function addMappings(sch, i) {
if (sch.const) addMapping(sch.const, i);
else if (sch.enum) for (const tagValue of sch.enum) addMapping(tagValue, i);
else throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
}
function addMapping(tagValue, i) {
if (typeof tagValue != "string" || tagValue in oneOfMapping) throw new Error(`discriminator: "${tagName}" values must be unique strings`);
oneOfMapping[tagValue] = i;
}
}
}
};
exports.default = def;
});
var require_json_schema_draft_07 = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "http://json-schema.org/draft-07/schema#",
"title": "Core schema meta-schema",
"definitions": {
"schemaArray": {
"type": "array",
"minItems": 1,
"items": { "$ref": "#" }
},
"nonNegativeInteger": {
"type": "integer",
"minimum": 0
},
"nonNegativeIntegerDefault0": { "allOf": [{ "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 }] },
"simpleTypes": { "enum": [
"array",
"boolean",
"integer",
"null",
"number",
"object",
"string"
] },
"stringArray": {
"type": "array",
"items": { "type": "string" },
"uniqueItems": true,
"default": []
}
},
"type": ["object", "boolean"],
"properties": {
"$id": {
"type": "string",
"format": "uri-reference"
},
"$schema": {
"type": "string",
"format": "uri"
},
"$ref": {
"type": "string",
"format": "uri-reference"
},
"$comment": { "type": "string" },
"title": { "type": "string" },
"description": { "type": "string" },
"default": true,
"readOnly": {
"type": "boolean",
"default": false
},
"examples": {
"type": "array",
"items": true
},
"multipleOf": {
"type": "number",
"exclusiveMinimum": 0
},
"maximum": { "type": "number" },
"exclusiveMaximum": { "type": "number" },
"minimum": { "type": "number" },
"exclusiveMinimum": { "type": "number" },
"maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
"minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
"pattern": {
"type": "string",
"format": "regex"
},
"additionalItems": { "$ref": "#" },
"items": {
"anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/schemaArray" }],
"default": true
},
"maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
"minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
"uniqueItems": {
"type": "boolean",
"default": false
},
"contains": { "$ref": "#" },
"maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
"minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
"required": { "$ref": "#/definitions/stringArray" },
"additionalProperties": { "$ref": "#" },
"definitions": {
"type": "object",
"additionalProperties": { "$ref": "#" },
"default": {}
},
"properties": {
"type": "object",
"additionalProperties": { "$ref": "#" },
"default": {}
},
"patternProperties": {
"type": "object",
"additionalProperties": { "$ref": "#" },
"propertyNames": { "format": "regex" },
"default": {}
},
"dependencies": {
"type": "object",
"additionalProperties": { "anyOf": [{ "$ref": "#" }, { "$ref": "#/definitions/stringArray" }] }
},
"propertyNames": { "$ref": "#" },
"const": true,
"enum": {
"type": "array",
"items": true,
"minItems": 1,
"uniqueItems": true
},
"type": { "anyOf": [{ "$ref": "#/definitions/simpleTypes" }, {
"type": "array",
"items": { "$ref": "#/definitions/simpleTypes" },
"minItems": 1,
"uniqueItems": true
}] },
"format": { "type": "string" },
"contentMediaType": { "type": "string" },
"contentEncoding": { "type": "string" },
"if": { "$ref": "#" },
"then": { "$ref": "#" },
"else": { "$ref": "#" },
"allOf": { "$ref": "#/definitions/schemaArray" },
"anyOf": { "$ref": "#/definitions/schemaArray" },
"oneOf": { "$ref": "#/definitions/schemaArray" },
"not": { "$ref": "#" }
},
"default": true
};
});
var require_ajv = /* @__PURE__ */ __commonJSMin((exports, module) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0;
const core_1 = require_core$3();
const draft7_1 = require_draft7();
const discriminator_1 = require_discriminator();
const draft7MetaSchema = require_json_schema_draft_07();
const META_SUPPORT_DATA = ["/properties"];
const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
var Ajv2 = class extends core_1.default {
_addVocabularies() {
super._addVocabularies();
draft7_1.default.forEach((v) => this.addVocabulary(v));
if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
}
_addDefaultMetaSchema() {
super._addDefaultMetaSchema();
if (!this.opts.meta) return;
const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema;
this.addMetaSchema(metaSchema, META_SCHEMA_ID, false);
this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
}
defaultMeta() {
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
}
};
exports.Ajv = Ajv2;
module.exports = exports = Ajv2;
module.exports.Ajv = Ajv2;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Ajv2;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", {
enumerable: true,
get: function() {
return validate_1.KeywordCxt;
}
});
var codegen_1 = require_codegen();
Object.defineProperty(exports, "_", {
enumerable: true,
get: function() {
return codegen_1._;
}
});
Object.defineProperty(exports, "str", {
enumerable: true,
get: function() {
return codegen_1.str;
}
});
Object.defineProperty(exports, "stringify", {
enumerable: true,
get: function() {
return codegen_1.stringify;
}
});
Object.defineProperty(exports, "nil", {
enumerable: true,
get: function() {
return codegen_1.nil;
}
});
Object.defineProperty(exports, "Name", {
enumerable: true,
get: function() {
return codegen_1.Name;
}
});
Object.defineProperty(exports, "CodeGen", {
enumerable: true,
get: function() {
return codegen_1.CodeGen;
}
});
var validation_error_1 = require_validation_error();
Object.defineProperty(exports, "ValidationError", {
enumerable: true,
get: function() {
return validation_error_1.default;
}
});
var ref_error_1 = require_ref_error();
Object.defineProperty(exports, "MissingRefError", {
enumerable: true,
get: function() {
return ref_error_1.default;
}
});
});
var require_dynamicAnchor = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.dynamicAnchor = void 0;
const codegen_1 = require_codegen();
const names_1 = require_names();
const compile_1 = require_compile();
const ref_1 = require_ref();
const def = {
keyword: "$dynamicAnchor",
schemaType: "string",
code: (cxt) => dynamicAnchor(cxt, cxt.schema)
};
function dynamicAnchor(cxt, anchor2) {
const { gen, it } = cxt;
it.schemaEnv.root.dynamicAnchors[anchor2] = true;
const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor2)}`;
const validate2 = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate2));
}
exports.dynamicAnchor = dynamicAnchor;
function _getValidate(cxt) {
const { schemaEnv, schema, self } = cxt.it;
const { root, baseId, localRefs, meta: meta3 } = schemaEnv.root;
const { schemaId } = self.opts;
const sch = new compile_1.SchemaEnv({
schema,
schemaId,
root,
baseId,
localRefs,
meta: meta3
});
compile_1.compileSchema.call(self, sch);
return (0, ref_1.getValidate)(cxt, sch);
}
exports.default = def;
});
var require_dynamicRef = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.dynamicRef = void 0;
const codegen_1 = require_codegen();
const names_1 = require_names();
const ref_1 = require_ref();
const def = {
keyword: "$dynamicRef",
schemaType: "string",
code: (cxt) => dynamicRef(cxt, cxt.schema)
};
function dynamicRef(cxt, ref) {
const { gen, keyword, it } = cxt;
if (ref[0] !== "#") throw new Error(`"${keyword}" only supports hash fragment reference`);
const anchor2 = ref.slice(1);
if (it.allErrors) _dynamicRef();
else {
const valid = gen.let("valid", false);
_dynamicRef(valid);
cxt.ok(valid);
}
function _dynamicRef(valid) {
if (it.schemaEnv.root.dynamicAnchors[anchor2]) {
const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor2)}`);
gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
} else _callRef(it.validateName, valid)();
}
function _callRef(validate2, valid) {
return valid ? () => gen.block(() => {
(0, ref_1.callRef)(cxt, validate2);
gen.let(valid, true);
}) : () => (0, ref_1.callRef)(cxt, validate2);
}
}
exports.dynamicRef = dynamicRef;
exports.default = def;
});
var require_recursiveAnchor = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const dynamicAnchor_1 = require_dynamicAnchor();
const util_1 = require_util();
const def = {
keyword: "$recursiveAnchor",
schemaType: "boolean",
code(cxt) {
if (cxt.schema) (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
else (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
}
};
exports.default = def;
});
var require_recursiveRef = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const dynamicRef_1 = require_dynamicRef();
const def = {
keyword: "$recursiveRef",
schemaType: "string",
code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
};
exports.default = def;
});
var require_dynamic = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const dynamicAnchor_1 = require_dynamicAnchor();
const dynamicRef_1 = require_dynamicRef();
const recursiveAnchor_1 = require_recursiveAnchor();
const recursiveRef_1 = require_recursiveRef();
const dynamic = [
dynamicAnchor_1.default,
dynamicRef_1.default,
recursiveAnchor_1.default,
recursiveRef_1.default
];
exports.default = dynamic;
});
var require_dependentRequired = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const dependencies_1 = require_dependencies();
const def = {
keyword: "dependentRequired",
type: "object",
schemaType: "object",
error: dependencies_1.error,
code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
};
exports.default = def;
});
var require_dependentSchemas = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const dependencies_1 = require_dependencies();
const def = {
keyword: "dependentSchemas",
type: "object",
schemaType: "object",
code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
};
exports.default = def;
});
var require_limitContains = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require_util();
const def = {
keyword: ["maxContains", "minContains"],
type: "array",
schemaType: "number",
code({ keyword, parentSchema, it }) {
if (parentSchema.contains === void 0) (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
}
};
exports.default = def;
});
var require_next = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const dependentRequired_1 = require_dependentRequired();
const dependentSchemas_1 = require_dependentSchemas();
const limitContains_1 = require_limitContains();
const next = [
dependentRequired_1.default,
dependentSchemas_1.default,
limitContains_1.default
];
exports.default = next;
});
var require_unevaluatedProperties = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const names_1 = require_names();
const def = {
keyword: "unevaluatedProperties",
type: "object",
schemaType: ["boolean", "object"],
trackErrors: true,
error: {
message: "must NOT have unevaluated properties",
params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
},
code(cxt) {
const { gen, schema, data, errsCount, it } = cxt;
if (!errsCount) throw new Error("ajv implementation error");
const { allErrors, props } = it;
if (props instanceof codegen_1.Name) gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
else if (props !== true) gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
it.props = true;
cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
function unevaluatedPropCode(key) {
if (schema === false) {
cxt.setParams({ unevaluatedProperty: key });
cxt.error();
if (!allErrors) gen.break();
return;
}
if (!(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.name("valid");
cxt.subschema({
keyword: "unevaluatedProperties",
dataProp: key,
dataPropType: util_1.Type.Str
}, valid);
if (!allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
}
}
function unevaluatedDynamic(evaluatedProps, key) {
return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
}
function unevaluatedStatic(evaluatedProps, key) {
const ps = [];
for (const p in evaluatedProps) if (evaluatedProps[p] === true) ps.push((0, codegen_1._)`${key} !== ${p}`);
return (0, codegen_1.and)(...ps);
}
}
};
exports.default = def;
});
var require_unevaluatedItems = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const codegen_1 = require_codegen();
const util_1 = require_util();
const def = {
keyword: "unevaluatedItems",
type: "array",
schemaType: ["boolean", "object"],
error: {
message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
},
code(cxt) {
const { gen, schema, data, it } = cxt;
const items = it.items || 0;
if (items === true) return;
const len = gen.const("len", (0, codegen_1._)`${data}.length`);
if (schema === false) {
cxt.setParams({ len: items });
cxt.fail((0, codegen_1._)`${len} > ${items}`);
} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
cxt.ok(valid);
}
it.items = true;
function validateItems(valid, from) {
gen.forRange("i", from, len, (i) => {
cxt.subschema({
keyword: "unevaluatedItems",
dataProp: i,
dataPropType: util_1.Type.Num
}, valid);
if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
});
}
}
};
exports.default = def;
});
var require_unevaluated$1 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const unevaluatedProperties_1 = require_unevaluatedProperties();
const unevaluatedItems_1 = require_unevaluatedItems();
const unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
exports.default = unevaluated;
});
var require_schema$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2019-09/schema",
"$id": "https://json-schema.org/draft/2019-09/schema",
"$vocabulary": {
"https://json-schema.org/draft/2019-09/vocab/core": true,
"https://json-schema.org/draft/2019-09/vocab/applicator": true,
"https://json-schema.org/draft/2019-09/vocab/validation": true,
"https://json-schema.org/draft/2019-09/vocab/meta-data": true,
"https://json-schema.org/draft/2019-09/vocab/format": false,
"https://json-schema.org/draft/2019-09/vocab/content": true
},
"$recursiveAnchor": true,
"title": "Core and Validation specifications meta-schema",
"allOf": [
{ "$ref": "meta/core" },
{ "$ref": "meta/applicator" },
{ "$ref": "meta/validation" },
{ "$ref": "meta/meta-data" },
{ "$ref": "meta/format" },
{ "$ref": "meta/content" }
],
"type": ["object", "boolean"],
"properties": {
"definitions": {
"$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
"type": "object",
"additionalProperties": { "$recursiveRef": "#" },
"default": {}
},
"dependencies": {
"$comment": '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
"type": "object",
"additionalProperties": { "anyOf": [{ "$recursiveRef": "#" }, { "$ref": "meta/validation#/$defs/stringArray" }] }
}
}
};
});
var require_applicator$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2019-09/schema",
"$id": "https://json-schema.org/draft/2019-09/meta/applicator",
"$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/applicator": true },
"$recursiveAnchor": true,
"title": "Applicator vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"additionalItems": { "$recursiveRef": "#" },
"unevaluatedItems": { "$recursiveRef": "#" },
"items": { "anyOf": [{ "$recursiveRef": "#" }, { "$ref": "#/$defs/schemaArray" }] },
"contains": { "$recursiveRef": "#" },
"additionalProperties": { "$recursiveRef": "#" },
"unevaluatedProperties": { "$recursiveRef": "#" },
"properties": {
"type": "object",
"additionalProperties": { "$recursiveRef": "#" },
"default": {}
},
"patternProperties": {
"type": "object",
"additionalProperties": { "$recursiveRef": "#" },
"propertyNames": { "format": "regex" },
"default": {}
},
"dependentSchemas": {
"type": "object",
"additionalProperties": { "$recursiveRef": "#" }
},
"propertyNames": { "$recursiveRef": "#" },
"if": { "$recursiveRef": "#" },
"then": { "$recursiveRef": "#" },
"else": { "$recursiveRef": "#" },
"allOf": { "$ref": "#/$defs/schemaArray" },
"anyOf": { "$ref": "#/$defs/schemaArray" },
"oneOf": { "$ref": "#/$defs/schemaArray" },
"not": { "$recursiveRef": "#" }
},
"$defs": { "schemaArray": {
"type": "array",
"minItems": 1,
"items": { "$recursiveRef": "#" }
} }
};
});
var require_content$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2019-09/schema",
"$id": "https://json-schema.org/draft/2019-09/meta/content",
"$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/content": true },
"$recursiveAnchor": true,
"title": "Content vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"contentMediaType": { "type": "string" },
"contentEncoding": { "type": "string" },
"contentSchema": { "$recursiveRef": "#" }
}
};
});
var require_core$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2019-09/schema",
"$id": "https://json-schema.org/draft/2019-09/meta/core",
"$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/core": true },
"$recursiveAnchor": true,
"title": "Core vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"$id": {
"type": "string",
"format": "uri-reference",
"$comment": "Non-empty fragments not allowed.",
"pattern": "^[^#]*#?$"
},
"$schema": {
"type": "string",
"format": "uri"
},
"$anchor": {
"type": "string",
"pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
},
"$ref": {
"type": "string",
"format": "uri-reference"
},
"$recursiveRef": {
"type": "string",
"format": "uri-reference"
},
"$recursiveAnchor": {
"type": "boolean",
"default": false
},
"$vocabulary": {
"type": "object",
"propertyNames": {
"type": "string",
"format": "uri"
},
"additionalProperties": { "type": "boolean" }
},
"$comment": { "type": "string" },
"$defs": {
"type": "object",
"additionalProperties": { "$recursiveRef": "#" },
"default": {}
}
}
};
});
var require_format = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2019-09/schema",
"$id": "https://json-schema.org/draft/2019-09/meta/format",
"$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/format": true },
"$recursiveAnchor": true,
"title": "Format vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": { "format": { "type": "string" } }
};
});
var require_meta_data$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2019-09/schema",
"$id": "https://json-schema.org/draft/2019-09/meta/meta-data",
"$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/meta-data": true },
"$recursiveAnchor": true,
"title": "Meta-data vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"title": { "type": "string" },
"description": { "type": "string" },
"default": true,
"deprecated": {
"type": "boolean",
"default": false
},
"readOnly": {
"type": "boolean",
"default": false
},
"writeOnly": {
"type": "boolean",
"default": false
},
"examples": {
"type": "array",
"items": true
}
}
};
});
var require_validation$1 = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2019-09/schema",
"$id": "https://json-schema.org/draft/2019-09/meta/validation",
"$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/validation": true },
"$recursiveAnchor": true,
"title": "Validation vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"multipleOf": {
"type": "number",
"exclusiveMinimum": 0
},
"maximum": { "type": "number" },
"exclusiveMaximum": { "type": "number" },
"minimum": { "type": "number" },
"exclusiveMinimum": { "type": "number" },
"maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
"minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
"pattern": {
"type": "string",
"format": "regex"
},
"maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
"minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
"uniqueItems": {
"type": "boolean",
"default": false
},
"maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
"minContains": {
"$ref": "#/$defs/nonNegativeInteger",
"default": 1
},
"maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
"minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
"required": { "$ref": "#/$defs/stringArray" },
"dependentRequired": {
"type": "object",
"additionalProperties": { "$ref": "#/$defs/stringArray" }
},
"const": true,
"enum": {
"type": "array",
"items": true
},
"type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, {
"type": "array",
"items": { "$ref": "#/$defs/simpleTypes" },
"minItems": 1,
"uniqueItems": true
}] }
},
"$defs": {
"nonNegativeInteger": {
"type": "integer",
"minimum": 0
},
"nonNegativeIntegerDefault0": {
"$ref": "#/$defs/nonNegativeInteger",
"default": 0
},
"simpleTypes": { "enum": [
"array",
"boolean",
"integer",
"null",
"number",
"object",
"string"
] },
"stringArray": {
"type": "array",
"items": { "type": "string" },
"uniqueItems": true,
"default": []
}
}
};
});
var require_json_schema_2019_09 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const metaSchema = require_schema$1();
const applicator = require_applicator$1();
const content = require_content$1();
const core = require_core$1();
const format = require_format();
const metadata = require_meta_data$1();
const validation = require_validation$1();
const META_SUPPORT_DATA = ["/properties"];
function addMetaSchema2019($data) {
[
metaSchema,
applicator,
content,
core,
with$data(this, format),
metadata,
with$data(this, validation)
].forEach((sch) => this.addMetaSchema(sch, void 0, false));
return this;
function with$data(ajv, sch) {
return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
}
}
exports.default = addMetaSchema2019;
});
var require__2019 = /* @__PURE__ */ __commonJSMin((exports, module) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2019 = void 0;
const core_1 = require_core$3();
const draft7_1 = require_draft7();
const dynamic_1 = require_dynamic();
const next_1 = require_next();
const unevaluated_1 = require_unevaluated$1();
const discriminator_1 = require_discriminator();
const json_schema_2019_09_1 = require_json_schema_2019_09();
const META_SCHEMA_ID = "https://json-schema.org/draft/2019-09/schema";
var Ajv2019 = class extends core_1.default {
constructor(opts = {}) {
super({
...opts,
dynamicRef: true,
next: true,
unevaluated: true
});
}
_addVocabularies() {
super._addVocabularies();
this.addVocabulary(dynamic_1.default);
draft7_1.default.forEach((v) => this.addVocabulary(v));
this.addVocabulary(next_1.default);
this.addVocabulary(unevaluated_1.default);
if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
}
_addDefaultMetaSchema() {
super._addDefaultMetaSchema();
const { $data, meta: meta3 } = this.opts;
if (!meta3) return;
json_schema_2019_09_1.default.call(this, $data);
this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
}
defaultMeta() {
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
}
};
exports.Ajv2019 = Ajv2019;
module.exports = exports = Ajv2019;
module.exports.Ajv2019 = Ajv2019;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Ajv2019;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", {
enumerable: true,
get: function() {
return validate_1.KeywordCxt;
}
});
var codegen_1 = require_codegen();
Object.defineProperty(exports, "_", {
enumerable: true,
get: function() {
return codegen_1._;
}
});
Object.defineProperty(exports, "str", {
enumerable: true,
get: function() {
return codegen_1.str;
}
});
Object.defineProperty(exports, "stringify", {
enumerable: true,
get: function() {
return codegen_1.stringify;
}
});
Object.defineProperty(exports, "nil", {
enumerable: true,
get: function() {
return codegen_1.nil;
}
});
Object.defineProperty(exports, "Name", {
enumerable: true,
get: function() {
return codegen_1.Name;
}
});
Object.defineProperty(exports, "CodeGen", {
enumerable: true,
get: function() {
return codegen_1.CodeGen;
}
});
var validation_error_1 = require_validation_error();
Object.defineProperty(exports, "ValidationError", {
enumerable: true,
get: function() {
return validation_error_1.default;
}
});
var ref_error_1 = require_ref_error();
Object.defineProperty(exports, "MissingRefError", {
enumerable: true,
get: function() {
return ref_error_1.default;
}
});
});
var require_draft2020 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const core_1 = require_core$2();
const validation_1 = require_validation$2();
const applicator_1 = require_applicator$2();
const dynamic_1 = require_dynamic();
const next_1 = require_next();
const unevaluated_1 = require_unevaluated$1();
const format_1 = require_format$1();
const metadata_1 = require_metadata();
const draft2020Vocabularies = [
dynamic_1.default,
core_1.default,
validation_1.default,
(0, applicator_1.default)(true),
format_1.default,
metadata_1.metadataVocabulary,
metadata_1.contentVocabulary,
next_1.default,
unevaluated_1.default
];
exports.default = draft2020Vocabularies;
});
var require_schema = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/schema",
"$vocabulary": {
"https://json-schema.org/draft/2020-12/vocab/core": true,
"https://json-schema.org/draft/2020-12/vocab/applicator": true,
"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
"https://json-schema.org/draft/2020-12/vocab/validation": true,
"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
"https://json-schema.org/draft/2020-12/vocab/content": true
},
"$dynamicAnchor": "meta",
"title": "Core and Validation specifications meta-schema",
"allOf": [
{ "$ref": "meta/core" },
{ "$ref": "meta/applicator" },
{ "$ref": "meta/unevaluated" },
{ "$ref": "meta/validation" },
{ "$ref": "meta/meta-data" },
{ "$ref": "meta/format-annotation" },
{ "$ref": "meta/content" }
],
"type": ["object", "boolean"],
"$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
"properties": {
"definitions": {
"$comment": '"definitions" has been replaced by "$defs".',
"type": "object",
"additionalProperties": { "$dynamicRef": "#meta" },
"deprecated": true,
"default": {}
},
"dependencies": {
"$comment": '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
"type": "object",
"additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] },
"deprecated": true,
"default": {}
},
"$recursiveAnchor": {
"$comment": '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
"$ref": "meta/core#/$defs/anchorString",
"deprecated": true
},
"$recursiveRef": {
"$comment": '"$recursiveRef" has been replaced by "$dynamicRef".',
"$ref": "meta/core#/$defs/uriReferenceString",
"deprecated": true
}
}
};
});
var require_applicator = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/meta/applicator",
"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/applicator": true },
"$dynamicAnchor": "meta",
"title": "Applicator vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"prefixItems": { "$ref": "#/$defs/schemaArray" },
"items": { "$dynamicRef": "#meta" },
"contains": { "$dynamicRef": "#meta" },
"additionalProperties": { "$dynamicRef": "#meta" },
"properties": {
"type": "object",
"additionalProperties": { "$dynamicRef": "#meta" },
"default": {}
},
"patternProperties": {
"type": "object",
"additionalProperties": { "$dynamicRef": "#meta" },
"propertyNames": { "format": "regex" },
"default": {}
},
"dependentSchemas": {
"type": "object",
"additionalProperties": { "$dynamicRef": "#meta" },
"default": {}
},
"propertyNames": { "$dynamicRef": "#meta" },
"if": { "$dynamicRef": "#meta" },
"then": { "$dynamicRef": "#meta" },
"else": { "$dynamicRef": "#meta" },
"allOf": { "$ref": "#/$defs/schemaArray" },
"anyOf": { "$ref": "#/$defs/schemaArray" },
"oneOf": { "$ref": "#/$defs/schemaArray" },
"not": { "$dynamicRef": "#meta" }
},
"$defs": { "schemaArray": {
"type": "array",
"minItems": 1,
"items": { "$dynamicRef": "#meta" }
} }
};
});
var require_unevaluated = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true },
"$dynamicAnchor": "meta",
"title": "Unevaluated applicator vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"unevaluatedItems": { "$dynamicRef": "#meta" },
"unevaluatedProperties": { "$dynamicRef": "#meta" }
}
};
});
var require_content = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/meta/content",
"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/content": true },
"$dynamicAnchor": "meta",
"title": "Content vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"contentEncoding": { "type": "string" },
"contentMediaType": { "type": "string" },
"contentSchema": { "$dynamicRef": "#meta" }
}
};
});
var require_core = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/meta/core",
"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true },
"$dynamicAnchor": "meta",
"title": "Core vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"$id": {
"$ref": "#/$defs/uriReferenceString",
"$comment": "Non-empty fragments not allowed.",
"pattern": "^[^#]*#?$"
},
"$schema": { "$ref": "#/$defs/uriString" },
"$ref": { "$ref": "#/$defs/uriReferenceString" },
"$anchor": { "$ref": "#/$defs/anchorString" },
"$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
"$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
"$vocabulary": {
"type": "object",
"propertyNames": { "$ref": "#/$defs/uriString" },
"additionalProperties": { "type": "boolean" }
},
"$comment": { "type": "string" },
"$defs": {
"type": "object",
"additionalProperties": { "$dynamicRef": "#meta" }
}
},
"$defs": {
"anchorString": {
"type": "string",
"pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
},
"uriString": {
"type": "string",
"format": "uri"
},
"uriReferenceString": {
"type": "string",
"format": "uri-reference"
}
}
};
});
var require_format_annotation = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true },
"$dynamicAnchor": "meta",
"title": "Format vocabulary meta-schema for annotation results",
"type": ["object", "boolean"],
"properties": { "format": { "type": "string" } }
};
});
var require_meta_data = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/meta-data": true },
"$dynamicAnchor": "meta",
"title": "Meta-data vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"title": { "type": "string" },
"description": { "type": "string" },
"default": true,
"deprecated": {
"type": "boolean",
"default": false
},
"readOnly": {
"type": "boolean",
"default": false
},
"writeOnly": {
"type": "boolean",
"default": false
},
"examples": {
"type": "array",
"items": true
}
}
};
});
var require_validation = /* @__PURE__ */ __commonJSMin((exports, module) => {
module.exports = {
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://json-schema.org/draft/2020-12/meta/validation",
"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/validation": true },
"$dynamicAnchor": "meta",
"title": "Validation vocabulary meta-schema",
"type": ["object", "boolean"],
"properties": {
"type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, {
"type": "array",
"items": { "$ref": "#/$defs/simpleTypes" },
"minItems": 1,
"uniqueItems": true
}] },
"const": true,
"enum": {
"type": "array",
"items": true
},
"multipleOf": {
"type": "number",
"exclusiveMinimum": 0
},
"maximum": { "type": "number" },
"exclusiveMaximum": { "type": "number" },
"minimum": { "type": "number" },
"exclusiveMinimum": { "type": "number" },
"maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
"minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
"pattern": {
"type": "string",
"format": "regex"
},
"maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
"minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
"uniqueItems": {
"type": "boolean",
"default": false
},
"maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
"minContains": {
"$ref": "#/$defs/nonNegativeInteger",
"default": 1
},
"maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
"minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
"required": { "$ref": "#/$defs/stringArray" },
"dependentRequired": {
"type": "object",
"additionalProperties": { "$ref": "#/$defs/stringArray" }
}
},
"$defs": {
"nonNegativeInteger": {
"type": "integer",
"minimum": 0
},
"nonNegativeIntegerDefault0": {
"$ref": "#/$defs/nonNegativeInteger",
"default": 0
},
"simpleTypes": { "enum": [
"array",
"boolean",
"integer",
"null",
"number",
"object",
"string"
] },
"stringArray": {
"type": "array",
"items": { "type": "string" },
"uniqueItems": true,
"default": []
}
}
};
});
var require_json_schema_2020_12 = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
const metaSchema = require_schema();
const applicator = require_applicator();
const unevaluated = require_unevaluated();
const content = require_content();
const core = require_core();
const format = require_format_annotation();
const metadata = require_meta_data();
const validation = require_validation();
const META_SUPPORT_DATA = ["/properties"];
function addMetaSchema2020($data) {
[
metaSchema,
applicator,
unevaluated,
content,
core,
with$data(this, format),
metadata,
with$data(this, validation)
].forEach((sch) => this.addMetaSchema(sch, void 0, false));
return this;
function with$data(ajv, sch) {
return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
}
}
exports.default = addMetaSchema2020;
});
var require__2020 = /* @__PURE__ */ __commonJSMin((exports, module) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
const core_1 = require_core$3();
const draft2020_1 = require_draft2020();
const discriminator_1 = require_discriminator();
const json_schema_2020_12_1 = require_json_schema_2020_12();
const META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
var Ajv2020 = class extends core_1.default {
constructor(opts = {}) {
super({
...opts,
dynamicRef: true,
next: true,
unevaluated: true
});
}
_addVocabularies() {
super._addVocabularies();
draft2020_1.default.forEach((v) => this.addVocabulary(v));
if (this.opts.discriminator) this.addKeyword(discriminator_1.default);
}
_addDefaultMetaSchema() {
super._addDefaultMetaSchema();
const { $data, meta: meta3 } = this.opts;
if (!meta3) return;
json_schema_2020_12_1.default.call(this, $data);
this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
}
defaultMeta() {
return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
}
};
exports.Ajv2020 = Ajv2020;
module.exports = exports = Ajv2020;
module.exports.Ajv2020 = Ajv2020;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = Ajv2020;
var validate_1 = require_validate();
Object.defineProperty(exports, "KeywordCxt", {
enumerable: true,
get: function() {
return validate_1.KeywordCxt;
}
});
var codegen_1 = require_codegen();
Object.defineProperty(exports, "_", {
enumerable: true,
get: function() {
return codegen_1._;
}
});
Object.defineProperty(exports, "str", {
enumerable: true,
get: function() {
return codegen_1.str;
}
});
Object.defineProperty(exports, "stringify", {
enumerable: true,
get: function() {
return codegen_1.stringify;
}
});
Object.defineProperty(exports, "nil", {
enumerable: true,
get: function() {
return codegen_1.nil;
}
});
Object.defineProperty(exports, "Name", {
enumerable: true,
get: function() {
return codegen_1.Name;
}
});
Object.defineProperty(exports, "CodeGen", {
enumerable: true,
get: function() {
return codegen_1.CodeGen;
}
});
var validation_error_1 = require_validation_error();
Object.defineProperty(exports, "ValidationError", {
enumerable: true,
get: function() {
return validation_error_1.default;
}
});
var ref_error_1 = require_ref_error();
Object.defineProperty(exports, "MissingRefError", {
enumerable: true,
get: function() {
return ref_error_1.default;
}
});
});
var require_formats = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
function fmtDef(validate2, compare) {
return {
validate: validate2,
compare
};
}
exports.fullFormats = {
date: fmtDef(date5, compareDate),
time: fmtDef(getTime(true), compareTime),
"date-time": fmtDef(getDateTime(true), compareDateTime),
"iso-time": fmtDef(getTime(), compareIsoTime),
"iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
uri,
"uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
"uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
regex,
uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
"json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
"json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
"relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
byte,
int32: {
type: "number",
validate: validateInt32
},
int64: {
type: "number",
validate: validateInt64
},
float: {
type: "number",
validate: validateNumber
},
double: {
type: "number",
validate: validateNumber
},
password: true,
binary: true
};
exports.fastFormats = {
...exports.fullFormats,
date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
"date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
"iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
"iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
"uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
};
exports.formatNames = Object.keys(exports.fullFormats);
function isLeapYear(year) {
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
}
const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
const DAYS = [
0,
31,
28,
31,
30,
31,
30,
31,
31,
30,
31,
30,
31
];
function date5(str) {
const matches = DATE.exec(str);
if (!matches) return false;
const year = +matches[1];
const month = +matches[2];
const day = +matches[3];
return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
}
function compareDate(d1, d2) {
if (!(d1 && d2)) return void 0;
if (d1 > d2) return 1;
if (d1 < d2) return -1;
return 0;
}
const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
function getTime(strictTimeZone) {
return function time3(str) {
const matches = TIME.exec(str);
if (!matches) return false;
const hr = +matches[1];
const min = +matches[2];
const sec = +matches[3];
const tz = matches[4];
const tzSign = matches[5] === "-" ? -1 : 1;
const tzH = +(matches[6] || 0);
const tzM = +(matches[7] || 0);
if (tzH > 23 || tzM > 59 || strictTimeZone && !tz) return false;
if (hr <= 23 && min <= 59 && sec < 60) return true;
const utcMin = min - tzM * tzSign;
const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
};
}
function compareTime(s1, s2) {
if (!(s1 && s2)) return void 0;
const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf();
const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf();
if (!(t1 && t2)) return void 0;
return t1 - t2;
}
function compareIsoTime(t1, t2) {
if (!(t1 && t2)) return void 0;
const a1 = TIME.exec(t1);
const a2 = TIME.exec(t2);
if (!(a1 && a2)) return void 0;
t1 = a1[1] + a1[2] + a1[3];
t2 = a2[1] + a2[2] + a2[3];
if (t1 > t2) return 1;
if (t1 < t2) return -1;
return 0;
}
const DATE_TIME_SEPARATOR = /t|\s/i;
function getDateTime(strictTimeZone) {
const time3 = getTime(strictTimeZone);
return function date_time(str) {
const dateTime = str.split(DATE_TIME_SEPARATOR);
return dateTime.length === 2 && date5(dateTime[0]) && time3(dateTime[1]);
};
}
function compareDateTime(dt1, dt2) {
if (!(dt1 && dt2)) return void 0;
const d1 = new Date(dt1).valueOf();
const d2 = new Date(dt2).valueOf();
if (!(d1 && d2)) return void 0;
return d1 - d2;
}
function compareIsoDateTime(dt1, dt2) {
if (!(dt1 && dt2)) return void 0;
const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
const res = compareDate(d1, d2);
if (res === void 0) return void 0;
return res || compareTime(t1, t2);
}
const NOT_URI_FRAGMENT = /\/|:/;
const URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
function uri(str) {
return NOT_URI_FRAGMENT.test(str) && URI.test(str);
}
const BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
function byte(str) {
BYTE.lastIndex = 0;
return BYTE.test(str);
}
const MIN_INT32 = -(2 ** 31);
const MAX_INT32 = 2 ** 31 - 1;
function validateInt32(value) {
return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
}
function validateInt64(value) {
return Number.isInteger(value);
}
function validateNumber() {
return true;
}
const Z_ANCHOR = /[^\\]\\Z/;
function regex(str) {
if (Z_ANCHOR.test(str)) return false;
try {
new RegExp(str);
return true;
} catch (e) {
return false;
}
}
});
var require_limit = /* @__PURE__ */ __commonJSMin((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatLimitDefinition = void 0;
const ajv_1 = require_ajv();
const codegen_1 = require_codegen();
const ops = codegen_1.operators;
const KWDs = {
formatMaximum: {
okStr: "<=",
ok: ops.LTE,
fail: ops.GT
},
formatMinimum: {
okStr: ">=",
ok: ops.GTE,
fail: ops.LT
},
formatExclusiveMaximum: {
okStr: "<",
ok: ops.LT,
fail: ops.GTE
},
formatExclusiveMinimum: {
okStr: ">",
ok: ops.GT,
fail: ops.LTE
}
};
const error62 = {
message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`,
params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
};
exports.formatLimitDefinition = {
keyword: Object.keys(KWDs),
type: "string",
schemaType: "string",
$data: true,
error: error62,
code(cxt) {
const { gen, data, schemaCode, keyword, it } = cxt;
const { opts, self } = it;
if (!opts.validateFormats) return;
const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
if (fCxt.$data) validate$DataFormat();
else validateFormat();
function validate$DataFormat() {
const fmts = gen.scopeValue("formats", {
ref: self.formats,
code: opts.code.formats
});
const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`);
cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
}
function validateFormat() {
const format = fCxt.schema;
const fmtDef = self.formats[format];
if (!fmtDef || fmtDef === true) return;
if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
const fmt = gen.scopeValue("formats", {
key: format,
ref: fmtDef,
code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0
});
cxt.fail$data(compareCode(fmt));
}
function compareCode(fmt) {
return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`;
}
},
dependencies: ["format"]
};
const formatLimitPlugin = (ajv) => {
ajv.addKeyword(exports.formatLimitDefinition);
return ajv;
};
exports.default = formatLimitPlugin;
});
var require_dist = /* @__PURE__ */ __commonJSMin((exports, module) => {
Object.defineProperty(exports, "__esModule", { value: true });
const formats_1 = require_formats();
const limit_1 = require_limit();
const codegen_1 = require_codegen();
const fullName = new codegen_1.Name("fullFormats");
const fastName = new codegen_1.Name("fastFormats");
const formatsPlugin = (ajv, opts = { keywords: true }) => {
if (Array.isArray(opts)) {
addFormats2(ajv, opts, formats_1.fullFormats, fullName);
return ajv;
}
const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
addFormats2(ajv, opts.formats || formats_1.formatNames, formats, exportName);
if (opts.keywords) (0, limit_1.default)(ajv);
return ajv;
};
formatsPlugin.get = (name, mode = "full") => {
const f = (mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats)[name];
if (!f) throw new Error(`Unknown format "${name}"`);
return f;
};
function addFormats2(ajv, list, fs3, exportName) {
var _a3;
var _b;
(_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
for (const f of list) ajv.addFormat(f, fs3[f]);
}
module.exports = exports = formatsPlugin;
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = formatsPlugin;
});
var import_ajv = require_ajv();
var import__2019 = require__2019();
var import__2020 = require__2020();
var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
var addFormats = import_dist.default;
function createDefaultAjvInstance(engineClass) {
const ajv = new engineClass({
strict: false,
validateFormats: true,
validateSchema: false,
allErrors: true
});
addFormats(ajv);
return ajv;
}
var AjvJsonSchemaValidator = class {
_ajv;
/** Lazy classic (draft-07) engine, built on the first draft-07/draft-06-declared schema. */
_ajvDraft7;
/** Lazy 2019-09 engine, built on the first 2019-09-declared schema. */
_ajv2019;
/** True iff the constructor received a caller-supplied engine; the `$schema` dispatch is skipped. */
_userAjv;
/**
* @param ajv - Optional pre-configured AJV-compatible instance. When supplied, this instance is
* used for **every** schema regardless of its declared `$schema` (the caller owns dialect
* choice). When omitted, the provider constructs per-dialect engines (`Ajv2020`, `Ajv2019`,
* and the classic draft-07 `Ajv` for draft-07/06-declared schemas) with
* `strict: false`, `validateFormats: true`, `validateSchema: false`, `allErrors: true`, and
* `ajv-formats` registered — **lazily, on the first {@linkcode getValidator} call needing each**, so
* constructing the provider (e.g. as the default validator of a `Client`/`Server` that never
* validates a JSON Schema) does not pay the ajv + ajv-formats instantiation cost. The parameter
* is typed structurally so consumers who don't pass an instance need not have `ajv` installed.
*/
constructor(ajv) {
this._userAjv = ajv !== void 0;
this._ajv = ajv;
}
/** The underlying 2020-12 engine — the default instance is created on first use. */
get ajv() {
return this._ajv ??= createDefaultAjvInstance(import__2020.Ajv2020);
}
/**
* Pick the engine for a schema's declared dialect. A caller-supplied engine is used for
* every schema — do not second-guess by `$schema` (bring-your-own-validator means
* bring-your-own-dialect). Otherwise: no `$schema` or 2020-12 → `Ajv2020`; 2019-09 →
* `Ajv2019`; draft-07 or draft-06 → classic `Ajv`; anything else → `Error`.
*/
_engineFor(schema) {
if (this._userAjv) return this.ajv;
const dialect = declaredDialect(schema, "pass a pre-configured Ajv instance to AjvJsonSchemaValidator(ajv) to validate other dialects.");
if (dialect === "2020-12") return this.ajv;
if (dialect === "2019-09") return this._ajv2019 ??= createDefaultAjvInstance(import__2019.Ajv2019);
return this._ajvDraft7 ??= createDefaultAjvInstance(import_ajv.Ajv);
}
getValidator(schema) {
const engine = this._engineFor(schema);
const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? engine.getSchema(schema.$id) ?? engine.compile(schema) : engine.compile(schema);
return (input2) => {
return ajvValidator(input2) ? {
valid: true,
data: input2,
errorMessage: void 0
} : {
valid: false,
data: void 0,
errorMessage: engine.errorsText(ajvValidator.errors)
};
};
}
};
var Ajv = import_ajv.Ajv;
// node_modules/.pnpm/@modelcontextprotocol+client@2.4.0/node_modules/@modelcontextprotocol/client/dist/shimsNode.mjs
var CORS_IS_POSSIBLE = false;
// node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.node.js
var crypto;
crypto = globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
globalThis.crypto ?? // Node.js >18
import("node:crypto").then((m) => m.webcrypto);
async function getRandomValues(size) {
return (await crypto).getRandomValues(new Uint8Array(size));
}
async function random(size) {
const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
let result = "";
while (result.length < size) {
const randomBytes = await getRandomValues(size - result.length);
for (const randomByte of randomBytes) {
if (randomByte < evenDistCutoff) {
result += mask[randomByte % mask.length];
}
}
}
return result;
}
async function generateVerifier(length) {
return await random(length);
}
async function generateChallenge(code_verifier) {
const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
}
async function pkceChallenge(length) {
if (!length)
length = 43;
if (length < 43 || length > 128) {
throw `Expected a length between 43 and 128. Received ${length}.`;
}
const verifier = await generateVerifier(length);
const challenge = await generateChallenge(verifier);
return {
code_verifier: verifier,
code_challenge: challenge
};
}
// node_modules/.pnpm/@modelcontextprotocol+client@2.4.0/node_modules/@modelcontextprotocol/client/dist/public-CvV4ZHkX.mjs
var OAuthClientFlowError = class extends Error {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.OAuthClientFlowError" });
}
static [Symbol.hasInstance](value) {
return brandedHasInstance(this, value);
}
/**
* Brand-based type guard: equivalent to `value instanceof this`, as an
* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
* the caller's own brand via `this`, so every branded subclass gets a
* correctly-scoped guard by inheritance. Must be invoked on the class —
* in callback position write `v => SdkError.isInstance(v)`, not
* `.filter(SdkError.isInstance)` (detached calls throw rather than
* silently matching nothing).
*/
static isInstance(value) {
if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
return brandedHasInstance(this, value);
}
constructor(message) {
super(message);
this.name = new.target.name;
stampErrorBrands(this, new.target);
}
};
var IssuerMismatchError = class extends OAuthClientFlowError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.IssuerMismatchError" });
}
/** Which check failed — metadata echo (RFC 8414 §3.3) or authorization-response `iss` (RFC 9207). */
kind;
/** The issuer the client expected (from validated metadata / discovery input). */
expected;
/** The issuer value that was received. Attacker-controllable on the `'authorization_response'` path. */
received;
constructor(kind, expected, received) {
super(`Issuer mismatch in ${kind === "metadata" ? "authorization server metadata (RFC 8414 \xA73.3)" : "authorization response (RFC 9207)"}: expected ${JSON.stringify(expected)}, received ${JSON.stringify(received)}`);
this.kind = kind;
this.expected = expected;
this.received = received;
}
};
var RegistrationRejectedError = class extends OAuthClientFlowError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.RegistrationRejectedError" });
}
/** HTTP status code returned by the registration endpoint. */
status;
/** Raw response body text (typically an RFC 7591 error JSON document). */
body;
/** The exact client metadata that was POSTed (after SDK defaults were applied). */
submittedMetadata;
constructor(args) {
super(`Dynamic Client Registration rejected (HTTP ${args.status}): ${args.body}`);
this.status = args.status;
this.body = args.body;
this.submittedMetadata = args.submittedMetadata;
}
};
var InsecureTokenEndpointError = class extends OAuthClientFlowError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.InsecureTokenEndpointError" });
}
/** The token endpoint URL that was rejected. */
tokenEndpoint;
constructor(tokenEndpoint) {
super(`Refusing to send credentials to non-https token endpoint '${tokenEndpoint}'. OAuth token requests MUST use TLS (localhost / *.localhost / 127.0.0.1 / ::1 are exempt).`);
this.tokenEndpoint = tokenEndpoint;
}
};
var AuthorizationServerMismatchError = class extends OAuthClientFlowError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.AuthorizationServerMismatchError" });
}
constructor(recordedIssuer, currentIssuer) {
super(`Authorization server mismatch: credentials are bound to ${JSON.stringify(recordedIssuer)} but this call resolved ${JSON.stringify(currentIssuer)}; refusing to present them to a different authorization server`);
this.recordedIssuer = recordedIssuer;
this.currentIssuer = currentIssuer;
}
};
var InsufficientScopeError = class extends OAuthClientFlowError {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.InsufficientScopeError" });
}
/** The `scope` value from the `WWW-Authenticate` challenge — the scopes the resource server says are required. */
requiredScope;
/** The `resource_metadata` URL from the `WWW-Authenticate` challenge, if present. */
resourceMetadataUrl;
/** The `error_description` from the `WWW-Authenticate` challenge, if present. */
errorDescription;
constructor(init) {
super(`Insufficient scope${init.requiredScope ? `: required "${init.requiredScope}"` : ""}`);
this.requiredScope = init.requiredScope;
this.resourceMetadataUrl = init.resourceMetadataUrl;
this.errorDescription = init.errorDescription;
}
};
function discardIfIssuerMismatch(stored, issuer, opts) {
if (!stored) return void 0;
if (typeof stored.issuer !== "string") {
if (opts?.canPersistStamp !== false) console.warn("[mcp-sdk] SEP-2352: stored OAuth credential has no 'issuer' stamp (pre-upgrade storage or provider not round-tripping the value). SEP-2352 isolation is inactive for this read; ensure your provider round-trips the issuer field.");
return stored.issuer === void 0 ? stored : {
...stored,
issuer: void 0
};
}
return issuersMatch(stored.issuer, issuer) ? stored : void 0;
}
function issuersMatch(a, b) {
return a === b || a.endsWith("/") && a.slice(0, -1) === b || b.endsWith("/") && b.slice(0, -1) === a;
}
function isOAuthClientProvider(provider) {
if (provider == null) return false;
const p = provider;
return typeof p.tokens === "function" && typeof p.clientInformation === "function";
}
async function handleOAuthUnauthorized(provider, ctx, extraAuthOptions) {
const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(ctx.response);
if (await auth(provider, {
serverUrl: ctx.serverUrl,
resourceMetadataUrl,
scope,
fetchFn: ctx.fetchFn,
...extraAuthOptions
}) !== "AUTHORIZED") throw new UnauthorizedError();
}
function adaptOAuthProvider(provider, extraAuthOptions) {
return {
token: async () => {
return (await provider.tokens())?.access_token;
},
onUnauthorized: async (ctx) => handleOAuthUnauthorized(provider, ctx, extraAuthOptions)
};
}
var UnauthorizedError = class extends Error {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.UnauthorizedError" });
}
static [Symbol.hasInstance](value) {
return brandedHasInstance(this, value);
}
/**
* Brand-based type guard: equivalent to `value instanceof this`, as an
* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
* the caller's own brand via `this`, so every branded subclass gets a
* correctly-scoped guard by inheritance. Must be invoked on the class —
* in callback position write `v => SdkError.isInstance(v)`, not
* `.filter(SdkError.isInstance)` (detached calls throw rather than
* silently matching nothing).
*/
static isInstance(value) {
if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
return brandedHasInstance(this, value);
}
constructor(message) {
super(message ?? "Unauthorized");
this.name = "UnauthorizedError";
stampErrorBrands(this, new.target);
}
};
function isIssParameterSupported(metadata) {
return metadata?.authorization_response_iss_parameter_supported === true;
}
function validateAuthorizationResponseIssuer({ iss, expectedIssuer, issParameterSupported }) {
if (expectedIssuer === void 0) return;
if (iss === void 0) {
if (issParameterSupported) throw new IssuerMismatchError("authorization_response", expectedIssuer, void 0);
return;
}
if (iss !== expectedIssuer) throw new IssuerMismatchError("authorization_response", expectedIssuer, iss);
}
function computeScopeUnion(...scopes) {
const seen = /* @__PURE__ */ new Set();
for (const scope of scopes) {
if (!scope) continue;
for (const token of scope.split(/\s+/)) if (token) seen.add(token);
}
return seen.size > 0 ? [...seen].join(" ") : void 0;
}
function isStrictScopeSuperset(union2, current) {
if (!union2) return false;
const currentSet = new Set((current ?? "").split(/\s+/).filter(Boolean));
for (const token of union2.split(/\s+/)) if (token && !currentSet.has(token)) return true;
return false;
}
async function resolveAuthorizationCallbackParams(codeOrParams, iss, provider, serverUrl, opts) {
if (typeof codeOrParams === "string") return {
authorizationCode: codeOrParams,
iss
};
const issParam = codeOrParams.get("iss") ?? void 0;
const code = codeOrParams.get("code");
if (code) return {
authorizationCode: code,
iss: issParam
};
let metadata = (await provider.discoveryState?.())?.authorizationServerMetadata;
if (!metadata) try {
metadata = (await discoverOAuthServerInfo(serverUrl, opts)).authorizationServerMetadata;
} catch {
metadata = void 0;
}
if (!metadata) throw new UnauthorizedError("Authorization callback failed and the issuer could not be verified");
validateAuthorizationResponseIssuer({
iss: issParam,
expectedIssuer: metadata.issuer,
issParameterSupported: isIssParameterSupported(metadata)
});
const error62 = codeOrParams.get("error");
if (error62) throw new OAuthError(error62, codeOrParams.get("error_description") ?? error62, codeOrParams.get("error_uri") ?? void 0);
throw new UnauthorizedError("Authorization callback contained neither `code` nor `error`");
}
function isClientAuthMethod(method) {
return [
"client_secret_basic",
"client_secret_post",
"none"
].includes(method);
}
var AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
function selectClientAuthMethod(clientInformation, supportedMethods) {
const hasClientSecret = clientInformation.client_secret !== void 0;
if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) return clientInformation.token_endpoint_auth_method;
if (supportedMethods.length === 0) return hasClientSecret ? "client_secret_basic" : "none";
if (hasClientSecret && supportedMethods.includes("client_secret_basic")) return "client_secret_basic";
if (hasClientSecret && supportedMethods.includes("client_secret_post")) return "client_secret_post";
if (supportedMethods.includes("none")) return "none";
return hasClientSecret ? "client_secret_post" : "none";
}
function applyClientAuthentication(method, clientInformation, headers, params) {
const { client_id, client_secret } = clientInformation;
switch (method) {
case "client_secret_basic":
applyBasicAuth(client_id, client_secret, headers);
return;
case "client_secret_post":
applyPostAuth(client_id, client_secret, params);
return;
case "none":
applyPublicAuth(client_id, params);
return;
default:
throw new Error(`Unsupported client authentication method: ${method}`);
}
}
function applyBasicAuth(clientId, clientSecret, headers) {
if (!clientSecret) throw new Error("client_secret_basic authentication requires a client_secret");
const credentials = btoa(`${clientId}:${clientSecret}`);
headers.set("Authorization", `Basic ${credentials}`);
}
function applyPostAuth(clientId, clientSecret, params) {
params.set("client_id", clientId);
if (clientSecret) params.set("client_secret", clientSecret);
}
function applyPublicAuth(clientId, params) {
params.set("client_id", clientId);
}
function isLoopbackHost(hostname3) {
return hostname3 === "localhost" || hostname3.endsWith(".localhost") || hostname3 === "127.0.0.1" || hostname3 === "[::1]" || hostname3 === "::1";
}
function assertSecureTokenEndpoint(tokenEndpoint) {
const url2 = new URL(String(tokenEndpoint));
if (url2.protocol !== "https:" && !isLoopbackHost(url2.hostname)) throw new InsecureTokenEndpointError(url2.href);
return url2;
}
function deriveApplicationType(redirectUris) {
for (const raw of redirectUris ?? []) {
let url2;
try {
url2 = new URL(raw);
} catch {
continue;
}
if (url2.protocol !== "http:" && url2.protocol !== "https:") return "native";
if (isLoopbackHost(url2.hostname)) return "native";
}
return "web";
}
function resolveClientMetadata(provider) {
const clientMetadata = provider.clientMetadata;
return {
...clientMetadata,
grant_types: clientMetadata.grant_types ?? (provider.redirectUrl === void 0 ? void 0 : ["authorization_code", "refresh_token"]),
application_type: clientMetadata.application_type ?? deriveApplicationType(clientMetadata.redirect_uris)
};
}
async function parseErrorResponse(input2) {
const statusCode = input2 instanceof Response ? input2.status : void 0;
const body = input2 instanceof Response ? await input2.text() : input2;
try {
const result = OAuthErrorResponseSchema.parse(JSON.parse(body));
return OAuthError.fromResponse(result);
} catch (error62) {
const errorMessage = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error62}. Raw body: ${body}`;
return new OAuthError(OAuthErrorCode.ServerError, errorMessage);
}
}
function warnCredentialInvalidation(provider, error62, invalidated) {
const action = provider.invalidateCredentials === void 0 ? `retrying authorization without discarding the stored ${invalidated} (provider implements no invalidateCredentials())` : `invalidating the stored ${invalidated} and retrying authorization`;
console.warn(`[mcp-sdk] OAuth ${JSON.stringify(error62.code)} \u2014 ${action}. Cause: ${JSON.stringify(error62.message)}`);
}
async function auth(provider, options) {
try {
return await authInternal(provider, options);
} catch (error62) {
if (error62 instanceof OAuthError) {
if (error62.code === OAuthErrorCode.InvalidClient || error62.code === OAuthErrorCode.UnauthorizedClient) {
warnCredentialInvalidation(provider, error62, "client credentials and tokens");
await provider.invalidateCredentials?.("client");
await provider.invalidateCredentials?.("tokens");
return await authInternal(provider, options);
} else if (error62.code === OAuthErrorCode.InvalidGrant || error62.code === OAuthErrorCode.InvalidDpopProof) {
warnCredentialInvalidation(provider, error62, "tokens");
await provider.invalidateCredentials?.("tokens");
return await authInternal(provider, options);
}
}
throw error62;
}
}
function determineScope(options) {
const { requestedScope, resourceMetadata, authServerMetadata, clientMetadata } = options;
let effectiveScope = requestedScope || resourceMetadata?.scopes_supported?.join(" ") || clientMetadata.scope;
if (effectiveScope && authServerMetadata?.scopes_supported?.includes("offline_access") && !effectiveScope.split(" ").includes("offline_access") && clientMetadata.grant_types?.includes("refresh_token")) effectiveScope = `${effectiveScope} offline_access`;
return effectiveScope;
}
async function authInternal(provider, { serverUrl, authorizationCode, iss, scope, resourceMetadataUrl, fetchFn, skipIssuerMetadataValidation, forceReauthorization }) {
const clientMetadata = resolveClientMetadata(provider);
const cachedState = await provider.discoveryState?.();
let resourceMetadata;
let authorizationServerUrl;
let metadata;
let freshDiscoveryState;
let effectiveResourceMetadataUrl = resourceMetadataUrl;
if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
if (cachedState?.authorizationServerUrl) {
authorizationServerUrl = cachedState.authorizationServerUrl;
resourceMetadata = cachedState.resourceMetadata;
metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, {
fetchFn,
skipIssuerValidation: skipIssuerMetadataValidation
});
if (!resourceMetadata) try {
resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
} catch (error62) {
if (error62 instanceof TypeError) throw error62;
}
if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) await provider.saveDiscoveryState?.({
authorizationServerUrl: String(authorizationServerUrl),
resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
resourceMetadata,
authorizationServerMetadata: metadata
});
} else {
const serverInfo = await discoverOAuthServerInfo(serverUrl, {
resourceMetadataUrl: effectiveResourceMetadataUrl,
fetchFn,
skipIssuerMetadataValidation
});
authorizationServerUrl = serverInfo.authorizationServerUrl;
metadata = serverInfo.authorizationServerMetadata;
resourceMetadata = serverInfo.resourceMetadata;
freshDiscoveryState = {
authorizationServerUrl: String(authorizationServerUrl),
resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
resourceMetadata,
authorizationServerMetadata: metadata
};
}
const issuer = metadata?.issuer ?? String(authorizationServerUrl);
const infoCtx = { issuer };
await provider.saveAuthorizationServerUrl?.(issuer);
if (authorizationCode !== void 0) {
const recordedIssuer = cachedState?.authorizationServerMetadata?.issuer ?? cachedState?.authorizationServerUrl;
if (recordedIssuer === void 0) {
if (provider.saveDiscoveryState !== void 0) throw new AuthorizationServerMismatchError("discoveryState was not available on the callback leg; ensure your provider persists discoveryState alongside codeVerifier", issuer);
console.warn("[mcp-sdk] OAuthClientProvider does not implement saveDiscoveryState()/discoveryState(); the SEP-2352 callback-leg authorization-server binding cannot be checked. Implement discoveryState (persist alongside codeVerifier) \u2014 see docs/migration/upgrade-to-v2.md \xA7SEP-2352.");
} else if (!issuersMatch(recordedIssuer, issuer)) throw new AuthorizationServerMismatchError(recordedIssuer, issuer);
}
if (freshDiscoveryState) await provider.saveDiscoveryState?.(freshDiscoveryState);
const selectedResource = await selectResourceURL(serverUrl, provider, resourceMetadata);
const resource = selectedResource && resourceMetadata && !provider.validateResourceURL ? resourceMetadata.resource : selectedResource;
if (resource) await provider.saveResourceUrl?.(resourceIndicatorToString(resource));
const resolvedScope = determineScope({
requestedScope: scope,
resourceMetadata,
authServerMetadata: metadata,
clientMetadata: provider.clientMetadata
});
const rawClientInfo = await Promise.resolve(provider.clientInformation(infoCtx));
let clientInformation = discardIfIssuerMismatch(rawClientInfo, issuer, { canPersistStamp: provider.saveClientInformation !== void 0 });
if (clientInformation === void 0 && rawClientInfo?.issuer && provider.saveClientInformation === void 0) throw new AuthorizationServerMismatchError(rawClientInfo.issuer, issuer);
if (clientInformation && clientInformation.issuer === void 0) {
clientInformation = {
...clientInformation,
issuer
};
await provider.saveClientInformation?.(clientInformation, infoCtx);
}
if (!clientInformation) {
if (authorizationCode !== void 0) throw new Error("Existing OAuth client information is required when exchanging an authorization code");
const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
const clientMetadataUrl = provider.clientMetadataUrl;
if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) throw new OAuthError(OAuthErrorCode.InvalidClientMetadata, `clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
if (supportsUrlBasedClientId && clientMetadataUrl) {
clientInformation = {
client_id: clientMetadataUrl,
issuer
};
await provider.saveClientInformation?.(clientInformation, infoCtx);
} else {
if (!provider.saveClientInformation) throw new Error("OAuth client information must be saveable for dynamic registration");
clientInformation = {
...await registerClient(authorizationServerUrl, {
metadata,
clientMetadata,
scope: resolvedScope,
fetchFn
}),
issuer
};
await provider.saveClientInformation(clientInformation, infoCtx);
}
}
const nonInteractiveFlow = !provider.redirectUrl;
if (authorizationCode !== void 0 || nonInteractiveFlow) {
if (authorizationCode !== void 0) validateAuthorizationResponseIssuer({
iss,
expectedIssuer: metadata?.issuer,
issParameterSupported: isIssParameterSupported(metadata)
});
const tokens$1 = await fetchToken(provider, authorizationServerUrl, {
metadata,
resource,
authorizationCode,
iss,
scope: resolvedScope,
fetchFn
});
await provider.saveTokens({
...tokens$1,
issuer
}, infoCtx);
return "AUTHORIZED";
}
let tokens = discardIfIssuerMismatch(await provider.tokens(infoCtx), issuer);
if (tokens && tokens.issuer === void 0) {
tokens = {
...tokens,
issuer
};
await provider.saveTokens(tokens, infoCtx);
}
if (tokens?.refresh_token && !forceReauthorization) {
const refreshScope = await provider.scopeForRefresh?.(tokens);
let newTokens;
try {
newTokens = await refreshAuthorization(authorizationServerUrl, {
metadata,
clientInformation,
refreshToken: tokens.refresh_token,
scope: refreshScope,
resource,
addClientAuthentication: provider.addClientAuthentication,
dpop: await provider.dpop?.(),
fetchFn
});
} catch (error62) {
if (error62 instanceof InsecureTokenEndpointError) throw error62;
if (!(error62 instanceof OAuthError) || error62.code === OAuthErrorCode.ServerError) console.warn(`[mcp-sdk] Could not refresh OAuth tokens; falling back to a new authorization request. Cause: ${JSON.stringify(error62 instanceof Error ? error62.message : String(error62))}`);
else throw error62;
}
if (newTokens) {
await provider.saveTokens({
...newTokens,
issuer
}, infoCtx);
return "AUTHORIZED";
}
}
const state = provider.state ? await provider.state() : void 0;
const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
metadata,
clientInformation,
state,
redirectUrl: provider.redirectUrl,
scope: resolvedScope,
resource
});
await provider.saveCodeVerifier(codeVerifier);
await provider.redirectToAuthorization(authorizationUrl);
return "REDIRECT";
}
function isHttpsUrl(value) {
if (!value) return false;
try {
const url2 = new URL(value);
return url2.protocol === "https:" && url2.pathname !== "/";
} catch {
return false;
}
}
async function selectResourceURL(serverUrl, provider, resourceMetadata) {
const defaultResource = resourceUrlFromServerUrl(serverUrl);
if (provider.validateResourceURL) return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
if (!resourceMetadata) return;
if (!checkResourceAllowed({
requestedResource: defaultResource,
configuredResource: resourceMetadata.resource
})) throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
return new URL(resourceMetadata.resource);
}
var RECOGNIZED_CHALLENGE_SCHEMES = /* @__PURE__ */ new Set(["bearer", "dpop"]);
function extractWWWAuthenticateParams(res) {
const authenticateHeader = res.headers.get("WWW-Authenticate");
if (!authenticateHeader) return {};
const [type, scheme] = authenticateHeader.split(" ");
if (!type || !RECOGNIZED_CHALLENGE_SCHEMES.has(type.toLowerCase()) || !scheme) return {};
const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0;
let resourceMetadataUrl;
if (resourceMetadataMatch) try {
resourceMetadataUrl = new URL(resourceMetadataMatch);
} catch {
}
const scope = extractFieldFromWwwAuth(res, "scope") || void 0;
const error62 = extractFieldFromWwwAuth(res, "error") || void 0;
const errorDescription = extractFieldFromWwwAuth(res, "error_description") || void 0;
return {
resourceMetadataUrl,
scope,
error: error62,
errorDescription
};
}
function extractFieldFromWwwAuth(response, fieldName) {
const wwwAuthHeader = response.headers.get("WWW-Authenticate");
if (!wwwAuthHeader) return null;
const pattern = new RegExp(String.raw`${fieldName}=(?:"([^"]+)"|([^\s,]+))`);
const match = wwwAuthHeader.match(pattern);
if (match) {
const result = match[1] || match[2];
if (result) return result;
}
return null;
}
async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
protocolVersion: opts?.protocolVersion,
metadataUrl: opts?.resourceMetadataUrl
});
if (!response || response.status === 404) {
await response?.text?.().catch(() => {
});
throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
}
if (!response.ok) {
await response.text?.().catch(() => {
});
throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
}
return OAuthProtectedResourceMetadataSchema.parse(await response.json());
}
async function fetchWithCorsRetry(url2, headers, fetchFn = fetch) {
const withinOrigin = fetchWithinOrigin(fetchFn);
try {
return await withinOrigin(url2, { headers });
} catch (error62) {
if (!(error62 instanceof TypeError) || !CORS_IS_POSSIBLE) throw error62;
if (headers) try {
return await withinOrigin(url2, {});
} catch (retryError) {
if (!(retryError instanceof TypeError)) throw retryError;
return;
}
return;
}
}
function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
}
async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) {
return await fetchWithCorsRetry(url2, { "MCP-Protocol-Version": protocolVersion }, fetchFn);
}
function shouldAttemptFallback(response, pathname) {
if (!response) return true;
if (pathname === "/") return false;
return !response.ok && response.status < 500 || response.status === 502;
}
async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
const issuer = new URL(serverUrl);
const protocolVersion = opts?.protocolVersion ?? LATEST_PROTOCOL_VERSION;
let url2;
if (opts?.metadataUrl) url2 = new URL(opts.metadataUrl);
else {
const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
url2 = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
url2.search = issuer.search;
}
let response = await tryMetadataDiscovery(url2, protocolVersion, fetchFn);
if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) response = await tryMetadataDiscovery(new URL(`/.well-known/${wellKnownType}`, issuer), protocolVersion, fetchFn);
return response;
}
function buildDiscoveryUrls(authorizationServerUrl) {
const url2 = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
const hasPath = url2.pathname !== "/";
const urlsToTry = [];
if (!hasPath) {
urlsToTry.push({
url: new URL("/.well-known/oauth-authorization-server", url2.origin),
type: "oauth"
}, {
url: new URL(`/.well-known/openid-configuration`, url2.origin),
type: "oidc"
});
return urlsToTry;
}
let pathname = url2.pathname;
if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
urlsToTry.push({
url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url2.origin),
type: "oauth"
}, {
url: new URL(`/.well-known/openid-configuration${pathname}`, url2.origin),
type: "oidc"
}, {
url: new URL(`${pathname}/.well-known/openid-configuration`, url2.origin),
type: "oidc"
});
return urlsToTry;
}
async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION, skipIssuerValidation = false } = {}) {
const headers = {
"MCP-Protocol-Version": protocolVersion,
Accept: "application/json"
};
const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
for (const { url: endpointUrl, type } of urlsToTry) {
const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
if (!response)
continue;
if (!response.ok) {
await response.text?.().catch(() => {
});
if (response.status < 500 || response.status === 502) continue;
throw new Error(`HTTP ${response.status} trying to load ${type === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
}
const parsed = type === "oauth" ? OAuthMetadataSchema.parse(await response.json()) : OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
if (!skipIssuerValidation) {
const expectedIssuer = typeof authorizationServerUrl === "string" ? authorizationServerUrl : authorizationServerUrl.href;
if (!(parsed.issuer === expectedIssuer || expectedIssuer.endsWith("/") && parsed.issuer === expectedIssuer.slice(0, -1))) throw new IssuerMismatchError("metadata", expectedIssuer, parsed.issuer);
}
return parsed;
}
}
async function discoverOAuthServerInfo(serverUrl, opts) {
let resourceMetadata;
let authorizationServerUrl;
try {
resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) authorizationServerUrl = resourceMetadata.authorization_servers[0];
} catch (error62) {
if (error62 instanceof TypeError) throw error62;
}
if (!authorizationServerUrl) authorizationServerUrl = String(new URL("/", serverUrl));
const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
fetchFn: opts?.fetchFn,
skipIssuerValidation: opts?.skipIssuerMetadataValidation
});
return {
authorizationServerUrl,
authorizationServerMetadata,
resourceMetadata
};
}
function resourceIndicatorToString(resource) {
return typeof resource === "string" ? resource : resource.href;
}
async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
let authorizationUrl;
if (metadata) {
authorizationUrl = new URL(metadata.authorization_endpoint);
if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
} else authorizationUrl = new URL("/authorize", authorizationServerUrl);
const challenge = await pkceChallenge();
const codeVerifier = challenge.code_verifier;
const codeChallenge = challenge.code_challenge;
authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
authorizationUrl.searchParams.set("code_challenge", codeChallenge);
authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
if (state) authorizationUrl.searchParams.set("state", state);
if (scope) authorizationUrl.searchParams.set("scope", scope);
if (scope?.split(" ").includes("offline_access")) authorizationUrl.searchParams.append("prompt", "consent");
if (resource) authorizationUrl.searchParams.set("resource", resourceIndicatorToString(resource));
return {
authorizationUrl,
codeVerifier
};
}
function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
return new URLSearchParams({
grant_type: "authorization_code",
code: authorizationCode,
code_verifier: codeVerifier,
redirect_uri: String(redirectUri)
});
}
async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams: tokenRequestParams2, clientInformation, addClientAuthentication, resource, dpop, fetchFn }) {
const tokenUrl = assertSecureTokenEndpoint(metadata?.token_endpoint ?? new URL("/token", authorizationServerUrl));
const headers = new Headers({
"Content-Type": "application/x-www-form-urlencoded",
Accept: "application/json"
});
if (resource) tokenRequestParams2.set("resource", resourceIndicatorToString(resource));
if (!addClientAuthentication && clientInformation) applyClientAuthentication(selectClientAuthMethod(clientInformation, metadata?.token_endpoint_auth_methods_supported ?? []), clientInformation, headers, tokenRequestParams2);
const requestOnce = async () => {
const requestHeaders = new Headers(headers);
if (addClientAuthentication) await addClientAuthentication(requestHeaders, tokenRequestParams2, tokenUrl, metadata);
if (dpop) requestHeaders.set("DPoP", await dpop.buildProof({
htm: "POST",
htu: tokenUrl
}));
return fetchWithinOrigin(fetchFn ?? fetch)(tokenUrl, {
method: "POST",
headers: requestHeaders,
body: tokenRequestParams2
});
};
let response = await requestOnce();
if (dpop && response.status === 400) {
if ((await response.clone().json().catch(() => {
}))?.error === OAuthErrorCode.UseDpopNonce) {
dpop.observeNonce(response, tokenUrl);
response = await requestOnce();
}
}
dpop?.observeNonce(response, tokenUrl);
if (!response.ok) throw await parseErrorResponse(response);
const json2 = await response.json();
try {
return OAuthTokensSchema.parse(withoutIssuer(json2));
} catch (parseError) {
if (typeof json2 === "object" && json2 !== null && "error" in json2) throw await parseErrorResponse(JSON.stringify(json2));
throw parseError;
}
}
async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, scope, resource, addClientAuthentication, dpop, fetchFn }) {
const tokenRequestParams2 = new URLSearchParams({
grant_type: "refresh_token",
refresh_token: refreshToken
});
if (scope) tokenRequestParams2.set("scope", scope);
const tokens = await executeTokenRequest(authorizationServerUrl, {
metadata,
tokenRequestParams: tokenRequestParams2,
clientInformation,
addClientAuthentication,
resource,
dpop,
fetchFn
});
return {
refresh_token: refreshToken,
...tokens,
...scope && !tokens.scope && { scope }
};
}
async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, iss, scope, fetchFn } = {}) {
if (authorizationCode !== void 0) validateAuthorizationResponseIssuer({
iss,
expectedIssuer: metadata?.issuer,
issParameterSupported: isIssParameterSupported(metadata)
});
const issuer = metadata?.issuer ?? String(authorizationServerUrl);
const readClientInformation = async () => {
const rawClientInfo = await provider.clientInformation({ issuer });
const checked = discardIfIssuerMismatch(rawClientInfo, issuer, { canPersistStamp: false });
if (rawClientInfo && checked === void 0) throw new AuthorizationServerMismatchError(String(rawClientInfo.issuer), issuer);
return checked;
};
let clientInformation = await readClientInformation();
const effectiveScope = scope ?? provider.clientMetadata.scope;
let tokenRequestParams2;
if (provider.prepareTokenRequest) tokenRequestParams2 = await provider.prepareTokenRequest(effectiveScope);
if (!tokenRequestParams2) {
if (!authorizationCode) throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
if (!provider.redirectUrl) throw new Error("redirectUrl is required for authorization_code flow");
tokenRequestParams2 = prepareAuthorizationCodeRequest(authorizationCode, await provider.codeVerifier(), provider.redirectUrl);
}
clientInformation ??= await readClientInformation();
return executeTokenRequest(authorizationServerUrl, {
metadata,
tokenRequestParams: tokenRequestParams2,
clientInformation,
addClientAuthentication: provider.addClientAuthentication,
resource,
dpop: await provider.dpop?.(),
fetchFn
});
}
async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) {
let registrationUrl;
if (metadata) {
if (!metadata.registration_endpoint) throw new Error("Incompatible auth server: does not support dynamic client registration");
registrationUrl = new URL(metadata.registration_endpoint);
} else registrationUrl = new URL("/register", authorizationServerUrl);
const submittedMetadata = {
...clientMetadata,
...scope === void 0 ? {} : { scope }
};
const response = await fetchWithinOrigin(fetchFn ?? fetch)(registrationUrl, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(submittedMetadata)
});
if (!response.ok) throw new RegistrationRejectedError({
status: response.status,
body: await response.text(),
submittedMetadata
});
return OAuthClientInformationFullSchema.parse(withoutIssuer(await response.json()));
}
var CAP_EXEMPT_METHODS = /* @__PURE__ */ new Set([
"tools/list",
"prompts/list",
"resources/list",
"resources/templates/list",
"server/discover"
]);
var InMemoryResponseCacheStore = class {
_entries = /* @__PURE__ */ new Map();
_maxEntries;
_stamp = 0;
/** Count of held entries that are subject to the cap (i.e. not in {@linkcode CAP_EXEMPT_METHODS}). */
_cappedSize = 0;
constructor(options) {
this._maxEntries = options?.maxEntries ?? 512;
}
/** Number of held entries (for diagnostics / bounding tests). */
get size() {
return this._entries.size;
}
get(key) {
return this._entries.get(keyOf(key));
}
set(key, entry) {
const k = keyOf(key);
const exempt = CAP_EXEMPT_METHODS.has(key.method);
const isNew = !this._entries.has(k);
if (!exempt && isNew && this._maxEntries > 0 && this._cappedSize >= this._maxEntries) {
for (const oldKey of this._entries.keys()) if (!CAP_EXEMPT_METHODS.has(oldKey.slice(0, oldKey.indexOf("\0")))) {
this._entries.delete(oldKey);
this._cappedSize--;
break;
}
}
const stamp = ++this._stamp;
this._entries.set(k, {
...entry,
stamp
});
if (isNew && !exempt) this._cappedSize++;
return stamp;
}
delete(key) {
if (this._entries.delete(keyOf(key)) && !CAP_EXEMPT_METHODS.has(key.method)) this._cappedSize--;
}
evict(method) {
const prefix = `${method}\0`;
const exempt = CAP_EXEMPT_METHODS.has(method);
for (const k of this._entries.keys()) if (k.startsWith(prefix)) {
this._entries.delete(k);
if (!exempt) this._cappedSize--;
}
}
clear() {
this._entries.clear();
this._cappedSize = 0;
}
};
function keyOf(key) {
return `${key.method}\0${JSON.stringify([key.partition ?? "", key.params ?? ""])}`;
}
function genKey(method, params) {
return params === void 0 ? method : `${method}\0${params}`;
}
var MAX_CACHE_TTL_MS = 864e5;
var ClientResponseCache = class {
/**
* Per-logical-key eviction-generation counter. {@linkcode evict} (whole
* method) and {@linkcode evictKey} (single `{method, params}`) bump it
* before touching the store; {@linkcode captureGeneration} reads it before
* the request; {@linkcode write} skips when it moved — so a `list_changed`
* arriving mid-walk, or a `resources/updated` arriving while a
* `readResource()` for the same URI is in flight, is not overwritten by
* the in-flight request's stale write. The map key is `method` for the
* list singletons and `` `${method}\0${params}` `` for per-URI keys.
*
* Growth is bounded by keys the CLIENT has issued a `captureGeneration`
* for: {@linkcode captureGeneration} records the key (so an interleaved
* {@linkcode evictKey} sees there is an in-flight write to suppress);
* {@linkcode evictKey} only bumps a key that is already recorded — a
* server streaming `notifications/resources/updated` for URIs the client
* has never read therefore cannot grow this map.
*/
_evictionGeneration = /* @__PURE__ */ new Map();
/**
* `name → Tool` index derived from the cached `tools/list` entry, memoized
* against the entry's `stamp` so it re-derives only when the backing entry
* changes (mcp.d's `cachedTool` pattern).
*/
_toolIndex;
/**
* `name → compiled output-schema validator` derived from the cached
* `tools/list` entry; same stamp-keyed memoization as `_toolIndex`. Typed
* `unknown` so this class stays free of any validator-provider dependency
* — the compile callback supplied to {@linkcode outputValidator} owns the
* concrete type.
*/
_toolOutputValidatorIndex;
/**
* The connected server's identity (`serverInfo.name@version`, the
* transport's `sessionId`, or a client-generated per-connection
* surrogate). Set by the `Client` immediately after a successful connect;
* `''` is the pre-connect sentinel. Every storage partition is derived
* from this (see `_partitionFor`), so two clients sharing one store but
* connected to different servers never collide on `tools/list` and a
* server cannot read another server's `'public'` entries.
*/
_serverIdentity = "";
constructor(_store, _isUserSupplied, _reportError = () => {
}, _cachePartition = "", _now = Date.now) {
this._store = _store;
this._isUserSupplied = _isUserSupplied;
this._reportError = _reportError;
this._cachePartition = _cachePartition;
this._now = _now;
}
/** The clock used for every freshness computation and check. */
now() {
return this._now();
}
/**
* Record the connected server's identity. Called by `Client` immediately
* after a successful connect: `serverInfo.name@version` when the server
* identified itself, else the transport's `sessionId`, else a
* client-generated per-connection surrogate (`serverInfo` is a spec
* SHOULD on 2026-07-28, so anonymous servers exist). Surrogate-keyed
* partitions are NOT stable across reconnects — no identity means no
* cross-connection cache reuse, and a shared long-lived store should
* bound its own size accordingly. Every partition derived after this
* call is scoped to this identity; entries written under the pre-connect
* `''` sentinel are no longer reachable.
*/
setServerIdentity(identity) {
this._serverIdentity = identity;
}
/**
* Derive the storage partition for `scope`. The encoding is
* `JSON.stringify([serverIdentity, principal])` — JSON escaping makes it
* collision-free by construction: a malicious server cannot craft a
* `serverInfo.name`/`version` whose concatenated form bleeds into another
* server's namespace or another principal's slot, regardless of `@` / `|`
* / `"` / NUL in the server-controlled strings. `'public'` →
* `[serverIdentity, '']` (shared within this server); `'private'` →
* `[serverIdentity, cachePartition]`. When `cachePartition` is `''` the
* two coincide.
*/
_partitionFor(scope) {
return JSON.stringify([this._serverIdentity, scope === "public" ? "" : this._cachePartition]);
}
/**
* Two-probe lookup: this client's own (private) partition first, then the
* connected server's shared (public) partition. The shared probe is gated
* on `entry.scope === 'public'` — a co-tenant client that omits
* `cachePartition` writes its `'private'`-scoped entries at the public
* partition, and serving those to a correctly-partitioned client would
* leak private bodies (mcp.d's `cachedEntry` two-probe order; the scope
* gate is defence-in-depth on top of the partition split). When
* `cachePartition` is `''` the two partitions are identical and only one
* probe is issued.
*/
async _probe(method, params) {
const key = {
method,
params: params ?? ""
};
const ownPartition = this._partitionFor("private");
const own2 = await this._store.get({
...key,
partition: ownPartition
});
if (own2 !== void 0) return own2;
const sharedPartition = this._partitionFor("public");
if (sharedPartition === ownPartition) return void 0;
const shared = await this._store.get({
...key,
partition: sharedPartition
});
return shared?.scope === "public" ? shared : void 0;
}
/**
* Bump the per-method generation (so an in-flight {@linkcode write} for the
* same method becomes a no-op) and drop the connected server's two list
* singletons (own + shared partition; `params: ''`). The generation bump
* is unconditional and FIRST — the {@linkcode write} race guard relies on
* the bump, not on the store's deletes completing.
*
* Eviction is scoped to this client's `[serverIdentity, principal]`
* partitions (mirroring {@linkcode evictKey}) — the method-wide
* `store.evict()` is NOT called, so on a shared store one server's
* `list_changed` cannot wipe a co-tenant's entry. A custom store's
* `delete()` may throw or reject; each partition is guarded
* independently so a failure on one does not skip the other, the failure
* is reported via the constructor's sink, and the call resolves so
* dispatch proceeds.
*/
async evict(method) {
this._evictionGeneration.set(method, (this._evictionGeneration.get(method) ?? 0) + 1);
await this._deleteBoth(method, "");
}
/**
* Guarded two-partition delete of `{method, params}`: each partition's
* `delete` is independently wrapped so a custom store's failure on one is
* reported and does not skip the other, and the call always resolves.
*/
async _deleteBoth(method, params) {
const ownPartition = this._partitionFor("private");
const sharedPartition = this._partitionFor("public");
try {
await this._store.delete({
method,
params,
partition: ownPartition
});
} catch (error62) {
this._reportError(error62);
}
if (sharedPartition !== ownPartition) try {
await this._store.delete({
method,
params,
partition: sharedPartition
});
} catch (error62) {
this._reportError(error62);
}
}
/**
* Drop the single logical entry `{method, params}` from BOTH the private
* and public partitions for this client's connected server (mcp.d's
* `invalidateLogical`). Used for `notifications/resources/updated`'s
* per-URI eviction. The per-key generation is bumped FIRST (so an
* in-flight {@linkcode write} for the same `{method, params}` becomes a
* no-op and cannot re-cache the now-stale body) but only when the key was
* already recorded by {@linkcode captureGeneration} — bounding the map to
* keys the client has actually read. A custom store's `delete()` may
* throw or reject; each partition's delete is guarded independently so a
* failure on one does not skip the other, and the call resolves so
* dispatch proceeds.
*/
async evictKey(method, params) {
const gk = genKey(method, params);
const current = this._evictionGeneration.get(gk);
if (current !== void 0) this._evictionGeneration.set(gk, current + 1);
await this._deleteBoth(method, params);
}
/**
* Snapshot the eviction generation for `{method, params}` before issuing
* the request (a list walk's page 1, or a `resources/read` for `params`).
* Records the key so an interleaved {@linkcode evictKey} for the same
* `{method, params}` knows there is an in-flight write to suppress and
* bumps; without the record, `evictKey`'s recorded-only bump would skip
* and the stale body would be cached.
*/
captureGeneration(method, params) {
const gk = genKey(method, params);
const current = this._evictionGeneration.get(gk) ?? 0;
this._evictionGeneration.set(gk, current);
return current;
}
/**
* Write `value` under `{method}` unless the per-method generation moved
* since `capturedGen` was taken — a `list_changed` that landed mid-walk has
* already invalidated the result the caller is about to write, and
* overwriting the eviction with the stale aggregate would lose the
* invalidation.
*
* The value is stored as its JSON-serialized document; serialization
* doubles as the mutation barrier, so a caller mutating the returned
* aggregate cannot reach the cache or its derived indices. A value that
* is not JSON-serializable (reachable only via in-process transports)
* fails the write loudly into the `reportError` sink. A custom store
* whose `set()` throws or rejects is routed to the same sink and the
* write resolves — cache bookkeeping never costs the caller a result it
* already fetched.
*
* `freshness` carries the client-computed `expiresAt` (absolute ms epoch,
* `now + ttlMs`) and the server-reported `cacheScope`. The storage
* `partition` is derived from the scope via `_partitionFor`:
* `'public'` → `[serverIdentity, '']` (shared within this server);
* `'private'` → `[serverIdentity, cachePartition]` (so a shared store
* never serves a private entry to another identity). Absent `freshness`
* preserves the substrate write (no `expiresAt`, private partition) — the
* `tools/list` retain-for-schema posture: never served by
* {@linkcode read}'s freshness gate, always readable by
* {@linkcode toolDefinition}.
*
* After storing under the derived partition, the same `{method, params}`
* is deleted from the OPPOSITE partition (mirroring {@linkcode evictKey}'s
* two-partition posture). A server that flips a result's `cacheScope` for
* the same key would otherwise leave the previous entry in the other slot
* — and since `_probe` checks own-partition first, a stale private entry
* would shadow the fresh public one (or a stale public entry would keep
* serving co-tenants). Both store calls are independently guarded so a
* custom store's failure on one does not skip the other.
*/
async write(method, value, capturedGen, freshness) {
if ((this._evictionGeneration.get(genKey(method, freshness?.params)) ?? 0) !== capturedGen) return;
const params = freshness?.params ?? "";
const ownPartition = this._partitionFor("private");
const sharedPartition = this._partitionFor("public");
const partition = (freshness?.scope ?? "private") === "public" ? sharedPartition : ownPartition;
try {
await this._store.set({
method,
params,
partition
}, {
value: encodeCacheValue(value),
expiresAt: freshness?.expiresAt,
scope: freshness?.scope
});
} catch (error62) {
this._reportError(error62);
}
if (sharedPartition !== ownPartition) try {
await this._store.delete({
method,
params,
partition: partition === ownPartition ? sharedPartition : ownPartition
});
} catch (error62) {
this._reportError(error62);
}
}
/**
* Serve the fresh cached result for `{method, params}`, or `undefined`.
* Lookup is the two-probe order (own-partition then this server's shared
* partition, gated on `scope === 'public'`); freshness is
* `entry.expiresAt > now()` (a missing `expiresAt` is never fresh),
* checked BEFORE decoding so stale entries cost no parse. Every hit is
* freshly parsed, so the caller owns the value outright. An entry whose
* document does not parse or is not an object (corrupted external
* store) is reported,
* deleted, and treated as a miss — deleted because a fresh-but-corrupt
* entry would otherwise re-parse and re-report on every read until its
* `expiresAt` passes.
*/
async read(method, params) {
const entry = await this._probe(method, params);
if (entry?.expiresAt === void 0 || !(entry.expiresAt > this.now())) return void 0;
try {
const parsed = JSON.parse(entry.value);
if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError("cached document is not an object");
return { value: parsed };
} catch (error62) {
this._reportError(error62);
await this._deleteBoth(method, params ?? "");
return;
}
}
/**
* Connection reset. The per-instance default store IS cleared
* (connection-scoped); a user-supplied store is NOT — that would defeat
* the only reason to supply one. The generation map and every derived
* index are dropped regardless: they are connection-scoped even when the
* backing store survives, so the next read re-derives from whatever the
* store still holds. The server identity returns to the pre-connect
* sentinel. The default impl is synchronous, so the `MaybePromise<void>`
* return is a plain void here and the caller need not await.
*/
resetForReconnect() {
if (!this._isUserSupplied) this._store.clear();
this._evictionGeneration.clear();
this._toolIndex = void 0;
this._toolOutputValidatorIndex = void 0;
this._serverIdentity = "";
}
/**
* The descriptor for tool `name` taken from the cached `tools/list` entry.
* The `name → Tool` index is memoized against the entry's `stamp` and
* re-derived only when the backing entry changes (mcp.d's `cachedTool`).
* Returns `undefined` only when no `tools/list` response is held at all,
* or the held list does not contain `name`.
*
* Consumed by `callTool()`'s SEP-2243 `_resolveXMcpHeaderScan` (mirroring)
* and, via {@linkcode outputValidator}, its output-schema validation.
*/
async toolDefinition(name) {
const entry = await this._probe("tools/list");
if (entry === void 0) {
this._toolIndex = void 0;
return;
}
if (this._toolIndex?.stamp !== entry.stamp) {
const list = this._decodeListTools(entry);
const byName = /* @__PURE__ */ new Map();
if (list !== void 0) for (const tool of list.tools) byName.set(tool.name, tool);
this._toolIndex = {
stamp: entry.stamp,
byName
};
}
return this._toolIndex.byName.get(name);
}
/**
* The compiled output-schema validator for tool `name`, derived from the
* cached `tools/list` entry — same source and same stamp-keyed
* memoization as {@linkcode toolDefinition}. The `name → validator` index
* re-derives only when the backing entry's stamp changes (a refetched
* `tools/list` recompiles; a `list_changed` eviction drops it). Returns
* `undefined` when no `tools/list` is held, the tool is absent, or it has
* no `outputSchema`.
*
* `compile` is the caller-supplied validator-compile callback (the
* `Client` passes its `_jsonSchemaValidator` wrapper) so this
* class carries no validator-provider dependency. One tool's uncompilable
* `outputSchema` (e.g. an invalid `pattern` regex or unresolvable `$ref`)
* must not poison every other tool's `callTool` — the callback isolates
* that compile error per tool by returning a per-tool error variant which
* the index stores alongside the good ones, and `callTool` surfaces it as
* a typed `InvalidParams` only for that name. Because the error is held on
* this stamp-keyed substrate (not a parallel map), it inherits the
* substrate's invalidation lifecycle: a `list_changed` eviction drops it,
* a refetched `tools/list` re-derives it, and `resetForReconnect` clears
* the lot.
*/
async outputValidator(name, compile2) {
const entry = await this._probe("tools/list");
if (entry === void 0) {
this._toolOutputValidatorIndex = void 0;
return;
}
if (this._toolOutputValidatorIndex?.stamp !== entry.stamp) {
const list = this._decodeListTools(entry) ?? { tools: [] };
const byName = /* @__PURE__ */ new Map();
for (const tool of list.tools) {
const compiled = compile2(tool);
if (compiled !== void 0) byName.set(tool.name, compiled);
}
this._toolOutputValidatorIndex = {
stamp: entry.stamp,
byName
};
}
return this._toolOutputValidatorIndex.byName.get(name);
}
/** Parse a held `tools/list` document for the index builders; a document
* that does not parse OR whose `tools` is not an array of objects
* (both mean a corrupted external store) is reported and treated as if
* nothing were held. Callers memoize the outcome against the entry's
* stamp, so a corrupt document costs one parse + report per stamp, not
* per lookup. */
_decodeListTools(entry) {
try {
const parsed = JSON.parse(entry.value);
if (!Array.isArray(parsed?.tools) || !parsed.tools.every((t) => t !== null && typeof t === "object")) throw new TypeError("cached tools/list document has a malformed tools array");
return parsed;
} catch (error62) {
this._reportError(error62);
return;
}
}
};
function encodeCacheValue(value) {
let json2;
try {
json2 = JSON.stringify(value);
} catch (error62) {
throw new TypeError(`cache value is not JSON-serializable: ${error62 instanceof Error ? error62.message : String(error62)}`);
}
if (typeof json2 !== "string") throw new TypeError("cache value is not JSON-serializable: it has no JSON representation");
return json2;
}
var AUTH_SEAM = Symbol.for("mcp.authSeamEscape");
function markAuthSeamEscape(error62) {
if (typeof error62 === "object" && error62 !== null || typeof error62 === "function") try {
Object.defineProperty(error62, AUTH_SEAM, {
value: true,
configurable: true
});
} catch {
}
return error62;
}
function isAuthSeamEscape(error62) {
return (typeof error62 === "object" && error62 !== null || typeof error62 === "function") && error62[AUTH_SEAM] === true;
}
var UNSUPPORTED_PROTOCOL_VERSION = -32022;
var NOT_PROBE_RECOGNIZED = /* @__PURE__ */ new Set([
-32001,
-32020,
-32021
]);
function classifyProbeOutcome(outcome, context) {
switch (outcome.kind) {
case "result":
return classifyResult(outcome.result, context);
case "rpc-error":
return classifyRpcError(outcome, context);
case "http-error":
return classifyHttpError(outcome, context);
case "network-error":
return classifyNetworkError(outcome.error, context);
case "unusable-reply":
return {
kind: "error",
error: new SdkError(SdkErrorCode.EraNegotiationFailed, `Version negotiation probe failed: the server answered with an unusable reply (${describeError(outcome.error)})`, { cause: outcome.error }, { cause: outcome.error })
};
case "auth-required":
return {
kind: "error",
error: outcome.error
};
case "closed":
if (context.transportKind === "stdio") return { kind: "legacy" };
return classifyNetworkError(/* @__PURE__ */ new Error("Connection closed during the version negotiation probe"), context);
case "timeout":
if (context.transportKind === "stdio") return { kind: "legacy" };
return {
kind: "error",
error: new SdkError(SdkErrorCode.RequestTimeout, `Version negotiation probe timed out after ${outcome.timeoutMs}ms`, { timeout: outcome.timeoutMs })
};
}
}
function classifyResult(result, context) {
const parsed = codecForVersion(MODERN_WIRE_REVISION).validateResult("server/discover", result);
if (!parsed.ok) return { kind: "legacy" };
const supportedVersions = parsed.value.supportedVersions;
const overlap = context.clientModernVersions.find((version3) => supportedVersions.includes(version3));
if (overlap !== void 0) return {
kind: "modern",
version: overlap,
discover: parsed.value
};
if (context.fallbackAvailable) return { kind: "legacy" };
return {
kind: "error",
error: new UnsupportedProtocolVersionError({
supported: [...supportedVersions],
requested: context.requestedVersion
})
};
}
function classifyRpcError(outcome, context) {
const { code, message, data } = outcome;
if (code === UNSUPPORTED_PROTOCOL_VERSION) {
const supported = parseSupportedList(data);
if (supported === void 0) return { kind: "legacy" };
const error62 = new UnsupportedProtocolVersionError({
supported,
requested: parseRequested(data) ?? context.requestedVersion
}, message);
const supportedModern = modernProtocolVersions(supported);
const mutual = context.clientModernVersions.find((version3) => supportedModern.includes(version3));
if (mutual !== void 0) return {
kind: "corrective",
version: mutual,
error: error62
};
if (supportedModern.length > 0) return {
kind: "error",
error: error62
};
return context.fallbackAvailable ? { kind: "legacy" } : {
kind: "error",
error: error62
};
}
if (NOT_PROBE_RECOGNIZED.has(code)) return { kind: "legacy" };
return { kind: "legacy" };
}
function classifyHttpError(outcome, context) {
if (outcome.status === 401 || outcome.status === 403) {
const isDenial = outcome.status === 403;
return {
kind: "error",
error: new SdkHttpError(isDenial ? SdkErrorCode.ClientHttpForbidden : SdkErrorCode.ClientHttpAuthentication, `Version negotiation failed: ${isDenial ? "the server denied access (HTTP 403)" : "the server requires authorization (HTTP 401)"}`, {
status: outcome.status,
statusText: outcome.statusText,
text: outcome.body
})
};
}
if (outcome.status >= 500) return {
kind: "error",
error: new SdkHttpError(SdkErrorCode.EraNegotiationFailed, `Version negotiation failed: the server answered the probe with HTTP ${outcome.status}`, {
status: outcome.status,
statusText: outcome.statusText,
text: outcome.body
})
};
const rpcError = parseJsonRpcErrorBody(outcome.body);
if (rpcError !== void 0) return classifyRpcError(rpcError, context);
return { kind: "legacy" };
}
function classifyNetworkError(error62, context) {
if (context.environment === "browser" && isOpaqueFetchTypeError(error62)) return { kind: "legacy" };
return {
kind: "error",
error: new SdkError(SdkErrorCode.EraNegotiationFailed, `Version negotiation probe failed: ${describeError(error62)}`, { cause: error62 }, { cause: error62 })
};
}
function isOpaqueFetchTypeError(error62) {
return error62 instanceof TypeError || error62 instanceof Error && error62.name === "TypeError";
}
function describeError(error62) {
return error62 instanceof Error ? error62.message : String(error62);
}
function parseSupportedList(data) {
if (typeof data !== "object" || data === null) return void 0;
const supported = data.supported;
if (!Array.isArray(supported) || supported.length === 0 || !supported.every((v) => typeof v === "string")) return;
return supported;
}
function parseRequested(data) {
if (typeof data !== "object" || data === null) return void 0;
const requested = data.requested;
return typeof requested === "string" ? requested : void 0;
}
function parseJsonRpcErrorBody(body) {
if (body === void 0 || body === "") return void 0;
let parsed;
try {
parsed = JSON.parse(body);
} catch {
return;
}
if (typeof parsed !== "object" || parsed === null) return void 0;
const error62 = parsed.error;
if (typeof error62 !== "object" || error62 === null) return void 0;
const { code, message, data } = error62;
if (typeof code !== "number") return void 0;
return {
code,
message: typeof message === "string" ? message : "",
data
};
}
var DEFAULT_VERSION_NEGOTIATION_MODE = "legacy";
function resolveVersionNegotiation(options, supportedProtocolVersionsOption) {
const mode = options?.mode ?? DEFAULT_VERSION_NEGOTIATION_MODE;
if (mode === "legacy") return { kind: "legacy" };
const probe = options?.probe ?? {};
if (typeof mode === "object") {
if (!isModernProtocolVersion(mode.pin)) throw new TypeError(`versionNegotiation: { pin: '${mode.pin}' } is not a modern protocol revision \u2014 pinning is for 2026-07-28 and later; omit versionNegotiation (or use mode: 'legacy') for 2025-era servers.`);
return {
kind: "pin",
version: mode.pin,
probe
};
}
const explicitModern = supportedProtocolVersionsOption ? modernProtocolVersions(supportedProtocolVersionsOption) : [];
return {
kind: "auto",
modernVersions: explicitModern.length > 0 ? explicitModern : [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
fallbackAvailable: supportedProtocolVersionsOption ? legacyProtocolVersions(supportedProtocolVersionsOption).length > 0 : true,
probe
};
}
function detectProbeEnvironment() {
const g = globalThis;
return g.window !== void 0 && g.document !== void 0 ? "browser" : "node";
}
function detectProbeTransportKind(transport) {
return "stderr" in transport && "pid" in transport ? "stdio" : "http";
}
var ProbeWindow = class ProbeWindow2 {
_pending;
_probeCounter = 0;
_savedOnMessage;
_savedOnError;
_savedOnClose;
_closeDelivered = false;
constructor(_transport) {
this._transport = _transport;
this._savedOnMessage = _transport.onmessage;
this._savedOnError = _transport.onerror;
this._savedOnClose = _transport.onclose;
}
static async open(transport) {
const window = new ProbeWindow2(transport);
transport.onmessage = (message) => {
const pending = window._pending;
if (pending !== void 0 && (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) && message.id === pending.id) {
window._pending = void 0;
if (isJSONRPCResultResponse(message)) pending.resolve({
kind: "response",
result: message.result
});
else pending.resolve({
kind: "response",
error: message.error
});
return;
}
};
transport.onerror = (error62) => {
window._savedOnError?.(error62);
};
transport.onclose = () => {
const pending = window._pending;
if (pending !== void 0) {
window._pending = void 0;
pending.resolve({ kind: "closed" });
}
window._closeDelivered = true;
window._savedOnClose?.();
};
try {
await transport.start();
} catch (error62) {
window.detach();
throw error62;
}
return window;
}
/**
* Send one probe request and await its reply. Probe ids are strings, so they
* never collide with Protocol's numeric ids (e.g. on a shared stdio pipe).
*/
async exchange(buildRequest, timeoutMs) {
const id = `server-discover-probe-${++this._probeCounter}`;
return new Promise((resolve) => {
let settled = false;
const settle2 = (reply) => {
if (settled) return;
settled = true;
clearTimeout(timer);
if (this._pending?.id === id) this._pending = void 0;
resolve(reply);
};
const timer = setTimeout(() => settle2({ kind: "timeout" }), timeoutMs);
this._pending = {
id,
resolve: settle2
};
this._transport.send(buildRequest(id)).catch((error62) => settle2({
kind: "send-error",
error: error62
}));
});
}
/** Detach the window's handlers, restoring any the caller pre-set, leaving the transport's own `start` untouched. */
detach() {
this._pending = void 0;
this._transport.onmessage = this._savedOnMessage;
this._transport.onerror = this._savedOnError;
if (this._closeDelivered && this._savedOnClose !== void 0) {
const saved = this._savedOnClose;
const transport = this._transport;
let spent = false;
const wrapper = () => {
if (!spent) {
spent = true;
return;
}
saved();
};
transport.onclose = wrapper;
pendingSpentCloseGuards.set(transport, () => {
if (transport.onclose === wrapper) transport.onclose = saved;
});
} else this._transport.onclose = this._savedOnClose;
}
/** Detach the handlers and arm the one-shot `start()` pass-through for the `Protocol.connect()` handover. */
release() {
this.detach();
const transport = this._transport;
const originalStart = transport.start;
let armed = true;
transport.start = async function() {
if (armed) {
armed = false;
transport.start = originalStart;
return;
}
return originalStart.call(transport);
};
}
};
var pendingSpentCloseGuards = /* @__PURE__ */ new WeakMap();
function disarmSpentCloseGuard(transport) {
const disarm = pendingSpentCloseGuards.get(transport);
pendingSpentCloseGuards.delete(transport);
disarm?.();
}
function buildProbeRequest(id, protocolVersion, clientInfo, capabilities) {
return {
jsonrpc: "2.0",
id,
method: "server/discover",
params: { _meta: codecForVersion(protocolVersion).outboundEnvelope({
protocolVersion,
clientInfo,
clientCapabilities: capabilities
}) }
};
}
function isUnusableReplyError(error62) {
if (error62 instanceof SdkError && error62.code === SdkErrorCode.ClientHttpUnexpectedContent) return true;
return error62 instanceof Error && error62.name === "SyntaxError";
}
function normalizeReply(reply, timeoutMs) {
switch (reply.kind) {
case "response":
return reply.error === void 0 ? {
kind: "result",
result: reply.result
} : {
kind: "rpc-error",
...reply.error
};
case "send-error": {
const error62 = reply.error;
if (isAuthSeamEscape(error62) || error62 instanceof UnauthorizedError || error62 instanceof Error && error62.name === "UnauthorizedError") return {
kind: "auth-required",
error: error62
};
if (error62 instanceof SdkHttpError) {
const text = error62.data?.text;
return {
kind: "http-error",
status: error62.data.status,
body: typeof text === "string" ? text : void 0,
statusText: error62.data.statusText
};
}
if (isUnusableReplyError(error62)) return {
kind: "unusable-reply",
error: error62
};
return {
kind: "network-error",
error: error62
};
}
case "closed":
return { kind: "closed" };
case "timeout":
return {
kind: "timeout",
timeoutMs
};
}
}
async function negotiateEra(negotiation, deps) {
const timeoutMs = negotiation.probe.timeoutMs ?? deps.defaultTimeoutMs;
const maxRetries = Math.max(0, negotiation.probe.maxRetries ?? 0);
const clientModernVersions = negotiation.kind === "pin" ? [negotiation.version] : negotiation.modernVersions;
const fallbackAvailable = negotiation.kind === "auto" && negotiation.fallbackAvailable;
const window = await ProbeWindow.open(deps.transport);
const probe = async () => {
let requestedVersion = clientModernVersions[0];
let correctiveUsed = false;
let timeoutRetriesRemaining = maxRetries;
for (; ; ) {
const reply = await window.exchange((id) => buildProbeRequest(id, requestedVersion, deps.clientInfo, deps.capabilities), timeoutMs);
if (reply.kind === "timeout" && timeoutRetriesRemaining > 0) {
timeoutRetriesRemaining--;
continue;
}
const outcome = normalizeReply(reply, timeoutMs);
const verdict = classifyProbeOutcome(outcome, {
clientModernVersions,
requestedVersion,
fallbackAvailable,
environment: deps.environment,
transportKind: deps.transportKind
});
switch (verdict.kind) {
case "modern":
return {
era: "modern",
version: verdict.version,
discover: verdict.discover
};
case "corrective":
if (correctiveUsed) throw verdict.error;
correctiveUsed = true;
requestedVersion = verdict.version;
continue;
case "legacy": {
const closedCause = outcome.kind === "closed" ? "the connection closed during the server/discover probe" : void 0;
if (negotiation.kind === "pin") throw new SdkError(SdkErrorCode.EraNegotiationFailed, closedCause === void 0 ? `Version negotiation failed: the server did not offer pinned protocol version ${negotiation.version} via server/discover (no fallback in pin mode)` : `Version negotiation failed: ${closedCause} before the server offered pinned protocol version ${negotiation.version} (no fallback in pin mode)`);
if (!negotiation.fallbackAvailable) throw new SdkError(SdkErrorCode.EraNegotiationFailed, closedCause === void 0 ? "Version negotiation failed: the server gave no modern evidence and this client supports no pre-2026-07-28 protocol version to fall back to" : `Version negotiation failed: ${closedCause} and this client supports no pre-2026-07-28 protocol version to fall back to`);
if (closedCause !== void 0 && deps.disposableProbe !== true) throw new SdkError(SdkErrorCode.EraNegotiationFailed, `Version negotiation failed: ${closedCause} (this transport probed in place \u2014 the disposable sibling probe requires the SDK's base StdioClientTransport)`);
return { era: "legacy" };
}
case "error":
throw verdict.error;
}
}
};
let result;
try {
result = await probe();
} catch (error62) {
window.detach();
throw error62;
}
window.release();
return result;
}
function readStdioServerParams(transport) {
const proto = Object.getPrototypeOf(transport);
if (proto === null || !Object.prototype.hasOwnProperty.call(proto, "_dispose")) return;
const params = transport._serverParams;
return typeof params === "object" && params !== null && typeof params.command === "string" ? params : void 0;
}
async function negotiateStdioViaSibling(negotiation, sessionTransport, params, deps) {
const SiblingTransport = sessionTransport.constructor;
const sibling = new SiblingTransport({
...params,
stderr: "ignore"
});
const originalClose = sessionTransport.close;
let callerClosed = false;
let signalClosed;
const closedSignal = new Promise((_, reject) => {
signalClosed = () => reject(callerCloseAbortError());
});
sessionTransport.close = async function() {
callerClosed = true;
signalClosed?.();
return originalClose.call(sessionTransport);
};
let result;
try {
const negotiated = negotiateEra(negotiation, {
...deps,
transport: sibling,
transportKind: "stdio",
disposableProbe: true
});
negotiated.catch(() => {
});
result = await Promise.race([negotiated, closedSignal]);
} finally {
await disposeSibling(sibling);
sessionTransport.close = originalClose;
}
if (callerClosed) throw callerCloseAbortError();
return result;
}
function callerCloseAbortError() {
return new SdkError(SdkErrorCode.EraNegotiationFailed, "Version negotiation failed: the transport was closed during the server/discover probe");
}
async function disposeSibling(sibling) {
try {
const dispose = sibling._dispose;
await (typeof dispose === "function" ? dispose.call(sibling) : sibling.close());
} catch {
}
}
function serverInfoFromDiscover(discover) {
const fromMeta = discover._meta?.[SERVER_INFO_META_KEY];
return isSpecType.Implementation(fromMeta) ? fromMeta : void 0;
}
function applyElicitationDefaults(schema, data) {
if (!schema || data === null || typeof data !== "object") return;
if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
const obj = data;
const props = schema.properties;
for (const key of Object.keys(props)) {
const propSchema = props[key];
if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) obj[key] = propSchema.default;
if (obj[key] !== void 0) applyElicitationDefaults(propSchema, obj[key]);
}
}
if (Array.isArray(schema.anyOf)) {
for (const sub of schema.anyOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
}
if (Array.isArray(schema.oneOf)) {
for (const sub of schema.oneOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
}
}
function getSupportedElicitationModes(capabilities) {
if (!capabilities) return {
supportsFormMode: false,
supportsUrlMode: false
};
const hasFormCapability = capabilities.form !== void 0;
const hasUrlCapability = capabilities.url !== void 0;
return {
supportsFormMode: hasFormCapability || !hasFormCapability && !hasUrlCapability,
supportsUrlMode: hasUrlCapability
};
}
function validatePrior(prior) {
if (typeof prior === "object" && prior !== null) {
if (prior.kind === "legacy" && !("supportedVersions" in prior) && !("discover" in prior)) return prior;
if (prior.kind === "modern" && DiscoverResultSchema.safeParse(prior.discover).success) return prior;
}
throw new SdkError(SdkErrorCode.EraNegotiationFailed, "connect({ prior }): unrecognized prior \u2014 expected { kind: 'modern', discover } or { kind: 'legacy' }");
}
var LIST_CHANGED_EVICTIONS = {
"notifications/tools/list_changed": ["tools/list"],
"notifications/prompts/list_changed": ["prompts/list"],
"notifications/resources/list_changed": ["resources/list", "resources/templates/list"]
};
var DEFAULT_LIST_MAX_PAGES = 64;
var clientInternals = {};
var Client = class extends Protocol {
_serverCapabilities;
_serverVersion;
_capabilities;
_instructions;
_jsonSchemaValidator;
/**
* The response-cache substrate. Owns the backing store, the per-method
* eviction-generation counter, the user-supplied/default flag, and the
* stamp-memoized derived `name → Tool` / `name → output-validator`
* indices — the cache-coordination state that used to live as separate
* private fields here. The internal aggregating walk writes one entry per
* list verb; `list_changed` evicts the matching method;
* `_resetConnectionState` resets the lot. {@linkcode callTool}'s
* output-schema validation reads the derived `outputValidator` index (the
* substrate's first production caller); the stacked SEP-2243 PR wires
* `Mcp-Param-*` mirroring through `toolDefinition` on top.
*/
_cache;
_defaultCacheTtlMs;
_listMaxPages;
_listChangedDebounceTimers = /* @__PURE__ */ new Map();
/**
* The constructor `listChanged` configuration. Durable across reconnects:
* read fresh on every connect (legacy or modern), never consumed.
*/
_listChangedConfig;
_enforceStrictCapabilities;
_versionNegotiation;
_supportedProtocolVersionsOption;
_inputRequiredDriverConfig;
/**
* Active subscriptions/listen state, keyed by subscription id (= the
* listen request's JSON-RPC id verbatim). The id is a STRING from a
* Client-owned counter (`'listen:' + N`) — JSON-RPC permits string ids,
* and Protocol's numeric `_requestMessageId` counter only ever issues
* numbers, so listen ids cannot collide with ordinary request ids.
*/
_listenState = /* @__PURE__ */ new Map();
_nextListenId = 0;
/** The auto-opened subscription backing ClientOptions.listChanged on a modern connection. */
_autoOpenedSubscription;
/** Backing store for {@linkcode getDiscoverResult}. Per-connection. */
_discoverResult;
static {
clientInternals.enforceStrictCapabilities = (client) => client._enforceStrictCapabilities;
clientInternals.walkPages = (client, method, fetchPage, items) => client._walkPages(method, fetchPage, items);
clientInternals.readResource = (client, params, options) => client._readResource(params, options);
}
/**
* Clears every per-connection field in one place. Called at the start of
* each fresh (non-resuming) connect and from `close()`, so a stale
* negotiated era / server identity / auto-opened subscription cannot
* survive a reconnect.
*/
_resetConnectionState() {
this._negotiatedProtocolVersion = void 0;
this._serverCapabilities = void 0;
this._serverVersion = void 0;
this._instructions = void 0;
this._discoverResult = void 0;
this._autoOpenedSubscription = void 0;
if (this._listenState.size > 0) {
const reason = new SdkError(SdkErrorCode.ConnectionClosed, "subscriptions/listen: client reconnected or closed; subscription state from the previous connection was reset");
for (const entry of this._listenState.values()) entry.settle({
cause: "remote",
error: reason
});
}
this._listenState.clear();
for (const timer of this._listChangedDebounceTimers.values()) clearTimeout(timer);
this._listChangedDebounceTimers.clear();
this._cache.resetForReconnect();
}
async close() {
try {
await super.close();
} finally {
this._resetConnectionState();
}
}
/**
* Initializes this client with the given name and version information.
*/
constructor(_clientInfo, options) {
super(options);
this._clientInfo = _clientInfo;
this._capabilities = options?.capabilities ? { ...options.capabilities } : {};
this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
this._enforceStrictCapabilities = options?.enforceStrictCapabilities ?? false;
this._versionNegotiation = options?.versionNegotiation;
this._supportedProtocolVersionsOption = options?.supportedProtocolVersions;
this._inputRequiredDriverConfig = resolveInputRequiredDriverConfig(options?.inputRequired);
this._cache = new ClientResponseCache(options?.responseCacheStore ?? new InMemoryResponseCacheStore(), options?.responseCacheStore !== void 0, (error62) => this._reportStoreError(error62), options?.cachePartition ?? "");
this._defaultCacheTtlMs = options?.defaultCacheTtlMs ?? 0;
this._listMaxPages = options?.listMaxPages ?? DEFAULT_LIST_MAX_PAGES;
if (options?.listChanged) this._listChangedConfig = options.listChanged;
}
buildContext(ctx, _transportInfo) {
return ctx;
}
/**
* Era-keyed direction enforcement for inbound traffic on channels whose
* transport does not classify (e.g. stdio): the 2026-07-28 era has no
* server→client JSON-RPC request channel — server-to-client interactions
* are carried in-band in `input_required` results — and on stdio the
* client must never write JSON-RPC responses. An inbound request arriving
* on a connection that negotiated a modern era is therefore dropped
* (surfaced via `onerror`) rather than answered. Connections on a legacy
* era — and all responses and notifications — keep today's dispatch path.
*/
_shouldDropInbound(message) {
if (this._negotiatedProtocolVersion !== void 0 && isModernProtocolVersion(this._negotiatedProtocolVersion) && isJSONRPCRequest(message)) return "drop";
}
/**
* Per-request `_meta` envelope auto-emission (protocol revision 2026-07-28):
* on a connection that negotiated a modern era — auto-negotiated or pinned —
* every outgoing request and notification automatically carries the reserved
* protocol-version / client-info / client-capabilities `_meta` keys (the
* same envelope the connect-time `server/discover` probe sends).
* User-supplied `_meta` keys take precedence over the auto-attached ones.
*
* Legacy-era connections return `undefined`: the envelope seam is a no-op
* and outbound traffic is byte-identical to a 2025 client (the legacy
* `'auto'` fallback included).
*/
_outboundMetaEnvelope() {
const version3 = this._negotiatedProtocolVersion;
if (version3 === void 0) return void 0;
return this._wireCodec().outboundEnvelope({
protocolVersion: version3,
clientInfo: this._clientInfo,
clientCapabilities: this._capabilities
});
}
/**
* Wires the multi-round-trip auto-fulfilment engine (protocol revision
* 2026-07-28) into the response funnel: an `input_required` answer is
* fulfilled through the registered elicitation/sampling/roots handlers
* and the original request retried via `flow.retry`, up to
* `inputRequired.maxRounds` rounds. With auto-fulfilment disabled the
* response surfaces as a typed error steering to manual mode.
*/
_resolveNonCompleteResult(decoded, flow) {
if (!this._inputRequiredDriverConfig.autoFulfill) return Promise.reject(new SdkError(SdkErrorCode.UnsupportedResultType, `Unsupported result type 'input_required' for ${flow.request.method}: multi-round-trip auto-fulfilment is not enabled on this instance \u2014 pass allowInputRequired: true to handle it manually, or enable inputRequired.autoFulfill`, {
resultType: "input_required",
method: flow.request.method
}));
return runInputRequiredFlow({
getRequestHandler: (method) => this._getRequestHandler(method),
buildContext: (baseCtx) => this.buildContext(baseCtx, void 0),
sessionId: this.transport?.sessionId
}, this._inputRequiredDriverConfig, decoded, flow);
}
/**
* Set up handlers for list changed notifications based on config and server capabilities.
* This should only be called after initialization when server capabilities are known.
* Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
* @internal
*/
_setupListChangedHandlers(config2) {
if (config2.tools && this._serverCapabilities?.tools?.listChanged) this._setupListChangedHandler("tools", "notifications/tools/list_changed", config2.tools, async () => {
return (await this.listTools(void 0, { cacheMode: "refresh" })).tools;
});
if (config2.prompts && this._serverCapabilities?.prompts?.listChanged) this._setupListChangedHandler("prompts", "notifications/prompts/list_changed", config2.prompts, async () => {
return (await this.listPrompts(void 0, { cacheMode: "refresh" })).prompts;
});
if (config2.resources && this._serverCapabilities?.resources?.listChanged) this._setupListChangedHandler("resources", "notifications/resources/list_changed", config2.resources, async () => {
return (await this.listResources(void 0, { cacheMode: "refresh" })).resources;
});
}
/**
* Registers new capabilities. This can only be called before connecting to a transport.
*
* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
*/
registerCapabilities(capabilities) {
if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
this._capabilities = mergeCapabilities(this._capabilities, capabilities);
}
/**
* Configure protocol version negotiation before connecting (equivalent to
* passing `versionNegotiation` at construction time). Can only be called
* before connecting to a transport. Passing `undefined` clears a previously
* configured negotiation, restoring the default `'legacy'` posture.
*
* See {@linkcode ClientOptions | ClientOptions.versionNegotiation} for the mode semantics.
*/
setVersionNegotiation(options) {
if (this.transport) throw new Error("Cannot configure version negotiation after connecting to transport");
this._versionNegotiation = options;
}
/**
* Enforces client-side validation for `elicitation/create` and `sampling/createMessage`
* regardless of how the handler was registered.
*/
_wrapHandler(method, handler) {
if (method === "elicitation/create") return async (request, ctx) => {
const codec2 = codecForVersion(this._negotiatedProtocolVersion);
let validatedRequest = codec2.validateRequest("elicitation/create", request);
if (!validatedRequest.ok && validatedRequest.reason === "not-in-era") validatedRequest = codec2.validateInputRequest("elicitation/create", request);
if (!validatedRequest.ok) throw new ProtocolError(validatedRequest.reason === "not-in-era" ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams, validatedRequest.reason === "not-in-era" ? "No wire schema for elicitation/create in the resolved era" : `Invalid elicitation request: ${validatedRequest.message}`);
const { params } = validatedRequest.value;
params.mode = params.mode ?? "form";
const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
if (params.mode === "form" && !supportsFormMode) throw new ProtocolError(ProtocolErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
if (params.mode === "url" && !supportsUrlMode) throw new ProtocolError(ProtocolErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
const result = await handler(request, ctx);
let validationResult = codec2.validateResult("elicitation/create", result);
if (!validationResult.ok && validationResult.reason === "not-in-era") validationResult = codec2.validateInputResponse("elicitation/create", result);
if (!validationResult.ok) throw new ProtocolError(validationResult.reason === "not-in-era" ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams, validationResult.reason === "not-in-era" ? "No wire schema for elicitation/create in the resolved era" : `Invalid elicitation result: ${validationResult.message}`);
const validatedResult = validationResult.value;
const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema && this._capabilities.elicitation?.form?.applyDefaults) try {
applyElicitationDefaults(requestedSchema, validatedResult.content);
} catch {
}
return validatedResult;
};
if (method === "sampling/createMessage") return async (request, ctx) => {
const codec2 = codecForVersion(this._negotiatedProtocolVersion);
let validatedRequest = codec2.validateRequest("sampling/createMessage", request);
if (!validatedRequest.ok && validatedRequest.reason === "not-in-era") validatedRequest = codec2.validateInputRequest("sampling/createMessage", request);
if (!validatedRequest.ok) throw new ProtocolError(validatedRequest.reason === "not-in-era" ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams, validatedRequest.reason === "not-in-era" ? "No wire schema for sampling/createMessage in the resolved era" : `Invalid sampling request: ${validatedRequest.message}`);
const { params } = validatedRequest.value;
const result = await handler(request, ctx);
const hasTools = Boolean(params.tools || params.toolChoice);
let validatedResult = codec2.samplingResultVariant(hasTools, result);
if (!validatedResult.ok && validatedResult.reason === "not-in-era") validatedResult = codec2.validateInputResponse("sampling/createMessage", result);
if (!validatedResult.ok) throw new ProtocolError(validatedResult.reason === "not-in-era" ? ProtocolErrorCode.InternalError : ProtocolErrorCode.InvalidParams, validatedResult.reason === "not-in-era" ? "No result schema for sampling/createMessage in the resolved era" : `Invalid sampling result: ${validatedResult.message}`);
return validatedResult.value;
};
return handler;
}
assertCapability(capability, method) {
if (!this._serverCapabilities?.[capability]) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support ${capability} (required for ${method})`);
}
/**
* Connects to a server via the given transport and performs the MCP initialization handshake.
*
* @example Basic usage (stdio)
* ```ts source="./client.examples.ts#Client_connect_stdio"
* const client = new Client({ name: 'my-client', version: '1.0.0' });
* const transport = new StdioClientTransport({ command: 'my-mcp-server' });
* await client.connect(transport);
* ```
*
* @example Streamable HTTP with SSE fallback
* ```ts source="./client.examples.ts#Client_connect_sseFallback"
* const baseUrl = new URL(url);
*
* try {
* // Try modern Streamable HTTP transport first
* const client = new Client({ name: 'my-client', version: '1.0.0' });
* const transport = new StreamableHTTPClientTransport(baseUrl);
* await client.connect(transport);
* return { client, transport };
* } catch {
* // Fall back to legacy SSE transport
* const client = new Client({ name: 'my-client', version: '1.0.0' });
* const transport = new SSEClientTransport(baseUrl);
* await client.connect(transport);
* return { client, transport };
* }
* ```
*/
async connect(transport, options) {
if (options?.prior != null) return this._connectFromPrior(transport, validatePrior(options.prior), options);
const negotiation = resolveVersionNegotiation(this._versionNegotiation, this._supportedProtocolVersionsOption);
if (negotiation.kind !== "legacy") return this._connectNegotiated(transport, negotiation, options);
return this._connectPlainLegacy(transport, options);
}
/**
* Plain legacy connect — the pinned 2025 sequence, byte-untouched. The
* `mode: 'legacy'` connect body, shared with the `prior` legacy verdict.
*/
async _connectPlainLegacy(transport, options) {
await super.connect(transport);
if (transport.sessionId !== void 0) {
const negotiatedProtocolVersion = this._negotiatedProtocolVersion;
if (negotiatedProtocolVersion !== void 0) transport.setProtocolVersion?.(negotiatedProtocolVersion);
return;
}
this._resetConnectionState();
await this._legacyHandshake(transport, options);
}
/**
* The 2025 `initialize` handshake — the body of the plain legacy connect and
* the `'auto'`-mode fallback path (same `initialize` body, zero 2026 headers;
* on the stdio sibling path it opens the session child's fresh pipe, in the
* in-place modes it rides the probed connection). Callers clear the negotiated protocol version before
* the handshake; its completion sets the negotiated (legacy) version.
*/
async _legacyHandshake(transport, options) {
const legacyVersions = legacyProtocolVersions(this._supportedProtocolVersions);
try {
const offeredVersion = legacyVersions[0];
if (offeredVersion === void 0) throw new SdkError(SdkErrorCode.EraNegotiationFailed, "Cannot run the initialize handshake: supportedProtocolVersions contains no pre-2026-07-28 protocol version");
const result = await this.request({
method: "initialize",
params: {
protocolVersion: offeredVersion,
capabilities: this._capabilities,
clientInfo: this._clientInfo
}
}, options);
if (result === void 0) throw new Error(`Server sent invalid initialize result: ${result}`);
if (!legacyVersions.includes(result.protocolVersion)) throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
this._serverCapabilities = result.capabilities;
this._serverVersion = result.serverInfo;
this._cache.setServerIdentity(this._deriveServerIdentity(transport));
if (transport.setProtocolVersion) transport.setProtocolVersion(result.protocolVersion);
this._instructions = result.instructions;
await this.notification({ method: "notifications/initialized" });
this._negotiatedProtocolVersion = result.protocolVersion;
if (this._listChangedConfig) this._setupListChangedHandlers(this._listChangedConfig);
} catch (error62) {
this.close();
throw error62;
}
}
/**
* Negotiated connect (mode `'auto'` or `{ pin }`): probe with `server/discover`
* before the Protocol machinery attaches — on a disposable sibling process for
* the SDK's stdio transport, in place otherwise — then either establish the
* modern era or perform the plain legacy handshake.
*/
async _connectNegotiated(transport, negotiation, options) {
if (transport.sessionId !== void 0) {
await super.connect(transport);
const negotiatedProtocolVersion = this._negotiatedProtocolVersion;
if (negotiatedProtocolVersion !== void 0 && transport.setProtocolVersion) transport.setProtocolVersion(negotiatedProtocolVersion);
return;
}
this._resetConnectionState();
let result;
try {
const transportKind = detectProbeTransportKind(transport);
const baseDeps = {
clientInfo: this._clientInfo,
capabilities: this._capabilities,
environment: detectProbeEnvironment(),
defaultTimeoutMs: options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC
};
const stdioParams = transportKind === "stdio" ? readStdioServerParams(transport) : void 0;
result = stdioParams === void 0 ? await negotiateEra(negotiation, {
...baseDeps,
transport,
transportKind
}) : await negotiateStdioViaSibling(negotiation, transport, stdioParams, baseDeps);
} catch (error62) {
await transport.close().catch(() => {
});
disarmSpentCloseGuard(transport);
throw error62;
}
disarmSpentCloseGuard(transport);
await super.connect(transport);
if (result.era === "legacy") {
await this._legacyHandshake(transport, options);
return;
}
this._serverCapabilities = result.discover.capabilities;
this._serverVersion = serverInfoFromDiscover(result.discover);
this._cache.setServerIdentity(this._deriveServerIdentity(transport));
this._instructions = result.discover.instructions;
this._discoverResult = result.discover;
this._negotiatedProtocolVersion = result.version;
if (transport.setProtocolVersion) transport.setProtocolVersion(result.version);
if (this._listChangedConfig) {
const config2 = this._listChangedConfig;
const advertised = this._serverCapabilities;
const effective = {
...config2.tools && advertised?.tools?.listChanged && { tools: config2.tools },
...config2.prompts && advertised?.prompts?.listChanged && { prompts: config2.prompts },
...config2.resources && advertised?.resources?.listChanged && { resources: config2.resources }
};
let handlersRegistered = true;
try {
this._setupListChangedHandlers(effective);
} catch (error62) {
handlersRegistered = false;
this.onerror?.(error62 instanceof Error ? error62 : new Error(String(error62)));
}
const filter = handlersRegistered ? {
...effective.tools && { toolsListChanged: true },
...effective.prompts && { promptsListChanged: true },
...effective.resources && { resourcesListChanged: true }
} : {};
if (Object.keys(filter).length > 0) {
const ackAbort = new AbortController();
const onConnectAbort = () => ackAbort.abort(options?.signal?.reason);
if (options?.signal?.aborted) onConnectAbort();
options?.signal?.addEventListener("abort", onConnectAbort);
try {
this._autoOpenedSubscription = await this.listen(filter, {
timeout: options?.timeout,
signal: ackAbort.signal
});
} catch (error62) {
if (options?.signal?.aborted) {
await this.close().catch(() => {
});
throw error62;
}
this.onerror?.(error62 instanceof Error ? error62 : new Error(String(error62)));
} finally {
options?.signal?.removeEventListener("abort", onConnectAbort);
}
}
}
}
/**
* Connect from a validated {@linkcode PriorDiscovery}: the modern arm
* adopts the `DiscoverResult` (zero round trips; `EraNegotiationFailed`
* on no 2026-07-28+ overlap), the legacy arm runs the plain legacy connect.
*/
async _connectFromPrior(transport, prior, options) {
if (prior.kind === "legacy") return this._connectPlainLegacy(transport, options);
const discover = prior.discover;
this._resetConnectionState();
const explicit = this._supportedProtocolVersionsOption;
const version3 = (explicit && modernProtocolVersions(explicit).length > 0 ? modernProtocolVersions(explicit) : SUPPORTED_MODERN_PROTOCOL_VERSIONS).find((v) => discover.supportedVersions.includes(v));
if (version3 === void 0) throw new SdkError(SdkErrorCode.EraNegotiationFailed, "connect({ prior }) with a modern verdict requires a 2026-07-28+ mutual protocol version; the supplied DiscoverResult and this client's supportedProtocolVersions have no modern overlap. For a server known to be legacy, pass prior: { kind: 'legacy' } to skip the probe and initialize directly, or use versionNegotiation: { mode: 'auto' } to re-probe with legacy fallback.");
await super.connect(transport);
this._discoverResult = discover;
this._serverCapabilities = discover.capabilities;
this._serverVersion = serverInfoFromDiscover(discover);
this._cache.setServerIdentity(this._deriveServerIdentity(transport));
this._instructions = discover.instructions;
this._negotiatedProtocolVersion = version3;
transport.setProtocolVersion?.(version3);
if (this._listChangedConfig) try {
this._setupListChangedHandlers(this._listChangedConfig);
} catch (error62) {
this.onerror?.(error62 instanceof Error ? error62 : new Error(String(error62)));
}
}
/**
* After initialization has completed, this will be populated with the server's reported capabilities.
*/
getServerCapabilities() {
return this._serverCapabilities;
}
/**
* The connected server's self-reported name and version, when it
* identified itself: required on the legacy `initialize` result; a spec
* SHOULD in the discover result's `_meta` on 2026-07-28, so a successful
* modern connect against an anonymous server leaves this `undefined`.
*/
getServerVersion() {
return this._serverVersion;
}
/**
* The connected server's identity for response-cache partitioning. The
* `serverInfo` `name@version` pair when available (required on
* `initialize`; a SHOULD in the discover result's `_meta` since spec PR
* #3002); falls back to the transport's `sessionId`, then to a
* per-connection surrogate. The surrogate matters since #3002 made
* identity optional: without it, two identity-less servers reached over
* sessionId-less transports would share the cache's pre-connect `''`
* partition and read each other's entries — no stable identity means no
* cross-connection cache reuse. The value itself is server-controlled —
* the collision-safety of the storage partition comes from
* {@linkcode ClientResponseCache}'s JSON-array encoding around it, not
* from any character it does or does not contain.
*/
_deriveServerIdentity(transport) {
const v = this._serverVersion;
if (v !== void 0) return `${v.name}@${v.version}`;
return transport.sessionId ?? `anonymous:${Date.now()}-${Math.random().toString(36).slice(2)}`;
}
/**
* After initialization has completed, this will be populated with the protocol version negotiated
* during the initialize handshake. When manually reconstructing a transport for reconnection, pass this
* value to the new transport so it continues sending the required `mcp-protocol-version` header.
*/
getNegotiatedProtocolVersion() {
return this._negotiatedProtocolVersion;
}
/**
* After initialization has completed, this returns the protocol era of the
* connection: `'modern'` when the connection negotiated a 2026-07-28+
* revision (via `server/discover`), `'legacy'` for the 2025-era
* `initialize` handshake, or `undefined` before the connection is
* established.
*/
getProtocolEra() {
const version3 = this._negotiatedProtocolVersion;
if (version3 === void 0) return void 0;
return isModernProtocolVersion(version3) ? "modern" : "legacy";
}
/**
* After initialization has completed, this may be populated with information about the server's instructions.
*/
getInstructions() {
return this._instructions;
}
/**
* The {@linkcode DiscoverResult} from the last `'auto'`/pinned probe,
* {@linkcode discover} call, or `connect({ prior })` that adopted a
* modern verdict (a legacy verdict leaves this `undefined` — there is no
* `DiscoverResult` on that path). Persistable via `JSON.stringify`; wrap
* as `{ kind: 'modern', discover }` and feed to {@linkcode ConnectOptions}
* `prior`.
*/
getDiscoverResult() {
return this._discoverResult;
}
assertCapabilityForMethod(method) {
switch (method) {
case "logging/setLevel":
if (!this._serverCapabilities?.logging) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support logging (required for ${method})`);
break;
case "prompts/get":
case "prompts/list":
if (!this._serverCapabilities?.prompts) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support prompts (required for ${method})`);
break;
case "resources/list":
case "resources/templates/list":
case "resources/read":
case "resources/subscribe":
case "resources/unsubscribe":
if (!this._serverCapabilities?.resources) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support resources (required for ${method})`);
if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support resource subscriptions (required for ${method})`);
break;
case "tools/call":
case "tools/list":
if (!this._serverCapabilities?.tools) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support tools (required for ${method})`);
break;
case "completion/complete":
if (!this._serverCapabilities?.completions) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support completions (required for ${method})`);
break;
case "initialize":
break;
case "server/discover":
break;
case "ping":
break;
}
}
assertNotificationCapability(method) {
switch (method) {
case "notifications/roots/list_changed":
if (!this._capabilities.roots?.listChanged) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support roots list changed notifications (required for ${method})`);
break;
case "notifications/initialized":
break;
case "notifications/cancelled":
break;
case "notifications/progress":
break;
}
}
assertRequestHandlerCapability(method) {
switch (method) {
case "sampling/createMessage":
if (!this._capabilities.sampling) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support sampling capability (required for ${method})`);
break;
case "elicitation/create":
if (!this._capabilities.elicitation) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support elicitation capability (required for ${method})`);
break;
case "roots/list":
if (!this._capabilities.roots) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support roots capability (required for ${method})`);
break;
case "ping":
break;
}
}
async ping(options) {
return this.request({ method: "ping" }, options);
}
/**
* Send `server/discover` (2026-07-28+) and record the result for
* {@linkcode getDiscoverResult}.
*/
async discover(options) {
const result = await this._requestWithSchema({ method: "server/discover" }, DiscoverResultSchema, options);
this._discoverResult = result;
return result;
}
/** Requests argument autocompletion suggestions from the server for a prompt or resource. */
async complete(params, options) {
return this.request({
method: "completion/complete",
params
}, options);
}
/**
* Sets the minimum severity level for log messages sent by the server.
*
* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
* Remains functional during the deprecation window (at least twelve months).
* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
*/
async setLoggingLevel(level, options) {
return this.request({
method: "logging/setLevel",
params: { level }
}, options);
}
/** Retrieves a prompt by name from the server, passing the given arguments for template substitution. */
async getPrompt(params, options) {
return this.request({
method: "prompts/get",
params
}, options);
}
/**
* Lists available prompts.
*
* Called without a `cursor` (the common case), this walks every page and
* returns the complete aggregated list with no `nextCursor`; the
* aggregate is also written to the {@linkcode ResponseCacheStore}. Pass an
* explicit `{ cursor }` to fetch a single page and walk pagination
* yourself — the per-page path returns the server's raw page (with
* `nextCursor` for the next call) and does not write the response cache.
* The auto-aggregate path is capped by
* {@linkcode ClientOptions | ClientOptions.listMaxPages} (default 64); the per-page path
* is not.
*
* Returns an empty list if the server does not advertise prompts capability
* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
*
* @example
* ```ts source="./client.examples.ts#Client_listPrompts_pagination"
* // No cursor → all pages aggregated for you.
* const { prompts } = await client.listPrompts();
* console.log(
* 'Available prompts:',
* prompts.map(p => p.name)
* );
* ```
*/
async listPrompts(params, options) {
if (!this._serverCapabilities?.prompts && !this._enforceStrictCapabilities) {
console.debug("Client.listPrompts() called but server does not advertise prompts capability - returning empty list");
return { prompts: [] };
}
if (params?.cursor !== void 0) return this.request({
method: "prompts/list",
params
}, options);
const hit = await this._serveFromCache("prompts/list", void 0, options);
if (hit !== void 0) return hit;
return this._listAllPages("prompts/list", params, options, (r) => r.prompts);
}
/**
* Lists available resources.
*
* Called without a `cursor` (the common case), this walks every page and
* returns the complete aggregated list with no `nextCursor`; the
* aggregate is also written to the {@linkcode ResponseCacheStore}. Pass an
* explicit `{ cursor }` to fetch a single page and walk pagination
* yourself — the per-page path returns the server's raw page (with
* `nextCursor` for the next call) and does not write the response cache.
* The auto-aggregate path is capped by
* {@linkcode ClientOptions | ClientOptions.listMaxPages} (default 64); the per-page path
* is not.
*
* Returns an empty list if the server does not advertise resources capability
* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
*
* @example
* ```ts source="./client.examples.ts#Client_listResources_pagination"
* // No cursor → all pages aggregated for you.
* const { resources } = await client.listResources();
* console.log(
* 'Available resources:',
* resources.map(r => r.name)
* );
* ```
*/
async listResources(params, options) {
if (!this._serverCapabilities?.resources && !this._enforceStrictCapabilities) {
console.debug("Client.listResources() called but server does not advertise resources capability - returning empty list");
return { resources: [] };
}
if (params?.cursor !== void 0) return this.request({
method: "resources/list",
params
}, options);
const hit = await this._serveFromCache("resources/list", void 0, options);
if (hit !== void 0) return hit;
return this._listAllPages("resources/list", params, options, (r) => r.resources);
}
/**
* Lists available resource URI templates for dynamic resources.
*
* Called without a `cursor`, this walks every page and returns the
* complete aggregated list with no `nextCursor`; the aggregate is
* also written to the {@linkcode ResponseCacheStore}. Pass an explicit
* `{ cursor }` to fetch a single page — see
* {@linkcode listResources | listResources()} for the per-page contract.
*
* Returns an empty list if the server does not advertise resources capability
* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
*/
async listResourceTemplates(params, options) {
if (!this._serverCapabilities?.resources && !this._enforceStrictCapabilities) {
console.debug("Client.listResourceTemplates() called but server does not advertise resources capability - returning empty list");
return { resourceTemplates: [] };
}
if (params?.cursor !== void 0) return this.request({
method: "resources/templates/list",
params
}, options);
const hit = await this._serveFromCache("resources/templates/list", void 0, options);
if (hit !== void 0) return hit;
return this._listAllPages("resources/templates/list", params, options, (r) => r.resourceTemplates);
}
/**
* Walk every page of a paginated list verb, aggregate, and write ONE
* entry to the response cache. Internal — backs the public `list*`
* methods' no-`cursor` auto-aggregate path. Page 1's result object is
* mutated in place (its items array is extended; `nextCursor` is
* cleared); page-1 metadata (`ttlMs`, `cacheScope`, `_meta`) is preserved.
* A page with the same items and `nextCursor` as the previous page ends the walk;
* {@linkcode ClientOptions.listMaxPages} is a hard cap — hitting it
* throws, so a partial aggregate is never cached. The
* captured-generation guard skips the write when a `list_changed` landed
* mid-walk, so the eviction is never overwritten by a stale aggregate.
* `finalize` runs on the complete aggregate before the cache write — the
* SEP-2243 invalid-`x-mcp-header` exclusion hooks here so the cached
* `tools/list` entry is already filtered.
*
* The caller's `baseParams` (everything except `cursor`) is threaded into
* every page request — page 1 sends `{...baseParams}`, later pages
* `{...baseParams, cursor}` — so a typed, documented `_meta` (e.g. W3C
* trace context) supplied to the public `list*()` reaches every wire
* request the walk issues.
*/
async _listAllPages(method, baseParams, options, items, finalize2) {
const bypass = options?.cacheMode === "bypass";
const generation = this._cache.captureGeneration(method);
const fetchPage = (cursor) => {
const params = cursor === void 0 ? baseParams && { ...baseParams } : {
...baseParams,
cursor
};
return this.request({
method,
...params && { params }
}, options);
};
const acc = await this._walkPages(method, fetchPage, items);
delete acc.nextCursor;
finalize2?.(acc);
if (bypass) return acc;
await this._cache.write(method, acc, generation, this._freshness(acc));
return acc;
}
async _walkPages(method, fetchPage, items) {
const acc = await fetchPage(void 0);
let cursor = acc.nextCursor;
let previous = acc;
let pages = 1;
while (cursor !== void 0) {
if (this._listMaxPages !== 0 && pages >= this._listMaxPages) throw new SdkError(SdkErrorCode.ListPaginationExceeded, `${method}: exceeded listMaxPages (${this._listMaxPages}); server pagination did not terminate`, {
method,
listMaxPages: this._listMaxPages
});
const page = await fetchPage(cursor);
if (page.nextCursor === cursor && JSON.stringify(items(page)) === JSON.stringify(items(previous))) break;
items(acc).push(...items(page));
previous = page;
cursor = page.nextCursor;
pages++;
}
return acc;
}
/**
* Compute the {@linkcode ClientResponseCache.write} freshness payload from
* a cacheable result body. The single seam through which the client reads
* `ttlMs`/`cacheScope` (mcp.d's `cachedFetch` engine). The fields pass
* through the loose result schema, so they are read off the runtime body;
* a missing `ttlMs` falls back to
* {@linkcode ClientOptions | ClientOptions.defaultCacheTtlMs}; an explicit server-sent
* `ttlMs` (including `0` — the spec's "immediately stale") is honoured
* as-is. The default of `0` means `expiresAt === now()` ⇒ never served,
* only stored. A missing `cacheScope` is treated as `'private'` — the
* spec's `'public'` grant ("any client … MAY serve to any user") is too
* strong to infer by default, and matches this SDK's server-side stamp
* default.
*/
_freshness(result, params) {
const body = result;
const ttlMs = typeof body.ttlMs === "number" ? body.ttlMs : this._defaultCacheTtlMs;
const scope = body.cacheScope === "public" ? "public" : "private";
return {
expiresAt: this._cache.now() + Math.min(Math.max(0, ttlMs), MAX_CACHE_TTL_MS),
scope,
params
};
}
/**
* The cache-serving front of every cacheable verb (mcp.d's `cachedFetch`
* read half): under `cacheMode: 'use'` (the default), a fresh held entry
* is served and the round trip is skipped. `'refresh'` and `'bypass'`
* always fetch (the caller decides whether to write). Freshness and
* decoding live in {@linkcode ClientResponseCache.read}; every hit is
* freshly parsed, so the caller owns it outright. A custom store
* whose `get()` rejects is routed to `onerror` and treated as a miss —
* cache bookkeeping never blocks a request from reaching the wire.
*/
async _serveFromCache(method, params, options) {
if (options?.cacheMode === "bypass" || options?.cacheMode === "refresh") return void 0;
const hit = await this._cache.read(method, params).catch((error62) => void this._reportStoreError(error62));
if (hit !== void 0) {
if (options?.signal?.aborted) {
const reason = options.signal.reason;
throw reason instanceof SdkError ? reason : new SdkError(SdkErrorCode.RequestTimeout, String(reason));
}
return hit.value;
}
}
/** Route a custom-store failure to `onerror` without aborting the surrounding dispatch. */
_reportStoreError(e) {
this.onerror?.(e instanceof Error ? e : new Error(String(e)));
}
/**
* Compile a single tool's `outputSchema`. Passed as the compile callback to
* {@linkcode ClientResponseCache.outputValidator} so the cache class stays
* free of any validator-provider dependency, and called directly for the
* `options.toolDefinition` path of {@linkcode callTool} (a one-off
* caller-supplied definition is compiled in isolation and never enters the
* cache, so it cannot poison the listed tool of the same name).
*
* Returns `undefined` when the tool has no `outputSchema`, or a
* discriminated `{ok}` result otherwise. SEP-2106: ANY throw from the
* validator engine — unsupported `$schema` dialect, invalid `pattern`
* regex, unresolvable `$ref`, or any other engine error — is captured as
* `{ok: false, compileError}` so one bad schema does not poison the rest
* of the listing; `callTool()` surfaces it as an `InvalidParams` error
* before the request. The `{ok}` discriminator (not
* `compileError !== undefined`) means a custom provider that does
* `throw undefined` is still treated as a captured failure.
*/
_compileOutputValidator(tool) {
if (!tool.outputSchema) return void 0;
try {
return {
ok: true,
validator: this._jsonSchemaValidator.getValidator(tool.outputSchema)
};
} catch (error62) {
return {
ok: false,
compileError: error62
};
}
}
/**
* Resolve the SEP-2243 `x-mcp-header` declaration scan for a tool name.
*
* The caller-supplied `toolDefinition` escape hatch wins; otherwise the
* cached `tools/list` entry (via the cache's `toolDefinition`) is the
* source. Freshness is the response cache's lifecycle: `list_changed`
* evicts, otherwise the held schema is the best information available
* regardless of age, and a stale schema is recovered through the
* `HEADER_MISMATCH` → evict-refetch-retry path in {@linkcode callTool}.
* On a miss the call proceeds without `Mcp-Param-*` headers (the spec's
* "client SHOULD send without custom headers" guidance) and relies on the
* same recovery.
*/
async _resolveXMcpHeaderScan(name, override) {
const tool = override ?? await this._cache.toolDefinition(name);
return tool === void 0 ? void 0 : scanXMcpHeaderDeclarations(tool.inputSchema);
}
/**
* Reads the contents of a resource by URI.
*
* Honours the result's `ttlMs`/`cacheScope` (SEP-2549): a still-fresh
* cached body for the same `uri` is returned without a round trip
* (`cacheMode: 'use'`, the default). The cache key is `{method, uri}`
* partitioned by the resolved scope — `'private'` (the default when the
* server omits the field) is stored under this client's
* {@linkcode ClientOptions | ClientOptions.cachePartition}, so a shared
* store cannot serve one principal's resource body to another. Unlike the
* list verbs, a result whose resolved TTL is ≤0 is **not** stored
* (`resources/read` has no derived index and the URI keyspace is
* unbounded).
*/
async readResource(params, options) {
const { result } = await this._readResource(params, options);
return result;
}
async _readResource(params, options) {
const hit = await this._serveFromCache("resources/read", params.uri, options);
if (hit !== void 0) return {
result: hit,
cached: true
};
const generation = this._cache.captureGeneration("resources/read", params.uri);
const result = await this.request({
method: "resources/read",
params
}, options);
if (options?.cacheMode !== "bypass") {
const freshness = this._freshness(result, params.uri);
if (freshness.expiresAt > this._cache.now()) await this._cache.write("resources/read", result, generation, freshness);
else if (options?.cacheMode === "refresh") await this._cache.evictKey("resources/read", params.uri);
}
return {
result,
cached: false
};
}
/** Subscribes to change notifications for a resource. The server must support resource subscriptions. */
async subscribeResource(params, options) {
return this.request({
method: "resources/subscribe",
params
}, options);
}
/** Unsubscribes from change notifications for a resource. */
async unsubscribeResource(params, options) {
return this.request({
method: "resources/unsubscribe",
params
}, options);
}
/**
* Opens a `subscriptions/listen` stream (protocol revision 2026-07-28).
*
* Resolves once the server's `notifications/subscriptions/acknowledged`
* arrives (the standard request timeout applies to this ack phase). Change
* notifications delivered on the stream are dispatched to the existing
* {@linkcode setNotificationHandler} registrations — the same handlers the
* 2025-era unsolicited notifications fire on a legacy connection — so
* `listen()` is era-transparent for consumers that already register those.
*
* `close()` tears the subscription down by aborting the listen request's
* `requestSignal` (closes the SSE stream where the transport honors it)
* AND sending `notifications/cancelled` referencing the listen request id
* — both, unconditionally, so any spec-compliant server on any transport
* sees the cancel. No automatic re-listen — call `listen()` again to
* re-establish.
*
* On a 2025-era connection this throws a typed
* {@linkcode SdkErrorCode.MethodNotSupportedByProtocolVersion} steering to
* `resources/subscribe` and `ClientOptions.listChanged` (the legacy
* unsolicited delivery model still applies there); no transparent shim.
*/
async listen(filter, options) {
if (this.transport === void 0) throw new SdkError(SdkErrorCode.NotConnected, "Not connected");
const negotiated = this._negotiatedProtocolVersion;
if (negotiated === void 0 || !isModernProtocolVersion(negotiated)) throw new SdkError(SdkErrorCode.MethodNotSupportedByProtocolVersion, `subscriptions/listen requires a 2026-07-28-era connection (negotiated: ${negotiated ?? "none"}). On a 2025-era connection, change notifications are delivered unsolicited: use ClientOptions.listChanged and resources/subscribe instead.`, {
method: "subscriptions/listen",
protocolVersion: negotiated
});
if (options?.signal?.aborted) {
const reason = options.signal.reason;
throw reason instanceof SdkError ? reason : new SdkError(SdkErrorCode.RequestTimeout, String(reason));
}
const requestAbort = new AbortController();
const listenId = `listen:${this._nextListenId++}`;
let state = "opening";
let ackTimer;
let onCallerAbort;
let resolveOpening;
let rejectOpening;
const opening = new Promise((resolve, reject) => {
resolveOpening = resolve;
rejectOpening = reject;
});
let resolveClosed;
const closed = new Promise((resolve) => {
resolveClosed = resolve;
});
const settle2 = (outcome) => {
if (state === "closed") return;
const wasOpening = state === "opening";
if (ackTimer !== void 0) {
clearTimeout(ackTimer);
ackTimer = void 0;
}
if ("ack" in outcome) {
state = "open";
resolveOpening(outcome.ack);
return;
}
state = "closed";
if (onCallerAbort !== void 0) options?.signal?.removeEventListener("abort", onCallerAbort);
this._listenState.delete(listenId);
requestAbort.abort();
resolveClosed(outcome.cause);
if (wasOpening) rejectOpening(outcome.error ?? new SdkError(SdkErrorCode.ConnectionClosed, "subscriptions/listen closed before the server acknowledged"));
};
const wireTeardown = async () => {
requestAbort.abort();
await this.notification({
method: "notifications/cancelled",
params: { requestId: listenId }
}).catch(() => {
});
};
const close = async () => {
if (state === "closed") return;
settle2({ cause: "local" });
await wireTeardown();
};
this._listenState.set(listenId, { settle: settle2 });
const ackTimeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
ackTimer = setTimeout(() => {
settle2({
cause: "remote",
error: new SdkError(SdkErrorCode.RequestTimeout, "subscriptions/listen ack timed out", { timeout: ackTimeout })
});
wireTeardown().catch(() => {
});
}, ackTimeout);
if (options?.signal) {
const callerSignal = options.signal;
onCallerAbort = () => {
if (state === "closed") return;
const reason = callerSignal.reason;
settle2({
cause: "local",
error: reason instanceof Error ? reason : new Error(String(reason ?? "Aborted"))
});
wireTeardown().catch(() => {
});
};
callerSignal.addEventListener("abort", onCallerAbort, { once: true });
}
const jsonrpcRequest = {
jsonrpc: "2.0",
id: listenId,
method: "subscriptions/listen",
params: {
_meta: { ...this._outboundMetaEnvelope() },
notifications: filter
}
};
const routeSendFailure = (error62) => {
settle2({
cause: "remote",
error: error62 instanceof Error ? error62 : new Error(String(error62))
});
};
try {
this.transport.send(jsonrpcRequest, {
requestSignal: requestAbort.signal,
onRequestStreamEnd: () => settle2({
cause: "remote",
error: /* @__PURE__ */ new Error("subscriptions/listen: stream ended")
})
}).catch(routeSendFailure);
} catch (error62) {
routeSendFailure(error62);
}
return {
honoredFilter: await opening,
close,
closed
};
}
/**
* The subscription auto-opened by `ClientOptions.listChanged` on a modern
* connection — the listen filter is the intersection of the configured
* sub-options and the server-advertised `listChanged` capabilities.
* `undefined` on a legacy connection, before connect, or when that
* intersection is empty (auto-open skipped). Exposed so the consumer can
* `close()` it.
*/
get autoOpenedSubscription() {
return this._autoOpenedSubscription;
}
/**
* Transport-level demux for `subscriptions/listen` notifications, before
* any decoding/era-gating/handler dispatch. Consumes the leading
* `notifications/subscriptions/acknowledged` referencing a live
* subscription id (resolves the ack waiter) and an inbound
* `notifications/cancelled` referencing a live string-typed subscription
* id (server-side teardown on stdio). Change notifications carrying a
* subscription id pass through to the existing registered handlers via
* `super`. An unmatched ack/cancelled is NOT consumed: it reaches
* `setNotificationHandler` / `fallbackNotificationHandler` instead of
* being silently swallowed.
*/
_onnotification(raw, extra) {
const evicted = Object.hasOwn(LIST_CHANGED_EVICTIONS, raw.method) ? LIST_CHANGED_EVICTIONS[raw.method] : void 0;
if (raw.method === "notifications/resources/updated") {
const uri = raw.params?.uri;
if (typeof uri === "string") this._cache.evictKey("resources/read", uri);
} else if (evicted !== void 0) for (const method of evicted) this._cache.evict(method);
if (raw.method === "notifications/subscriptions/acknowledged") {
const subscriptionId = raw.params?._meta?.[SUBSCRIPTION_ID_META_KEY];
const entry = typeof subscriptionId === "string" ? this._listenState.get(subscriptionId) : void 0;
if (entry !== void 0) {
const honored = this._wireCodec().validateNotification("notifications/subscriptions/acknowledged", raw);
entry.settle({ ack: honored.ok ? honored.value.params.notifications : {} });
return;
}
}
if (raw.method === "notifications/cancelled") {
const cancelledId = raw.params?.requestId;
const entry = typeof cancelledId === "string" ? this._listenState.get(cancelledId) : void 0;
if (entry !== void 0) {
entry.settle({
cause: "remote",
error: /* @__PURE__ */ new Error("subscriptions/listen: server cancelled the subscription")
});
return;
}
}
super._onnotification(raw, extra);
}
/**
* Transport-level demux for `subscriptions/listen` responses. A JSON-RPC
* ERROR for the listen id is the server's pre-ack capacity/params
* rejection; a JSON-RPC RESULT for the listen id is the spec's
* `SubscriptionsListenResult` — the server's GRACEFUL-close signal (sent
* on shutdown). A string-id response that matches a live `_listenState`
* entry is consumed here (Protocol's `_responseHandlers` map is keyed by
* NUMBER and never holds a listen id, so passing a string-id response
* through would surface as "unknown message ID" via `onerror`).
*/
_onresponse(response) {
const id = response.id;
const entry = typeof id === "string" ? this._listenState.get(id) : void 0;
if (entry !== void 0) {
if (isJSONRPCErrorResponse(response)) entry.settle({
cause: "remote",
error: ProtocolError.fromError(response.error.code, response.error.message, response.error.data)
});
else entry.settle({
cause: "graceful",
error: new SdkError(SdkErrorCode.ConnectionClosed, "subscriptions/listen: server closed the subscription gracefully before acknowledging")
});
return;
}
super._onresponse(response);
}
/**
* Settle every live per-listen state machine on a transport-initiated
* close (the server dropping the connection on stdio/InMemory) before
* Protocol's `_onclose` tears the transport down. The base
* `_responseHandlers` settlement does not reach `_listenState` (listen
* ids are never registered there), so without this override a remote
* close would leave an in-flight `listen()` / open `McpSubscription`
* hanging.
*/
_onclose() {
if (this._listenState.size > 0) {
const reason = new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed");
for (const entry of this._listenState.values()) entry.settle({
cause: "remote",
error: reason
});
this._listenState.clear();
}
super._onclose();
}
/**
* Calls a tool on the connected server and returns the result. Automatically validates structured output
* if the tool has an `outputSchema`.
*
* Tool results have two error surfaces: `result.isError` for tool-level failures (the tool ran but reported
* a problem), and thrown {@linkcode ProtocolError} for protocol-level failures or {@linkcode SdkError} for
* SDK-level issues (timeouts, missing capabilities).
*
* @example Basic usage
* ```ts source="./client.examples.ts#Client_callTool_basic"
* const result = await client.callTool({
* name: 'calculate-bmi',
* arguments: { weightKg: 70, heightM: 1.75 }
* });
*
* // Tool-level errors are returned in the result, not thrown
* if (result.isError) {
* console.error('Tool error:', result.content);
* return;
* }
*
* console.log(result.content);
* ```
*
* @example Structured output
* ```ts source="./client.examples.ts#Client_callTool_structuredOutput"
* const result = await client.callTool({
* name: 'calculate-bmi',
* arguments: { weightKg: 70, heightM: 1.75 }
* });
*
* // Machine-readable output for the client application. SEP-2106: structuredContent is
* // `unknown` (any JSON value). Check for presence with `!== undefined` and narrow before use.
* if (result.structuredContent !== undefined) {
* const sc: unknown = result.structuredContent; // e.g. { bmi: 22.86 }
* if (typeof sc === 'object' && sc !== null && 'bmi' in sc) {
* console.log(sc.bmi);
* }
* }
* ```
*/
async callTool(params, options) {
const mirroringActive = this.getProtocolEra() === "modern" && detectProbeEnvironment() !== "browser";
const buildSendOptions = async () => {
if (!mirroringActive) return options;
let scan;
try {
scan = await this._resolveXMcpHeaderScan(params.name, options?.toolDefinition);
} catch (error62) {
this._reportStoreError(error62);
}
if (!scan?.valid || scan.declarations.length === 0) return options;
const paramHeaders = buildMcpParamHeaders(scan.declarations, params.arguments);
return Object.keys(paramHeaders).length === 0 ? options : {
...options,
headers: {
...options?.headers,
...paramHeaders
}
};
};
let compiled = options?.toolDefinition === void 0 ? await this._cache.outputValidator(params.name, (tool) => this._compileOutputValidator(tool)).catch((error62) => void this._reportStoreError(error62)) : this._compileOutputValidator(options.toolDefinition);
const assertCompiled = () => {
if (compiled === void 0 || compiled.ok) return;
const err = compiled.compileError;
const message = (err instanceof Error ? err.message : String(err)).slice(0, 200);
throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool '${params.name}' has an invalid outputSchema: ${message}`);
};
assertCompiled();
let result;
try {
result = await this.request({
method: "tools/call",
params
}, await buildSendOptions());
} catch (error62) {
const isHeaderMismatch = error62 instanceof ProtocolError && error62.code === HEADER_MISMATCH_ERROR_CODE;
if (!mirroringActive || !isHeaderMismatch || options?.toolDefinition !== void 0) throw error62;
const refreshOptions = {
signal: options?.signal,
timeout: options?.timeout,
cacheMode: "refresh"
};
await this._cache.evict("tools/list");
await this.listTools(void 0, refreshOptions).catch((error_) => this._reportStoreError(error_));
compiled = await this._cache.outputValidator(params.name, (tool) => this._compileOutputValidator(tool)).catch((error_) => void this._reportStoreError(error_));
assertCompiled();
result = await this.request({
method: "tools/call",
params
}, await buildSendOptions());
}
const validator = compiled !== void 0 && compiled.ok ? compiled.validator : void 0;
if (validator) {
if (result.structuredContent === void 0 && !result.isError) throw new ProtocolError(ProtocolErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
if (result.structuredContent !== void 0 && !result.isError) try {
const validationResult = validator(result.structuredContent);
if (!validationResult.valid) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
} catch (error62) {
if (error62 instanceof ProtocolError) throw error62;
throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Failed to validate structured content: ${error62 instanceof Error ? error62.message : String(error62)}`);
}
}
return result;
}
/**
* Lists available tools.
*
* Called without a `cursor` (the common case), this walks every page and
* returns the complete aggregated list with no `nextCursor`; the
* aggregate is also written to the {@linkcode ResponseCacheStore} (the
* source for {@linkcode callTool | callTool()}'s output-schema validation
* and SEP-2243 `Mcp-Param-*` header mirroring). Pass an explicit
* `{ cursor }` to fetch a single page and walk pagination yourself — the
* per-page path returns the server's raw page (with `nextCursor` for the
* next call) and does not write the response cache. The auto-aggregate
* path is capped by {@linkcode ClientOptions | ClientOptions.listMaxPages} (default 64);
* the per-page path is not.
*
* Returns an empty list if the server does not advertise tools capability
* (or throws if {@linkcode ClientOptions.enforceStrictCapabilities} is enabled).
*
* @example
* ```ts source="./client.examples.ts#Client_listTools_pagination"
* // No cursor → all pages aggregated for you.
* const { tools } = await client.listTools();
* console.log(
* 'Available tools:',
* tools.map(t => t.name)
* );
* ```
*/
async listTools(params, options) {
if (!this._serverCapabilities?.tools && !this._enforceStrictCapabilities) {
console.debug("Client.listTools() called but server does not advertise tools capability - returning empty list");
return { tools: [] };
}
if (params?.cursor !== void 0) {
const page = await this.request({
method: "tools/list",
params
}, options);
this._excludeInvalidXMcpHeaderTools(page);
return page;
}
const hit = await this._serveFromCache("tools/list", void 0, options);
if (hit !== void 0) return hit;
return this._listAllPages("tools/list", params, options, (r) => r.tools, (acc) => this._excludeInvalidXMcpHeaderTools(acc));
}
/**
* SEP-2243 (protocol revision 2026-07-28): a Streamable HTTP client MUST
* exclude tool definitions whose `x-mcp-header` declarations violate the
* constraints, and SHOULD log a warning naming the tool and the reason.
* Applied to the CACHED aggregated `tools/list` result (so the entry
* mirroring reads never holds an unmirrorable tool) AND to every public
* per-page {@linkcode listTools | listTools()} return (the spec's MUST
* has no carve-out for paginated reads). The gate is era-only on
* non-stdio transports — `detectProbeTransportKind` cannot distinguish a
* real HTTP transport from in-memory/custom transports (it only
* positively recognizes stdio), and over-excluding on a non-HTTP modern
* connection is harmless: those transports never carry per-request
* headers, so an excluded tool would have been uncallable on a Streamable
* HTTP arm of the same server. Mutates `result.tools` in place.
*/
_excludeInvalidXMcpHeaderTools(result) {
if (this.getProtocolEra() !== "modern" || !this.transport || detectProbeTransportKind(this.transport) === "stdio") return;
const filtered = result.tools.filter((tool) => {
const scan = scanXMcpHeaderDeclarations(tool.inputSchema);
if (!scan.valid) {
console.warn(`[mcp-sdk] excluding tool '${tool.name}' from tools/list: invalid x-mcp-header declaration \u2014 ${scan.reason}`);
return false;
}
return true;
});
if (filtered.length !== result.tools.length) result.tools = filtered;
}
/**
* Set up a single list changed handler.
* @internal
*/
_setupListChangedHandler(listType, notificationMethod, options, fetcher) {
const parseResult = parseSchema(ListChangedOptionsBaseSchema, options);
if (!parseResult.success) throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
if (typeof options.onChanged !== "function") throw new TypeError(`Invalid ${listType} listChanged options: onChanged must be a function`);
const { autoRefresh, debounceMs } = parseResult.data;
const { onChanged } = options;
const refresh = async () => {
if (!autoRefresh) {
onChanged(null, null);
return;
}
try {
onChanged(null, await fetcher());
} catch (error62) {
onChanged(error62 instanceof Error ? error62 : new Error(String(error62)), null);
}
};
const handler = () => {
if (debounceMs) {
const existingTimer = this._listChangedDebounceTimers.get(listType);
if (existingTimer) clearTimeout(existingTimer);
const timer = setTimeout(refresh, debounceMs);
this._listChangedDebounceTimers.set(listType, timer);
} else refresh();
};
this.setNotificationHandler(notificationMethod, handler);
}
/**
* Notifies the server that the client's root list has changed. Requires the `roots.listChanged` capability.
*
* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
* Remains functional during the deprecation window (at least twelve months).
* Migrate to passing paths via tool parameters, resource URIs, or configuration.
*/
async sendRootsListChanged() {
return this.notification({ method: "notifications/roots/list_changed" });
}
};
// node_modules/.pnpm/eventsource-parser@3.1.1/node_modules/eventsource-parser/dist/index.js
var ParseError = class extends Error {
constructor(message, options) {
super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
}
};
var LF = 10;
var CR = 13;
var SPACE = 32;
function noop(_arg) {
}
function createParser(config2) {
if (typeof config2 == "function")
throw new TypeError(
"`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
);
const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config2, pendingFragments = [];
let pendingFragmentsLength = 0, isFirstChunk = true, id, data = "", dataLines = 0, eventType, terminated = false;
function feed(chunk) {
if (terminated)
throw new Error(
"Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
);
if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
const trailing2 = processLines(chunk);
trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
return;
}
if (chunk.indexOf(`
`) === -1 && chunk.indexOf("\r") === -1) {
pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
return;
}
pendingFragments.push(chunk);
const input2 = pendingFragments.join("");
pendingFragments.length = 0, pendingFragmentsLength = 0;
const trailing = processLines(input2);
trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
}
function checkBufferSize() {
maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
type: "max-buffer-size-exceeded"
})
)));
}
function processLines(chunk) {
let searchIndex = 0;
if (chunk.indexOf("\r") === -1) {
let lfIndex = chunk.indexOf(`
`, searchIndex);
for (; lfIndex !== -1; ) {
if (searchIndex === lfIndex) {
dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
`, searchIndex);
continue;
}
const firstCharCode = chunk.charCodeAt(searchIndex);
if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
`, searchIndex);
continue;
}
data = dataLines === 0 ? value : `${data}
${value}`, dataLines++;
} else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
lfIndex
) || void 0 : parseLine(chunk, searchIndex, lfIndex);
searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
`, searchIndex);
}
return chunk.slice(searchIndex);
}
for (; searchIndex < chunk.length; ) {
const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
`, searchIndex);
let lineEnd = -1;
if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
break;
parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
}
return chunk.slice(searchIndex);
}
function parseLine(chunk, start, end) {
if (start === end) {
dispatchEvent();
return;
}
const firstCharCode = chunk.charCodeAt(start);
if (isDataPrefix(chunk, start, firstCharCode)) {
const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
data = dataLines === 0 ? value2 : `${data}
${value2}`, dataLines++;
return;
}
if (isEventPrefix(chunk, start, firstCharCode)) {
eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
return;
}
if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
value2.includes("\0") || (id = value2);
return;
}
if (firstCharCode === 58) {
if (onComment) {
const line2 = chunk.slice(start, end);
onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
}
return;
}
const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
if (fieldSeparatorIndex === -1) {
processField(line, "", line);
return;
}
const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
processField(field, value, line);
}
function processField(field, value, line) {
switch (field) {
case "event":
eventType = value || void 0;
break;
case "data":
data = dataLines === 0 ? value : `${data}
${value}`, dataLines++;
break;
case "id":
value.includes("\0") || (id = value);
break;
case "retry":
/^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
new ParseError(`Invalid \`retry\` value: "${value}"`, {
type: "invalid-retry",
value,
line
})
);
break;
default:
onError(
new ParseError(
`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
{ type: "unknown-field", field, value, line }
)
);
break;
}
}
function dispatchEvent() {
dataLines > 0 && onEvent({
id,
event: eventType,
data
}), id = void 0, data = "", dataLines = 0, eventType = void 0;
}
function reset(options = {}) {
if (options.consume && pendingFragments.length > 0) {
const incompleteLine = pendingFragments.join("");
parseLine(incompleteLine, 0, incompleteLine.length);
}
isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
}
return { feed, reset };
}
function isDataPrefix(chunk, i, firstCharCode) {
return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
}
function isEventPrefix(chunk, i, firstCharCode) {
return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
}
// node_modules/.pnpm/eventsource@3.0.7/node_modules/eventsource/dist/index.js
var ErrorEvent = class extends Event {
/**
* Constructs a new `ErrorEvent` instance. This is typically not called directly,
* but rather emitted by the `EventSource` object when an error occurs.
*
* @param type - The type of the event (should be "error")
* @param errorEventInitDict - Optional properties to include in the error event
*/
constructor(type, errorEventInitDict) {
var _a3, _b;
super(type), this.code = (_a3 = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a3 : void 0, this.message = (_b = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b : void 0;
}
/**
* Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
* when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
* we explicitly include the properties in the `inspect` method.
*
* This is automatically called by Node.js when you `console.log` an instance of this class.
*
* @param _depth - The current depth
* @param options - The options passed to `util.inspect`
* @param inspect - The inspect function to use (prevents having to import it from `util`)
* @returns A string representation of the error
*/
[Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
return inspect(inspectableError(this), options);
}
/**
* Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
* when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
* we explicitly include the properties in the `inspect` method.
*
* This is automatically called by Deno when you `console.log` an instance of this class.
*
* @param inspect - The inspect function to use (prevents having to import it from `util`)
* @param options - The options passed to `Deno.inspect`
* @returns A string representation of the error
*/
[Symbol.for("Deno.customInspect")](inspect, options) {
return inspect(inspectableError(this), options);
}
};
function syntaxError(message) {
const DomException = globalThis.DOMException;
return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
}
function flattenError2(err) {
return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError2).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError2(err.cause)}` : err.message : `${err}`;
}
function inspectableError(err) {
return {
type: err.type,
message: err.message,
code: err.code,
defaultPrevented: err.defaultPrevented,
cancelable: err.cancelable,
timeStamp: err.timeStamp
};
}
var __typeError = (msg) => {
throw TypeError(msg);
};
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
var _readyState;
var _url2;
var _redirectUrl;
var _withCredentials;
var _fetch;
var _reconnectInterval;
var _reconnectTimer;
var _lastEventId;
var _controller;
var _parser;
var _onError;
var _onMessage;
var _onOpen;
var _EventSource_instances;
var connect_fn;
var _onFetchResponse;
var _onFetchError;
var getRequestOptions_fn;
var _onEvent;
var _onRetryChange;
var failConnection_fn;
var scheduleReconnect_fn;
var _reconnect;
var EventSource = class extends EventTarget {
constructor(url2, eventSourceInitDict) {
var _a3, _b;
super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url2), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
var _a22;
__privateGet(this, _parser).reset();
const { body, redirected, status, headers } = response;
if (status === 204) {
__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
return;
}
if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
return;
}
if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
return;
}
if (__privateGet(this, _readyState) === this.CLOSED)
return;
__privateSet(this, _readyState, this.OPEN);
const openEvent = new Event("open");
if ((_a22 = __privateGet(this, _onOpen)) == null || _a22.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
__privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
return;
}
const decoder = new TextDecoder(), reader = body.getReader();
let open3 = true;
do {
const { done, value } = await reader.read();
value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open3 = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
} while (open3);
}), __privateAdd(this, _onFetchError, (err) => {
__privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError2(err));
}), __privateAdd(this, _onEvent, (event) => {
typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
const messageEvent = new MessageEvent(event.event || "message", {
data: event.data,
origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url2).origin,
lastEventId: event.id || ""
});
__privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
}), __privateAdd(this, _onRetryChange, (value) => {
__privateSet(this, _reconnectInterval, value);
}), __privateAdd(this, _reconnect, () => {
__privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
});
try {
if (url2 instanceof URL)
__privateSet(this, _url2, url2);
else if (typeof url2 == "string")
__privateSet(this, _url2, new URL(url2, getBaseURL()));
else
throw new Error("Invalid URL");
} catch {
throw syntaxError("An invalid or illegal string was specified");
}
__privateSet(this, _parser, createParser({
onEvent: __privateGet(this, _onEvent),
onRetry: __privateGet(this, _onRetryChange)
})), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a3 = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a3 : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
}
/**
* Returns the state of this EventSource object's connection. It can have the values described below.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
*
* Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
* defined in the TypeScript `dom` library.
*
* @public
*/
get readyState() {
return __privateGet(this, _readyState);
}
/**
* Returns the URL providing the event stream.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
*
* @public
*/
get url() {
return __privateGet(this, _url2).href;
}
/**
* Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
*/
get withCredentials() {
return __privateGet(this, _withCredentials);
}
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
get onerror() {
return __privateGet(this, _onError);
}
set onerror(value) {
__privateSet(this, _onError, value);
}
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
get onmessage() {
return __privateGet(this, _onMessage);
}
set onmessage(value) {
__privateSet(this, _onMessage, value);
}
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
get onopen() {
return __privateGet(this, _onOpen);
}
set onopen(value) {
__privateSet(this, _onOpen, value);
}
addEventListener(type, listener, options) {
const listen = listener;
super.addEventListener(type, listen, options);
}
removeEventListener(type, listener, options) {
const listen = listener;
super.removeEventListener(type, listen, options);
}
/**
* Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
*
* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
*
* @public
*/
close() {
__privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
}
};
_readyState = /* @__PURE__ */ new WeakMap(), _url2 = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /**
* Connect to the given URL and start receiving events
*
* @internal
*/
connect_fn = function() {
__privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url2), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
}, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /**
* Get request options for the `fetch()` request
*
* @returns The request options
* @internal
*/
getRequestOptions_fn = function() {
var _a3;
const init = {
// [spec] Let `corsAttributeState` be `Anonymous`…
// [spec] …will have their mode set to "cors"…
mode: "cors",
redirect: "follow",
headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0 },
cache: "no-store",
signal: (_a3 = __privateGet(this, _controller)) == null ? void 0 : _a3.signal
};
return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
}, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /**
* Handles the process referred to in the EventSource specification as "failing a connection".
*
* @param error - The error causing the connection to fail
* @param code - The HTTP status code, if available
* @internal
*/
failConnection_fn = function(message, code) {
var _a3;
__privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
const errorEvent = new ErrorEvent("error", { code, message });
(_a3 = __privateGet(this, _onError)) == null || _a3.call(this, errorEvent), this.dispatchEvent(errorEvent);
}, /**
* Schedules a reconnection attempt against the EventSource endpoint.
*
* @param message - The error causing the connection to fail
* @param code - The HTTP status code, if available
* @internal
*/
scheduleReconnect_fn = function(message, code) {
var _a3;
if (__privateGet(this, _readyState) === this.CLOSED)
return;
__privateSet(this, _readyState, this.CONNECTING);
const errorEvent = new ErrorEvent("error", { code, message });
(_a3 = __privateGet(this, _onError)) == null || _a3.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
}, _reconnect = /* @__PURE__ */ new WeakMap(), /**
* ReadyState representing an EventSource currently trying to connect
*
* @public
*/
EventSource.CONNECTING = 0, /**
* ReadyState representing an EventSource connection that is open (eg connected)
*
* @public
*/
EventSource.OPEN = 1, /**
* ReadyState representing an EventSource connection that is closed (eg disconnected)
*
* @public
*/
EventSource.CLOSED = 2;
function getBaseURL() {
const doc = "document" in globalThis ? globalThis.document : void 0;
return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
}
// node_modules/.pnpm/eventsource-parser@3.1.1/node_modules/eventsource-parser/dist/stream.js
var EventSourceParserStream = class extends TransformStream {
constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
let parser;
super({
start(controller) {
parser = createParser({
onEvent: (event) => {
controller.enqueue(event);
},
onError(error62) {
typeof onError == "function" && onError(error62), (onError === "terminate" || error62.type === "max-buffer-size-exceeded") && controller.error(error62);
},
onRetry,
onComment,
maxBufferSize
});
},
transform(chunk) {
parser.feed(chunk);
}
});
}
};
// node_modules/.pnpm/@modelcontextprotocol+client@2.4.0/node_modules/@modelcontextprotocol/client/dist/index.mjs
function hasDpopChallenge(wwwAuthenticate) {
return /(?:^|,)\s*dpop(?:\s|$|,)/i.test(wwwAuthenticate);
}
function isDpopNonceChallenge(response) {
if (response.status !== 401) return false;
const wwwAuthenticate = response.headers.get("www-authenticate") ?? "";
return hasDpopChallenge(wwwAuthenticate) && /use_dpop_nonce/i.test(wwwAuthenticate);
}
var withDpop = (session, getToken) => (next) => {
const resolveSession = typeof session === "function" ? session : () => session;
return async (input2, init) => {
const method = (init?.method ?? "GET").toUpperCase();
const url2 = new URL(input2.toString());
const activeSession = await resolveSession();
if (!activeSession) return next(input2, init);
const makeRequest = async () => {
const accessToken = await getToken();
if (!accessToken) return next(input2, init);
const headers = new Headers(init?.headers);
const proof = await activeSession.buildProof({
htm: method,
htu: url2,
accessToken
});
headers.set("Authorization", `DPoP ${accessToken}`);
headers.set("DPoP", proof);
return next(input2, {
...init,
headers
});
};
let response = await makeRequest();
if (isDpopNonceChallenge(response) && response.headers.has("dpop-nonce")) {
activeSession.observeNonce(response, url2);
await response.text?.().catch(() => {
});
response = await makeRequest();
}
activeSession.observeNonce(response, url2);
return response;
};
};
var withDpopFromProvider = (provider) => withDpop(async () => {
try {
return await provider.dpop?.();
} catch (error62) {
throw markAuthSeamEscape(error62);
}
}, async () => {
let tokens;
try {
tokens = await provider.tokens();
} catch (error62) {
throw markAuthSeamEscape(error62);
}
return tokens?.token_type?.toLowerCase() === "dpop" ? tokens.access_token : void 0;
});
var SseError = class extends Error {
static {
Object.defineProperty(this, "mcpBrand", { value: "mcp.SseError" });
}
static [Symbol.hasInstance](value) {
return brandedHasInstance(this, value);
}
/**
* Brand-based type guard: equivalent to `value instanceof this`, as an
* explicit static predicate (the axios/AWS-SDK `isInstance` style). Reads
* the caller's own brand via `this`, so every branded subclass gets a
* correctly-scoped guard by inheritance. Must be invoked on the class —
* in callback position write `v => SdkError.isInstance(v)`, not
* `.filter(SdkError.isInstance)` (detached calls throw rather than
* silently matching nothing).
*/
static isInstance(value) {
if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
return brandedHasInstance(this, value);
}
constructor(code, message, event) {
super(`SSE error: ${message}`);
this.code = code;
this.event = event;
stampErrorBrands(this, new.target);
}
};
var SSEClientTransport = class {
_eventSource;
_endpoint;
_abortController;
_url;
_resourceMetadataUrl;
_scope;
_eventSourceInit;
_requestInit;
_authProvider;
_oauthProvider;
_skipIssuerMetadataValidation;
_fetch;
_fetchWithInit;
_redirectPolicy;
_dpop;
_protocolVersion;
onclose;
onerror;
onmessage;
constructor(url2, opts) {
this._url = url2;
this._resourceMetadataUrl = void 0;
this._scope = void 0;
this._eventSourceInit = opts?.eventSourceInit;
this._requestInit = opts?.requestInit;
this._skipIssuerMetadataValidation = opts?.skipIssuerMetadataValidation;
this._fetch = opts?.fetch;
if (isOAuthClientProvider(opts?.authProvider)) {
this._oauthProvider = opts.authProvider;
this._authProvider = adaptOAuthProvider(opts.authProvider, { skipIssuerMetadataValidation: opts.skipIssuerMetadataValidation });
if (opts.authProvider.dpop) {
this._dpop = withDpopFromProvider(opts.authProvider);
this._fetch = this._dpop(opts.fetch ?? fetch);
}
} else this._authProvider = opts?.authProvider;
this._redirectPolicy = opts?.redirectPolicy;
this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
if (this._redirectPolicy === "follow") this._fetchWithInit = fetchLeavingRedirects(this._fetchWithInit);
}
_last401Response;
_connectAuthRetried = false;
/** `baseFetch` with redirects handled as `redirectPolicy` says. */
_redirects(baseFetch) {
return this._redirectPolicy === "follow" ? baseFetch : fetchWithinOrigin(baseFetch);
}
/** Error text for a redirect `response` that was not followed, or `undefined` for any other response. */
_unfollowedRedirect(url2, response) {
const text = this._redirectPolicy === "follow" ? void 0 : unfollowedRedirect(url2, response);
return text && `${text} (redirectPolicy: 'same-origin')`;
}
async _commonHeaders() {
const headers = new Headers(this._requestInit?.headers || void 0);
let token;
try {
token = await this._authProvider?.token();
} catch (error62) {
throw markAuthSeamEscape(error62);
}
if (token) headers.set("Authorization", `Bearer ${token}`);
if (this._protocolVersion) headers.set("mcp-protocol-version", this._protocolVersion);
return headers;
}
_startOrAuth() {
const eventSourceFetch = this._eventSourceInit?.fetch;
const fetchImpl = this._redirects(eventSourceFetch ? this._dpop?.(eventSourceFetch) ?? eventSourceFetch : this._fetch ?? fetch);
let redirect;
return new Promise((resolve, reject) => {
this._eventSource = new EventSource(this._url.href, {
...this._eventSourceInit,
fetch: async (url2, init) => {
const headers = await this._commonHeaders();
headers.set("Accept", "text/event-stream");
const response = await fetchImpl(url2, {
...init,
headers
});
redirect = this._unfollowedRedirect(url2, response);
if (response.status === 401) {
this._last401Response = response;
if (response.headers.has("www-authenticate")) {
const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
this._resourceMetadataUrl = resourceMetadataUrl;
this._scope = scope;
}
}
return response;
}
});
this._abortController = new AbortController();
this._eventSource.onerror = (event) => {
if (event.code === 401 && this._authProvider) {
if (this._authProvider.onUnauthorized && this._last401Response && !this._connectAuthRetried) {
const response = this._last401Response;
this._last401Response = void 0;
this._connectAuthRetried = true;
this._eventSource?.close();
this._authProvider.onUnauthorized({
response,
serverUrl: this._url,
fetchFn: this._fetchWithInit
}).then(() => this._startOrAuth().then(resolve, reject), (error$2) => {
this._connectAuthRetried = false;
markAuthSeamEscape(error$2);
this.onerror?.(error$2);
reject(error$2);
});
return;
}
const retried = this._connectAuthRetried;
this._connectAuthRetried = false;
const error$1 = markAuthSeamEscape(retried ? new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
status: 401,
statusText: this._last401Response?.statusText ?? ""
}) : new UnauthorizedError());
this._last401Response = void 0;
reject(error$1);
this.onerror?.(error$1);
return;
}
this._connectAuthRetried = false;
const error62 = new SseError(event.code, redirect ?? event.message, event);
reject(error62);
this.onerror?.(error62);
};
this._eventSource.onopen = () => {
this._connectAuthRetried = false;
};
this._eventSource.addEventListener("endpoint", (event) => {
const messageEvent = event;
try {
this._endpoint = new URL(messageEvent.data, this._url);
if (this._endpoint.origin !== this._url.origin) throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`);
} catch (error62) {
reject(error62);
this.onerror?.(error62);
this.close();
return;
}
resolve();
});
this._eventSource.onmessage = (event) => {
const messageEvent = event;
let message;
try {
message = JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
} catch (error62) {
this.onerror?.(error62);
return;
}
this.onmessage?.(message);
};
});
}
async start() {
if (this._eventSource) throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.");
return await this._startOrAuth();
}
async finishAuth(codeOrParams, iss) {
if (!this._oauthProvider) throw new UnauthorizedError("finishAuth requires an OAuthClientProvider");
const { authorizationCode, iss: issParam } = await resolveAuthorizationCallbackParams(codeOrParams, iss, this._oauthProvider, this._url, {
fetchFn: this._fetchWithInit,
resourceMetadataUrl: this._resourceMetadataUrl
});
if (await auth(this._oauthProvider, {
serverUrl: this._url,
authorizationCode,
iss: issParam,
resourceMetadataUrl: this._resourceMetadataUrl,
scope: this._scope,
fetchFn: this._fetchWithInit,
skipIssuerMetadataValidation: this._skipIssuerMetadataValidation
}) !== "AUTHORIZED") throw new UnauthorizedError("Failed to authorize");
}
async close() {
this._abortController?.abort();
this._eventSource?.close();
this.onclose?.();
}
async send(message) {
return this._send(message, false);
}
async _send(message, isAuthRetry) {
if (!this._endpoint) throw new SdkError(SdkErrorCode.NotConnected, "Not connected");
try {
const headers = await this._commonHeaders();
headers.set("content-type", "application/json");
const init = {
...this._requestInit,
method: "POST",
headers,
body: JSON.stringify(message),
signal: this._abortController?.signal
};
const response = await this._redirects(this._fetch ?? fetch)(this._endpoint, init);
if (!response.ok) {
if (response.status === 401 && this._authProvider) {
if (response.headers.has("www-authenticate")) {
const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
this._resourceMetadataUrl = resourceMetadataUrl;
this._scope = scope;
}
if (this._authProvider.onUnauthorized && !isAuthRetry) {
try {
await this._authProvider.onUnauthorized({
response,
serverUrl: this._url,
fetchFn: this._fetchWithInit
});
} catch (error62) {
throw markAuthSeamEscape(error62);
}
await response.text?.().catch(() => {
});
return this._send(message, true);
}
await response.text?.().catch(() => {
});
if (isAuthRetry) throw markAuthSeamEscape(new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
status: 401,
statusText: response.statusText
}));
throw markAuthSeamEscape(new UnauthorizedError());
}
const text = await response.text?.().catch(() => null);
throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${this._unfollowedRedirect(this._endpoint, response) ?? text}`);
}
await response.text?.().catch(() => {
});
} catch (error62) {
this.onerror?.(error62);
throw error62;
}
}
setProtocolVersion(version3) {
this._protocolVersion = version3;
}
};
var DEFAULT_MAX_STEP_UP_RETRIES = 1;
var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
initialReconnectionDelay: 1e3,
maxReconnectionDelay: 3e4,
reconnectionDelayGrowFactor: 1.5,
maxRetries: 2
};
var RESERVED_REQUEST_HEADER_NAMES = /* @__PURE__ */ new Set([
"authorization",
"dpop",
"content-type",
"mcp-protocol-version",
"mcp-method",
"mcp-name",
"mcp-session-id"
]);
function anySignal(a, b) {
if (typeof AbortSignal.any === "function") return AbortSignal.any([a, b]);
const controller = new AbortController();
if (a.aborted) return controller.abort(a.reason), controller.signal;
if (b.aborted) return controller.abort(b.reason), controller.signal;
const cleanup = () => {
a.removeEventListener("abort", onA);
b.removeEventListener("abort", onB);
};
function onA() {
cleanup();
controller.abort(a.reason);
}
function onB() {
cleanup();
controller.abort(b.reason);
}
a.addEventListener("abort", onA, { once: true });
b.addEventListener("abort", onB, { once: true });
return controller.signal;
}
var StreamableHTTPClientTransport = class {
_abortController;
_url;
_resourceMetadataUrl;
_scope;
_requestInit;
_authProvider;
_oauthProvider;
_skipIssuerMetadataValidation;
_fetch;
_fetchWithInit;
_redirectPolicy;
_sessionId;
_reconnectionOptions;
_protocolVersion;
_onInsufficientScope;
_maxStepUpRetries;
_serverRetryMs;
_reconnectionScheduler;
_cancelReconnection;
onclose;
onerror;
onmessage;
/**
* Streamable HTTP opens one POST (and SSE response stream) per outbound
* request and honors `TransportSendOptions.requestSignal`. On a 2026-era
* connection the protocol layer aborts that per-request stream as the
* spec cancellation signal instead of POSTing `notifications/cancelled`.
*/
hasPerRequestStream = true;
constructor(url2, opts) {
this._url = url2;
this._resourceMetadataUrl = void 0;
this._scope = void 0;
this._requestInit = opts?.requestInit;
this._skipIssuerMetadataValidation = opts?.skipIssuerMetadataValidation;
this._fetch = opts?.fetch;
if (isOAuthClientProvider(opts?.authProvider)) {
this._oauthProvider = opts.authProvider;
this._authProvider = adaptOAuthProvider(opts.authProvider, { skipIssuerMetadataValidation: opts.skipIssuerMetadataValidation });
if (opts.authProvider.dpop) this._fetch = withDpopFromProvider(opts.authProvider)(opts.fetch ?? fetch);
} else this._authProvider = opts?.authProvider;
this._redirectPolicy = opts?.redirectPolicy;
this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
if (this._redirectPolicy === "follow") this._fetchWithInit = fetchLeavingRedirects(this._fetchWithInit);
this._sessionId = opts?.sessionId;
this._protocolVersion = opts?.protocolVersion;
this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
this._reconnectionScheduler = opts?.reconnectionScheduler;
this._onInsufficientScope = opts?.onInsufficientScope ?? "reauthorize";
this._maxStepUpRetries = Math.max(0, opts?.maxStepUpRetries ?? DEFAULT_MAX_STEP_UP_RETRIES);
}
/**
* SEP-2350 step-up: compute the union scope, decide whether refresh must be
* bypassed, and run {@linkcode auth}. Returns the auth result so the caller
* can decide whether to retry. Shared by the POST `_send` path and the GET
* `_startOrAuthSse` path so both apply the same `'throw'` short-circuit,
* the same superset-gated refresh bypass, and the same retry cap.
*/
async _stepUpAuthorize(challenge, stepUpRetries) {
try {
return await this._stepUpAuthorizeInner(challenge, stepUpRetries);
} catch (error62) {
throw markAuthSeamEscape(error62);
}
}
async _stepUpAuthorizeInner(challenge, stepUpRetries) {
if (this._onInsufficientScope === "throw") throw new InsufficientScopeError({
requiredScope: challenge.scope,
resourceMetadataUrl: challenge.resourceMetadataUrl,
errorDescription: challenge.errorDescription
});
if (!this._oauthProvider) throw new InsufficientScopeError({
requiredScope: challenge.scope,
resourceMetadataUrl: challenge.resourceMetadataUrl,
errorDescription: challenge.errorDescription
});
if (stepUpRetries >= this._maxStepUpRetries) throw new SdkHttpError(SdkErrorCode.ClientHttpForbidden, `Server returned 403 insufficient_scope after step-up re-authorization (retry limit ${this._maxStepUpRetries} reached)`, {
status: 403,
statusText: challenge.statusText ?? "Forbidden",
text: challenge.text
});
if (challenge.resourceMetadataUrl) this._resourceMetadataUrl = challenge.resourceMetadataUrl;
const tokens = await this._oauthProvider.tokens();
const unionScope = computeScopeUnion(this._scope, tokens?.scope, challenge.scope);
this._scope = unionScope;
const forceReauthorization = isStrictScopeSuperset(unionScope, tokens?.scope);
return auth(this._oauthProvider, {
serverUrl: this._url,
resourceMetadataUrl: this._resourceMetadataUrl,
scope: unionScope,
forceReauthorization,
fetchFn: this._fetchWithInit,
skipIssuerMetadataValidation: this._skipIssuerMetadataValidation
});
}
/** `baseFetch` with redirects handled as `redirectPolicy` says. */
_redirects(baseFetch) {
return this._redirectPolicy === "follow" ? baseFetch : fetchWithinOrigin(baseFetch);
}
/** Error text for a redirect `response` that was not followed, or `undefined` for any other response. */
_unfollowedRedirect(url2, response) {
const text = this._redirectPolicy === "follow" ? void 0 : unfollowedRedirect(url2, response);
return text && `${text} (redirectPolicy: 'same-origin')`;
}
async _commonHeaders() {
const headers = new Headers(this._requestInit?.headers || void 0);
let token;
try {
token = await this._authProvider?.token();
} catch (error62) {
throw markAuthSeamEscape(error62);
}
if (token) headers.set("Authorization", `Bearer ${token}`);
if (this._sessionId) headers.set("mcp-session-id", this._sessionId);
if (this._protocolVersion) headers.set("mcp-protocol-version", this._protocolVersion);
return headers;
}
/**
* Body-derived per-request headers: when an outgoing request carries a
* protocol-version claim in its `_meta` envelope (the version negotiation
* probe is the first such sender), `MCP-Protocol-Version` and `Mcp-Method`
* derive from the message itself. The connection-level version slot is
* neither consulted nor mutated; messages without an envelope claim are
* untouched, so no 2026 header can appear on a legacy exchange.
*/
_applyBodyDerivedHeaders(headers, message) {
if (Array.isArray(message) || !isJSONRPCRequest(message)) return;
const envelopeVersion = message.params?._meta?.[PROTOCOL_VERSION_META_KEY];
if (typeof envelopeVersion !== "string") return;
headers.set("mcp-protocol-version", envelopeVersion);
headers.set("mcp-method", message.method);
const source = mcpNameSource(message.method, message.params);
if (source?.value !== void 0) headers.set("mcp-name", encodeMcpParamValue(source.value));
}
/**
* `true` when the outbound message is a single request carrying a
* modern-era protocol-version envelope claim — the same predicate that
* gates body-derived `mcp-method`/`mcp-name` emission. Used to confine the
* 400-body-as-ProtocolError delivery to modern-era exchanges only.
*/
_isModernEnvelopedRequest(message) {
if (Array.isArray(message) || !isJSONRPCRequest(message)) return false;
const v = message.params?._meta?.[PROTOCOL_VERSION_META_KEY];
return typeof v === "string" && isModernProtocolVersion(v);
}
async _startOrAuthSse(options, isAuthRetry = false, stepUpRetries = 0) {
const { resumptionToken, requestSignal } = options;
const isIntentionalAbort = () => this._abortController?.signal.aborted === true || requestSignal?.aborted === true;
try {
const headers = await this._commonHeaders();
const types = [...headers.get("accept")?.split(",").map((s) => s.trim().toLowerCase()) ?? [], "text/event-stream"];
headers.set("accept", [...new Set(types)].join(", "));
if (resumptionToken) headers.set("last-event-id", resumptionToken);
const transportSignal = this._abortController?.signal;
const signal = requestSignal !== void 0 && transportSignal !== void 0 ? anySignal(transportSignal, requestSignal) : requestSignal ?? transportSignal;
const response = await this._redirects(this._fetch ?? fetch)(this._url, {
...this._requestInit,
method: "GET",
headers,
signal
});
if (!response.ok) {
if (response.status === 401 && this._authProvider) {
if (response.headers.has("www-authenticate")) {
const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
this._resourceMetadataUrl = resourceMetadataUrl;
this._scope = computeScopeUnion(this._scope, scope);
}
if (this._authProvider.onUnauthorized && !isAuthRetry) {
try {
await this._authProvider.onUnauthorized({
response,
serverUrl: this._url,
fetchFn: this._fetchWithInit
});
} catch (error62) {
throw markAuthSeamEscape(error62);
}
await response.text?.().catch(() => {
});
return this._startOrAuthSse(options, true, stepUpRetries);
}
await response.text?.().catch(() => {
});
if (isAuthRetry) throw markAuthSeamEscape(new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
status: 401,
statusText: response.statusText
}));
throw markAuthSeamEscape(new UnauthorizedError());
}
if (response.status === 403) {
const { resourceMetadataUrl, scope, error: error62, errorDescription } = extractWWWAuthenticateParams(response);
if (error62 === "insufficient_scope") {
const text = await response.text?.().catch(() => null);
if (await this._stepUpAuthorize({
scope,
resourceMetadataUrl,
errorDescription,
statusText: response.statusText,
text
}, stepUpRetries) !== "AUTHORIZED") throw markAuthSeamEscape(new UnauthorizedError());
return this._startOrAuthSse(options, isAuthRetry, stepUpRetries + 1);
}
}
await response.text?.().catch(() => {
});
if (response.status === 405) {
options.onRequestStreamEnd?.();
return;
}
const reason = this._unfollowedRedirect(this._url, response) ?? response.statusText;
throw new SdkHttpError(SdkErrorCode.ClientHttpFailedToOpenStream, `Failed to open SSE stream: ${reason}`, {
status: response.status,
statusText: response.statusText
});
}
this._handleSseStream(response.body, options, true);
} catch (error62) {
if (!isIntentionalAbort()) this.onerror?.(error62);
throw error62;
}
}
/**
* Calculates the next reconnection delay using a backoff algorithm
*
* @param attempt Current reconnection attempt count for the specific stream
* @returns Time to wait in milliseconds before next reconnection attempt
*/
_getNextReconnectionDelay(attempt) {
if (this._serverRetryMs !== void 0) return this._serverRetryMs;
const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
}
/**
* Schedule a reconnection attempt using server-provided retry interval or backoff
*
* @param lastEventId The ID of the last received event for resumability
* @param attemptCount Current reconnection attempt count for this specific stream
*/
_scheduleReconnection(options, attemptCount = 0) {
const maxRetries = this._reconnectionOptions.maxRetries;
if (attemptCount >= maxRetries) {
this.onerror?.(/* @__PURE__ */ new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
options.onRequestStreamEnd?.();
return;
}
const delay2 = this._getNextReconnectionDelay(attemptCount);
const reconnect = () => {
this._cancelReconnection = void 0;
if (this._abortController?.signal.aborted || options.requestSignal?.aborted) return;
this._startOrAuthSse(options).catch((error62) => {
if (this._abortController?.signal.aborted || options.requestSignal?.aborted) return;
this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect SSE stream: ${error62 instanceof Error ? error62.message : String(error62)}`));
try {
this._scheduleReconnection(options, attemptCount + 1);
} catch (scheduleError) {
this.onerror?.(scheduleError instanceof Error ? scheduleError : new Error(String(scheduleError)));
}
});
};
if (this._reconnectionScheduler) {
const cancel = this._reconnectionScheduler(reconnect, delay2, attemptCount);
this._cancelReconnection = typeof cancel === "function" ? cancel : void 0;
} else {
const handle = setTimeout(reconnect, delay2);
this._cancelReconnection = () => clearTimeout(handle);
}
}
_handleSseStream(stream, options, isReconnectable) {
if (!stream) {
options.onRequestStreamEnd?.();
return;
}
const { onresumptiontoken, replayMessageId, requestSignal, onRequestStreamEnd } = options;
const isIntentionalAbort = () => this._abortController?.signal.aborted === true || requestSignal?.aborted === true;
let lastEventId;
let hasPrimingEvent = false;
let receivedResponse = false;
const processStream = async () => {
try {
const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({ onRetry: (retryMs) => {
this._serverRetryMs = retryMs;
} })).getReader();
while (true) {
const { value: event, done } = await reader.read();
if (done) break;
if (event.id) {
lastEventId = event.id;
hasPrimingEvent = true;
onresumptiontoken?.(event.id);
}
if (!event.data) continue;
if (!event.event || event.event === "message") try {
const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
receivedResponse = true;
if (replayMessageId !== void 0) message.id = replayMessageId;
}
this.onmessage?.(message);
} catch (error62) {
this.onerror?.(error62);
}
}
if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !isIntentionalAbort()) this._scheduleReconnection({
resumptionToken: lastEventId,
onresumptiontoken,
replayMessageId,
requestSignal,
onRequestStreamEnd
}, 0);
else if (!isIntentionalAbort()) onRequestStreamEnd?.();
} catch (error62) {
if (isIntentionalAbort()) return;
this.onerror?.(/* @__PURE__ */ new Error(`SSE stream disconnected: ${error62}`));
if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !isIntentionalAbort()) try {
this._scheduleReconnection({
resumptionToken: lastEventId,
onresumptiontoken,
replayMessageId,
requestSignal,
onRequestStreamEnd
}, 0);
} catch (error$1) {
this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect: ${error$1 instanceof Error ? error$1.message : String(error$1)}`));
onRequestStreamEnd?.();
}
else onRequestStreamEnd?.();
}
};
processStream();
}
async start() {
if (this._abortController) throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
this._abortController = new AbortController();
}
async finishAuth(codeOrParams, iss) {
if (!this._oauthProvider) throw new UnauthorizedError("finishAuth requires an OAuthClientProvider");
const { authorizationCode, iss: issParam } = await resolveAuthorizationCallbackParams(codeOrParams, iss, this._oauthProvider, this._url, {
fetchFn: this._fetchWithInit,
resourceMetadataUrl: this._resourceMetadataUrl
});
if (await auth(this._oauthProvider, {
serverUrl: this._url,
authorizationCode,
iss: issParam,
resourceMetadataUrl: this._resourceMetadataUrl,
scope: this._scope,
fetchFn: this._fetchWithInit,
skipIssuerMetadataValidation: this._skipIssuerMetadataValidation
}) !== "AUTHORIZED") throw new UnauthorizedError("Failed to authorize");
}
async close() {
try {
this._cancelReconnection?.();
} finally {
this._cancelReconnection = void 0;
this._abortController?.abort();
this.onclose?.();
}
}
async send(message, options) {
return this._send(message, options, false);
}
async _send(message, options, isAuthRetry, stepUpRetries = 0) {
try {
const { resumptionToken, onresumptiontoken } = options || {};
if (resumptionToken) {
this._startOrAuthSse({
resumptionToken,
replayMessageId: isJSONRPCRequest(message) ? message.id : void 0,
requestSignal: options?.requestSignal
}).catch((error62) => this.onerror?.(error62));
return;
}
const headers = await this._commonHeaders();
this._applyBodyDerivedHeaders(headers, message);
const isHandshake = Array.isArray(message) ? message.some((m) => isInitializeRequest(m)) : isInitializeRequest(message);
if (isHandshake) headers.delete("mcp-session-id");
if (options?.headers !== void 0) for (const [name, value] of Object.entries(options.headers)) {
if (RESERVED_REQUEST_HEADER_NAMES.has(name.toLowerCase())) continue;
headers.set(name, value);
}
headers.set("content-type", "application/json");
const types = [
...headers.get("accept")?.split(",").map((s) => s.trim().toLowerCase()) ?? [],
"application/json",
"text/event-stream"
];
headers.set("accept", [...new Set(types)].join(", "));
const transportSignal = this._abortController?.signal;
const signal = options?.requestSignal !== void 0 && transportSignal !== void 0 ? anySignal(transportSignal, options.requestSignal) : options?.requestSignal ?? transportSignal;
const init = {
...this._requestInit,
method: "POST",
headers,
body: JSON.stringify(message),
signal
};
const response = await this._redirects(this._fetch ?? fetch)(this._url, init);
if (isHandshake && response.ok) this._sessionId = response.headers.get("mcp-session-id") || void 0;
if (!response.ok) {
if (response.status === 401 && this._authProvider) {
if (response.headers.has("www-authenticate")) {
const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
this._resourceMetadataUrl = resourceMetadataUrl;
this._scope = computeScopeUnion(this._scope, scope);
}
if (this._authProvider.onUnauthorized && !isAuthRetry) {
try {
await this._authProvider.onUnauthorized({
response,
serverUrl: this._url,
fetchFn: this._fetchWithInit
});
} catch (error62) {
throw markAuthSeamEscape(error62);
}
await response.text?.().catch(() => {
});
return this._send(message, options, true, stepUpRetries);
}
await response.text?.().catch(() => {
});
if (isAuthRetry) throw markAuthSeamEscape(new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, "Server returned 401 after re-authentication", {
status: 401,
statusText: response.statusText
}));
throw markAuthSeamEscape(new UnauthorizedError());
}
const text = await response.text?.().catch(() => null);
if (response.status === 403) {
const { resourceMetadataUrl, scope, error: error62, errorDescription } = extractWWWAuthenticateParams(response);
if (error62 === "insufficient_scope") {
if (await this._stepUpAuthorize({
scope,
resourceMetadataUrl,
errorDescription,
statusText: response.statusText,
text
}, stepUpRetries) !== "AUTHORIZED") throw markAuthSeamEscape(new UnauthorizedError());
return this._send(message, options, isAuthRetry, stepUpRetries + 1);
}
}
if (response.status === 400 && typeof text === "string" && this._isModernEnvelopedRequest(message)) try {
const parsed = JSONRPCMessageSchema.parse(JSON.parse(text));
const requests = (Array.isArray(message) ? message : [message]).filter((m) => isJSONRPCRequest(m));
if (isJSONRPCErrorResponse(parsed) && requests.some((r) => r.id === parsed.id)) {
this.onmessage?.(parsed);
return;
}
} catch {
}
const reason = this._unfollowedRedirect(this._url, response) ?? text;
throw new SdkHttpError(SdkErrorCode.ClientHttpNotImplemented, `Error POSTing to endpoint: ${reason}`, {
status: response.status,
statusText: response.statusText,
text
});
}
if (response.status === 202) {
await response.text?.().catch(() => {
});
if (isInitializedNotification(message)) this._startOrAuthSse({ resumptionToken: void 0 }).catch((error62) => this.onerror?.(error62));
return;
}
const hasRequests = (Array.isArray(message) ? message : [message]).some((msg) => "method" in msg && "id" in msg && msg.id !== void 0);
const contentType = response.headers.get("content-type");
const responseMediaType = mediaTypeEssence(contentType);
if (hasRequests) if (responseMediaType === "text/event-stream") this._handleSseStream(response.body, {
onresumptiontoken,
requestSignal: options?.requestSignal,
onRequestStreamEnd: options?.onRequestStreamEnd
}, false);
else if (responseMediaType === "application/json") {
const data = await response.json();
const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
for (const msg of responseMessages) this.onmessage?.(msg);
} else {
await response.text?.().catch(() => {
});
throw new SdkError(SdkErrorCode.ClientHttpUnexpectedContent, `Unexpected content type: ${contentType}`, { contentType });
}
else await response.text?.().catch(() => {
});
} catch (error62) {
if (options?.requestSignal?.aborted !== true) this.onerror?.(error62);
throw error62;
}
}
get sessionId() {
return this._sessionId;
}
/**
* Terminates the current session by sending a `DELETE` request to the server.
*
* Clients that no longer need a particular session
* (e.g., because the user is leaving the client application) SHOULD send an
* HTTP `DELETE` to the MCP endpoint with the `Mcp-Session-Id` header to explicitly
* terminate the session.
*
* The server MAY respond with HTTP `405 Method Not Allowed`, indicating that
* the server does not allow clients to terminate sessions.
*/
async terminateSession() {
if (!this._sessionId) return;
try {
const headers = await this._commonHeaders();
const init = {
...this._requestInit,
method: "DELETE",
headers,
signal: this._abortController?.signal
};
const response = await this._redirects(this._fetch ?? fetch)(this._url, init);
await response.text?.().catch(() => {
});
if (!response.ok && response.status !== 405) throw new SdkHttpError(SdkErrorCode.ClientHttpFailedToTerminateSession, `Failed to terminate session: ${this._unfollowedRedirect(this._url, response) ?? response.statusText}`, {
status: response.status,
statusText: response.statusText
});
this._sessionId = void 0;
} catch (error62) {
this.onerror?.(error62);
throw error62;
}
}
setProtocolVersion(version3) {
this._protocolVersion = version3;
}
get protocolVersion() {
return this._protocolVersion;
}
/**
* Resume an SSE stream from a previous event ID.
* Opens a `GET` SSE connection with `Last-Event-ID` header to replay missed events.
*
* @param lastEventId The event ID to resume from
* @param options Optional callback to receive new resumption tokens
*/
async resumeStream(lastEventId, options) {
await this._startOrAuthSse({
resumptionToken: lastEventId,
onresumptiontoken: options?.onresumptiontoken
});
}
};
// package.json
var version2 = "0.16.5";
// src/lib/protocol-era.ts
var FIRST_MODERN_PROTOCOL_VERSION2 = "2026-07-28";
var SUPPORTED_MODERN_VERSIONS = [FIRST_MODERN_PROTOCOL_VERSION2];
var MODERN_ERROR_CODES = /* @__PURE__ */ new Set([
-32022
// UnsupportedProtocolVersion
]);
function discoverRequest(id, identity, version3 = FIRST_MODERN_PROTOCOL_VERSION2) {
return stampModernMeta({ jsonrpc: "2.0", id, method: "server/discover", params: {} }, identity, version3);
}
function readEraFromDiscoverResponse(message) {
if (message.error) {
const { code } = message.error;
if (code === void 0 || !MODERN_ERROR_CODES.has(code)) {
return { era: "legacy", reason: `the server answered server/discover with error ${code}` };
}
const supported = parseSupportedVersions(message.error.data);
const version4 = supported && chooseModernVersion(supported);
if (version4) {
return { era: "incompatible", reason: `the server asked for protocol version ${version4}, which the probe already offered` };
}
if (!supported || supported.some((offered) => offered < FIRST_MODERN_PROTOCOL_VERSION2)) {
return {
era: "legacy",
reason: `the server offers no modern revision this proxy speaks${supported ? ` (it offers ${supported.join(", ")})` : ""}`
};
}
return {
era: "incompatible",
reason: `the server offers ${supported.join(", ")}, and this proxy speaks ${SUPPORTED_MODERN_VERSIONS.join(", ")}`
};
}
const parsed = DiscoverResultSchema.safeParse(message.result);
if (!parsed.success) {
return { era: "legacy", reason: "the server answered server/discover with something that is not a DiscoverResult" };
}
const discover = { ...parsed.data, capabilities: message.result.capabilities };
const version3 = chooseModernVersion(discover.supportedVersions);
if (!version3) {
return {
era: "incompatible",
reason: `the server offers ${discover.supportedVersions.join(", ")}, and this proxy speaks ${SUPPORTED_MODERN_VERSIONS.join(", ")}`
};
}
return { era: "modern", version: version3, discover };
}
function chooseModernVersion(supportedVersions) {
return SUPPORTED_MODERN_VERSIONS.find((candidate) => supportedVersions.includes(candidate));
}
function parseSupportedVersions(data) {
const supported = data?.supported;
if (!Array.isArray(supported)) return void 0;
const versions = supported.filter((entry) => typeof entry === "string");
return versions.length > 0 ? versions : void 0;
}
function synthesizeInitializeResult(discover, identity) {
const requested = identity.protocolVersion;
const protocolVersion = requested && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : LATEST_PROTOCOL_VERSION;
const advertised = discover._meta?.[SERVER_INFO_META_KEY];
const serverInfo = advertised?.name ? advertised : { name: "remote MCP server", version: FIRST_MODERN_PROTOCOL_VERSION2 };
return {
protocolVersion,
capabilities: discover.capabilities ?? {},
serverInfo,
...discover.instructions ? { instructions: discover.instructions } : {}
};
}
function stampLogLevel(message, logLevel) {
if (!logLevel) return message;
return { ...message, params: { ...message.params, _meta: { ...message.params?._meta, [LOG_LEVEL_META_KEY]: logLevel } } };
}
function stampModernMeta(message, identity, version3) {
const existing = message.params?._meta ?? {};
return {
...message,
params: {
...message.params,
_meta: {
...existing,
[PROTOCOL_VERSION_META_KEY]: existing[PROTOCOL_VERSION_META_KEY] ?? version3,
[CLIENT_CAPABILITIES_META_KEY]: existing[CLIENT_CAPABILITIES_META_KEY] ?? identity.capabilities ?? {},
...identity.clientInfo ? { [CLIENT_INFO_META_KEY]: existing[CLIENT_INFO_META_KEY] ?? identity.clientInfo } : {}
}
}
};
}
var ANSWERED_LOCALLY = Object.assign(/* @__PURE__ */ Object.create(null), {
ping: {},
// The 2026-07-28 era replaced these with the `subscriptions/listen` stream this proxy already
// holds open, and with a per-request `_meta` key. The client still calls them, because the
// capabilities it was handed still advertise them - so they are honoured here rather than sent to
// a server that no longer has the methods.
"resources/subscribe": {},
"resources/unsubscribe": {},
"logging/setLevel": {}
});
var localAnswerFor = (method) => ANSWERED_LOCALLY[method];
var RETIRED_IN_MODERN_ERA = {
subscribeResource: "resources/subscribe",
unsubscribeResource: "resources/unsubscribe",
setLogLevel: "logging/setLevel"
};
var DROPPED_NOTIFICATIONS = /* @__PURE__ */ new Set([
"notifications/initialized",
// Not in the 2026-07-28 notification registry: the era carries client capabilities on every
// request instead, so a change to them is simply reflected in the next one this proxy stamps
"notifications/roots/list_changed"
]);
var isDroppedInModernEra = (method) => DROPPED_NOTIFICATIONS.has(method);
var MODERN_ONLY_NOTIFICATIONS = /* @__PURE__ */ new Set(["notifications/subscriptions/acknowledged"]);
var isModernOnlyNotification = (method) => MODERN_ONLY_NOTIFICATIONS.has(method);
function translateModernResult(result) {
if (!result || typeof result !== "object") return { result };
const { resultType, ...rest } = result;
if (resultType === void 0 || resultType === "complete") {
return { result: rest };
}
if (resultType === "input_required") {
return {
error: {
code: -32603,
message: "The remote server asked for more input mid-request (a 2026-07-28 multi-round-trip request). The local client speaks a protocol revision with no way to answer that, so the request cannot be completed."
}
};
}
return {
error: { code: -32603, message: `The remote server returned a result of an unrecognised type: ${String(resultType)}` }
};
}
function subscriptionFilterFor(capabilities, resourceSubscriptions = []) {
const tools = capabilities?.tools;
const prompts = capabilities?.prompts;
const resources = capabilities?.resources;
const filter = {
...tools?.listChanged ? { toolsListChanged: true } : {},
...prompts?.listChanged ? { promptsListChanged: true } : {},
...resources?.listChanged ? { resourcesListChanged: true } : {},
...resourceSubscriptions.length > 0 ? { resourceSubscriptions } : {}
};
return Object.keys(filter).length > 0 ? filter : void 0;
}
function unacknowledgedSubscriptions(requested, acknowledged) {
if (!acknowledged || typeof acknowledged !== "object") return [];
const granted = acknowledged;
return Object.keys(requested).filter((key) => {
if (key === "resourceSubscriptions") {
const asked = requested[key];
const got = Array.isArray(granted[key]) ? granted[key] : [];
return asked.some((uri) => !got.includes(uri));
}
return !granted[key];
});
}
function subscriptionsListenRequest(id, identity, version3, notifications) {
return stampModernMeta({ jsonrpc: "2.0", id, method: "subscriptions/listen", params: { notifications } }, identity, version3);
}
function stripSubscriptionMeta(message) {
const meta3 = message.params?._meta;
if (!meta3 || !(SUBSCRIPTION_ID_META_KEY in meta3)) return message;
const { [SUBSCRIPTION_ID_META_KEY]: _subscriptionId, ...rest } = meta3;
const params = { ...message.params };
if (Object.keys(rest).length > 0) {
params._meta = rest;
} else {
delete params._meta;
}
return { ...message, params };
}
var MAX_INPUT_REQUIRED_ROUNDS = 10;
var isInputRequiredResult2 = (result) => result?.resultType === "input_required";
function inputRequiredRetryParams(originalParams, responses, requestState) {
const hasResponses = Object.keys(responses).length > 0;
return {
...originalParams,
...hasResponses ? { inputResponses: responses } : {},
...requestState !== void 0 ? { requestState } : {}
};
}
var FULFILLABLE_INPUT_METHODS = /* @__PURE__ */ new Set(["sampling/createMessage", "roots/list", "elicitation/create"]);
function canFulfilInputRequest(method, params) {
if (!FULFILLABLE_INPUT_METHODS.has(method)) return false;
if (method === "elicitation/create" && params?.mode === "url") return false;
return true;
}
var CAPABILITY_FOR_INPUT_METHOD = Object.assign(/* @__PURE__ */ Object.create(null), {
"sampling/createMessage": "sampling",
"roots/list": "roots",
"elicitation/create": "elicitation"
});
function clientDeclaredCapabilityFor(method, capabilities) {
const required2 = CAPABILITY_FOR_INPUT_METHOD[method];
if (!required2) return false;
return capabilities?.[required2] !== void 0;
}
var MAX_INPUT_REQUESTS_PER_ROUND = 8;
// src/lib/mcp-auth-config.ts
import path from "path";
import os from "os";
import fs from "fs/promises";
import { randomUUID } from "node:crypto";
var CONFIG_STORE_VERSION = 1;
function getConfigDir() {
const baseConfigDir = process.env.MCP_REMOTE_CONFIG_DIR || path.join(os.homedir(), ".mcp-auth");
return path.join(baseConfigDir, `mcp-remote-v${CONFIG_STORE_VERSION}`);
}
async function ensureConfigDir() {
try {
const configDir = getConfigDir();
await fs.mkdir(configDir, { recursive: true });
} catch (error62) {
log("Error creating config directory:", error62);
throw error62;
}
}
function getConfigFilePath(serverUrlHash, filename) {
const configDir = getConfigDir();
return path.join(configDir, `${serverUrlHash}_${filename}`);
}
async function deleteConfigFile(serverUrlHash, filename) {
try {
const filePath = getConfigFilePath(serverUrlHash, filename);
await fs.unlink(filePath);
} catch (error62) {
if (error62.code !== "ENOENT") {
log(`Error deleting ${filename}:`, error62);
}
}
}
async function deleteJsonFileIf(serverUrlHash, filename, schema, shouldDelete) {
const filePath = getConfigFilePath(serverUrlHash, filename);
const judge = (raw) => {
let content;
try {
content = schema.parse(JSON.parse(raw));
} catch {
content = void 0;
}
return shouldDelete(content);
};
let checked;
try {
checked = await fs.readFile(filePath, "utf-8");
} catch (error62) {
if (error62.code !== "ENOENT") log(`Error reading ${filename}:`, error62);
return false;
}
if (!judge(checked)) return false;
const aside = `${filePath}.${process.pid}.${randomUUID()}.discard`;
try {
await fs.rename(filePath, aside);
} catch (error62) {
if (error62.code === "ENOENT") return false;
debugLog(`Could not set ${filename} aside; deleting it in place`, error62);
await deleteConfigFile(serverUrlHash, filename);
return true;
}
try {
const setAside = await fs.readFile(aside, "utf-8").catch(() => void 0);
if (setAside !== void 0 && (setAside === checked || judge(setAside))) return true;
debugLog(`Kept ${filename}, which changed after it was checked`);
await restoreConfigFile(aside, filePath);
return false;
} finally {
await fs.unlink(aside).catch(() => {
});
}
}
async function restoreConfigFile(aside, filePath) {
try {
await fs.link(aside, filePath);
} catch (error62) {
if (error62.code === "EEXIST") return;
await fs.copyFile(aside, filePath, fs.constants.COPYFILE_EXCL).catch((copyError) => {
if (copyError.code !== "EEXIST") log(`Error restoring ${path.basename(filePath)}:`, copyError);
});
}
}
async function deleteStaleConfigFiles(serverUrlHash, prefix, maxAgeMs) {
try {
const configDir = getConfigDir();
const cutoff = Date.now() - maxAgeMs;
const entries = await fs.readdir(configDir);
await Promise.all(
entries.filter((entry) => entry.startsWith(`${serverUrlHash}_${prefix}`)).map(async (entry) => {
const filePath = path.join(configDir, entry);
try {
if ((await fs.stat(filePath)).mtimeMs > cutoff) return;
await fs.unlink(filePath);
debugLog(`Removed stale config file: ${entry}`);
} catch (error62) {
debugLog(`Could not remove stale config file ${entry}`, error62);
}
})
);
} catch (error62) {
debugLog("Could not sweep stale config files", error62);
}
}
async function readJsonFile(serverUrlHash, filename, schema) {
try {
await ensureConfigDir();
const filePath = getConfigFilePath(serverUrlHash, filename);
const content = await fs.readFile(filePath, "utf-8");
const result = await schema.parseAsync(JSON.parse(content));
return result;
} catch (error62) {
if (error62.code === "ENOENT") {
return void 0;
}
log(`Error reading ${filename}:`, error62);
return void 0;
}
}
async function writeJsonFile(serverUrlHash, filename, data) {
try {
await ensureConfigDir();
const filePath = getConfigFilePath(serverUrlHash, filename);
const serialized = JSON.stringify(data, null, 2);
const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
try {
await fs.writeFile(tempPath, serialized, { encoding: "utf-8", mode: 384 });
await fs.rename(tempPath, filePath);
} catch (renameError) {
await fs.unlink(tempPath).catch(() => {
});
if (process.platform === "win32") {
debugLog("Atomic rename failed, falling back to a direct write", { filename, renameError });
await fs.writeFile(filePath, serialized, { encoding: "utf-8", mode: 384 });
return;
}
throw renameError;
}
} catch (error62) {
log(`Error writing ${filename}:`, error62);
throw error62;
}
}
async function readTextFile(serverUrlHash, filename, errorMessage) {
try {
await ensureConfigDir();
const filePath = getConfigFilePath(serverUrlHash, filename);
return await fs.readFile(filePath, "utf-8");
} catch (error62) {
throw new Error(errorMessage || `Error reading ${filename}`, { cause: error62 });
}
}
async function writeTextFile(serverUrlHash, filename, text) {
try {
await ensureConfigDir();
const filePath = getConfigFilePath(serverUrlHash, filename);
await fs.writeFile(filePath, text, { encoding: "utf-8", mode: 384 });
} catch (error62) {
log(`Error writing ${filename}:`, error62);
throw error62;
}
}
var ConfigLeaseSchema = external_exports.object({ pid: external_exports.number().int().positive(), nonce: external_exports.string().min(1), at: external_exports.number() });
function processIsAlive(pid2) {
try {
process.kill(pid2, 0);
return true;
} catch (error62) {
return error62.code === "EPERM";
}
}
async function acquireConfigLease(serverUrlHash, filename, maxAgeMs) {
await ensureConfigDir();
const filePath = getConfigFilePath(serverUrlHash, filename);
const nonce = randomUUID();
for (const attempt of [0, 1]) {
try {
const lease = { pid: process.pid, nonce, at: Date.now() };
await fs.writeFile(filePath, JSON.stringify(lease, null, 2), { encoding: "utf-8", mode: 384, flag: "wx" });
return (await readLeaseFile(serverUrlHash, filename))?.nonce === nonce ? nonce : void 0;
} catch (error62) {
if (error62.code !== "EEXIST" || attempt > 0) return void 0;
const held = await readConfigLease(serverUrlHash, filename, maxAgeMs);
if (held?.live) return void 0;
debugLog("Clearing an abandoned lease", { filename, heldBy: held?.pid });
await fs.unlink(filePath).catch(() => {
});
}
}
return void 0;
}
async function readLeaseFile(serverUrlHash, filename) {
return readJsonFile(serverUrlHash, filename, ConfigLeaseSchema);
}
async function readConfigLease(serverUrlHash, filename, maxAgeMs) {
const lease = await readLeaseFile(serverUrlHash, filename);
if (!lease) return void 0;
return { ...lease, live: Date.now() - lease.at < maxAgeMs && processIsAlive(lease.pid) };
}
async function releaseConfigLease(serverUrlHash, filename, nonce) {
if ((await readLeaseFile(serverUrlHash, filename))?.nonce !== nonce) return;
await deleteConfigFile(serverUrlHash, filename);
}
// src/lib/protected-resource-metadata.ts
function parseWWWAuthenticateHeader(header) {
const result = {};
if (!header) {
return result;
}
const paramString = header.replace(/^Bearer\s+/i, "");
const paramRegex = /(\w+)=(?:"([^"]*)"|([\w-]+))/g;
let match;
while ((match = paramRegex.exec(paramString)) !== null) {
const key = match[1];
const value = match[2] ?? match[3];
switch (key) {
case "resource_metadata":
result.resourceMetadataUrl = value;
break;
case "scope":
result.scope = value;
break;
case "error":
result.error = value;
break;
case "error_description":
result.errorDescription = value;
break;
}
}
debugLog("Parsed WWW-Authenticate header", {
hasResourceMetadata: !!result.resourceMetadataUrl,
hasScope: !!result.scope,
error: result.error
});
return result;
}
function buildProtectedResourceMetadataUrls(resourceUrl) {
const url2 = new URL(resourceUrl);
const urls = [];
const path3 = url2.pathname.replace(/\/$/, "");
if (path3 && path3 !== "/") {
urls.push(`${url2.origin}/.well-known/oauth-protected-resource${path3}`);
}
urls.push(`${url2.origin}/.well-known/oauth-protected-resource`);
debugLog("Built Protected Resource Metadata URLs", { resourceUrl, urls });
return urls;
}
async function fetchProtectedResourceMetadataFromUrl(metadataUrl) {
debugLog("Fetching Protected Resource Metadata", { metadataUrl });
try {
const response = await fetch(metadataUrl, {
headers: {
Accept: "application/json",
"Accept-Encoding": "identity"
},
signal: AbortSignal.timeout(5e3)
});
if (!response.ok) {
if (response.status === 404) {
debugLog("Protected Resource Metadata not found (404)", { metadataUrl });
} else {
debugLog("Failed to fetch Protected Resource Metadata", {
status: response.status,
statusText: response.statusText
});
}
return void 0;
}
const metadata = await response.json();
debugLog("Successfully fetched Protected Resource Metadata", {
resource: metadata.resource,
authorizationServers: metadata.authorization_servers,
scopesSupported: metadata.scopes_supported
});
return metadata;
} catch (error62) {
debugLog("Error fetching Protected Resource Metadata", {
error: error62 instanceof Error ? error62.message : String(error62),
metadataUrl
});
return void 0;
}
}
async function discoverProtectedResourceMetadata(resourceUrl, wwwAuthenticateHeader) {
debugLog("Starting Protected Resource Metadata discovery", {
resourceUrl,
hasWWWAuthenticateHeader: !!wwwAuthenticateHeader
});
if (wwwAuthenticateHeader) {
const params = parseWWWAuthenticateHeader(wwwAuthenticateHeader);
if (params.resourceMetadataUrl) {
debugLog("Using resource_metadata URL from WWW-Authenticate header", {
url: params.resourceMetadataUrl
});
const metadata = await fetchProtectedResourceMetadataFromUrl(params.resourceMetadataUrl);
if (metadata) {
return metadata;
}
debugLog("Failed to fetch from WWW-Authenticate URL, falling back to well-known discovery");
}
}
const wellKnownUrls = buildProtectedResourceMetadataUrls(resourceUrl);
for (const url2 of wellKnownUrls) {
const metadata = await fetchProtectedResourceMetadataFromUrl(url2);
if (metadata) {
return metadata;
}
}
debugLog("Protected Resource Metadata discovery failed - no metadata found");
return void 0;
}
function getAuthorizationServerUrl(metadata) {
if (metadata.authorization_servers && metadata.authorization_servers.length > 0) {
return metadata.authorization_servers[0];
}
return void 0;
}
// src/lib/authorization-server-metadata.ts
function getMetadataUrls(serverUrl) {
const url2 = new URL(serverUrl);
const oauthPath = "/.well-known/oauth-authorization-server";
const oidcPath = "/.well-known/openid-configuration";
const pathname = url2.pathname.replace(/\/+$/, "");
if (pathname === "") {
return [`${url2.origin}${oauthPath}`, `${url2.origin}${oidcPath}`];
}
return [
// RFC 8414 §3.1: insert the well-known segment between host and path
`${url2.origin}${oauthPath}${pathname}`,
// Servers that ignore the path and answer only at the root, which is what
// this function used to assume and what #240 relies on
`${url2.origin}${oauthPath}`,
// The same two shapes again for OIDC issuers, e.g. Keycloak realms
`${url2.origin}${oidcPath}${pathname}`,
`${url2.origin}${pathname}${oidcPath}`
];
}
async function fetchAuthorizationServerMetadata(serverUrl) {
const candidates = getMetadataUrls(serverUrl);
debugLog("Fetching authorization server metadata", { serverUrl, candidates });
for (const metadataUrl of candidates) {
const metadata = await fetchMetadataFrom(metadataUrl);
if (metadata) {
return metadata;
}
}
debugLog("No authorization server metadata found at any candidate URL", { serverUrl, candidates });
return void 0;
}
async function fetchMetadataFrom(metadataUrl) {
try {
const response = await fetch(metadataUrl, {
headers: {
Accept: "application/json",
"Accept-Encoding": "identity"
},
// Short timeout to avoid blocking
signal: AbortSignal.timeout(5e3)
});
if (!response.ok) {
if (response.status === 404) {
debugLog("Authorization server metadata endpoint not found (404)", { metadataUrl });
} else {
debugLog("Failed to fetch authorization server metadata", {
status: response.status,
statusText: response.statusText
});
}
return void 0;
}
const metadata = await response.json();
debugLog("Successfully fetched authorization server metadata", {
issuer: metadata.issuer,
scopes_supported: metadata.scopes_supported,
scopeCount: metadata.scopes_supported?.length || 0
});
return metadata;
} catch (error62) {
debugLog("Error fetching authorization server metadata", {
error: error62 instanceof Error ? error62.message : String(error62),
metadataUrl
});
return void 0;
}
}
// src/lib/cookie-jar.ts
function createCookieJar() {
const byOrigin = /* @__PURE__ */ new Map();
return {
capture(url2, response) {
const setCookies = response.headers.getSetCookie?.() ?? [];
if (setCookies.length === 0) return;
const target = new URL(url2);
let jar = byOrigin.get(target.origin);
if (!jar) {
jar = /* @__PURE__ */ new Map();
byOrigin.set(target.origin, jar);
}
for (const header of setCookies) {
const cookie = parseSetCookie(header, target);
if (!cookie) continue;
if (cookie.expiresAt !== void 0 && cookie.expiresAt <= Date.now()) {
jar.delete(cookie.name);
continue;
}
jar.set(cookie.name, { value: cookie.value, path: cookie.path, expiresAt: cookie.expiresAt });
}
debugLog("Stored cookies set by the remote server", { origin: target.origin, names: [...jar.keys()] });
},
header(url2) {
const target = new URL(url2);
const jar = byOrigin.get(target.origin);
if (!jar) return void 0;
const now = Date.now();
const pairs = [];
for (const [name, cookie] of jar) {
if (cookie.expiresAt !== void 0 && cookie.expiresAt <= now) {
jar.delete(name);
continue;
}
if (!pathMatches(target.pathname, cookie.path)) continue;
pairs.push(`${name}=${cookie.value}`);
}
return pairs.length > 0 ? pairs.join("; ") : void 0;
}
};
}
function parseSetCookie(header, target) {
const [pair, ...attributes] = header.split(";");
const separator = pair.indexOf("=");
if (separator < 1) return void 0;
const name = pair.slice(0, separator).trim();
const value = pair.slice(separator + 1).trim();
if (!name) return void 0;
let path3 = defaultPath(target.pathname);
let expires;
let maxAge;
for (const attribute of attributes) {
const index = attribute.indexOf("=");
const key = (index === -1 ? attribute : attribute.slice(0, index)).trim().toLowerCase();
const attributeValue = index === -1 ? "" : attribute.slice(index + 1).trim();
if (key === "path" && attributeValue.startsWith("/")) {
path3 = attributeValue;
} else if (key === "expires") {
const parsed = Date.parse(attributeValue);
if (!Number.isNaN(parsed)) expires = parsed;
} else if (key === "max-age") {
const seconds = Number(attributeValue);
if (attributeValue !== "" && Number.isFinite(seconds)) maxAge = seconds;
}
}
return { name, value, path: path3, expiresAt: maxAge !== void 0 ? Date.now() + maxAge * 1e3 : expires };
}
function defaultPath(pathname) {
if (!pathname.startsWith("/")) return "/";
const lastSlash = pathname.lastIndexOf("/");
return lastSlash === 0 ? "/" : pathname.slice(0, lastSlash);
}
function pathMatches(requestPath, cookiePath) {
if (requestPath === cookiePath) return true;
if (!requestPath.startsWith(cookiePath)) return false;
return cookiePath.endsWith("/") || requestPath[cookiePath.length] === "/";
}
// src/lib/utils.ts
import express from "express";
import crypto2 from "crypto";
import fs2 from "fs";
import { readFile, rm } from "fs/promises";
import path2 from "path";
import { Agent, EnvHttpProxyAgent, fetch as fetch2, Headers as Headers2, setGlobalDispatcher } from "undici";
var REASON_AUTH_NEEDED = "authentication-needed";
var REASON_SIBLING_TOKENS = "signed-in-by-another-instance";
var REASON_TRANSPORT_FALLBACK = "falling-back-to-alternate-transport";
var REASON_REJECTED_TOKEN = "server-rejected-a-freshly-issued-token";
var DEFAULT_KEEP_ALIVE_INTERVAL_MS = 3e4;
var MCP_NAME_SOURCES = {
"tools/call": "name",
"prompts/get": "name",
"resources/read": "uri"
};
function mcpHeadersFromBody(body) {
if (typeof body !== "string") return void 0;
let message;
try {
message = JSON.parse(body);
} catch {
return void 0;
}
if (!message || typeof message !== "object" || Array.isArray(message)) return void 0;
const { method, params } = message;
if (typeof method !== "string" || method.length === 0) return void 0;
const source = MCP_NAME_SOURCES[method];
if (!source || !params || typeof params !== "object") return { method };
const name = params[source];
return typeof name === "string" && name.length > 0 ? { method, name } : { method };
}
function encodeMcpHeaderValue(value) {
const headerSafe = /^[\x21-\x7e](?:[\x20-\x7e\t]*[\x21-\x7e])?$/.test(value);
const looksEncoded = value.startsWith("=?base64?") && value.endsWith("?=");
return headerSafe && !looksEncoded ? value : `=?base64?${Buffer.from(value, "utf8").toString("base64")}?=`;
}
var fetchWithMcpHeaders = async (url2, init) => {
const mirrored = mcpHeadersFromBody(init?.body);
const cookie = cookieHeaderFor(url2);
let request = init;
if (mirrored || cookie) {
const headers = new Headers2(init?.headers);
if (mirrored) {
if (!headers.has("Mcp-Method")) headers.set("Mcp-Method", mirrored.method);
if (mirrored.name !== void 0 && !headers.has("Mcp-Name")) {
headers.set("Mcp-Name", encodeMcpHeaderValue(mirrored.name));
}
}
if (cookie && !headers.has("Cookie")) headers.set("Cookie", cookie);
request = { ...init, headers };
}
const response = await fetch2(url2, request);
captureCookies(url2, response);
return response.ok ? response : asGlobalResponse(response);
};
function coordinatedFetch(authProvider, fetchFn) {
const coordinator = authProvider;
return typeof coordinator?.coordinateTokenRequests === "function" ? coordinator.coordinateTokenRequests(fetchFn) : fetchFn;
}
var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
function asGlobalResponse(response) {
const body = NULL_BODY_STATUSES.has(response.status) ? null : response.body;
const rebuilt = new globalThis.Response(body, {
status: response.status,
statusText: response.statusText,
headers: [...response.headers]
});
Object.defineProperty(rebuilt, "url", { value: response.url });
return rebuilt;
}
var cookieJar = createCookieJar();
var COOKIES_ENABLED = true;
var NON_INTERACTIVE_FLOW = false;
function cookieHeaderFor(url2) {
return COOKIES_ENABLED ? cookieJar.header(url2) : void 0;
}
function captureCookies(url2, response) {
if (COOKIES_ENABLED) cookieJar.capture(url2, response);
}
var RECONNECT_ENDPOINT_TIMEOUT_MS = 1e4;
var RECONNECT_ENDPOINT_POLL_MS = 25;
function isRejectedAfterAuthorizing(error62) {
return error62 instanceof SdkHttpError && error62.code === SdkErrorCode.ClientHttpAuthentication && error62.status === 401;
}
async function forgetRejectedAuthorization(authProvider) {
try {
await authProvider.invalidateCredentials?.("tokens");
} catch (error62) {
debugLog("Could not discard the refused token", error62);
}
}
var pid = process.pid;
var DEBUG = false;
var SILENT = false;
function getTimestamp() {
const now = /* @__PURE__ */ new Date();
return now.toISOString();
}
function debugLog(message, ...args) {
if (!DEBUG) return;
const serverUrlHash = global.currentServerUrlHash;
if (!serverUrlHash) {
console.error("[DEBUG LOG ERROR] global.currentServerUrlHash is not set. Cannot write debug log.");
return;
}
try {
const formattedMessage = `[${getTimestamp()}][${pid}] ${message}`;
console.error(formattedMessage, ...args);
const configDir = getConfigDir();
fs2.mkdirSync(configDir, { recursive: true, mode: 448 });
const logPath = path2.join(configDir, `${serverUrlHash}_debug.log`);
const logMessage = `${formattedMessage} ${args.map((arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)).join(" ")}
`;
fs2.appendFileSync(logPath, logMessage, { encoding: "utf8", mode: 384 });
} catch (error62) {
console.error(`[DEBUG LOG ERROR] ${error62}`);
}
}
function log(str, ...rest) {
if (!SILENT) {
console.error(`[${pid}] ${str}`, ...rest);
}
debugLog(str, ...rest);
}
var MESSAGE_BLOCKED = Symbol("MessageBlocked");
var LIFECYCLE_BARRIER_TIMEOUT_MS = 1e4;
var INITIALIZE_TIMEOUT_MS = 3e4;
var DISCOVER_TIMEOUT_MS = 1e4;
var SUBSCRIPTION_LIFETIME_MS = 24 * 60 * 60 * 1e3;
var MULTI_ROUND_TRIP_LEG_TIMEOUT_MS = 10 * 60 * 1e3;
var SUBSCRIPTION_REOPEN_DELAY_MS = 2e3;
var SUBSCRIPTION_REOPEN_LIMIT = 5;
var SUBSCRIPTION_HELD_OPEN_MS = 3e4;
var sleep2 = (ms) => new Promise((resolve) => {
setTimeout(resolve, ms).unref?.();
});
var isMessageBlocked = (value) => value === MESSAGE_BLOCKED;
function createMessageTransformer({
transformRequestFunction,
transformResponseFunction
} = {}) {
const pendingRequests = /* @__PURE__ */ new Map();
const isRequest = (message) => message?.id != null && message.method !== void 0;
const isResponse = (message) => message?.id != null && message.method === void 0;
const applyTransform = (transform2, message) => {
try {
return transform2();
} catch (error62) {
log("Error transforming message, forwarding it unchanged:", error62);
debugLog("Message transform failed", { id: message?.id, method: message?.method, error: error62 });
return message;
}
};
const interceptRequest = (message) => {
if (!isRequest(message)) return message;
pendingRequests.set(message.id, message);
if (!transformRequestFunction) return message;
return applyTransform(() => transformRequestFunction(message) ?? message, message);
};
const interceptResponse = (message) => {
if (!isResponse(message)) return message;
const originalRequest = pendingRequests.get(message.id);
if (!originalRequest) return message;
pendingRequests.delete(message.id);
if (!transformResponseFunction) return message;
return applyTransform(() => transformResponseFunction(originalRequest, message) ?? message, message);
};
const release = (id, only) => {
if (only !== void 0 && pendingRequests.get(id) !== only) return;
pendingRequests.delete(id);
};
return {
interceptRequest,
interceptResponse,
release
};
}
function mcpProxy({
transportToClient,
transportToServer,
ignoredTools = [],
keepAlive,
protocolMode = "legacy",
reauthorize,
forgetRejectedAuthorization: forgetRejectedTokens
}) {
let transportToClientClosed = false;
let transportToServerClosed = false;
let initializeRequestId;
let lastInitialize = null;
let reinitSeq = 0;
const pendingReinit = /* @__PURE__ */ new Map();
const pendingPings = /* @__PURE__ */ new Set();
let pingSeq = 0;
let keepAliveTimer = null;
let initializedDelivered = null;
let era = null;
let clientIdentity = {};
let eraNegotiation = null;
const subscribedResources = /* @__PURE__ */ new Set();
let requestedLogLevel;
let refreshSubscription;
let activeStream;
let wakeIdleWait;
let dropResourceSubscriptions = false;
const modernRetryIds = /* @__PURE__ */ new Map();
const liveExchanges = /* @__PURE__ */ new Map();
let exchangeSeq = 0;
let discoverSeq = 0;
const pendingDiscover = /* @__PURE__ */ new Map();
const OWN_ID_PREFIX = "mcp-remote-";
const isOwnId = (id) => typeof id === "string" && id.startsWith(OWN_ID_PREFIX);
const pendingOwnRequests = /* @__PURE__ */ new Map();
const pendingClientRequests = /* @__PURE__ */ new Map();
let ownRequestSeq = 0;
const modernOriginals = /* @__PURE__ */ new Map();
let reauthorizeInFlight = null;
let sessionResumption = null;
const pendingRequests = /* @__PURE__ */ new Set();
const messageTransformer = createMessageTransformer({
transformRequestFunction: (request) => {
if (request.method === "tools/call" && request.params?.name) {
const toolName = request.params.name;
if (!shouldIncludeTool(ignoredTools, toolName)) {
const errorResponse = {
jsonrpc: "2.0",
id: request.id,
error: {
code: -32603,
message: `Tool "${toolName}" is not available`
}
};
transportToClient.send(errorResponse).catch(onClientError);
return MESSAGE_BLOCKED;
}
}
return request;
},
transformResponseFunction: (req, response) => {
let res = response;
if (era?.era === "modern" && res.result !== void 0) {
const translated = translateModernResult(res.result);
if ("error" in translated) return { jsonrpc: "2.0", id: res.id, error: translated.error };
res = { ...res, result: translated.result };
}
if (req.method !== "tools/list") return res;
const tools = res.result?.tools;
if (!Array.isArray(tools)) return res;
return {
...res,
result: {
...res.result,
tools: tools.filter((tool) => shouldIncludeTool(ignoredTools, tool.name))
}
};
}
});
transportToClient.onmessage = (_message) => {
const answeringId = _message.id;
if (isOwnId(answeringId)) {
if (_message.method !== void 0) {
log(`Refusing a client request whose id is reserved by this proxy: ${answeringId}`);
transportToClient.send({
jsonrpc: "2.0",
id: answeringId,
error: { code: -32600, message: `mcp-remote reserves request ids beginning with "${OWN_ID_PREFIX}"` }
}).catch(onClientError);
return;
}
const settle2 = pendingClientRequests.get(answeringId);
pendingClientRequests.delete(answeringId);
if (settle2) settle2(_message);
else debugLog("Discarding a late answer to a question this proxy had given up on", { id: answeringId });
return;
}
const message = messageTransformer.interceptRequest(_message);
if (isMessageBlocked(message)) {
const blockedId = _message.id;
if (blockedId !== void 0 && blockedId !== null) messageTransformer.release(blockedId);
return;
}
log("[Local\u2192Remote]", message.method || message.id);
debugLog("Local \u2192 Remote message", {
method: message.method,
id: message.id,
params: message.params ? JSON.stringify(message.params).substring(0, 500) : void 0
});
if (message.method === "initialize") {
initializeRequestId = message.id;
const { clientInfo } = message.params;
if (clientInfo) clientInfo.name = `${clientInfo.name} (via mcp-remote ${version2})`;
log(JSON.stringify(message, null, 2));
debugLog("Initialize message with modified client info", { clientInfo });
lastInitialize = message;
clientIdentity = {
protocolVersion: message.params?.protocolVersion,
capabilities: message.params?.capabilities ?? {},
clientInfo
};
if (protocolMode === "auto" && era === null && !eraNegotiation) {
const negotiation = negotiateEra2(message).finally(() => {
if (eraNegotiation === negotiation) eraNegotiation = null;
});
eraNegotiation = negotiation;
return;
}
}
forwardInOrder(message);
};
transportToServer.onmessage = (_message) => {
const incomingId = _message.id;
if (isOwnId(incomingId) && _message.method !== void 0) {
log(`Refusing a server request whose id is reserved by this proxy: ${incomingId}`);
transportToServer.send({
jsonrpc: "2.0",
id: incomingId,
error: { code: -32600, message: `mcp-remote reserves request ids beginning with "${OWN_ID_PREFIX}"` }
}).catch(onServerError);
return;
}
if (isOwnId(incomingId)) {
if (pendingPings.delete(incomingId)) return;
for (const pending of [pendingOwnRequests, pendingDiscover, pendingReinit]) {
const settle2 = pending.get(incomingId);
if (settle2) {
pending.delete(incomingId);
settle2(_message);
return;
}
}
debugLog("Discarding an answer to a request this proxy is no longer waiting on", { id: incomingId });
return;
}
if (era?.era === "modern" && _message.method && isModernOnlyNotification(_message.method)) {
const requested = subscriptionFilterFor(era.discover.capabilities, [...subscribedResources]);
const missing = requested ? unacknowledgedSubscriptions(requested, _message.params?.notifications) : [];
if (missing.length > 0) {
log(`The remote server did not subscribe this client to: ${missing.join(", ")}`);
}
debugLog("Consuming a notification that belongs to this proxy, not the client", { method: _message.method });
return;
}
if (era?.era === "modern" && incomingId !== void 0 && incomingId !== null && isInputRequiredResult2(_message.result)) {
const original = modernOriginals.get(incomingId);
if (!original) {
debugLog("Discarding a request for more input on an exchange that is already over", { id: incomingId });
return;
}
{
modernOriginals.delete(incomingId);
log("[Remote\u2192Local]", `${incomingId} (asking for more input)`);
const exchange = ++exchangeSeq;
liveExchanges.set(incomingId, exchange);
driveInputRequired(original, _message.result, era.version, exchange).catch((error62) => {
onServerError(error62);
answerClient(
{ jsonrpc: "2.0", id: original.id, error: { code: -32001, message: `mcp-remote: ${error62.message}` } },
exchange,
original
);
});
return;
}
}
if (incomingId !== void 0 && incomingId !== null) {
pendingRequests.delete(incomingId);
modernOriginals.delete(incomingId);
modernRetryIds.delete(incomingId);
}
const message = era?.era === "modern" ? stripSubscriptionMeta(messageTransformer.interceptResponse(_message)) : messageTransformer.interceptResponse(_message);
log("[Remote\u2192Local]", message.method || message.id);
debugLog("Remote \u2192 Local message", {
method: message.method,
id: message.id,
result: message.result ? "result-present" : void 0,
error: message.error
});
if (initializeRequestId !== void 0 && message.id === initializeRequestId) {
initializeRequestId = void 0;
applyNegotiatedProtocolVersion(message);
}
transportToClient.send(message).catch(onClientError);
};
transportToClient.onclose = () => {
stopKeepAlive();
transportToClientClosed = true;
failOwnPendingRequests("the connection closed before this could be answered");
if (transportToServerClosed) {
return;
}
debugLog("Local transport closed, closing remote transport");
transportToServer.close().catch(onServerError);
};
transportToServer.onclose = () => {
stopKeepAlive();
transportToServerClosed = true;
failOwnPendingRequests("the connection closed before this could be answered");
if (transportToClientClosed) {
return;
}
debugLog("Remote transport closed, closing local transport");
transportToClient.close().catch(onClientError);
};
transportToClient.onerror = onClientError;
transportToServer.onerror = onServerError;
transportToServer.onStreamReconnect = () => {
const droppedEndpoint = postEndpoint();
failPendingRequests("the connection to the remote server dropped before this could be answered");
sessionResumption = (async () => {
try {
await awaitReconnectedEndpoint(droppedEndpoint);
await reinitializeSession();
} catch (error62) {
onServerError(error62);
}
})().finally(() => {
sessionResumption = null;
});
};
if (keepAlive?.enabled) {
keepAliveTimer = startKeepAlive(keepAlive.intervalMs);
}
function onClientError(error62) {
log("Error from local client:", error62);
debugLog("Error from local client", { stack: error62.stack });
}
function applyNegotiatedProtocolVersion(response) {
const protocolVersion = response.result?.protocolVersion;
if (typeof protocolVersion === "string") {
debugLog("Setting negotiated protocol version on remote transport", protocolVersion);
transportToServer.setProtocolVersion?.(protocolVersion);
}
}
function onServerError(error62) {
log("Error from remote server:", error62);
debugLog("Error from remote server", { stack: error62.stack });
}
function isSessionExpired(error62) {
return error62 instanceof SdkHttpError && error62.status === 404 && transportToServer.sessionId !== void 0;
}
function postEndpoint() {
return transportToServer._endpoint?.href;
}
async function awaitReconnectedEndpoint(droppedEndpoint) {
const deadline = Date.now() + RECONNECT_ENDPOINT_TIMEOUT_MS;
while (postEndpoint() === droppedEndpoint && Date.now() < deadline) {
await sleep2(RECONNECT_ENDPOINT_POLL_MS);
}
}
async function negotiateEra2(initialize) {
const id = `mcp-remote-discover-${++discoverSeq}`;
try {
const response = await new Promise((resolve, reject) => {
const timer = setTimeout(() => {
pendingDiscover.delete(id);
reject(new Error("timed out waiting for the server/discover response"));
}, DISCOVER_TIMEOUT_MS);
timer.unref?.();
pendingDiscover.set(id, (message) => {
clearTimeout(timer);
resolve(message);
});
transportToServer.send(discoverRequest(id, clientIdentity)).catch((error62) => {
clearTimeout(timer);
pendingDiscover.delete(id);
reject(error62);
});
});
era = readEraFromDiscoverResponse(response);
} catch (error62) {
debugLog("server/discover produced no evidence of a modern server", error62);
era = { era: "legacy", reason: error62.message };
}
if (era.era === "modern") {
log(`Remote server speaks MCP ${era.version}; answering the local client's handshake here and bridging every request`);
debugLog("Bridging to a modern server", { version: era.version, capabilities: era.discover.capabilities });
initializeRequestId = void 0;
transportToServer.setProtocolVersion?.(era.version);
transportToClient.send({ jsonrpc: "2.0", id: initialize.id, result: synthesizeInitializeResult(era.discover, clientIdentity) }).catch(onClientError);
openChangeSubscription(era.version, era.discover.capabilities).catch(onServerError);
return;
}
if (era.era === "incompatible") {
log(`Cannot bridge to this server: ${era.reason}`);
transportToClient.send({
jsonrpc: "2.0",
id: initialize.id,
error: { code: -32603, message: `mcp-remote cannot bridge to this server: ${era.reason}` }
}).catch(onClientError);
return;
}
debugLog("Treating the remote server as legacy", { reason: era.reason });
void sendToServer(initialize);
}
async function askRemote(build2, timeoutMs, cancelled) {
const id = `mcp-remote-own-${++ownRequestSeq}`;
let cancelledBeforeSending = false;
let cancellation;
let abandon;
cancelled?.catch((reason) => {
cancelledBeforeSending = true;
cancellation = reason;
abandon?.(reason);
});
if (sessionResumption) {
await sessionResumption;
}
if (cancelledBeforeSending) throw cancellation;
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
pendingOwnRequests.delete(id);
reject(new Error("timed out waiting for the remote server to answer"));
}, timeoutMs);
timer.unref?.();
const release = () => {
clearTimeout(timer);
pendingOwnRequests.delete(id);
};
pendingOwnRequests.set(id, (message) => {
release();
resolve(message);
});
abandon = (reason) => {
release();
transportToServer.send({ jsonrpc: "2.0", method: "notifications/cancelled", params: { requestId: id } }).catch(() => {
});
reject(reason);
};
transportToServer.send(build2(id)).catch((error62) => {
release();
reject(error62);
});
});
}
function askClient(method, params, timeoutMs) {
const id = `mcp-remote-input-${++ownRequestSeq}`;
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
pendingClientRequests.delete(id);
reject(new Error(`the local client did not answer ${method}`));
}, timeoutMs);
timer.unref?.();
pendingClientRequests.set(id, (message) => {
clearTimeout(timer);
resolve(message);
});
transportToClient.send({ jsonrpc: "2.0", id, method, params }).catch((error62) => {
clearTimeout(timer);
pendingClientRequests.delete(id);
reject(error62);
});
});
}
async function openChangeSubscription(version3, capabilities) {
refreshSubscription = () => {
wakeIdleWait?.();
activeStream?.reopen();
};
let shortLivedStreams = 0;
while (shortLivedStreams < SUBSCRIPTION_REOPEN_LIMIT) {
const notifications = subscriptionFilterFor(capabilities, dropResourceSubscriptions ? [] : [...subscribedResources]);
if (!notifications) {
debugLog("Nothing to subscribe to yet; waiting for the client to ask for something");
shortLivedStreams = 0;
if (!await waitForSubscriptionChange()) return;
continue;
}
const openedAt = Date.now();
let reopening = false;
try {
debugLog("Subscribing to change notifications on the client behalf", { notifications });
const cancelled = new Promise((_, rejectStream) => {
activeStream = {
reopen: () => {
reopening = true;
rejectStream(new Error("the subscription is being reopened against a new filter"));
}
};
});
const response = await askRemote(
(id) => subscriptionsListenRequest(id, clientIdentity, version3, notifications),
SUBSCRIPTION_LIFETIME_MS,
cancelled
);
if (response.error) {
if (transportToClientClosed || transportToServerClosed) return;
if (!dropResourceSubscriptions && subscribedResources.size > 0) {
log(`The remote server refused a subscription naming resources; listening for the rest: ${JSON.stringify(response.error)}`);
dropResourceSubscriptions = true;
continue;
}
log(`The remote server refused the change-notification subscription: ${JSON.stringify(response.error)}`);
return;
}
debugLog("The change-notification stream ended", { heldForMs: Date.now() - openedAt });
} catch (error62) {
if (reopening) {
debugLog("Reopening the change-notification stream against a filter the client changed");
if (transportToClientClosed || transportToServerClosed) return;
await sleep2(SUBSCRIPTION_REOPEN_DELAY_MS);
if (transportToClientClosed || transportToServerClosed) return;
continue;
}
debugLog("The change-notification stream failed", { heldForMs: Date.now() - openedAt, error: error62 });
} finally {
activeStream = void 0;
}
if (Date.now() - openedAt >= SUBSCRIPTION_HELD_OPEN_MS) shortLivedStreams = 0;
else shortLivedStreams++;
if (transportToClientClosed || transportToServerClosed) return;
await sleep2(SUBSCRIPTION_REOPEN_DELAY_MS);
if (transportToClientClosed || transportToServerClosed) return;
}
log("Giving up on change notifications: the subscription stream kept ending as soon as it opened");
}
function waitForSubscriptionChange() {
return new Promise((resolve) => {
const timer = setInterval(() => {
if (transportToClientClosed || transportToServerClosed) {
clearInterval(timer);
wakeIdleWait = void 0;
resolve(false);
}
}, SUBSCRIPTION_REOPEN_DELAY_MS);
timer.unref?.();
wakeIdleWait = () => {
clearInterval(timer);
wakeIdleWait = void 0;
resolve(true);
};
});
}
function answerClient(message, exchange, original) {
if (message.id !== void 0 && message.id !== null) {
if (exchange !== void 0 && liveExchanges.get(message.id) !== exchange) {
debugLog("Dropping an answer from an exchange that no longer speaks for this request", { id: message.id, exchange });
if (original) messageTransformer.release(message.id, original);
return;
}
pendingRequests.delete(message.id);
modernRetryIds.delete(message.id);
liveExchanges.delete(message.id);
}
transportToClient.send(messageTransformer.interceptResponse(message)).catch(onClientError);
}
async function driveInputRequired(original, firstResult, version3, exchange) {
let pending = firstResult;
for (let round = 0; round < MAX_INPUT_REQUIRED_ROUNDS; round++) {
const requests = pending.inputRequests ?? {};
const responses = {};
if (Object.keys(requests).length === 0 && pending.requestState === void 0) {
throw new Error("the remote server asked for more input but named none, and carried no state to continue from");
}
if (Object.keys(requests).length > MAX_INPUT_REQUESTS_PER_ROUND) {
throw new Error(
`the remote server embedded ${Object.keys(requests).length} questions in one answer, which is more than this proxy will put to a client at once`
);
}
for (const [key, request] of Object.entries(requests)) {
if (!canFulfilInputRequest(request.method, request.params)) {
throw new Error(`the remote server asked for ${request.method}, which this proxy cannot put to a 2025-era client`);
}
if (!clientDeclaredCapabilityFor(request.method, clientIdentity.capabilities)) {
throw new Error(`the remote server asked for ${request.method}, which this client did not declare it supports`);
}
const answer = await askClient(request.method, request.params, MULTI_ROUND_TRIP_LEG_TIMEOUT_MS);
if (answer.error) {
throw new Error(`the local client refused ${request.method}: ${JSON.stringify(answer.error)}`);
}
responses[key] = answer.result;
}
const retryParams = inputRequiredRetryParams(original.params, responses, pending.requestState);
const reply = await askRemote((id) => {
modernRetryIds.set(original.id, id);
return stampLogLevel(
stampModernMeta({ ...original, id, params: retryParams }, clientIdentity, version3),
requestedLogLevel
);
}, MULTI_ROUND_TRIP_LEG_TIMEOUT_MS);
if (reply.error) {
answerClient({ jsonrpc: "2.0", id: original.id, error: reply.error }, exchange, original);
return;
}
if (!isInputRequiredResult2(reply.result)) {
const translated = translateModernResult(reply.result);
const answer = "error" in translated ? { error: translated.error } : { result: translated.result };
answerClient({ jsonrpc: "2.0", id: original.id, ...answer }, exchange, original);
return;
}
pending = reply.result;
}
throw new Error(`the remote server asked for more input ${MAX_INPUT_REQUIRED_ROUNDS} times without answering`);
}
let reinitInFlight = null;
function reinitializeSession() {
if (!reinitInFlight) {
reinitInFlight = doReinitializeSession().finally(() => {
reinitInFlight = null;
});
}
return reinitInFlight;
}
async function doReinitializeSession() {
if (!lastInitialize) {
throw new Error("no initialize request was seen, cannot re-establish the session");
}
;
transportToServer._sessionId = void 0;
const id = `mcp-remote-reinit-${++reinitSeq}`;
const response = await new Promise((resolve, reject) => {
const timer = setTimeout(() => {
pendingReinit.delete(id);
reject(new Error("timed out waiting for the re-initialize response"));
}, 3e4);
pendingReinit.set(id, (message) => {
clearTimeout(timer);
resolve(message);
});
transportToServer.send({ ...lastInitialize, id }).catch((error62) => {
clearTimeout(timer);
pendingReinit.delete(id);
reject(error62);
});
});
if (response.error) {
throw new Error(`server rejected re-initialize: ${JSON.stringify(response.error)}`);
}
applyNegotiatedProtocolVersion(response);
await transportToServer.send({ jsonrpc: "2.0", method: "notifications/initialized" });
log(`Re-established session ${transportToServer.sessionId ?? "(none)"} after server expiry`);
}
function startKeepAlive(intervalMs) {
const timer = setInterval(() => {
if (era?.era === "modern") return;
const id = `mcp-remote-keepalive-${++pingSeq}`;
pendingPings.add(id);
transportToServer.send({ jsonrpc: "2.0", id, method: "ping" }).catch((error62) => {
pendingPings.delete(id);
log(`Keep-alive ping failed: ${error62 instanceof Error ? error62.message : String(error62)}`);
});
}, intervalMs);
timer.unref?.();
log(`Keep-alive enabled, pinging every ${intervalMs / 1e3} seconds`);
return timer;
}
function stopKeepAlive() {
if (keepAliveTimer) {
clearInterval(keepAliveTimer);
keepAliveTimer = null;
}
pendingPings.clear();
}
function forwardInOrder(message) {
if (eraNegotiation) {
eraNegotiation.then(() => forwardInOrder(message)).catch(onServerError);
return;
}
if (era?.era === "modern" && message.method) {
if (message.method === "notifications/cancelled" && liveExchanges.has(message.params?.requestId)) {
const cancelledId = message.params.requestId;
liveExchanges.delete(cancelledId);
pendingRequests.delete(cancelledId);
const retryId = modernRetryIds.get(cancelledId);
modernRetryIds.delete(cancelledId);
if (retryId !== void 0) {
debugLog("Re-addressing a cancellation to the leg the server is actually running", { retryId });
void sendToServer({ ...message, params: { ...message.params, requestId: retryId } });
} else {
debugLog("Cancelling an exchange that has nothing in flight with the server yet", { id: cancelledId });
}
return;
}
const answer = localAnswerFor(message.method);
if (answer) {
if (message.method === RETIRED_IN_MODERN_ERA.subscribeResource && typeof message.params?.uri === "string") {
subscribedResources.add(message.params.uri);
dropResourceSubscriptions = false;
refreshSubscription?.();
} else if (message.method === RETIRED_IN_MODERN_ERA.unsubscribeResource && typeof message.params?.uri === "string") {
subscribedResources.delete(message.params.uri);
dropResourceSubscriptions = false;
refreshSubscription?.();
} else if (message.method === RETIRED_IN_MODERN_ERA.setLogLevel && typeof message.params?.level === "string") {
requestedLogLevel = message.params.level;
debugLog("Recording the log level to carry on every later request", { level: requestedLogLevel });
}
if (message.id !== void 0 && message.id !== null) {
debugLog("Answering locally a method the modern era does not define", { method: message.method });
messageTransformer.release(message.id);
transportToClient.send({ jsonrpc: "2.0", id: message.id, result: answer }).catch(onClientError);
} else {
debugLog("Dropping a notification for a method the modern era does not define", { method: message.method });
}
return;
}
if (isDroppedInModernEra(message.method)) {
debugLog("Dropping a notification the modern era has no place for", { method: message.method });
return;
}
if (message.method === "initialize" && message.id !== void 0 && message.id !== null) {
debugLog("Answering a repeated handshake from the bridge rather than forwarding it");
transportToClient.send({ jsonrpc: "2.0", id: message.id, result: synthesizeInitializeResult(era.discover, clientIdentity) }).catch(onClientError);
return;
}
}
if (message.method === "notifications/initialized") {
initializedDelivered = Promise.race([sendToServer(message), sleep2(LIFECYCLE_BARRIER_TIMEOUT_MS)]);
return;
}
if (initializedDelivered) {
void initializedDelivered.then(() => sendToServer(message));
return;
}
void sendToServer(message);
}
function isUnauthorized(error62) {
return error62 instanceof UnauthorizedError || error62.message.includes("Unauthorized");
}
function reauthorizeOnce() {
if (!reauthorizeInFlight) {
reauthorizeInFlight = reauthorize().finally(() => {
reauthorizeInFlight = null;
});
}
return reauthorizeInFlight;
}
async function sendToServer(message, alreadyReauthorized = false, alreadyDiscardedToken = false) {
if (sessionResumption) {
await sessionResumption;
}
const awaitsAnswer = message.method !== void 0 && message.id !== void 0 && message.id !== null;
if (awaitsAnswer) pendingRequests.add(message.id);
const outgoing = era?.era === "modern" && awaitsAnswer ? stampLogLevel(stampModernMeta(message, clientIdentity, era.version), requestedLogLevel) : message;
if (era?.era === "modern" && awaitsAnswer) {
liveExchanges.delete(message.id);
modernRetryIds.delete(message.id);
modernOriginals.set(message.id, message);
}
try {
await transportToServer.send(outgoing);
if (message.method === "initialize") scheduleInitializeTimeout(message);
return;
} catch (error62) {
if (awaitsAnswer) {
pendingRequests.delete(message.id);
modernOriginals.delete(message.id);
}
if (forgetRejectedTokens && !alreadyDiscardedToken && isRejectedAfterAuthorizing(error62)) {
log("The server rejected a token it had just issued - discarding it and asking for another");
debugLog("Rejected token mid-session", { id: message.id, method: message.method });
try {
await forgetRejectedTokens();
await sendToServer(message, alreadyReauthorized, true);
} catch (discardError) {
onServerError(discardError);
replyWithError(message, discardError);
}
return;
}
if (reauthorize && !alreadyReauthorized && isUnauthorized(error62)) {
log("Remote server requires authorization, completing sign-in");
debugLog("Unauthorized send, re-authorizing", { id: message.id, method: message.method });
try {
await reauthorizeOnce();
await sendToServer(message, true, alreadyDiscardedToken);
} catch (authError) {
onServerError(authError);
replyWithError(message, authError);
}
return;
}
if (!isSessionExpired(error62) || message.method === "initialize") {
onServerError(error62);
replyWithError(message, error62);
return;
}
log("Remote session expired, re-initializing");
debugLog("Remote session expired", { id: message.id, method: message.method });
try {
await reinitializeSession();
await transportToServer.send(message);
} catch (retryError) {
onServerError(retryError);
replyWithError(message, retryError);
}
}
}
function scheduleInitializeTimeout(message) {
setTimeout(() => {
if (!pendingRequests.has(message.id)) return;
pendingRequests.delete(message.id);
const seconds = INITIALIZE_TIMEOUT_MS / 1e3;
log(`Remote server did not answer 'initialize' within ${seconds}s`);
replyWithError(message, new Error(`timed out after ${seconds}s waiting for the remote server to answer 'initialize'`));
}, INITIALIZE_TIMEOUT_MS).unref?.();
}
function failPendingRequests(reason) {
if (pendingRequests.size === 0) return;
debugLog("Failing requests the dropped session can no longer answer", { ids: [...pendingRequests] });
for (const id of pendingRequests) {
messageTransformer.release(id);
transportToClient.send({ jsonrpc: "2.0", id, error: { code: -32001, message: `mcp-remote: ${reason}` } }).catch(onClientError);
modernOriginals.delete(id);
modernRetryIds.delete(id);
liveExchanges.delete(id);
}
pendingRequests.clear();
}
function failOwnPendingRequests(reason) {
for (const [id, settle2] of [...pendingOwnRequests, ...pendingClientRequests, ...pendingDiscover, ...pendingReinit]) {
settle2({ jsonrpc: "2.0", id, error: { code: -32001, message: `mcp-remote: ${reason}` } });
}
pendingOwnRequests.clear();
pendingClientRequests.clear();
pendingDiscover.clear();
pendingReinit.clear();
}
function replyWithError(message, error62) {
if (message.method === void 0 || message.id === void 0 || message.id === null) {
return;
}
messageTransformer.release(message.id, message);
transportToClient.send({
jsonrpc: "2.0",
id: message.id,
error: { code: -32001, message: `mcp-remote: ${error62.message ?? String(error62)}` }
}).catch(onClientError);
}
}
async function discoverOAuthServerInfo2(serverUrl, headers = {}, tokenEndpoint) {
if (tokenEndpoint) {
const endpoint = new URL(tokenEndpoint);
debugLog("Using the explicitly configured token endpoint; skipping OAuth discovery", {
tokenEndpointOrigin: endpoint.origin
});
return {
authorizationServerUrl: endpoint.origin,
authorizationServerMetadata: {
issuer: endpoint.origin,
token_endpoint: endpoint.toString()
}
};
}
debugLog("Starting OAuth server discovery", { serverUrl });
let wwwAuthenticateHeader;
let wwwAuthenticateScope;
try {
debugLog("Probing MCP server for WWW-Authenticate header");
const response = await fetch2(serverUrl, {
method: "GET",
headers: {
...headers,
Accept: "application/json, text/event-stream"
},
signal: AbortSignal.timeout(1e4)
});
if (response.ok) {
debugLog("Server responded OK without auth, using server URL as authorization server");
const authServerMetadata = await fetchAuthorizationServerMetadata(serverUrl);
return {
authorizationServerUrl: serverUrl,
authorizationServerMetadata: authServerMetadata
};
}
if (response.status === 401) {
wwwAuthenticateHeader = response.headers.get("WWW-Authenticate") || void 0;
debugLog("Received 401 with WWW-Authenticate header", {
hasHeader: !!wwwAuthenticateHeader,
header: wwwAuthenticateHeader
});
if (wwwAuthenticateHeader) {
const params = parseWWWAuthenticateHeader(wwwAuthenticateHeader);
wwwAuthenticateScope = params.scope;
}
}
} catch (error62) {
debugLog("Error probing MCP server", {
error: error62 instanceof Error ? error62.message : String(error62)
});
}
const protectedResourceMetadata = await discoverProtectedResourceMetadata(serverUrl, wwwAuthenticateHeader);
let authorizationServerUrl;
if (protectedResourceMetadata) {
const discoveredUrl = getAuthorizationServerUrl(protectedResourceMetadata);
if (discoveredUrl) {
authorizationServerUrl = discoveredUrl;
debugLog("Using authorization server from Protected Resource Metadata", {
authorizationServerUrl
});
} else {
authorizationServerUrl = serverUrl;
debugLog("PRM found but no authorization_servers, falling back to server URL");
}
} else {
authorizationServerUrl = serverUrl;
debugLog("No Protected Resource Metadata found, falling back to server URL as authorization server");
}
const authorizationServerMetadata = await fetchAuthorizationServerMetadata(authorizationServerUrl);
return {
authorizationServerUrl,
authorizationServerMetadata,
protectedResourceMetadata,
wwwAuthenticateScope
};
}
function substituteEnvVars(value, context) {
return value.replace(/\$\{([^}]+)}/g, (match, envVarName) => {
if (!Object.hasOwn(process.env, envVarName)) {
log(`Warning: Environment variable '${envVarName}' not found for ${context}; leaving ${match} as it is.`);
return match;
}
log(`Replacing ${match} with environment value in ${context}`);
return process.env[envVarName];
});
}
function parseJsonWithEnvVars(raw, context) {
const expanded = raw.includes("${") ? substituteEnvVars(raw, context) : raw;
try {
return JSON.parse(expanded);
} catch {
throw new Error(`Could not parse the ${context} as JSON${raw.includes("${") ? " after expanding its ${...} placeholders" : ""}`);
}
}
function headerEntries(source) {
if (!source) return [];
if (Array.isArray(source)) return source;
const iterable = source;
if (typeof iterable.entries === "function") return [...iterable.entries()];
return Object.entries(source);
}
function mergeHeaders(...sources) {
const merged = /* @__PURE__ */ new Map();
for (const source of sources) {
for (const [name, value] of headerEntries(source)) {
merged.set(name.toLowerCase(), [name, value]);
}
}
return Object.fromEntries(merged.values());
}
async function connectToRemoteServer(client, serverUrl, authProvider, headers, authInitializer, transportStrategy = "http-first", protocolMode = "legacy", recursionReasons = /* @__PURE__ */ new Set()) {
log(`[${pid}] Connecting to remote server: ${serverUrl}`);
const url2 = new URL(serverUrl);
const transportFetch = coordinatedFetch(authProvider, fetchWithMcpHeaders);
const eventStreamFetch = coordinatedFetch(authProvider, fetch2);
let sseStreamOpened = 0;
const eventSourceInit = {
fetch: (requestUrl, init) => {
return Promise.resolve(authProvider?.tokens?.()).then((tokens) => {
const cookie = cookieHeaderFor(requestUrl);
return eventStreamFetch(requestUrl, {
...init,
headers: mergeHeaders(
init?.headers,
// The stream is usually where a balancer plants its cookie, and always where it
// has to be sent back, or the POSTs land on a node that never saw this session.
cookie ? { Cookie: cookie } : void 0,
headers,
tokens?.access_token ? { Authorization: `Bearer ${tokens.access_token}` } : void 0,
{ Accept: "text/event-stream" }
)
});
}).then((response) => {
captureCookies(requestUrl, response);
if (response.ok && ++sseStreamOpened > 1) {
log("Remote SSE stream reconnected");
transport.onStreamReconnect?.();
}
return response;
});
}
};
log(`Using transport strategy: ${transportStrategy}`);
const shouldAttemptFallback2 = transportStrategy === "http-first" || transportStrategy === "sse-first";
const sseTransport = transportStrategy === "sse-only" || transportStrategy === "sse-first";
const transport = sseTransport ? new SSEClientTransport(url2, {
authProvider,
requestInit: { headers },
eventSourceInit,
fetch: transportFetch
}) : new StreamableHTTPClientTransport(url2, {
authProvider,
requestInit: { headers },
fetch: transportFetch
});
let authChallengeTransport;
try {
debugLog("Attempting to connect to remote server", { sseTransport });
if (client) {
debugLog("Connecting client to transport");
await client.connect(transport);
} else {
debugLog("Starting transport directly");
await transport.start();
if (!sseTransport) {
debugLog("Creating test transport for HTTP-only connection test");
const testTransport = new StreamableHTTPClientTransport(url2, {
authProvider,
requestInit: { headers },
fetch: transportFetch
});
authChallengeTransport = testTransport;
const testClient = new Client(
{ name: "mcp-remote-fallback-test", version: "0.0.0" },
{ capabilities: {}, ...protocolMode === "auto" ? { versionNegotiation: { mode: "auto" } } : {} }
);
await testClient.connect(testTransport);
}
}
log(`Connected to remote server using ${transport.constructor.name}`);
return transport;
} catch (error62) {
const httpStatusCode = error62 instanceof SdkHttpError ? error62.status : null;
const shouldFallbackOnError = shouldAttemptFallback2 && error62 instanceof Error && (httpStatusCode === 404 || httpStatusCode === 405 || error62.message.includes("405") || error62.message.includes("Method Not Allowed") || error62.message.includes("404") || error62.message.includes("Not Found"));
if (shouldFallbackOnError) {
log(`Received error (status ${httpStatusCode ?? "unknown"}): ${error62.message}`);
if (recursionReasons.has(REASON_TRANSPORT_FALLBACK)) {
const errorMessage = `Already attempted transport fallback. Giving up.`;
log(errorMessage);
throw new Error(errorMessage, { cause: error62 });
}
log(`Recursively reconnecting for reason: ${REASON_TRANSPORT_FALLBACK}`);
recursionReasons.add(REASON_TRANSPORT_FALLBACK);
return connectToRemoteServer(
client,
serverUrl,
authProvider,
headers,
authInitializer,
sseTransport ? "http-only" : "sse-only",
protocolMode,
recursionReasons
);
} else if (isRejectedAfterAuthorizing(error62)) {
if (recursionReasons.has(REASON_REJECTED_TOKEN)) {
log("The server rejected a freshly issued token as well. Giving up.");
throw error62;
}
log("The server rejected a token it had just issued - discarding it and signing in again");
debugLog("Rejected token after a successful authorization", { message: error62.message });
await forgetRejectedAuthorization(authProvider);
recursionReasons.add(REASON_REJECTED_TOKEN);
return connectToRemoteServer(
client,
serverUrl,
authProvider,
headers,
authInitializer,
transportStrategy,
protocolMode,
recursionReasons
);
} else if (error62 instanceof UnauthorizedError || error62 instanceof Error && error62.message.includes("Unauthorized")) {
log("Authentication required. Initializing auth...");
debugLog("Authentication error detected", {
errorCode: error62 instanceof OAuthError ? error62.code : void 0,
errorMessage: error62.message,
stack: error62.stack
});
const giveUpIfAlreadyRetried = () => {
if (!recursionReasons.has(REASON_AUTH_NEEDED)) return;
const errorMessage = `Already attempted reconnection for reason: ${REASON_AUTH_NEEDED}. Giving up.`;
log(errorMessage);
debugLog("Already attempted auth reconnection, giving up", {
recursionReasons: Array.from(recursionReasons)
});
throw new Error(errorMessage, { cause: error62 });
};
if (NON_INTERACTIVE_FLOW) {
log("Signed in without a browser - reconnecting with the tokens it produced");
giveUpIfAlreadyRetried();
recursionReasons.add(REASON_AUTH_NEEDED);
return connectToRemoteServer(
client,
serverUrl,
authProvider,
headers,
authInitializer,
transportStrategy,
protocolMode,
recursionReasons
);
}
debugLog("Calling authInitializer to start auth flow");
const handoverAlreadyTried = recursionReasons.has(REASON_SIBLING_TOKENS);
const { waitForAuthCode, skipBrowserAuth } = await authInitializer({ forceRefresh: handoverAlreadyTried });
if (skipBrowserAuth) {
if (handoverAlreadyTried) {
log("Another instance owns the sign-in, and the tokens it wrote were refused; giving up");
throw new Error("Another instance completed the sign-in, but the remote server refused the tokens it wrote", { cause: error62 });
}
log("Authentication was completed by another instance - reconnecting with the tokens it wrote");
recursionReasons.add(REASON_SIBLING_TOKENS);
debugLog("Recursively reconnecting using a sibling instance tokens", {
recursionReasons: Array.from(recursionReasons)
});
return connectToRemoteServer(
client,
serverUrl,
authProvider,
headers,
authInitializer,
transportStrategy,
protocolMode,
recursionReasons
);
}
log("Authentication required. Waiting for authorization...");
debugLog("Waiting for auth code from callback server");
const { code, state, iss, completeAuthorization } = await waitForAuthCode();
debugLog("Received auth code from callback server");
try {
if (state && "useAuthorizationState" in authProvider && typeof authProvider.useAuthorizationState === "function") {
authProvider.useAuthorizationState(state);
}
giveUpIfAlreadyRetried();
log("Completing authorization...");
await (authChallengeTransport ?? transport).finishAuth(code, iss);
completeAuthorization?.(true);
debugLog("Authorization completed successfully");
recursionReasons.add(REASON_AUTH_NEEDED);
log(`Recursively reconnecting for reason: ${REASON_AUTH_NEEDED}`);
debugLog("Recursively reconnecting after auth", { recursionReasons: Array.from(recursionReasons) });
return connectToRemoteServer(
client,
serverUrl,
authProvider,
headers,
authInitializer,
transportStrategy,
protocolMode,
recursionReasons
);
} catch (authError) {
completeAuthorization?.(false);
log("Authorization error:", authError);
debugLog("Authorization error during finishAuth", {
errorMessage: authError.message,
stack: authError.stack
});
throw authError;
}
} else {
log("Connection error:", error62);
debugLog("Connection error", {
errorMessage: error62.message,
stack: error62.stack,
transportType: transport.constructor.name
});
throw error62;
}
}
}
async function setupOAuthCallbackServerWithLongPoll(options) {
const unclaimedCodes = [];
const waitingForCode = [];
let authEverCompleted = false;
const app = express();
let authCompletedResolve;
const authCompletedPromise = new Promise((resolve) => {
authCompletedResolve = resolve;
});
app.get(LONG_POLL_PATH, (req, res) => {
if (authEverCompleted) {
log("Auth already completed, returning 200");
res.status(200).send("Authentication completed");
return;
}
if (req.query.poll === "false") {
log("Client requested no long poll, responding with 202");
res.status(202).send("Authentication in progress");
return;
}
const longPollTimeout = setTimeout(() => {
log("Long poll timeout reached, responding with 202");
res.status(202).send("Authentication in progress");
}, options.authTimeoutMs || 3e4);
authCompletedPromise.then(() => {
clearTimeout(longPollTimeout);
if (!res.headersSent) {
log("Auth completed during long poll, responding with 200");
res.status(200).send("Authentication completed");
}
}).catch(() => {
clearTimeout(longPollTimeout);
if (!res.headersSent) {
log("Auth failed during long poll, responding with 500");
res.status(500).send("Authentication failed");
}
});
});
app.get(MCP_REMOTE_ID_PATH, (_req, res) => {
res.json({ mcpRemote: true, serverUrlHash: options.serverUrlHash });
});
app.get(options.path, (req, res) => {
res.set({ "Cache-Control": "no-store", "Referrer-Policy": "no-referrer" });
const code = req.query.code;
const state = req.query.state;
const iss = req.query.iss;
const authorizationError = req.query.error;
if (authorizationError) {
const description = req.query.error_description ?? authorizationError;
log(`Authorization failed: ${authorizationError} - ${description}`);
res.status(400).type("text/plain").send(
options.authSuccessUrl ? "Authorization failed. You may close this window and return to the CLI." : `Authorization failed: ${description}
You may close this window and return to the CLI.`
);
options.events.emit("auth-code-failed", new Error(`Authorization failed: ${authorizationError} - ${description}`));
return;
}
if (!code) {
res.status(400).send("Error: No authorization code received");
return;
}
const received = { code, state, iss };
if (options.authSuccessUrl) {
const timeout = setTimeout(() => {
if (!res.writableEnded && !res.destroyed) {
res.status(504).send("Authorization timed out. You may close this window and try again from the CLI.");
}
}, options.authTimeoutMs ?? 3e4);
res.once("close", () => clearTimeout(timeout));
let finished = false;
received.completeAuthorization = (success2) => {
if (finished) return;
finished = true;
clearTimeout(timeout);
if (success2) {
authEverCompleted = true;
authCompletedResolve(received);
}
if (res.writableEnded || res.destroyed) return;
if (success2) res.status(303).set("Location", options.authSuccessUrl).end();
else res.status(502).send("Authorization failed. You may close this window and try again from the CLI.");
};
} else {
authEverCompleted = true;
authCompletedResolve(received);
}
log("Auth code received, resolving promise");
const waiter = waitingForCode.shift();
if (waiter) waiter.resolve(received);
else unclaimedCodes.push(received);
if (!options.authSuccessUrl)
res.send(`
Authorization successful!
You may close this window and return to the CLI.
<script>
// If this is a non-interactive session (no manual approval step was required) then
// this should automatically close the window. If not, this will have no effect and
// the user will see the message above.
window.close();
</script>
`);
options.events.emit("auth-code-received", code, state);
});
const bindHost = options.bindHost?.trim() ? options.bindHost : DEFAULT_BIND_HOST;
const { server, actualPort } = await new Promise((resolve, reject) => {
const httpServer = app.listen(options.port, bindHost);
httpServer.once("error", (err) => {
if (err.code === "EADDRINUSE") {
reject(
Object.assign(new Error(`Callback port ${options.port} is already in use`), { code: "EADDRINUSE", requestedPort: options.port })
);
return;
}
reject(err);
});
httpServer.once("listening", () => {
const addr = httpServer.address();
log(`OAuth callback server running at http://${formatHostForUrl(addr.address)}:${addr.port}`);
resolve({ server: httpServer, actualPort: addr.port });
});
});
const waitForAuthCode = () => {
const alreadyHere = unclaimedCodes.shift();
if (alreadyHere) return Promise.resolve(alreadyHere);
return new Promise((resolve, reject) => {
const entry = {
resolve,
// An authorization the user denied never produces a code, and waiting for one holds the
// callback port for the life of the process
reject: (error62) => {
options.events.off("auth-code-failed", onFailure);
reject(error62);
}
};
const onFailure = (error62) => {
const index = waitingForCode.indexOf(entry);
if (index !== -1) waitingForCode.splice(index, 1);
entry.reject(error62);
};
waitingForCode.push(entry);
options.events.once("auth-code-failed", onFailure);
});
};
return { server, actualPort, authCode: null, waitForAuthCode, authCompletedPromise };
}
var DEFAULT_CALLBACK_PATH = "/oauth/callback";
var MCP_REMOTE_ID_PATH = "/.mcp-remote/id";
var LONG_POLL_PATH = "/wait-for-auth";
var DEFAULT_BIND_HOST = "127.0.0.1";
function formatHostForUrl(address) {
return address.includes(":") && !address.startsWith("[") ? `[${address}]` : address;
}
function buildRedirectUrl(host, port, callbackPath = DEFAULT_CALLBACK_PATH) {
return `http://${host}:${port}${callbackPath}`;
}
async function invalidateMismatchedClientRegistration(serverUrlHash, redirectUrl) {
const clientInfo = await readJsonFile(serverUrlHash, "client_info.json", OAuthClientInformationFullSchema);
if (!clientInfo || clientInfo.redirect_uris.includes(redirectUrl)) {
return;
}
log(
`Cached client registration is for ${clientInfo.redirect_uris.join(", ")} but this session will use ${redirectUrl}. Deleting it so the client re-registers.`
);
await rm(getConfigFilePath(serverUrlHash, "client_info.json"), { force: true });
}
function isClientMetadataUrl(value) {
try {
const url2 = new URL(value);
return url2.protocol === "https:" && url2.pathname !== "/";
} catch {
return false;
}
}
function calculateDefaultPort(serverUrlHash) {
const offset = parseInt(serverUrlHash.substring(0, 4), 16);
return 3335 + offset % 45816;
}
var RESERVED_AUTHORIZE_PARAMS = /* @__PURE__ */ new Set([
"client_id",
"redirect_uri",
"response_type",
"state",
"code_challenge",
"code_challenge_method"
]);
function parseAuthorizeParams(args) {
const params = {};
for (let i = 0; i < args.length - 1; i++) {
if (args[i] !== "--authorize-param") continue;
const raw = args[i + 1];
const separator = raw.indexOf("=");
if (separator < 1) {
throw new Error(
`Invalid --authorize-param value: "${raw}". Expected key=value, e.g. --authorize-param audience=https://api.example.com`
);
}
const key = raw.slice(0, separator).trim();
const value = raw.slice(separator + 1);
if (RESERVED_AUTHORIZE_PARAMS.has(key)) {
throw new Error(`--authorize-param cannot set "${key}": it is part of the authorization flow itself and is derived per request.`);
}
if (key === "resource") {
log("Warning: --authorize-param resource=... only applies to the authorization request. Use --resource so the token request agrees.");
}
params[key] = value;
}
return params;
}
function parseSecondsOption(args, flag, { allowZero = false } = {}) {
const index = args.indexOf(flag);
if (index === -1 || index >= args.length - 1) return void 0;
const raw = args[index + 1];
const seconds = Number(raw);
if (!Number.isFinite(seconds) || seconds < 0 || seconds === 0 && !allowZero) {
log(`Warning: Ignoring invalid ${flag} value: ${raw}. Must be a ${allowZero ? "non-negative" : "positive"} number of seconds.`);
return void 0;
}
return Math.round(seconds * 1e3);
}
function parseHeaderLine(line) {
const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
return match ? { name: match[1], value: match[2] } : void 0;
}
async function readHeaderFile(filePath) {
let contents;
try {
contents = await readFile(filePath, "utf8");
} catch (error62) {
throw new Error(`Could not read the header file ${filePath}: ${error62.message}`, { cause: error62 });
}
const headers = {};
contents.split(/\r?\n/).forEach((line, index) => {
const trimmed = line.trim();
if (!trimmed || trimmed.startsWith("#")) return;
const parsed = parseHeaderLine(trimmed);
if (!parsed) {
log(`Warning: ignoring line ${index + 1} of ${filePath}, which is not in Name:Value form`);
return;
}
headers[parsed.name] = parsed.value;
});
log(`Loaded ${Object.keys(headers).length} header(s) from ${filePath}`);
return headers;
}
async function parseCommandLineArgs(args, usage) {
if (args.includes("--help") || args.includes("-h")) {
process.stdout.write(`${usage}
`);
process.exit(0);
}
if (args.includes("--version")) {
process.stdout.write(`${version2}
`);
process.exit(0);
}
const headers = {};
let i = 0;
while (i < args.length) {
if (args[i] === "--header" && i < args.length - 1) {
const value = args[i + 1];
const parsed = parseHeaderLine(value);
if (parsed) headers[parsed.name] = parsed.value;
else log("Warning: ignoring a --header argument that is not in Name:Value form");
args.splice(i, 2);
continue;
}
if (args[i] === "--header-file" && i < args.length - 1) {
Object.assign(headers, await readHeaderFile(args[i + 1]));
args.splice(i, 2);
continue;
}
i++;
}
const serverUrl = args[0];
const specifiedPort = args[1] ? parseInt(args[1]) : void 0;
const allowHttp = args.includes("--allow-http");
const debug = args.includes("--debug");
if (debug) {
DEBUG = true;
log("Debug mode enabled - detailed logs will be written to ~/.mcp-auth/");
}
const silent = args.includes("--silent");
if (silent) {
SILENT = true;
log("Silent mode enabled - stderr output will be suppressed, except when --debug is also enabled");
}
const connectTimeoutMs = parseSecondsOption(args, "--connect-timeout");
const bodyTimeoutMs = parseSecondsOption(args, "--body-timeout", { allowZero: true });
const headersTimeoutMs = parseSecondsOption(args, "--headers-timeout", { allowZero: true });
const forceIpv4 = args.includes("--ipv4");
const dispatcherOptions = {};
if (connectTimeoutMs !== void 0 || forceIpv4) {
dispatcherOptions.connect = {
...connectTimeoutMs !== void 0 ? { timeout: connectTimeoutMs } : {},
// Happy-eyeballs tries every A and AAAA record it gets back. On a network where the IPv6
// routes are black holes rather than refusals, those attempts time out instead of failing
// fast and take the whole request with them, even though the IPv4 addresses are reachable.
...forceIpv4 ? { family: 4 } : {}
};
}
if (bodyTimeoutMs !== void 0) dispatcherOptions.bodyTimeout = bodyTimeoutMs;
if (headersTimeoutMs !== void 0) dispatcherOptions.headersTimeout = headersTimeoutMs;
if (forceIpv4) log("Restricting connections to IPv4");
if (connectTimeoutMs !== void 0) log(`Using connect timeout: ${connectTimeoutMs / 1e3} seconds`);
if (bodyTimeoutMs !== void 0) log(`Using body timeout: ${bodyTimeoutMs === 0 ? "disabled" : `${bodyTimeoutMs / 1e3} seconds`}`);
if (headersTimeoutMs !== void 0) {
log(`Using headers timeout: ${headersTimeoutMs === 0 ? "disabled" : `${headersTimeoutMs / 1e3} seconds`}`);
}
const enableProxy = args.includes("--enable-proxy");
if (enableProxy) {
setGlobalDispatcher(new EnvHttpProxyAgent(dispatcherOptions));
log("HTTP proxy support enabled - using system HTTP_PROXY/HTTPS_PROXY environment variables");
} else if (Object.keys(dispatcherOptions).length > 0) {
setGlobalDispatcher(new Agent(dispatcherOptions));
}
const pingIntervalMs = parseSecondsOption(args, "--ping-interval");
const keepAlive = {
enabled: args.includes("--keep-alive") || pingIntervalMs !== void 0,
intervalMs: pingIntervalMs ?? DEFAULT_KEEP_ALIVE_INTERVAL_MS
};
let transportStrategy = "http-first";
const transportIndex = args.indexOf("--transport");
if (transportIndex !== -1 && transportIndex < args.length - 1) {
const strategy = args[transportIndex + 1];
if (strategy === "sse-only" || strategy === "http-only" || strategy === "sse-first" || strategy === "http-first") {
transportStrategy = strategy;
log(`Using transport strategy: ${transportStrategy}`);
} else {
log(`Warning: Ignoring invalid transport strategy: ${strategy}. Valid values are: sse-only, http-only, sse-first, http-first`);
}
}
let protocolMode = "legacy";
const protocolIndex = args.indexOf("--protocol");
if (protocolIndex !== -1 && protocolIndex < args.length - 1) {
const mode = args[protocolIndex + 1];
if (mode === "legacy" || mode === "auto") {
protocolMode = mode;
log(`Using protocol mode: ${protocolMode}`);
} else {
log(`Warning: Ignoring invalid protocol mode: ${mode}. Valid values are: legacy, auto`);
}
}
let host = process.platform === "win32" ? "127.0.0.1" : "localhost";
const hostIndex = args.indexOf("--host");
if (hostIndex !== -1 && hostIndex < args.length - 1) {
host = formatHostForUrl(args[hostIndex + 1]);
log(`Using callback hostname: ${host}`);
}
let bindHost = DEFAULT_BIND_HOST;
const bindHostIndex = args.indexOf("--bind-host");
if (bindHostIndex !== -1 && bindHostIndex < args.length - 1) {
const requestedBindHost = args[bindHostIndex + 1].replace(/^\[(.*)\]$/, "$1");
if (requestedBindHost.trim() === "") {
log("Warning: ignoring an empty --bind-host; the OAuth callback server stays on loopback");
} else {
bindHost = requestedBindHost;
log(`Binding the OAuth callback server to: ${bindHost}`);
}
}
if (hostIndex === -1 && bindHost === "::1") {
host = "[::1]";
log(`Using callback hostname: ${host} (derived from --bind-host)`);
}
let callbackPath = DEFAULT_CALLBACK_PATH;
const callbackPathIndex = args.indexOf("--callback-path");
if (callbackPathIndex !== -1 && callbackPathIndex < args.length - 1) {
const value = args[callbackPathIndex + 1];
if (!value.startsWith("/")) {
log(`Warning: Ignoring invalid callback path: ${value}. It must start with '/'.`);
} else if (value === LONG_POLL_PATH || value === MCP_REMOTE_ID_PATH) {
log(`Warning: Ignoring reserved callback path: ${value}. It is used to coordinate concurrent instances.`);
} else {
callbackPath = value;
log(`Using callback path: ${callbackPath}`);
}
}
let authSuccessUrl;
const authSuccessIndex = args.indexOf("--auth-success-url");
if (authSuccessIndex !== -1) {
const value = args[authSuccessIndex + 1];
const invalid = () => {
throw new Error(
"--auth-success-url requires one HTTPS URL (or HTTP on loopback/with --allow-http), without credentials, query or fragment"
);
};
if (!value || value.startsWith("--") || args.lastIndexOf("--auth-success-url") !== authSuccessIndex) invalid();
let url3;
try {
url3 = new URL(value);
} catch {
return invalid();
}
const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url3.hostname);
if (url3.protocol !== "https:" && !(url3.protocol === "http:" && (loopback || allowHttp)) || url3.username || url3.password || value.includes("?") || value.includes("#"))
invalid();
authSuccessUrl = url3.href;
}
let staticOAuthClientMetadata = null;
const staticOAuthClientMetadataIndex = args.indexOf("--static-oauth-client-metadata");
if (staticOAuthClientMetadataIndex !== -1 && staticOAuthClientMetadataIndex < args.length - 1) {
const staticOAuthClientMetadataArg = args[staticOAuthClientMetadataIndex + 1];
if (staticOAuthClientMetadataArg.startsWith("@")) {
const filePath = staticOAuthClientMetadataArg.slice(1);
staticOAuthClientMetadata = JSON.parse(await readFile(filePath, "utf8"));
log(`Using static OAuth client metadata from file: ${filePath}`);
} else {
staticOAuthClientMetadata = JSON.parse(staticOAuthClientMetadataArg);
log(`Using static OAuth client metadata from string`);
}
}
let staticOAuthClientInfo = null;
const staticOAuthClientInfoIndex = args.indexOf("--static-oauth-client-info");
if (staticOAuthClientInfoIndex !== -1 && staticOAuthClientInfoIndex < args.length - 1) {
const staticOAuthClientInfoArg = args[staticOAuthClientInfoIndex + 1];
if (staticOAuthClientInfoArg.startsWith("@")) {
const filePath = staticOAuthClientInfoArg.slice(1);
staticOAuthClientInfo = parseJsonWithEnvVars(await readFile(filePath, "utf8"), "static OAuth client information");
log(`Using static OAuth client information from file: ${filePath}`);
} else {
staticOAuthClientInfo = parseJsonWithEnvVars(staticOAuthClientInfoArg, "static OAuth client information");
log(`Using static OAuth client information from string`);
}
}
let clientMetadataUrl;
const clientMetadataUrlIndex = args.indexOf("--client-metadata-url");
if (clientMetadataUrlIndex !== -1 && clientMetadataUrlIndex < args.length - 1) {
const value = args[clientMetadataUrlIndex + 1].trim();
if (isClientMetadataUrl(value)) {
clientMetadataUrl = value;
log(`Using client metadata document: ${value}`);
} else {
log(`Warning: Ignoring invalid client metadata URL: ${value}. It must be an HTTPS URL with a path.`);
}
}
if (args.includes("--disable-cookies")) {
COOKIES_ENABLED = false;
log("Cookies disabled; requests will not carry session stickiness");
}
const useDeviceCode = args.includes("--device-code");
if (useDeviceCode) {
log("Using the OAuth device grant; no browser will be opened on this machine");
}
const useClientCredentials = args.includes("--client-credentials");
if (useClientCredentials) {
log("Using the OAuth client_credentials grant; no browser will be opened and no user will be asked");
}
let tokenEndpoint;
const tokenEndpointIndex = args.indexOf("--token-endpoint");
if (tokenEndpointIndex !== -1) {
if (tokenEndpointIndex >= args.length - 1 || args[tokenEndpointIndex + 1].startsWith("--")) {
throw new Error("--token-endpoint requires an HTTPS URL");
}
if (!useClientCredentials) {
throw new Error("--token-endpoint can only be used with --client-credentials");
}
const value = args[tokenEndpointIndex + 1].trim();
let endpoint;
try {
endpoint = new URL(value);
} catch {
throw new Error("Invalid --token-endpoint value. Expected an HTTPS URL.");
}
const isLoopback = endpoint.protocol === "http:" && (endpoint.hostname === "localhost" || endpoint.hostname === "127.0.0.1" || endpoint.hostname === "[::1]");
if (endpoint.protocol !== "https:" && !isLoopback) {
throw new Error("--token-endpoint must use HTTPS, except for an HTTP loopback endpoint");
}
if (endpoint.username || endpoint.password || endpoint.hash) {
throw new Error("--token-endpoint must not contain credentials or a URL fragment");
}
tokenEndpoint = endpoint.toString();
log(`Using an explicit OAuth token endpoint at ${endpoint.origin}`);
}
NON_INTERACTIVE_FLOW = useDeviceCode || useClientCredentials;
const useIdToken = args.includes("--use-id-token");
if (useIdToken) {
log("Using the ID token as the bearer credential");
}
let authorizeResource;
let skipResourceParameter = args.includes("--disable-resource-parameter");
const resourceIndex = args.indexOf("--resource");
if (resourceIndex !== -1 && resourceIndex < args.length - 1) {
const value = args[resourceIndex + 1].trim();
if (value.length === 0) {
skipResourceParameter = true;
} else {
authorizeResource = value;
}
}
if (skipResourceParameter) {
if (authorizeResource) {
log(`Warning: --disable-resource-parameter overrides --resource ${authorizeResource}; the resource parameter will be omitted.`);
authorizeResource = void 0;
}
log("Resource parameter disabled - it will be omitted from authorization and token requests");
} else if (authorizeResource) {
try {
new URL(authorizeResource);
} catch {
throw new Error(`Invalid --resource value: "${authorizeResource}". RFC 8707 requires an absolute URI, e.g. https://example.com/mcp`);
}
log(`Using authorize resource: ${authorizeResource}`);
}
const authorizeParams = parseAuthorizeParams(args);
if (Object.keys(authorizeParams).length > 0) {
log(`Using extra authorization parameters: ${Object.keys(authorizeParams).join(", ")}`);
}
const ignoredTools = [];
let j = 0;
while (j < args.length) {
if (args[j] === "--ignore-tool" && j < args.length - 1) {
const toolName = args[j + 1];
ignoredTools.push(toolName);
log(`Ignoring tool: ${toolName}`);
args.splice(j, 2);
continue;
}
j++;
}
let authTimeoutMs = 3e4;
const authTimeoutIndex = args.indexOf("--auth-timeout");
if (authTimeoutIndex !== -1 && authTimeoutIndex < args.length - 1) {
const timeoutSeconds = parseInt(args[authTimeoutIndex + 1], 10);
if (!isNaN(timeoutSeconds) && timeoutSeconds > 0) {
authTimeoutMs = timeoutSeconds * 1e3;
log(`Using auth callback timeout: ${timeoutSeconds} seconds`);
} else {
log(`Warning: Ignoring invalid auth timeout value: ${args[authTimeoutIndex + 1]}. Must be a positive number.`);
}
}
if (!serverUrl) {
log(usage);
process.exit(1);
}
const url2 = new URL(serverUrl);
const isLocalhost = (url2.hostname === "localhost" || url2.hostname === "127.0.0.1") && url2.protocol === "http:";
if (!(url2.protocol == "https:" || isLocalhost || allowHttp)) {
log("Error: Non-HTTPS URLs are only allowed for localhost or when --allow-http flag is provided");
log(usage);
process.exit(1);
}
const serverUrlHash = getServerUrlHash(serverUrl, authorizeResource, headers, authorizeParams, clientMetadataUrl, tokenEndpoint);
global.currentServerUrlHash = serverUrlHash;
debugLog(`Starting mcp-remote with server URL: ${serverUrl}`);
const defaultPort = calculateDefaultPort(serverUrlHash);
let callbackPort;
if (specifiedPort) {
log(`Using specified callback port: ${specifiedPort}`);
callbackPort = specifiedPort;
} else {
log(`Using callback port derived from the server URL: ${defaultPort}`);
callbackPort = defaultPort;
}
if (!staticOAuthClientInfo) {
await invalidateMismatchedClientRegistration(serverUrlHash, buildRedirectUrl(host, callbackPort, callbackPath));
}
if (Object.keys(headers).length > 0) {
log(`Using custom headers: ${Object.keys(headers).join(", ")}`);
}
for (const [key, value] of Object.entries(headers)) {
headers[key] = substituteEnvVars(value, `header '${key}'`);
}
return {
serverUrl,
callbackPath,
callbackPort,
specifiedPort,
headers,
transportStrategy,
host,
debug,
staticOAuthClientMetadata,
staticOAuthClientInfo,
clientMetadataUrl,
useIdToken,
useDeviceCode,
useClientCredentials,
tokenEndpoint,
authorizeResource,
skipResourceParameter,
authorizeParams,
ignoredTools,
authTimeoutMs,
serverUrlHash,
keepAlive,
protocolMode,
authSuccessUrl,
bindHost
};
}
function setupSignalHandlers(cleanup) {
process.on("SIGINT", async () => {
log("\nShutting down...");
await cleanup();
process.exit(0);
});
process.stdin.resume();
process.stdin.on("end", async () => {
log("\nShutting down...");
await cleanup();
process.exit(0);
});
}
function getServerUrlHash(serverUrl, authorizeResource, headers, authorizeParams, clientMetadataUrl, tokenEndpoint) {
const parts = [serverUrl];
if (authorizeResource) parts.push(authorizeResource);
if (authorizeParams && Object.keys(authorizeParams).length > 0) {
const sorted = Object.keys(authorizeParams).sort();
parts.push(JSON.stringify(authorizeParams, sorted));
}
if (headers && Object.keys(headers).length > 0) {
const sortedKeys = Object.keys(headers).sort();
parts.push(JSON.stringify(headers, sortedKeys));
}
if (clientMetadataUrl) parts.push(clientMetadataUrl);
if (tokenEndpoint) parts.push(tokenEndpoint);
return crypto2.createHash("md5").update(parts.join("|")).digest("hex");
}
function patternToRegex(pattern) {
const parts = pattern.split("*");
const escapedParts = parts.map((part) => part.replace(/\W/g, "\\$&"));
const regexPattern = escapedParts.join(".*");
return new RegExp(`^${regexPattern}$`, "i");
}
function shouldIncludeTool(ignorePatterns, toolName) {
if (!ignorePatterns || ignorePatterns.length === 0) {
return true;
}
for (const pattern of ignorePatterns) {
const regex = patternToRegex(pattern);
if (regex.test(toolName)) {
return false;
}
}
return true;
}
// src/lib/open-browser.ts
import { spawn } from "child_process";
import open2 from "open";
var HELPER_SETTLE_MS = 500;
var LINUX_FALLBACKS = [
{ command: "/usr/bin/xdg-open", args: (url2) => [url2] },
{ command: "gio", args: (url2) => ["open", url2] },
{ command: "x-www-browser", args: (url2) => [url2] },
{ command: "sensible-browser", args: (url2) => [url2] }
];
function launched(child, name) {
return new Promise((resolve) => {
const settle2 = setTimeout(() => {
debugLog(`Browser helper ${name} is still running, treating it as the browser`);
resolve(true);
}, HELPER_SETTLE_MS);
settle2.unref?.();
const settled = (result) => {
clearTimeout(settle2);
resolve(result);
};
child.once("error", (error62) => {
debugLog(`Browser helper ${name} failed to start`, error62);
settled(false);
});
child.once("exit", (code) => {
debugLog(`Browser helper ${name} exited`, { code });
settled(code === 0);
});
});
}
async function openBrowser(url2) {
debugLog("Browser launch environment", {
DISPLAY: process.env.DISPLAY,
WAYLAND_DISPLAY: process.env.WAYLAND_DISPLAY,
DBUS_SESSION_BUS_ADDRESS: process.env.DBUS_SESSION_BUS_ADDRESS ? "set" : void 0,
BROWSER: process.env.BROWSER
});
try {
if (await launched(await open2(url2), "open")) {
return true;
}
} catch (error62) {
debugLog("Failed to spawn the bundled opener", error62);
}
if (process.platform !== "linux") {
return false;
}
for (const fallback of LINUX_FALLBACKS) {
try {
log(`Trying ${fallback.command} to open the browser...`);
if (await launched(spawn(fallback.command, fallback.args(url2), { stdio: "ignore" }), fallback.command)) {
return true;
}
} catch (error62) {
debugLog(`Failed to spawn ${fallback.command}`, error62);
}
}
return false;
}
// src/lib/device-authorization.ts
var DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
var DEFAULT_POLL_INTERVAL_SECONDS = 5;
var SLOW_DOWN_INCREMENT_SECONDS = 5;
var DEFAULT_EXPIRY_SECONDS = 30 * 60;
var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
function supportsDeviceAuthorization(metadata) {
if (!metadata?.device_authorization_endpoint) return false;
const grants = metadata.grant_types_supported;
return !Array.isArray(grants) || grants.includes(DEVICE_CODE_GRANT_TYPE);
}
async function authorizeWithDeviceCode({
metadata,
clientInformation,
scope,
resource
}) {
const deviceAuthorizationEndpoint = metadata.device_authorization_endpoint;
if (typeof deviceAuthorizationEndpoint !== "string") {
throw new Error("The authorization server does not offer a device authorization endpoint");
}
if (!metadata.token_endpoint) {
throw new Error("The authorization server metadata has no token endpoint");
}
const authMethod = selectClientAuthMethod(clientInformation, metadata.token_endpoint_auth_methods_supported ?? []);
const authorization = await requestDeviceAuthorization(deviceAuthorizationEndpoint, {
clientInformation,
authMethod,
scope,
resource
});
log("");
log("To authorize this client, visit:");
log(` ${authorization.verification_uri_complete ?? authorization.verification_uri}`);
if (!authorization.verification_uri_complete) {
log("");
log(`And enter the code: ${authorization.user_code}`);
}
log("");
log("Waiting for approval...");
return pollForTokens(metadata.token_endpoint, {
authorization,
clientInformation,
authMethod,
resource
});
}
async function requestDeviceAuthorization(endpoint, options) {
const headers = new Headers({ "content-type": "application/x-www-form-urlencoded", accept: "application/json" });
const params = new URLSearchParams();
applyClientAuthentication2(options.authMethod, options.clientInformation, headers, params);
if (options.scope) params.set("scope", options.scope);
if (options.resource) params.set("resource", options.resource.href);
debugLog("Requesting device authorization", { endpoint, scope: options.scope });
const response = await fetch(endpoint, { method: "POST", headers, body: params });
if (!response.ok) {
throw new Error(`Device authorization request failed (HTTP ${response.status}): ${await errorDetail(response)}`);
}
const authorization = await response.json();
if (!authorization?.device_code || !authorization.user_code || !authorization.verification_uri) {
throw new Error("The authorization server returned an incomplete device authorization response");
}
debugLog("Device authorization issued", {
verification_uri: authorization.verification_uri,
expires_in: authorization.expires_in,
interval: authorization.interval
});
return authorization;
}
async function pollForTokens(tokenEndpoint, options) {
const { authorization } = options;
let intervalSeconds = authorization.interval ?? DEFAULT_POLL_INTERVAL_SECONDS;
const deadline = Date.now() + (authorization.expires_in ?? DEFAULT_EXPIRY_SECONDS) * 1e3;
while (Date.now() < deadline) {
await delay(intervalSeconds * 1e3);
const headers = new Headers({ "content-type": "application/x-www-form-urlencoded", accept: "application/json" });
const params = new URLSearchParams({ grant_type: DEVICE_CODE_GRANT_TYPE, device_code: authorization.device_code });
applyClientAuthentication2(options.authMethod, options.clientInformation, headers, params);
if (options.resource) params.set("resource", options.resource.href);
const response = await fetch(tokenEndpoint, { method: "POST", headers, body: params });
if (response.ok) {
log("Authorized.");
return OAuthTokensSchema.parse(await response.json());
}
const body = await response.json().catch(() => void 0);
switch (body?.error) {
case "authorization_pending":
continue;
case "slow_down":
intervalSeconds += SLOW_DOWN_INCREMENT_SECONDS;
debugLog("Device token endpoint asked us to slow down", { intervalSeconds });
continue;
case "access_denied":
throw new Error("Authorization was denied");
case "expired_token":
throw new Error("The device code expired before it was approved");
default:
throw new Error(
`Device token request failed (HTTP ${response.status}): ${body?.error_description ?? body?.error ?? "unknown error"}`
);
}
}
throw new Error("The device code expired before it was approved");
}
function applyClientAuthentication2(method, clientInformation, headers, params) {
const { client_id, client_secret } = clientInformation;
if (method === "client_secret_basic") {
if (!client_secret) throw new Error("client_secret_basic authentication requires a client_secret");
headers.set("Authorization", `Basic ${Buffer.from(`${client_id}:${client_secret}`).toString("base64")}`);
return;
}
if (method === "client_secret_post") {
params.set("client_id", client_id);
if (client_secret) params.set("client_secret", client_secret);
return;
}
if (method !== "none") {
throw new Error(`Unsupported client authentication method: ${method}`);
}
params.set("client_id", client_id);
}
async function errorDetail(response) {
try {
const text = await response.text();
return text.slice(0, 500) || response.statusText;
} catch {
return response.statusText;
}
}
// src/lib/client-credentials.ts
async function authorizeWithClientCredentials({
metadata,
clientInformation,
scope,
resource
}) {
const tokenEndpoint = metadata.token_endpoint;
if (typeof tokenEndpoint !== "string") {
throw new Error("The authorization server metadata has no token endpoint");
}
const endpoint = new URL(tokenEndpoint);
if (endpoint.protocol !== "https:" && endpoint.hostname !== "localhost" && endpoint.hostname !== "127.0.0.1") {
throw new Error(
`Refusing to send the client secret to ${endpoint.origin} over ${endpoint.protocol.replace(":", "")}. The client_credentials grant needs an https token endpoint.`
);
}
log(`Requesting a token from ${endpoint.origin} with the client_credentials grant`);
if (!clientInformation.client_secret) {
throw new Error(
"The client_credentials grant needs a client secret. Supply one with --static-oauth-client-info, which accepts `@path/to/file.json` and `${ENV_VAR}` placeholders so the secret need not sit in the command line."
);
}
const authMethod = selectClientAuthMethod(clientInformation, metadata.token_endpoint_auth_methods_supported ?? []);
const headers = new Headers({ "content-type": "application/x-www-form-urlencoded", accept: "application/json" });
const params = new URLSearchParams({ grant_type: "client_credentials" });
applyClientAuthentication2(authMethod, clientInformation, headers, params);
if (scope) params.set("scope", scope);
if (resource) params.set("resource", resource.href);
debugLog("Requesting a token with the client_credentials grant", { tokenEndpoint, authMethod, scope, resource: resource?.href });
const response = await fetch(tokenEndpoint, { method: "POST", headers, body: params });
if (!response.ok) {
const body = await response.json().catch(() => void 0);
const detail = (body?.error_description ?? body?.error ?? "unknown error").slice(0, 500);
throw new Error(`The client_credentials token request failed (HTTP ${response.status}): ${detail}`);
}
const tokens = OAuthTokensSchema.parse(await response.json());
log("Signed in with the client_credentials grant");
return tokens;
}
// src/lib/node-oauth-client-provider.ts
import { sanitizeUrl } from "strict-url-sanitise";
import { createHash, randomUUID as randomUUID2 } from "node:crypto";
var OAuthTokensWithExpiresAtSchema = OAuthTokensSchema.extend({
expires_at: external_exports.coerce.number().optional(),
requested_scope: external_exports.string().optional(),
issuer: external_exports.string().optional()
});
var DiscoveryStateSchema = external_exports.looseObject({
authorizationServerUrl: external_exports.string(),
resourceMetadataUrl: external_exports.string().optional(),
authorizationServerMetadata: external_exports.union([OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema]).optional(),
resourceMetadata: OAuthProtectedResourceMetadataSchema.optional()
});
var ClientInformationStoreSchema = OAuthClientInformationFullSchema.extend({
issuer: external_exports.string().optional()
});
var FALLBACK_SCOPE = "openid email profile";
var ISSUED_STATE = /^[A-Za-z0-9-]{1,64}$/;
var CODE_VERIFIER_PREFIX = "code_verifier_";
var TOKEN_STORM_LIMIT = 20;
var TOKEN_STORM_WINDOW_MS = 3e4;
var AUTHORIZATION_STORM_LIMIT = 5;
var TOKEN_EXPIRY_MARGIN_MS = 6e4;
var REFRESH_LEASE_FILE = "refresh_in_progress.json";
var DISCOVERY_STATE_PREFIX = "discovery_state_";
var REFRESH_LEASE_MS = 3e4;
var REFRESH_POLL_MS = 200;
var REFRESH_LEASE_WAIT_MS = 2 * REFRESH_LEASE_MS;
var REFUSING_ERRORS = /* @__PURE__ */ new Set([
OAuthErrorCode.InvalidGrant,
OAuthErrorCode.InvalidClient,
OAuthErrorCode.UnauthorizedClient
]);
var REFUSALS_REMEMBERED = 16;
var UNCOORDINATED = "";
var ABANDONED_FLOW_AGE_MS = 10 * 60 * 1e3;
var CONCURRENT_FLOW_WINDOW_MS = 1e4;
function codeChallengeFor(codeVerifier) {
return createHash("sha256").update(codeVerifier).digest("base64url");
}
var TOKEN_ENDPOINT_AUTH_METHOD_PREFERENCE = ["none", "client_secret_post", "client_secret_basic"];
function jwtExpiresAt(token) {
const payload = token.split(".")[1];
if (!payload) return void 0;
try {
const { exp } = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
return typeof exp === "number" ? exp * 1e3 : void 0;
} catch {
return void 0;
}
}
function staleClientRegistrationError(value) {
if (!value || typeof value !== "object") {
return void 0;
}
const response = value;
const message = typeof response.error_description === "string" ? response.error_description : "Cached OAuth client registration is no longer valid";
if (response.error === OAuthErrorCode.InvalidClient) {
return new OAuthError(OAuthErrorCode.InvalidClient, message);
}
if (response.error === OAuthErrorCode.UnauthorizedClient) {
return new OAuthError(OAuthErrorCode.UnauthorizedClient, message);
}
return void 0;
}
function tokenRequestParams(init) {
if (init?.method?.toUpperCase() !== "POST") return void 0;
if (init.body instanceof URLSearchParams) return init.body;
if (typeof init.body === "string" && new Headers(init.headers).get("Content-Type")?.startsWith("application/x-www-form-urlencoded")) {
return new URLSearchParams(init.body);
}
return void 0;
}
function refreshTokenRedeemedBy(init) {
const params = tokenRequestParams(init);
return params?.get("grant_type") === "refresh_token" ? params.get("refresh_token") ?? void 0 : void 0;
}
function withRefreshToken(init, refreshToken) {
const params = tokenRequestParams(init);
if (!params || params.get("refresh_token") === refreshToken) return init;
const body = new URLSearchParams(params);
body.set("refresh_token", refreshToken);
return { ...init, body };
}
function answerWithStoredTokens(stored) {
const expiresIn = stored.expires_at === void 0 ? stored.expires_in : Math.max(1, Math.floor((stored.expires_at - Date.now()) / 1e3));
const body = {
access_token: stored.access_token,
token_type: stored.token_type,
refresh_token: stored.refresh_token,
scope: stored.scope,
id_token: stored.id_token,
expires_in: expiresIn
};
return new Response(JSON.stringify(body), { status: 200, headers: { "Content-Type": "application/json", "Cache-Control": "no-store" } });
}
var NodeOAuthClientProvider = class {
/**
* Creates a new NodeOAuthClientProvider
* @param options Configuration options for the provider
*/
constructor(options) {
this.options = options;
this.serverUrlHash = options.serverUrlHash;
this.callbackPath = options.callbackPath || "/oauth/callback";
this.clientName = options.clientName || "MCP CLI Client";
this.clientUri = options.clientUri || "https://github.com/modelcontextprotocol/mcp-cli";
this.softwareId = options.softwareId || "2e6dc280-f3c3-4e01-99a7-8181dbd1d23d";
this.softwareVersion = options.softwareVersion || version2;
this.staticOAuthClientMetadata = options.staticOAuthClientMetadata;
this.staticOAuthClientInfo = options.staticOAuthClientInfo;
this.clientMetadataUrl = options.clientMetadataUrl;
this.useIdToken = options.useIdToken ?? false;
this.useDeviceCode = options.useDeviceCode ?? false;
this.useClientCredentials = options.useClientCredentials ?? false;
const trimmedAuthorizeResource = options.authorizeResource?.trim();
this.authorizeResource = trimmedAuthorizeResource ? trimmedAuthorizeResource : void 0;
this.skipResourceParameter = options.skipResourceParameter ?? false;
this.authorizeParams = options.authorizeParams ?? {};
this._state = randomUUID2();
this._clientInfo = void 0;
this.clientRegistrationSource = void 0;
this.authorizationServerMetadata = options.authorizationServerMetadata;
this.protectedResourceMetadata = options.protectedResourceMetadata;
this.wwwAuthenticateScope = options.wwwAuthenticateScope;
if (this.skipResourceParameter) {
this.validateResourceURL = async () => {
debugLog("Resource parameter disabled; omitting it from authorization and token requests");
return void 0;
};
} else if (this.authorizeResource) {
const resourceUrl = new URL(this.authorizeResource);
this.validateResourceURL = async () => resourceUrl;
} else if (this.hasExplicitTokenEndpoint) {
this.validateResourceURL = async () => void 0;
}
}
serverUrlHash;
callbackPath;
clientName;
clientUri;
softwareId;
softwareVersion;
staticOAuthClientMetadata;
staticOAuthClientInfo;
/**
* URL of a Client ID Metadata Document, which SEP-991 lets a server accept in place of a
* registered client id. Read by the SDK, hence a public field rather than a private one.
*/
clientMetadataUrl;
useIdToken;
useDeviceCode;
useClientCredentials;
/** So a server that never issues an ID token is reported once, not on every outgoing request. */
warnedAboutMissingIdToken = false;
authorizeResource;
authorizeParams;
skipResourceParameter;
/**
* Overrides how the SDK picks the RFC 8707 `resource` indicator. Only defined when we have
* an opinion; otherwise the SDK derives it from Protected Resource Metadata as usual.
*/
validateResourceURL;
_state;
_clientInfo;
clientRegistrationSource;
/** So {@link forgetSavedStaticClient} searches the store once, not on every read. */
checkedForSavedStaticClient = false;
incomingState;
authorizationServerMetadata;
protectedResourceMetadata;
wwwAuthenticateScope;
/** When tokens were last written, for spotting an exchange loop. See {@link TOKEN_STORM_LIMIT}. */
recentTokenWrites = [];
/** When sign-ins were last started, for spotting a loop that never gets as far as a token. */
recentAuthorizations = [];
/** In-flight proactive refresh, so concurrent requests share one refresh_token use */
refreshInFlight = null;
/**
* Refresh tokens the authorization server refused, and bearer credentials the MCP server answered
* with 401: what "the refused token" means when this instance is asked to discard it, rather than
* whatever the shared store happens to hold by then. See {@link discardRefusedTokens}.
*/
refusedRefreshTokens = /* @__PURE__ */ new Set();
rejectedBearers = /* @__PURE__ */ new Set();
/** Concurrent requests share one client_credentials renewal, which has no refresh token. */
clientCredentialsInFlight = null;
/**
* The sign-in being started, so concurrent arms join it rather than race it.
*
* `challenge` is set by whichever arm saved its verifier first, and is what identifies that
* arm's redirect among the several that follow. See {@link CONCURRENT_FLOW_WINDOW_MS}.
*/
pendingFlow = null;
/** The discovery the next redirect is built from, until {@link saveCodeVerifier} files it under its flow. */
flowDiscovery;
setCallbackPort(port) {
this.options.callbackPort = port;
}
get hasExplicitTokenEndpoint() {
return this.useClientCredentials && !!this.options.tokenEndpoint;
}
get redirectUrl() {
if (this.hasExplicitTokenEndpoint) return void 0;
return buildRedirectUrl(this.options.host, this.options.callbackPort, this.callbackPath);
}
/**
* The authorization-server discovery behind the current sign-in.
*
* For the authorization-code flow this is what {@link saveCodeVerifier} persisted for the flow
* being redeemed, so the callback leg - possibly in whichever process ended up holding the
* callback port - can check that the server which issued the code is the one it is redeemed
* against (SEP-2352). With an explicit token endpoint there is no discovery and nothing to read
* back: the state is synthesized from configuration.
*
* Scoped to a flow rather than kept as a cache. The SDK prefers a cached state over a live
* challenge, so one that outlived its sign-in would pin a server that moved to another
* authorization server to the old one - and nothing here would ever notice, since that server
* never hands out a token to be refused. Outside a sign-in there is nothing to read, and the SDK
* discovers afresh as it always has.
*/
async discoveryState() {
if (this.hasExplicitTokenEndpoint) {
const endpoint = new URL(this.options.tokenEndpoint);
return {
authorizationServerUrl: endpoint.origin,
authorizationServerMetadata: {
issuer: endpoint.origin,
token_endpoint: endpoint.href,
grant_types_supported: ["client_credentials"]
// The SDK types full OAuth/OIDC documents, but this grant has no authorization endpoint.
},
// Both layers must be present: the SDK otherwise still probes protected-resource metadata
// after a 401, even when the authorization server and token endpoint are already known.
resourceMetadata: { resource: this.resourceServerUrl, authorization_servers: [endpoint.origin] }
};
}
this.flowDiscovery = await readJsonFile(
this.serverUrlHash,
this.discoveryStateFile(this.flowState),
DiscoveryStateSchema
);
return this.flowDiscovery;
}
/**
* Holds the discovery the SDK just ran until {@link saveCodeVerifier} writes it.
*
* The SDK saves it before it asks for the flow's state, so there is no flow to file it under yet.
* It needs the same durability as the code verifier - the redirect may complete in a different
* process, which reads it back off disk - and is written alongside it.
*
* The explicit-token-endpoint flow performs no discovery, so the only state it could record is
* the synthesized state above, which needs no persisting.
*/
async saveDiscoveryState(state) {
if (this.hasExplicitTokenEndpoint) return;
this.flowDiscovery = state;
}
async prepareTokenRequest(scope) {
if (!this.hasExplicitTokenEndpoint) return void 0;
if (this.inTokenStorm()) throw this.tokenStormError();
const clientInformation = await this.clientInformation();
if (!clientInformation?.client_secret) {
throw new Error("The client_credentials grant needs a client secret; supply it with --static-oauth-client-info");
}
const params = new URLSearchParams({ grant_type: "client_credentials" });
const effectiveScope = this.staticOAuthClientMetadata?.scope?.trim() || scope;
if (effectiveScope) params.set("scope", effectiveScope);
this.wwwAuthenticateScope = effectiveScope;
log(`Requesting a token from ${new URL(this.options.tokenEndpoint).origin} with the client_credentials grant`);
return params;
}
/**
* The MCP server URL, for the RFC 8707 resource indicator. `options.serverUrl` holds the
* authorization server URL by the time it reaches this class (see proxy.ts/client.ts), which
* only coincides with the resource server when the two share an origin.
*/
get resourceServerUrl() {
return this.options.resourceServerUrl ?? this.options.serverUrl;
}
get clientMetadata() {
const effectiveScope = this.getEffectiveScope();
return {
redirect_uris: this.redirectUrl ? [this.redirectUrl] : [],
token_endpoint_auth_method: this.getTokenEndpointAuthMethod(),
grant_types: this.grantTypes(),
response_types: ["code"],
client_name: this.clientName,
client_uri: this.clientUri,
software_id: this.softwareId,
software_version: this.softwareVersion,
...this.staticOAuthClientMetadata,
...effectiveScope ? { scope: effectiveScope } : {}
};
}
/**
* The `state` this authorization will carry.
*
* Called once per flow, and the first provider method a new flow reaches, so it is where a
* flow is recognised as new. Concurrent arms are handed the state of the flow already being
* started: only one of them can be redeemed, and sharing the state means the code that comes
* back names the verifier that flow actually saved.
*
* A new flow supersedes any code received for an earlier one, so the state a callback last
* reported is dropped here - otherwise {@link flowState} would keep reading for a verifier this
* flow never wrote (and {@link saveTokens} has since deleted).
*/
state() {
const pending = this.pendingFlow;
if (pending && Date.now() - pending.startedAt < CONCURRENT_FLOW_WINDOW_MS) {
debugLog("Joining the sign-in already being started", { state: pending.state });
return pending.state;
}
this._state = randomUUID2();
this.incomingState = void 0;
this.pendingFlow = { state: this._state, startedAt: Date.now() };
return this._state;
}
/**
* Gets the authorization server metadata, fetching it if not already available
* @returns The authorization server metadata, or undefined if unavailable
*/
async getAuthorizationServerMetadata() {
debugLog(`authorizationServerMetadata: ${JSON.stringify(this.authorizationServerMetadata)}`);
if (this.authorizationServerMetadata) {
return this.authorizationServerMetadata;
}
try {
this.authorizationServerMetadata = await fetchAuthorizationServerMetadata(this.options.serverUrl);
if (this.authorizationServerMetadata?.scopes_supported) {
debugLog("Authorization server supports scopes", {
scopes_supported: this.authorizationServerMetadata.scopes_supported
});
}
return this.authorizationServerMetadata;
} catch (error62) {
debugLog("Failed to fetch authorization server metadata", error62);
return void 0;
}
}
/**
* Picks how this client will authenticate at the token endpoint, from what the server offers.
*
* `none` comes first because that is what this client honestly is: a public client on someone's
* laptop, holding no secret worth the name and relying on PKCE. Registering as anything else,
* only to be handed a secret that npx writes to disk, buys nothing.
*
* But an authorization server that leaves `none` out of `token_endpoint_auth_methods_supported`
* has said it will not accept public clients, and registering as one anyway produced a client
* whose token requests it then refused (see issue #184). So when `none` is not on offer we take
* the best of the secret-based methods we can actually perform and let dynamic registration hand
* us the secret; the SDK reads the method back off the registration and sends it that way.
*
* `private_key_jwt` and its relatives are left out deliberately - they need a key pair and a
* signed assertion, neither of which this client has any way to produce.
*
* With no metadata to read we stay on `none`, which is what every server working today already
* gets. RFC 8414's `client_secret_basic` default describes servers that publish metadata; one
* that publishes none has told us nothing to act on.
*/
getTokenEndpointAuthMethod() {
const supported = this.authorizationServerMetadata?.token_endpoint_auth_methods_supported;
if (!Array.isArray(supported) || supported.length === 0) {
return "none";
}
const method = TOKEN_ENDPOINT_AUTH_METHOD_PREFERENCE.find((candidate) => supported.includes(candidate));
if (!method) {
debugLog("Authorization server advertises no token endpoint auth method this client can perform", {
token_endpoint_auth_methods_supported: supported
});
return "none";
}
if (method !== "none") {
debugLog("Registering with the token endpoint auth method the authorization server advertises", {
token_endpoint_auth_method: method,
token_endpoint_auth_methods_supported: supported
});
}
return method;
}
getEffectiveScope() {
return this.requestedScope() ?? (this.hasExplicitTokenEndpoint ? "" : FALLBACK_SCOPE);
}
requestedScope() {
if (this.staticOAuthClientMetadata?.scope && this.staticOAuthClientMetadata.scope.trim().length > 0) {
debugLog("Using scope from staticOAuthClientMetadata", { scope: this.staticOAuthClientMetadata.scope });
return this.staticOAuthClientMetadata.scope;
}
if (this.wwwAuthenticateScope && this.wwwAuthenticateScope.trim().length > 0) {
debugLog("Using scope from WWW-Authenticate header", { scope: this.wwwAuthenticateScope });
return this.wwwAuthenticateScope;
}
const resourceScopes = this.protectedResourceMetadata?.scopes_supported;
if (resourceScopes !== void 0) {
if (resourceScopes.length === 0) {
debugLog("Protected resource advertises no scopes (scopes_supported: []), omitting scope");
return "";
}
const scope = resourceScopes.join(" ");
debugLog("Using scopes from Protected Resource Metadata", {
scopes_supported: resourceScopes,
scope
});
return scope;
}
if (this._clientInfo?.scope && this._clientInfo.scope.trim().length > 0) {
debugLog("Using scope from client registration response", { scope: this._clientInfo.scope });
return this._clientInfo.scope;
}
const authScopes = this.authorizationServerMetadata?.scopes_supported;
if (authScopes !== void 0) {
if (authScopes.length === 0) {
debugLog("Authorization server advertises no scopes (scopes_supported: []), omitting scope");
return "";
}
const scope = authScopes.join(" ");
debugLog("Using scopes from Authorization Server Metadata", {
scopes_supported: authScopes,
scope
});
return scope;
}
debugLog("No source describes the scope to request");
return void 0;
}
/**
* Client authentication for every token request the SDK or this provider sends (the SDK's
* `executeTokenRequest`). Once a provider supplies this hook the SDK skips its own client
* authentication, so the hook reproduces that first, then adds the one parameter the SDK
* leaves out: `scope` on a `refresh_token` grant.
*
* RFC 6749 section 6 makes `scope` optional on refresh and the SDK omits it. Microsoft Entra ID
* reads a scopeless refresh from an app whose client id is also the resource as "requesting a
* token for itself" and answers `AADSTS90009`, so the session dies at every access-token expiry
* (modelcontextprotocol/typescript-sdk#2718, anthropics/claude-ai-mcp#840). Repeating the scope
* the grant carries turns that 400 into a 200, and names nothing the original grant did not, so
* every other server accepts it too. Authorization-code exchanges are left exactly as they were.
*
* An arrow property rather than a method: the SDK passes `provider.addClientAuthentication`
* around unbound (see its `auth()`), so `this` has to travel with it.
*/
addClientAuthentication = async (headers, params, _url3, metadata) => {
const clientInformation = await this.clientInformation();
if (clientInformation) {
const authMethod = selectClientAuthMethod(
this.hasExplicitTokenEndpoint && this.staticOAuthClientMetadata?.token_endpoint_auth_method ? { ...clientInformation, token_endpoint_auth_method: this.staticOAuthClientMetadata.token_endpoint_auth_method } : clientInformation,
metadata?.token_endpoint_auth_methods_supported ?? []
);
applyClientAuthentication2(authMethod, clientInformation, headers, params);
}
if (params.get("grant_type") === "refresh_token" && !params.has("scope")) {
const scope = await this.scopeToRepeatOnRefresh();
if (scope) {
params.set("scope", scope);
debugLog("Added the requested scope to the refresh_token grant", { scope });
}
}
};
/**
* The scope to repeat on a refresh: what the authorization server actually granted, when it said
* so in the token response, and otherwise what this client asked for.
*
* RFC 6749 section 6 forbids a refresh from naming a scope the resource owner never granted, so
* echoing the request back at a server that downscoped the authorization earns `invalid_scope` -
* the refresh this exists to fix, broken a different way. The grant is the safe thing to repeat.
*/
async scopeToRepeatOnRefresh() {
const stored = await readJsonFile(this.serverUrlHash, "tokens.json", OAuthTokensWithExpiresAtSchema);
return stored?.scope ?? this.getEffectiveScope();
}
/**
* Gets the client information if it exists
* @param ctx The authorization server the SDK resolved, when it is the SDK asking
* @returns The client information or undefined
*/
async clientInformation(ctx) {
debugLog("Reading client info");
if (this.staticOAuthClientInfo) {
debugLog("Returning static client info");
this._clientInfo = this.staticOAuthClientInfo;
this.clientRegistrationSource = "static";
await this.forgetSavedStaticClient();
return ctx ? { ...this.staticOAuthClientInfo, issuer: ctx.issuer } : this.staticOAuthClientInfo;
}
const clientIdMetadataDocument = await this.clientIdMetadataDocument();
if (clientIdMetadataDocument) {
this.clientRegistrationSource = "client-id-metadata-document";
return clientIdMetadataDocument;
}
const clientInfo = await readJsonFile(
this.serverUrlHash,
"client_info.json",
ClientInformationStoreSchema
);
if (clientInfo) {
this._clientInfo = clientInfo;
if (this.clientRegistrationSource !== "fresh-dynamic") {
this.clientRegistrationSource = "cached-dynamic";
}
}
debugLog("Client info result:", clientInfo ? "Found" : "Not found");
return clientInfo;
}
/**
* The client id to use when the authorization server accepts a Client ID Metadata Document.
*
* SEP-991 lets a client be identified by an HTTPS URL that serves its own metadata, removing the
* need to register at all. That helps against servers with no dynamic registration, and against
* those that hand out a fresh client on every run.
*
* The SDK has this branch too, but only reaches it when nothing is cached. Deciding it here
* means a client that already registered dynamically switches over as soon as the flag is
* passed, instead of quietly carrying on with the old registration.
*/
async clientIdMetadataDocument() {
if (!this.clientMetadataUrl) {
return void 0;
}
const metadata = await this.getAuthorizationServerMetadata();
if (metadata?.client_id_metadata_document_supported !== true) {
debugLog("Authorization server does not accept a client metadata document; registering instead", {
clientMetadataUrl: this.clientMetadataUrl
});
return void 0;
}
debugLog("Identifying this client by its metadata document", { client_id: this.clientMetadataUrl });
return { client_id: this.clientMetadataUrl };
}
/**
* Removes the copy of the static client that versions before this one saved to client_info.json.
*
* They let the SDK's issuer stamp through to {@link saveClientInformation}, which wrote the static
* client - secret and all - into the store. Only that copy goes: a registration of any other
* client is what a run without the flag goes back to.
*/
async forgetSavedStaticClient() {
if (this.checkedForSavedStaticClient) return;
this.checkedForSavedStaticClient = true;
const saved = await readJsonFile(
this.serverUrlHash,
"client_info.json",
external_exports.looseObject({ client_id: external_exports.string() })
);
if (saved && saved.client_id === this.staticOAuthClientInfo?.client_id) {
debugLog("Removing the copy of the static client an earlier version saved");
await deleteConfigFile(this.serverUrlHash, "client_info.json");
}
}
/**
* Saves client information
* @param clientInformation The client information to save
*/
async saveClientInformation(clientInformation) {
if (this.clientMetadataUrl && clientInformation.client_id === this.clientMetadataUrl) {
debugLog("Not caching a client id that came from a client metadata document");
this.clientRegistrationSource = "client-id-metadata-document";
return;
}
if (this.staticOAuthClientInfo) {
debugLog("Not caching the static client");
return;
}
const isRestampOfCachedClient = this.clientRegistrationSource === "cached-dynamic" && clientInformation.client_id === this._clientInfo?.client_id;
debugLog("Saving client info", { client_id: clientInformation.client_id, restamp: isRestampOfCachedClient });
this._clientInfo = clientInformation;
if (!isRestampOfCachedClient) {
this.clientRegistrationSource = "fresh-dynamic";
}
await writeJsonFile(this.serverUrlHash, "client_info.json", clientInformation);
}
/**
* Gets the OAuth tokens if they exist
* @returns The OAuth tokens or undefined
*/
async tokens() {
debugLog("Reading OAuth tokens");
debugLog("Token request stack trace:", new Error().stack);
const tokens = await readJsonFile(this.serverUrlHash, "tokens.json", OAuthTokensWithExpiresAtSchema);
if (tokens && this._clientInfo === void 0) {
await this.clientInformation();
}
if (tokens && this.scopeRequestChanged(tokens)) {
log("The scopes this client asks for have changed since it signed in; signing in again");
debugLog("Discarding a token obtained for a different scope request", {
obtainedFor: tokens.requested_scope,
nowRequesting: this.getEffectiveScope()
});
await deleteJsonFileIf(
this.serverUrlHash,
"tokens.json",
OAuthTokensWithExpiresAtSchema,
(stored) => stored === void 0 || stored.access_token === tokens.access_token
);
return void 0;
}
if (tokens) {
const timeLeft = tokens.expires_in || 0;
if (typeof tokens.expires_in !== "number" || tokens.expires_in < 0) {
debugLog("\u26A0\uFE0F WARNING: Invalid expires_in detected while reading tokens \u26A0\uFE0F", {
expiresIn: tokens.expires_in,
tokenObject: JSON.stringify(tokens),
stack: new Error("Invalid expires_in value").stack
});
}
const expiresAt = this.bearerExpiresAt(tokens);
const isExpired = expiresAt ? Date.now() >= expiresAt - TOKEN_EXPIRY_MARGIN_MS : false;
debugLog("Token result:", {
found: true,
hasAccessToken: !!tokens.access_token,
hasIdToken: !!tokens.id_token,
hasRefreshToken: !!tokens.refresh_token,
expiresIn: `${timeLeft} seconds`,
expiresAt: expiresAt ? new Date(expiresAt).toISOString() : "unknown",
isExpired
});
if (isExpired && this.hasExplicitTokenEndpoint) {
try {
await this.renewClientCredentials(tokens.requested_scope ?? tokens.scope);
return this.asBearerTokens(
await readJsonFile(this.serverUrlHash, "tokens.json", OAuthTokensWithExpiresAtSchema)
);
} catch (error62) {
debugLog("Proactive client_credentials renewal failed", error62);
log("Proactive token renewal failed, falling back to the stored token");
return this.asBearerTokens(tokens);
}
}
if (isExpired && tokens.refresh_token) {
const refreshed = await this.refreshTokens(tokens.refresh_token);
if (refreshed) {
return this.asBearerTokens(refreshed);
}
log("Proactive token refresh failed, falling back to the stored token");
}
} else {
debugLog("Token result: Not found");
}
return this.asBearerTokens(tokens);
}
async renewClientCredentials(scope) {
if (!this.clientCredentialsInFlight) {
this.clientCredentialsInFlight = auth(this, { serverUrl: this.resourceServerUrl, scope, fetchFn: this.options.fetchFn }).then(() => {
}).finally(() => {
this.clientCredentialsInFlight = null;
});
}
await this.clientCredentialsInFlight;
}
/**
* The token to present as the Bearer credential.
*
* An access token says what the caller may do; an ID token says who they are. A server that
* verifies identity against an OIDC JWKS endpoint and reads claims like `sub` and `email` wants
* the second and rejects the first outright - AWS Cognito in front of Bedrock AgentCore being
* the deployment this was reported for (issue #219).
*
* Only the credential presented is swapped. The refresh token, and everything the SDK does with
* it, is left alone, so renewal still happens the way the authorization server expects.
*/
asBearerTokens(tokens) {
if (!tokens || !this.useIdToken) {
return tokens;
}
if (!tokens.id_token) {
if (!this.warnedAboutMissingIdToken) {
this.warnedAboutMissingIdToken = true;
log(
"Warning: --use-id-token was passed but the authorization server issued no ID token, so the access token is being sent instead. An ID token is only returned when `openid` is among the requested scopes."
);
}
return tokens;
}
debugLog("Presenting the ID token as the bearer credential");
return { ...tokens, access_token: tokens.id_token };
}
/**
* When the credential this client actually sends stops being accepted.
*
* `expires_in` describes the access token, which under `--use-id-token` is not what goes on the
* wire. An ID token is issued alongside it with a lifetime of its own, so reading `exp` off the
* JWT is what keeps the proactive refresh honest about the credential in use.
*/
bearerExpiresAt(tokens) {
if (!this.useIdToken || !tokens.id_token) {
return tokens.expires_at;
}
return jwtExpiresAt(tokens.id_token) ?? tokens.expires_at;
}
/**
* Whether this run is asking for something different from what the stored token was obtained for.
*
* Compares request against request, deliberately, not against what the server granted. An
* authorization server may grant *less* than it was asked for (RFC 6749 3.3), and treating that
* as a reason to sign in again is a loop with nothing to break it: the next sign-in returns the
* same narrower grant, which is rejected the same way. Comparing the two requests only fires
* when the configuration actually changed - a scope added to `--static-oauth-client-metadata`,
* say - and then only once, because the new token records the new request.
*
* A token stored before this was recorded has no request to compare, and is left alone.
*
* @param tokens The tokens read from disk
* @returns True if a fresh authorization is needed to cover what is being asked for now
*/
scopeRequestChanged(tokens) {
if (tokens.requested_scope === void 0) return false;
const requested = this.requestedScope();
if (requested === void 0) return false;
return tokens.requested_scope !== requested;
}
/**
* Exchanges a refresh token for a new access token, reusing the same authorization
* server, client credentials and RFC 8707 resource indicator the SDK would have
* picked, so the refresh request agrees with the authorization that produced it.
*
* Concurrent callers share one attempt: `tokens()` runs on every outgoing request,
* and with refresh token rotation a second, parallel use of the same token can
* invalidate the whole chain rather than merely wasting a round trip.
*
* @param refreshToken The refresh token to redeem
* @returns The refreshed tokens, or undefined if the refresh could not be completed
*/
async refreshTokens(refreshToken) {
if (!this.refreshInFlight) {
this.refreshInFlight = this.refreshOncePerHost(refreshToken).finally(() => {
this.refreshInFlight = null;
});
}
return this.refreshInFlight;
}
/**
* Redeems the refresh token, or waits for whichever instance is already redeeming it.
*
* A host runs several instances against one server and they share a token store, so a refresh
* token rotated by one of them is dead in the hands of the rest. {@link refreshInFlight} holds
* this instance to a single use; nothing held the instances to a single use between them, and a
* server that rotates without a grace period answers the second use by revoking the chain - a
* browser sign-in in return for a burst of requests that were all legitimate.
*
* The callback port that arbitrates a sign-in is no help here. It is held only while a flow is
* running, and a refresh happens without one, so there is no existing mutex to reuse and the
* lease has to stand in for one. Losing the race is not fatal: the loser reads the token the
* winner wrote, and failing that returns undefined into the path that existed before any of this.
*
* @param refreshToken The refresh token this instance set out to redeem
* @returns The refreshed tokens, or undefined if the refresh could not be completed
*/
async refreshOncePerHost(refreshToken) {
let lease = await this.takeRefreshLease();
if (lease === void 0) {
const sibling = await this.awaitRefreshBySibling();
if (sibling.tokens) {
debugLog("Another instance refreshed the token");
return sibling.tokens;
}
if (!sibling.abandoned) return void 0;
lease = await this.takeRefreshLease();
if (lease === void 0) return void 0;
}
try {
const stored = await readJsonFile(this.serverUrlHash, "tokens.json", OAuthTokensWithExpiresAtSchema);
return await this.doRefreshTokens(stored?.refresh_token ?? refreshToken);
} finally {
if (lease !== UNCOORDINATED) await releaseConfigLease(this.serverUrlHash, REFRESH_LEASE_FILE, lease);
}
}
/**
* Takes the refresh lease.
*
* A store this instance cannot write is the refresh's own problem to report - it fails, says so,
* and hands back undefined the way it always did. Failing here instead would turn that into an
* exception out of `tokens()`, which is on the path of every outgoing request.
*
* @returns The lease, undefined if a sibling holds it, or {@link UNCOORDINATED} if no lease can be taken at all
*/
async takeRefreshLease() {
try {
return await acquireConfigLease(this.serverUrlHash, REFRESH_LEASE_FILE, REFRESH_LEASE_MS);
} catch (error62) {
debugLog("Could not take the refresh lease; refreshing without coordinating", error62);
return UNCOORDINATED;
}
}
/**
* Waits on the instance holding the refresh lease, until it has something to show for it.
*
* Bounded by the lease rather than by a clock of its own: an owner that died is spotted within a
* poll, and one that is alive but stuck runs out its {@link REFRESH_LEASE_MS} and is treated the
* same. Reading the token before the lease matters, because the winner writes the token first
* and only then lets go of the lease.
*
* @returns The token a sibling wrote, or whether it died still owing one
*/
async awaitRefreshBySibling() {
debugLog("Waiting for the instance already refreshing this token");
for (; ; ) {
await new Promise((resolve) => setTimeout(resolve, REFRESH_POLL_MS));
const stored = await readJsonFile(this.serverUrlHash, "tokens.json", OAuthTokensWithExpiresAtSchema);
if (stored?.expires_at !== void 0 && Date.now() < stored.expires_at - TOKEN_EXPIRY_MARGIN_MS) return { tokens: stored };
const holder = await readConfigLease(this.serverUrlHash, REFRESH_LEASE_FILE, REFRESH_LEASE_MS);
if (!holder) return {};
if (!holder.live) return { abandoned: true };
}
}
async doRefreshTokens(refreshToken) {
try {
const clientInformation = await this.clientInformation();
if (!clientInformation) {
debugLog("No client information available, cannot refresh proactively");
return void 0;
}
const metadata = await this.getAuthorizationServerMetadata();
const authorizationServerUrl = (this.protectedResourceMetadata ? getAuthorizationServerUrl(this.protectedResourceMetadata) : void 0) ?? new URL("/", this.options.serverUrl).toString();
const resource = await selectResourceURL(new URL(this.resourceServerUrl), this, this.protectedResourceMetadata);
debugLog("Refreshing access token before it expires", { authorizationServerUrl, resource: resource?.toString() });
const tokenRequestMetadata = metadata ? {
token_endpoint: metadata.token_endpoint,
token_endpoint_auth_methods_supported: metadata.token_endpoint_auth_methods_supported
} : void 0;
const refreshed = await refreshAuthorization(authorizationServerUrl, {
metadata: tokenRequestMetadata,
clientInformation,
refreshToken,
resource,
addClientAuthentication: this.addClientAuthentication
});
await this.saveTokens(refreshed);
log("Refreshed the access token before it expired");
return OAuthTokensWithExpiresAtSchema.parse({
...refreshed,
expires_at: refreshed.expires_in ? Date.now() + refreshed.expires_in * 1e3 : void 0
});
} catch (error62) {
if (error62 instanceof OAuthError && REFUSING_ERRORS.has(error62.code)) this.rememberRefusal(this.refusedRefreshTokens, refreshToken);
debugLog("Proactive token refresh failed", error62);
return void 0;
}
}
/**
* Wraps the fetch the transports send with, so the SDK's own refresh is held to one use per host
* as well.
*
* {@link tokens} renews a token about to expire under the refresh lease, but that is not the only
* redemption. A token the MCP server refuses before it expires - revoked, say, or after a sleep
* the clock did not notice - comes back as a 401, and the SDK's `auth()` answers that by redeeming
* the refresh token itself, outside any lease. Instances that meet the 401 together each spend
* the same refresh token. A server that rotates refuses all but the first with `invalid_grant`,
* and the SDK answers that by discarding the stored token - by then, the fresh one the first
* instance saved (issues #389, #380).
*
* The SDK sends that request through the transport's fetch, which is what this wraps. Anything
* other than a `refresh_token` grant passes straight through, noting on the way any bearer
* credential the MCP server answered with 401. See {@link discardRefusedTokens}.
*
* @param fetchFn The fetch to send requests with
* @returns The same fetch, with refresh token redemptions coordinated across the host
*/
coordinateTokenRequests(fetchFn) {
return async (url2, init) => {
const refreshToken = refreshTokenRedeemedBy(init);
if (refreshToken !== void 0) return this.redeemForSdk(refreshToken, (sent) => fetchFn(url2, withRefreshToken(init, sent)));
const response = await fetchFn(url2, init);
if (response.status === 401) this.noteRejectedBearer(init);
return response;
};
}
/**
* Sends the SDK's refresh only while holding the refresh lease, and not at all once another
* instance has redeemed the same refresh token.
*
* With the lease held the store is read again. A token there that already answers the refresh -
* typically one a sibling saved after redeeming the same refresh token first - is the answer:
* spending the old refresh token again earns `invalid_grant`, or under reuse detection (RFC 9700
* §4.14.2) costs the whole grant. See {@link alreadyAnswers}. Otherwise the request goes out,
* redeeming whatever refresh token is on disk now, and what it brings back is saved before the
* lease is let go, so the next instance in line finds it rather than redeeming the same token.
*
* @param requested The refresh token the SDK set out to redeem
* @param send Sends the request, redeeming the given refresh token
* @returns The token endpoint's response, or one carrying the token already on disk
*/
async redeemForSdk(requested, send) {
const seen = (await this.readStoredTokens())?.access_token;
const deadline = Date.now() + REFRESH_LEASE_WAIT_MS;
let lease = await this.takeRefreshLease();
while (lease === void 0) {
const replacement = await this.awaitRedemptionBySibling(requested, seen);
if (replacement) {
debugLog("Another instance already redeemed this refresh token; answering with the token it saved");
return answerWithStoredTokens(replacement);
}
lease = await this.takeRefreshLease();
if (lease === void 0 && Date.now() >= deadline) {
debugLog("Could not take the refresh lease in time; refreshing without coordinating");
lease = UNCOORDINATED;
}
}
try {
const stored = await this.readStoredTokens();
if (stored && this.alreadyAnswers(stored, requested, seen)) {
debugLog("Another instance already redeemed this refresh token; answering with the token it saved");
return answerWithStoredTokens(stored);
}
const redeemed = stored?.refresh_token ?? requested;
const response = await send(redeemed);
await this.recordRedemption(redeemed, response, stored);
return response;
} finally {
if (lease !== UNCOORDINATED) await releaseConfigLease(this.serverUrlHash, REFRESH_LEASE_FILE, lease);
}
}
/**
* Waits on the instance holding the refresh lease, until it saves a replacement for the token the
* SDK set out to refresh or lets the lease go without one.
*
* @returns The replacement, or undefined once the lease is there to take - released, or abandoned by an owner that died or stalled
*/
async awaitRedemptionBySibling(requested, seen) {
for (; ; ) {
await new Promise((resolve) => setTimeout(resolve, REFRESH_POLL_MS));
const stored = await this.readStoredTokens();
if (stored && this.alreadyAnswers(stored, requested, seen)) return stored;
const holder = await readConfigLease(this.serverUrlHash, REFRESH_LEASE_FILE, REFRESH_LEASE_MS);
if (!holder?.live) return void 0;
}
}
/**
* Whether the stored token already answers the SDK's refresh, so redeeming would only rotate
* again.
*
* It does when it replaced the token the SDK set out to refresh - another refresh token, or from
* a server that does not rotate them, another access token than was on disk when the SDK asked.
* It also does when the SDK is reacting to a 401 on an older token: the SDK refreshes whatever
* `tokens()` hands it, and by the time it asks, that may already be the token a sibling, or this
* instance's own proactive refresh, saved in its place. Rotating again then gains nothing, and a
* server that revokes the previous access token on rotation would refuse every request already
* carrying the new one.
*
* A token known to be refused, or already expired, answers nothing.
*
* @param stored What the store holds now
* @param requested The refresh token the SDK set out to redeem
* @param seen The access token on disk when it did
*/
alreadyAnswers(stored, requested, seen) {
const expiresAt = this.bearerExpiresAt(stored);
if (expiresAt !== void 0 && Date.now() >= expiresAt) return false;
if (this.wasRefused(stored)) return false;
if (stored.refresh_token !== requested || stored.access_token !== seen) return true;
return this.rejectedBearers.size > 0;
}
/**
* Saves what the token endpoint issued while the lease is still held, or notes the refresh token
* it refused.
*
* The SDK saves the tokens too, but only once the response is back in its hands - after the lease
* is gone, when the next instance in line would already have redeemed the old refresh token
* again. A save that fails here is left to the SDK's: failing the response for it would turn a
* refresh that worked into a sign-in.
*/
async recordRedemption(redeemed, response, stored) {
const body = await response.clone().json().catch(() => void 0);
if (!response.ok) {
const error62 = body?.error;
if (typeof error62 === "string" && REFUSING_ERRORS.has(error62)) this.rememberRefusal(this.refusedRefreshTokens, redeemed);
return;
}
const issued = OAuthTokensSchema.safeParse(body);
if (!issued.success) return;
try {
await writeJsonFile(
this.serverUrlHash,
"tokens.json",
// A server that does not rotate leaves the refresh token out of its response
this.storedForm({ ...issued.data, refresh_token: issued.data.refresh_token ?? redeemed, issuer: stored?.issuer })
);
} catch (error62) {
debugLog("Could not save the refreshed token before releasing the lease", error62);
}
}
/** Notes the bearer credential a 401 answered, so that token counts as refused. */
noteRejectedBearer(init) {
const bearer = new Headers(init?.headers).get("Authorization")?.match(/^Bearer\s+(\S+)/i)?.[1];
if (bearer) this.rememberRefusal(this.rejectedBearers, bearer);
}
rememberRefusal(refusals, credential) {
refusals.add(credential);
for (const oldest of refusals) {
if (refusals.size <= REFUSALS_REMEMBERED) break;
refusals.delete(oldest);
}
}
/** Whether this instance has seen the token refused: its refresh token turned down, or its bearer answered with 401. */
wasRefused(tokens) {
return tokens.refresh_token !== void 0 && this.refusedRefreshTokens.has(tokens.refresh_token) || this.rejectedBearers.has(tokens.access_token) || tokens.id_token !== void 0 && this.rejectedBearers.has(tokens.id_token);
}
/**
* Deletes the stored token if it is one this instance has seen refused, and only then.
*
* A request to invalidate the tokens means the token that was refused: the SDK asks after a
* refresh comes back `invalid_grant`, this package after the MCP server rejects a token it was
* just issued. But the store is shared, and by the time the request arrives it may hold another
* token - the one a sibling saved after redeeming the same refresh token first. Deleting by name
* threw that away and sent every instance to the browser (issues #389, #380). A file that cannot
* be read is no use to anyone, and goes either way.
*/
async discardRefusedTokens() {
const deleted = await deleteJsonFileIf(
this.serverUrlHash,
"tokens.json",
OAuthTokensWithExpiresAtSchema,
(stored) => stored === void 0 || this.wasRefused(stored)
);
debugLog(deleted ? "OAuth tokens invalidated" : "Kept the stored token, which is not the one that was refused");
}
readStoredTokens() {
return readJsonFile(this.serverUrlHash, "tokens.json", OAuthTokensWithExpiresAtSchema);
}
/** The tokens as they are kept on disk: with an absolute expiry, and the scope request they answer. */
storedForm(tokens) {
return {
...tokens,
expires_at: tokens.expires_at ?? (tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : void 0),
requested_scope: this.getEffectiveScope()
};
}
/**
* Saves OAuth tokens
* @param tokens The tokens to save
*/
/**
* Stops this client taking part in a token exchange loop.
*
* An authorization server that keeps honouring a refresh token, for a resource server that keeps
* rejecting the access tokens it returns, is a loop with nothing to end it: every rejection looks
* to the SDK like a token worth refreshing. The SDK breaks that cycle for the request path, but
* not for the standalone SSE stream, whose 401 handler re-enters authorization and reopens the
* stream with no circuit breaker and no backoff - measured at several hundred exchanges a second,
* indefinitely, which is what gets people rate-limited by their own identity provider.
*
* Every one of those exchanges ends here, so this is the one place the loop can be seen from and
* the one place it can be stopped. Throwing fails the authorization that asked for the write,
* which is what unwinds the stream's retry.
*
* The window is a sliding one, so a client that stops hammering is trusted again shortly after.
*/
inTokenStorm() {
const now = Date.now();
this.recentTokenWrites = this.recentTokenWrites.filter((at) => now - at < TOKEN_STORM_WINDOW_MS);
return this.recentTokenWrites.length >= TOKEN_STORM_LIMIT;
}
/** The error both halves of the brake raise, so the cause reads the same wherever it surfaces. */
tokenStormError() {
const seconds = TOKEN_STORM_WINDOW_MS / 1e3;
log(
`Stopping: ${TOKEN_STORM_LIMIT} access tokens were issued in the last ${seconds}s and the MCP server rejected them all. Asking for another would only repeat the exchange.`
);
debugLog("Token exchange loop detected", { writes: this.recentTokenWrites.length, windowMs: TOKEN_STORM_WINDOW_MS });
return new Error(
`Stopped after ${TOKEN_STORM_LIMIT} token exchanges in ${seconds}s. The tokens being issued are not accepted by the MCP server - check that its audience and scopes match, or sign in again.`
);
}
guardAgainstTokenStorm() {
if (this.inTokenStorm()) throw this.tokenStormError();
this.recentTokenWrites.push(Date.now());
}
/**
* Stops a reconnect loop from opening a browser tab per turn.
*
* The token brake cannot see this one: a loop that fails before any token is issued leaves
* {@link recentTokenWrites} empty, so the only thing that accumulates is tabs.
*/
guardAgainstAuthorizationStorm() {
const now = Date.now();
this.recentAuthorizations = this.recentAuthorizations.filter((at) => now - at < TOKEN_STORM_WINDOW_MS);
if (this.recentAuthorizations.length >= AUTHORIZATION_STORM_LIMIT) {
const seconds = TOKEN_STORM_WINDOW_MS / 1e3;
log(`Stopping: ${AUTHORIZATION_STORM_LIMIT} sign-ins were started in the last ${seconds}s and none of them completed.`);
debugLog("Authorization loop detected", { starts: this.recentAuthorizations.length, windowMs: TOKEN_STORM_WINDOW_MS });
throw new Error(
`Stopped after ${AUTHORIZATION_STORM_LIMIT} sign-ins in ${seconds}s, none of which completed. Opening another browser tab would only repeat it - check that the server accepts the tokens this client is being issued.`
);
}
this.recentAuthorizations.push(now);
}
/**
* Takes the stored shape rather than the SDK's `OAuthTokens`, because the SDK hands back
* whatever {@link tokens} returned when it re-saves - `expires_at` and all. Naming that here
* is what lets the expiry below be read instead of cast for.
*/
async saveTokens(tokens) {
this.guardAgainstTokenStorm();
const timeLeft = tokens.expires_in || 0;
if (typeof tokens.expires_in !== "number" || tokens.expires_in < 0) {
debugLog("\u26A0\uFE0F WARNING: Invalid expires_in detected in tokens \u26A0\uFE0F", {
expiresIn: tokens.expires_in,
tokenObject: JSON.stringify(tokens),
stack: new Error("Invalid expires_in value").stack
});
}
debugLog("Saving tokens", {
hasAccessToken: !!tokens.access_token,
hasRefreshToken: !!tokens.refresh_token,
expiresIn: `${timeLeft} seconds`,
expiresInValue: tokens.expires_in
});
await writeJsonFile(this.serverUrlHash, "tokens.json", this.storedForm(tokens));
await deleteConfigFile(this.serverUrlHash, this.codeVerifierFile(this.flowState));
await deleteConfigFile(this.serverUrlHash, this.discoveryStateFile(this.flowState));
await deleteStaleConfigFiles(this.serverUrlHash, CODE_VERIFIER_PREFIX, ABANDONED_FLOW_AGE_MS);
await deleteStaleConfigFiles(this.serverUrlHash, DISCOVERY_STATE_PREFIX, ABANDONED_FLOW_AGE_MS);
this.pendingFlow = null;
}
/**
* Redirects the user to the authorization URL
* @param authorizationUrl The URL to redirect to
*/
async redirectToAuthorization(authorizationUrl) {
if (this.inTokenStorm()) throw this.tokenStormError();
if (!this.ownsPendingFlow(authorizationUrl)) {
log("A sign-in for this server is already under way; not starting another");
debugLog("Suppressed a concurrent authorization redirect", { state: this.pendingFlow?.state });
return;
}
if (this.useDeviceCode) {
await this.authorizeWithDeviceCode();
return;
}
if (this.useClientCredentials) {
await this.authorizeWithClientCredentials();
return;
}
this.getAuthorizationServerMetadata().catch(() => {
});
this.applyScope(authorizationUrl);
this.applyAuthorizeParams(authorizationUrl);
log(`
Please authorize this client by visiting:
${authorizationUrl.toString()}
`);
debugLog("Redirecting to authorization URL", authorizationUrl.toString());
await this.preflightCachedDynamicClientRegistration(authorizationUrl);
this.guardAgainstAuthorizationStorm();
if (await openBrowser(sanitizeUrl(authorizationUrl.toString()))) {
log("Browser opened automatically.");
} else {
log("Could not open a browser automatically. Please copy and paste the URL above into your browser.");
}
}
/**
* Signs in with the device grant, and leaves the tokens where the next attempt will find them.
*
* Runs to completion here rather than handing anything back, because there is nothing to hand
* back: no code arrives at a callback port, so the only trace of a finished sign-in is the
* tokens on disk.
*/
async authorizeWithDeviceCode() {
const metadata = await this.getAuthorizationServerMetadata();
if (!supportsDeviceAuthorization(metadata)) {
throw new Error(
"--device-code was passed but the authorization server does not offer the device grant. Remove the flag to sign in through a browser instead."
);
}
const clientInformation = await this.clientInformation();
if (!clientInformation) {
throw new Error("No OAuth client is registered, so there is nothing to authorize");
}
const scope = this.getEffectiveScope();
const tokens = await authorizeWithDeviceCode({
metadata,
clientInformation,
scope: scope || void 0,
resource: await this.deviceAuthorizationResource()
});
await this.saveTokens(tokens);
}
/**
* The RFC 8707 resource indicator to send with a device authorization, matching what the SDK
* would put on an authorization code flow so the two cannot disagree about what the token is for.
*/
/**
* The grants to register for.
*
* `client_credentials` is listed alone: it has no user to come back as a refresh, and asking for
* `authorization_code` alongside it would register a redirect-based client this flow never uses.
*/
grantTypes() {
if (this.useClientCredentials) return ["client_credentials"];
if (this.useDeviceCode) return [DEVICE_CODE_GRANT_TYPE, "refresh_token"];
return ["authorization_code", "refresh_token"];
}
/**
* Signs in as the software itself, and leaves the token where the next attempt will find it.
*
* Runs to completion here for the same reason the device grant does: nothing arrives at a
* callback port, so the only trace of a finished sign-in is the token on disk.
*/
async authorizeWithClientCredentials() {
const metadata = await this.getAuthorizationServerMetadata();
if (!metadata) {
throw new Error("Could not discover the authorization server metadata, so there is no token endpoint to ask");
}
const clientInformation = await this.clientInformation();
if (!clientInformation) {
throw new Error("No OAuth client credentials were supplied; pass them with --static-oauth-client-info");
}
const scope = this.requestedScope();
const tokens = await authorizeWithClientCredentials({
metadata,
clientInformation,
scope: scope || void 0,
resource: await this.deviceAuthorizationResource()
});
await this.saveTokens(tokens);
}
async deviceAuthorizationResource() {
return selectResourceURL(new URL(this.resourceServerUrl), this, this.protectedResourceMetadata);
}
async preflightCachedDynamicClientRegistration(authorizationUrl) {
if (this.clientRegistrationSource !== "cached-dynamic") {
return;
}
let response;
try {
response = await fetch(authorizationUrl.toString(), {
redirect: "manual",
headers: { Accept: "application/json" },
signal: AbortSignal.timeout(5e3)
});
} catch (error62) {
debugLog("Authorization preflight failed; continuing to browser authorization", error62);
return;
}
if (response.status !== 400 && response.status !== 401) {
return;
}
let errorResponse;
try {
errorResponse = await response.json();
} catch (error62) {
debugLog("Authorization preflight returned invalid JSON; continuing to browser authorization", error62);
return;
}
const registrationError = staleClientRegistrationError(errorResponse);
if (!registrationError) {
return;
}
throw registrationError;
}
/**
* Decides which scope the authorization request asks for.
*
* The SDK has already put one on the URL, picked - in its order - from a scope it parsed out of a
* live `WWW-Authenticate` challenge, the protected resource's `scopes_supported`, or the `scope`
* in our own client metadata. The last two originate here, and this client's priority order for
* them is not the SDK's, so they are replaced with what `getEffectiveScope` decided.
*
* A challenge scope does not originate here, and replacing it defeated the one thing it is for: a
* 403 `insufficient_scope` names the scopes the call actually needed, the SDK re-runs
* authorization asking for them, and overwriting them here re-requested exactly the scope that
* had just been refused - so it was refused again and the SDK gave up with "Server returned 403
* after trying upscoping" (see https://github.com/geelen/mcp-remote/issues/134).
*
* A scope the user pinned with `--static-oauth-client-metadata` still wins over both. They set it
* because the scopes the server advertises do not work for them, and a challenge is the server
* advertising them again.
*
* @param authorizationUrl The authorization URL to set the scope on, modified in place
*/
/**
* Adds the caller's own parameters to the authorization URL.
*
* Applied after everything this client decides for itself, so an explicitly requested value wins
* - the flag exists precisely for servers whose requirements this client does not model. The
* parameters the flow derives per request are refused at parse time instead.
*
* @param authorizationUrl The authorization URL to add parameters to, modified in place
*/
applyAuthorizeParams(authorizationUrl) {
for (const [key, value] of Object.entries(this.authorizeParams)) {
authorizationUrl.searchParams.set(key, value);
}
if (Object.keys(this.authorizeParams).length > 0) {
debugLog("Added extra parameters to authorization URL", { keys: Object.keys(this.authorizeParams) });
}
}
applyScope(authorizationUrl) {
const effectiveScope = this.getEffectiveScope();
const requestedScope = authorizationUrl.searchParams.get("scope");
const pinnedByUser = !!this.staticOAuthClientMetadata?.scope?.trim();
const couldBeOurs = [effectiveScope, this.protectedResourceMetadata?.scopes_supported?.join(" ")];
if (!pinnedByUser && requestedScope && !couldBeOurs.includes(requestedScope)) {
log(`Authorizing with the scope the server asked for: ${requestedScope}`);
debugLog("Keeping a scope this client did not supply", { scope: requestedScope, effectiveScope });
return;
}
if (effectiveScope) {
authorizationUrl.searchParams.set("scope", effectiveScope);
debugLog("Added scope parameter to authorization URL", { scopes: effectiveScope });
} else {
debugLog("Omitting scope parameter from authorization URL (no effective scope)");
}
}
/**
* Saves the PKCE code verifier
*
* The filename is scoped to this flow's authorization state rather than to the process, so a
* code can still be redeemed by an instance that took the callback port over from the one that
* started the flow. See https://github.com/geelen/mcp-remote/issues/235.
*
* Concurrent arms each generate their own PKCE pair, but only one challenge can be the one the
* browser is sent to, and only the verifier matching it can be redeemed. The first to land wins
* and later ones are dropped: overwriting meant the exchange presented one flow's verifier
* against another's challenge, which every authorization server correctly rejects as
* `invalid_grant` (see https://github.com/punkpeye/mcp-remote/issues/353).
* @param codeVerifier The code verifier to save
*/
async saveCodeVerifier(codeVerifier) {
const flow = this.pendingFlow;
if (flow?.challenge !== void 0) {
debugLog("Keeping the code verifier already saved for this sign-in", { state: flow.state });
return;
}
debugLog("Saving code verifier");
const state = flow?.state ?? this._state;
await writeTextFile(this.serverUrlHash, this.codeVerifierFile(state), codeVerifier);
if (this.flowDiscovery) {
debugLog("Saving OAuth discovery state", { state });
await writeJsonFile(this.serverUrlHash, this.discoveryStateFile(state), this.flowDiscovery);
}
if (flow) flow.challenge = codeChallengeFor(codeVerifier);
}
/**
* Records the state a code came back with, so the flow that produced it decides which verifier
* redeems it
* @param state The state from the callback
*/
useAuthorizationState(state) {
if (!ISSUED_STATE.test(state)) {
log("Ignoring an authorization state this client could not have issued");
debugLog("Rejected authorization state", { state });
return;
}
this.incomingState = state;
}
/** The flow this instance is redeeming for: another instance's when a code names it. */
get flowState() {
return this.incomingState ?? this._state;
}
/**
* Whether this redirect belongs to the flow whose verifier is the one on disk.
*
* The challenge in the authorization URL is the only thing tying a redirect back to the
* verifier that produced it, since the SDK hands neither call a flow of its own to name.
* Unrecognised flows are allowed through: suppressing a sign-in that turns out to be the only
* one costs the user their connection, while an extra tab merely annoys.
*/
ownsPendingFlow(authorizationUrl) {
const challenge = this.pendingFlow?.challenge;
if (challenge === void 0) return true;
return authorizationUrl.searchParams.get("code_challenge") === challenge;
}
codeVerifierFile(state) {
return `${CODE_VERIFIER_PREFIX}${state}.txt`;
}
discoveryStateFile(state) {
return `${DISCOVERY_STATE_PREFIX}${state}.json`;
}
/**
* Gets the PKCE code verifier
* @returns The code verifier
*/
async codeVerifier() {
debugLog("Reading code verifier");
const verifier = await readTextFile(this.serverUrlHash, this.codeVerifierFile(this.flowState), "No code verifier saved for session");
debugLog("Code verifier found:", !!verifier);
return verifier;
}
/**
* Invalidates the specified credentials
* @param scope The scope of credentials to invalidate
*/
async invalidateCredentials(scope) {
debugLog(`Invalidating credentials: ${scope}`);
switch (scope) {
case "all":
await Promise.all([
deleteConfigFile(this.serverUrlHash, "client_info.json"),
deleteConfigFile(this.serverUrlHash, "tokens.json"),
deleteConfigFile(this.serverUrlHash, this.codeVerifierFile(this.flowState)),
deleteConfigFile(this.serverUrlHash, this.discoveryStateFile(this.flowState))
]);
this._clientInfo = void 0;
this.clientRegistrationSource = void 0;
this.pendingFlow = null;
this.flowDiscovery = void 0;
debugLog("All credentials invalidated");
break;
case "client":
await deleteConfigFile(this.serverUrlHash, "client_info.json");
this._clientInfo = void 0;
this.clientRegistrationSource = void 0;
this.pendingFlow = null;
debugLog("Client information invalidated");
break;
case "tokens":
await this.discardRefusedTokens();
break;
case "verifier":
await deleteConfigFile(this.serverUrlHash, this.codeVerifierFile(this.flowState));
await deleteConfigFile(this.serverUrlHash, this.discoveryStateFile(this.flowState));
this.pendingFlow = null;
debugLog("Code verifier invalidated");
break;
case "discovery":
await deleteConfigFile(this.serverUrlHash, this.discoveryStateFile(this.flowState));
this.flowDiscovery = void 0;
debugLog("Discovery state invalidated");
break;
default:
throw new Error(`Unknown credential scope: ${scope}`);
}
}
};
// src/lib/coordination.ts
import { Agent as Agent2 } from "undici";
import express2 from "express";
var FOLLOWER_PATIENCE_MS = 3 * 6e4;
var REFRESH_FOLLOWER_PATIENCE_MS = 1e4;
function createLazyAuthCoordinator(serverUrlHash, callbackPath, callbackPort, events, authTimeoutMs, strictPort = false, authSuccessUrl, bindHost = DEFAULT_BIND_HOST) {
let authState = null;
const closeHeld = async () => {
const held = authState;
authState = null;
await held?.then(({ server }) => new Promise((resolve) => server.close(() => resolve()))).catch(() => {
});
};
return {
release: closeHeld,
initializeAuth: async (options) => {
let refreshed = false;
if (authState && options?.forceRefresh) {
debugLog("Discarding the cached auth coordination verdict and looking again");
refreshed = true;
await closeHeld();
}
if (authState) {
debugLog("Auth already initializing or initialized, reusing it");
return authState;
}
log("Initializing auth coordination on-demand");
debugLog("Initializing auth coordination on-demand", { serverUrlHash, callbackPort });
authState = coordinateAuth(
serverUrlHash,
callbackPath,
callbackPort,
events,
authTimeoutMs,
strictPort,
refreshed ? REFRESH_FOLLOWER_PATIENCE_MS : void 0,
authSuccessUrl,
bindHost
);
try {
const resolved = await authState;
debugLog("Auth coordination completed", { skipBrowserAuth: resolved.skipBrowserAuth, actualPort: resolved.actualPort });
return resolved;
} catch (error62) {
authState = null;
throw error62;
}
}
};
}
var PORT_CANDIDATES = 8;
var FOLLOWER_POLL_INTERVAL_MS = 250;
var loopbackDispatcher = new Agent2();
function probeHostFor(bindHost) {
return bindHost === "0.0.0.0" || bindHost === "::" ? "127.0.0.1" : formatHostForUrl(bindHost);
}
async function portHeldBySiblingFor(port, serverUrlHash, bindHost) {
try {
const response = await fetch(`http://${probeHostFor(bindHost)}:${port}${MCP_REMOTE_ID_PATH}`, {
signal: AbortSignal.timeout(1e3),
dispatcher: loopbackDispatcher
});
if (!response.ok) return false;
const body = await response.json();
return body?.mcpRemote === true && body.serverUrlHash === serverUrlHash;
} catch {
return false;
}
}
async function serverIssuesAuthChallenge(serverUrl, headers = {}) {
try {
const response = await fetch(serverUrl, {
method: "GET",
headers: { ...headers, accept: "application/json, text/event-stream" },
signal: AbortSignal.timeout(5e3)
});
debugLog("Probed the server for an auth challenge", { status: response.status });
return response.status === 401;
} catch (error62) {
debugLog("Could not probe the server for an auth challenge", error62);
return false;
}
}
async function hasUsableTokens(serverUrlHash) {
const tokens = await readJsonFile(
serverUrlHash,
"tokens.json",
OAuthTokensWithExpiresAtSchema
);
if (!tokens) return false;
if (tokens.expires_at && Date.now() >= tokens.expires_at - TOKEN_EXPIRY_MARGIN_MS2) {
return !!tokens.refresh_token;
}
return true;
}
var TOKEN_EXPIRY_MARGIN_MS2 = 6e4;
async function coordinateAuth(serverUrlHash, callbackPath, callbackPort, events, authTimeoutMs, strictPort = false, followerPatienceMs = FOLLOWER_PATIENCE_MS, authSuccessUrl, bindHost = DEFAULT_BIND_HOST) {
debugLog("Coordinating authentication", { serverUrlHash, callbackPath, callbackPort });
const candidates = strictPort ? [callbackPort] : Array.from({ length: PORT_CANDIDATES }, (_, i) => callbackPort + i);
for (const port of candidates) {
try {
const { server, actualPort, waitForAuthCode } = await setupOAuthCallbackServerWithLongPoll({
port,
path: callbackPath,
events,
authTimeoutMs,
serverUrlHash,
authSuccessUrl,
bindHost
});
const established = await firstSiblingBefore(candidates, port, serverUrlHash, bindHost);
if (established !== void 0) {
debugLog("Yielding to a sibling established on an earlier candidate", { ours: actualPort, theirs: established });
await new Promise((resolve) => server.close(() => resolve()));
return followUntilTokensOrPort(
serverUrlHash,
callbackPath,
established,
events,
authTimeoutMs,
followerPatienceMs,
authSuccessUrl,
bindHost
);
}
log(`This instance is running the sign-in for this server (callback port ${actualPort})`);
return { server, actualPort, waitForAuthCode, skipBrowserAuth: false };
} catch (error62) {
const code = error62.code;
if (code !== "EADDRINUSE" && code !== "EACCES") throw error62;
if (code === "EACCES") {
debugLog(`Not permitted to bind port ${port}`, { serverUrlHash });
if (strictPort) throw error62;
continue;
}
if (await portHeldBySiblingFor(port, serverUrlHash, bindHost)) {
log(`Another instance is running the sign-in for this server on port ${port}`);
return followUntilTokensOrPort(
serverUrlHash,
callbackPath,
port,
events,
authTimeoutMs,
followerPatienceMs,
authSuccessUrl,
bindHost
);
}
debugLog(`Port ${port} is held by an unrelated process`, { serverUrlHash });
if (strictPort) throw error62;
}
}
throw new Error(
`Could not find a free callback port for this server (tried ${candidates[0]}-${candidates[candidates.length - 1]}). Close whatever is holding those ports, or pass a port as the second argument to choose one.`
);
}
async function firstSiblingBefore(candidates, port, serverUrlHash, bindHost) {
for (const candidate of candidates) {
if (candidate === port) return void 0;
if (await portHeldBySiblingFor(candidate, serverUrlHash, bindHost)) return candidate;
}
return void 0;
}
async function followUntilTokensOrPort(serverUrlHash, callbackPath, port, events, authTimeoutMs, followerPatienceMs, authSuccessUrl, bindHost = DEFAULT_BIND_HOST) {
const deadline = Date.now() + Math.max(authTimeoutMs, followerPatienceMs);
while (Date.now() < deadline) {
if (await hasUsableTokens(serverUrlHash)) {
log("The sign-in was completed by another instance; using the tokens it wrote");
return unownedFlow(port);
}
try {
const { server, actualPort, waitForAuthCode } = await setupOAuthCallbackServerWithLongPoll({
port,
path: callbackPath,
events,
authTimeoutMs,
serverUrlHash,
authSuccessUrl,
bindHost
});
log(`The instance running the sign-in exited; taking it over on port ${actualPort}`);
return { server, actualPort, waitForAuthCode, skipBrowserAuth: false };
} catch (error62) {
if (error62.code !== "EADDRINUSE") throw error62;
}
await new Promise((resolve) => setTimeout(resolve, FOLLOWER_POLL_INTERVAL_MS));
}
throw new Error(
`Authentication is still pending in another instance on port ${port}. Complete that sign-in and retry, or close the other instance to start a new sign-in.`
);
}
function unownedFlow(port) {
return {
server: express2().listen(0, "127.0.0.1").on("error", () => {
}),
actualPort: port,
waitForAuthCode: () => Promise.reject(new Error("This instance does not own the sign-in; it cannot receive an authorization code")),
skipBrowserAuth: true
};
}
export {
toJSONSchema,
safeParse2 as safeParse,
string2 as string,
email2 as email,
url,
number2 as number,
boolean2 as boolean,
_null3 as _null,
unknown,
array,
object,
looseObject,
union,
discriminatedUnion,
intersection,
record,
_enum2 as _enum,
literal,
optional,
lazy,
preprocess,
iso_exports,
LATEST_PROTOCOL_VERSION,
SUPPORTED_PROTOCOL_VERSIONS,
PROTOCOL_VERSION_META_KEY,
CLIENT_INFO_META_KEY,
SERVER_INFO_META_KEY,
CLIENT_CAPABILITIES_META_KEY,
LOG_LEVEL_META_KEY,
JSONValueSchema,
JSONObjectSchema,
JSONArraySchema,
ProgressTokenSchema,
CursorSchema,
TaskMetadataSchema,
RelatedTaskMetadataSchema,
RequestMetaSchema,
BaseRequestParamsSchema,
TaskAugmentedRequestParamsSchema,
RequestSchema,
NotificationsParamsSchema,
NotificationSchema,
ResultMetaObjectSchema,
ResultSchema,
RequestIdSchema,
JSONRPCRequestSchema,
JSONRPCNotificationSchema,
JSONRPCResultResponseSchema,
JSONRPCErrorResponseSchema,
JSONRPCMessageSchema,
JSONRPCResponseSchema,
EmptyResultSchema,
CancelledNotificationParamsSchema,
CancelledNotificationSchema,
IconSchema,
IconsSchema,
BaseMetadataSchema,
ImplementationSchema,
ClientTasksCapabilitySchema,
ServerTasksCapabilitySchema,
ClientCapabilitiesSchema,
InitializeRequestParamsSchema,
InitializeRequestSchema,
ServerCapabilitiesSchema,
InitializeResultSchema,
InitializedNotificationSchema,
DiscoverRequestSchema,
DiscoverResultSchema,
PingRequestSchema,
ProgressSchema,
ProgressNotificationParamsSchema,
ProgressNotificationSchema,
PaginatedRequestParamsSchema,
PaginatedRequestSchema,
PaginatedResultSchema,
ResourceContentsSchema,
TextResourceContentsSchema,
BlobResourceContentsSchema,
RoleSchema,
AnnotationsSchema,
ResourceSchema,
ResourceTemplateSchema,
ListResourcesRequestSchema,
ListResourcesResultSchema,
ListResourceTemplatesRequestSchema,
ListResourceTemplatesResultSchema,
ResourceRequestParamsSchema,
ReadResourceRequestParamsSchema,
ReadResourceRequestSchema,
ReadResourceResultSchema,
ResourceListChangedNotificationSchema,
SubscribeRequestParamsSchema,
SubscribeRequestSchema,
UnsubscribeRequestParamsSchema,
UnsubscribeRequestSchema,
SubscriptionFilterSchema,
SubscriptionsListenRequestParamsSchema,
SubscriptionsListenRequestSchema,
SubscriptionsAcknowledgedNotificationParamsSchema,
SubscriptionsAcknowledgedNotificationSchema,
SubscriptionsListenResultMetaSchema,
SubscriptionsListenResultSchema,
ResourceUpdatedNotificationParamsSchema,
ResourceUpdatedNotificationSchema,
PromptArgumentSchema,
PromptSchema,
ListPromptsRequestSchema,
ListPromptsResultSchema,
GetPromptRequestParamsSchema,
GetPromptRequestSchema,
TextContentSchema,
ImageContentSchema,
AudioContentSchema,
ToolUseContentSchema,
EmbeddedResourceSchema,
ResourceLinkSchema,
ContentBlockSchema,
PromptMessageSchema,
GetPromptResultSchema,
PromptListChangedNotificationSchema,
ToolAnnotationsSchema,
ToolExecutionSchema,
ToolSchema,
ListToolsRequestSchema,
ListToolsResultSchema,
CallToolResultSchema,
CompatibilityCallToolResultSchema,
CallToolRequestParamsSchema,
CallToolRequestSchema,
ToolListChangedNotificationSchema,
ListChangedOptionsBaseSchema,
LoggingLevelSchema,
SetLevelRequestParamsSchema,
SetLevelRequestSchema,
LoggingMessageNotificationParamsSchema,
LoggingMessageNotificationSchema,
ModelHintSchema,
ModelPreferencesSchema,
ToolChoiceSchema,
ToolResultContentSchema,
SamplingContentSchema,
SamplingMessageContentBlockSchema,
SamplingMessageSchema,
CreateMessageRequestParamsSchema,
CreateMessageRequestSchema,
CreateMessageResultSchema,
CreateMessageResultWithToolsSchema,
BooleanSchemaSchema,
StringSchemaSchema,
NumberSchemaSchema,
UntitledSingleSelectEnumSchemaSchema,
TitledSingleSelectEnumSchemaSchema,
LegacyTitledEnumSchemaSchema,
SingleSelectEnumSchemaSchema,
UntitledMultiSelectEnumSchemaSchema,
TitledMultiSelectEnumSchemaSchema,
MultiSelectEnumSchemaSchema,
EnumSchemaSchema,
PrimitiveSchemaDefinitionSchema,
ElicitRequestFormParamsSchema,
ElicitRequestURLParamsSchema,
ElicitRequestParamsSchema,
ElicitRequestSchema,
ElicitationCompleteNotificationParamsSchema,
ElicitationCompleteNotificationSchema,
ElicitResultSchema,
ResourceTemplateReferenceSchema,
PromptReferenceSchema,
CompleteRequestParamsSchema,
CompleteRequestSchema,
CompleteResultSchema,
RootSchema,
ListRootsRequestSchema,
ListRootsResultSchema,
RootsListChangedNotificationSchema,
TaskCreationParamsSchema,
TaskStatusSchema,
TaskSchema,
CreateTaskResultSchema,
TaskStatusNotificationParamsSchema,
TaskStatusNotificationSchema,
GetTaskRequestSchema,
GetTaskResultSchema,
GetTaskPayloadRequestSchema,
GetTaskPayloadResultSchema,
ListTasksRequestSchema,
ListTasksResultSchema,
CancelTaskRequestSchema,
CancelTaskResultSchema,
ClientRequestSchema,
ClientNotificationSchema,
ClientResultSchema,
ServerRequestSchema,
ServerNotificationSchema,
ServerResultSchema,
OAuthProtectedResourceMetadataSchema,
OAuthMetadataSchema,
OpenIdProviderMetadataSchema,
OpenIdProviderDiscoveryMetadataSchema,
OAuthTokensSchema,
IdJagTokenExchangeResponseSchema,
OAuthErrorResponseSchema,
OAuthClientMetadataSchema,
OAuthClientInformationSchema,
OAuthClientInformationFullSchema,
OAuthClientRegistrationErrorSchema,
OAuthTokenRevocationRequestSchema,
createFetchWithInit,
Client,
version2 as version,
fetchWithMcpHeaders,
forgetRejectedAuthorization,
debugLog,
log,
mcpProxy,
discoverOAuthServerInfo2 as discoverOAuthServerInfo,
connectToRemoteServer,
parseCommandLineArgs,
setupSignalHandlers,
NodeOAuthClientProvider,
createLazyAuthCoordinator,
serverIssuesAuthChallenge,
hasUsableTokens
};
/*! Bundled license information:
@modelcontextprotocol/client/dist/src-CeKsbNLO.mjs:
(*!
* content-type
* Copyright(c) 2015 Douglas Christopher Wilson
* MIT Licensed
*)
*/