@tempoxyz/id 0.0.0-stage → 0.0.0

package/dist/app/server/assets/schemas-C2lCYmR5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-C2lCYmR5.js","names":["util.jsonStringifyReplacer","initializer","core.$ZodAsyncError","util.finalizeIssue","core.config","util.rawShape","util.parsedType","util.stringifyPrimitive","util.joinValues","util.normalizeParams","checks.$ZodCheckLessThan","checks.$ZodCheckGreaterThan","checks.$ZodCheckMultipleOf","checks.$ZodCheckMaxLength","checks.$ZodCheckMinLength","checks.$ZodCheckLengthEquals","checks.$ZodCheckRegex","checks.$ZodCheckLowerCase","checks.$ZodCheckUpperCase","checks.$ZodCheckIncludes","checks.$ZodCheckStartsWith","checks.$ZodCheckEndsWith","checks.$ZodCheckOverwrite","util.slugify","issue","util.issue","checks.$ZodCheck","core.formatError","core.flattenError","util.jsonStringifyReplacer","en","core.memoizer","util.mergeDefs","core.clone","checks.overwrite","util.hide","core.standardProps","parse.parse","parse.parseAsync","parse.safeParse","parse.safeParseAsync","parse.validate","parse.validateAsync","parse.encode","parse.decode","parse.encodeAsync","parse.decodeAsync","parse.safeEncode","parse.safeDecode","parse.safeEncodeAsync","parse.safeDecodeAsync","processors.stringProcessor","processors.aggregateChecks","checks.regex","checks.includes","checks.startsWith","checks.endsWith","checks.minLength","checks.maxLength","checks.length","checks.lowercase","checks.uppercase","checks.trim","checks.normalize","checks.toLowerCase","checks.toUpperCase","checks.slugify","core._email","core._url","core._jwt","core._emoji","core._guid","core._uuid","core._uuidv4","core._uuidv6","core._uuidv7","core._nanoid","core._cuid","core._cuid2","core._ulid","core._base64","core._base64url","core._xid","core._ksuid","core._ipv4","core._ipv6","core._cidrv4","core._cidrv6","core._e164","core._isoDateTime","core._isoDate","core._isoTime","core._isoDuration","core._string","processors.numberProcessor","checks.gt","checks.gte","checks.lt","checks.lte","checks.multipleOf","core._number","core._int","processors.booleanProcessor","core._boolean","processors.bigintProcessor","core._bigint","processors.anyProcessor","core._any","processors.unknownProcessor","core._unknown","processors.neverProcessor","core._never","processors.dateProcessor","core._date","processors.arrayProcessor","core._array","processors.objectProcessor","util.extend","util.safeExtend","util.merge","util.pick","util.omit","util.partial","util.required","util.normalizeParams","processors.unionProcessor","processors.intersectionProcessor","processors.recordProcessor","processors.enumProcessor","processors.literalProcessor","processors.transformProcessor","core.$ZodEncodeError","issue","util.issue","processors.optionalProcessor","processors.nullableProcessor","processors.defaultProcessor","util.shallowClone","processors.prefaultProcessor","processors.nonoptionalProcessor","processors.catchProcessor","core.util.constantCatch","processors.pipeProcessor","processors.readonlyProcessor","processors.templateLiteralProcessor","processors.customProcessor","core._custom","core._refine","core._superRefine","$ZodGUID","globalConfig","createToJSONSchemaMethod","$ZodUnion","$ZodCUID","$ZodCheckLowerCase","recordProcessor","slugify","$ZodStringFormat","unionProcessor","$ZodULID","transformProcessor","$ZodType","$ZodBase64URL","$ZodCheckEndsWith","$ZodDate","$ZodCheckRegex","$ZodCatch","$ZodCheckMinLength","$ZodBigInt","$ZodCheckGreaterThan","$ZodE164","$ZodAsyncError","$ZodDefault","$ZodCheckStartsWith","$ZodBoolean","$ZodCheckIncludes","$ZodAny","$ZodXID","$ZodArray","standardProps","unknownProcessor","$ZodURL","$ZodBase64","$ZodCheck","$ZodExactOptional","config","$ZodCIDRv4","$ZodCheckLengthEquals","readonlyProcessor","shallowClone","$ZodString","templateLiteralProcessor","$ZodTransform","$ZodCodec","$ZodCheckMultipleOf","$ZodCUID2","$ZodCheckMaxLength","$ZodCustom","$ZodCheckOverwrite","$ZodEmoji","$constructor","$ZodEmail","$ZodEncodeError","$ZodEnum","numberProcessor","partial","$ZodOptional","bigintProcessor","finalizeIssue","$ZodISOTime","pipeProcessor","required","$ZodReadonly","customProcessor","issue","$ZodKSUID","enumProcessor","merge","$ZodNever","captureStackTrace","$ZodIPv4","intersectionProcessor","mergeDefs","$ZodNonOptional","nullableProcessor","parsedType","$ZodObjectJIT","nonoptionalProcessor","own","$ZodNumberFormat","arrayProcessor","extend","$ZodISODuration","globalRegistry","$ZodUnknown","createStandardJSONSchemaMethod","$ZodUUID","dateProcessor","joinValues","$ZodLiteral","neverProcessor","omit","$ZodNumber","aggregateChecks","constantCatch","$ZodISODate","booleanProcessor","hide","$ZodIntersection","literalProcessor","normalizeParams","$ZodNullable","$ZodDiscriminatedUnion","$ZodCheckUpperCase","anyProcessor","derived","$ZodISODateTime","catchProcessor","installLazyProp","$ZodJWT","clone","$ZodIPv6","defaultProcessor","jsonStringifyReplacer","$ZodNanoID","objectProcessor","pick","$ZodPipe","stringProcessor","stringifyPrimitive","$ZodTemplateLiteral","prefaultProcessor","safeExtend","$ZodRecord","optionalProcessor","rawShape","$ZodPrefault","$ZodCIDRv6","$ZodCheckLessThan","_getMessage","internals","_setMessage","value","_messageDesc","_issuesDesc","_installedToString","initializer$1","def","inst","proto","$ZodError","node","obj","key","make","flattenError","fieldErrors","formErrors","sub","error","mapper","formatError","processError","path","fullpath","curr","el","terminal","toDotPath","segs","_path","seg","finalizeParams","params","callee","_parse","fn","ctx","_ctx","result","schema","e","_params","_Err","iss","_parseAsync","_safeParse","failure","Err","issues","_safeParseAsync","COMPILE_INVALID","COMPILE_FALLBACK","validate","validator","validateFallback","fallbackRun","validateAsync","_encode","parse","_decode","_encodeAsync","parseAsync","_decodeAsync","_safeEncode","_safeDecode","_safeEncodeAsync","_safeDecodeAsync","$ZodCyclicError","STATE","NO_ISSUES","isRef","cloneIssues","recursive","NONE","ASSUMED","PROVEN","isRecursive","cached","stack","check","child","answer","resolve","shape","sh","desc","spread","raw","inner","settle","bucketFor","bucket","state","handoff","open","memo","empty","entry","payload","_a","base","wrapped","isBackEdge","isRecursiveInst","rechecked","lastCtx","lastBucket","walked","input","hit","depth","r","memoizer","backEdges","Sizable","getSizing","origin","FormatDictionary","TypeDictionary","getTypeName","type","adj","sizing","_issue","o","en_default","snapshotChecks","_string","Class","_coercedString","_email","_guid","_uuid","_uuidv4","_uuidv6","_uuidv7","_url","_emoji","_nanoid","_cuid","_cuid2","_ulid","_xid","_ksuid","_ipv4","_ipv6","_cidrv4","_cidrv6","_base64","_base64url","_e164","_jwt","_isoDateTime","_isoDate","_isoTime","_isoDuration","_number","_int","_boolean","_coercedBoolean","_bigint","_any","_unknown","_never","_date","_lt","_lte","_gt","_gte","_multipleOf","_maxLength","_minLength","_length","_regex","_lowercase","_uppercase","_includes","_startsWith","_endsWith","_overwrite","_normalize","form","_trim","_toLowerCase","_toUpperCase","_slugify","_array","_custom","norm","_refine","_superRefine","ch","_check","issue$2","_installedErrorProtos","_lazyMethod","ZodRealError","self","safeParse","safeParseAsync","encode","decode","encodeAsync","decodeAsync","safeEncode","safeDecode","safeEncodeAsync","safeDecodeAsync","_ensureDefaultLocale","_ensureDefaultMemoizer","ZodType","chks","reg","meta","refine","superRefine","refinement","optional","exactOptional","nullable","nonoptional","array","union","arg","intersection","pipe","transform","tx","_default","d","prefault","_catch","target","readonly","cl","args","data","_ZodString","json","ZodString","ZodEmail","ZodURL","ZodJWT","ZodEmoji","ZodGUID","ZodUUID","ZodNanoID","ZodCUID","ZodCUID2","ZodULID","ZodBase64","ZodBase64URL","ZodXID","ZodKSUID","ZodIPv4","ZodIPv6","ZodCIDRv4","ZodCIDRv6","ZodE164","ZodISODateTime","ZodISODate","ZodISOTime","ZodISODuration","string","ZodStringFormat","email","url","ipv4","ipv6","ZodNumber","minimum","exclusiveMinimum","maximum","exclusiveMaximum","isInt","multipleOf","int","number","ZodNumberFormat","ZodBoolean","boolean","ZodBigInt","bigint","ZodAny","any","ZodUnknown","unknown","ZodNever","never","ZodDate","date","ZodArray","n","element","ZodObject","_enum","incoming","other","mask","ZodOptional","ZodExactOptional","ZodNonOptional","object","strictObject","looseObject","ZodUnion","ZodDiscriminatedUnion","discriminatedUnion","ZodIntersection","ZodRecord","record","valueType","keyType","ZodEnum","keys","newEntries","values","v","ZodLiteral","literal","ZodTransform","issue$1","output","ZodNullable","ZodDefault","defaultValue","ZodPrefault","ZodCatch","catchValue","ZodPipe","in_","ZodCodec","codec","ZodReadonly","ZodTemplateLiteral","templateLiteral","ZodCustom","custom"],"sources":["../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/errors.js","../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/parse.js","../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/memoizer.js","../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/locales/en.js","../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/api.js","../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/errors.js","../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/parse.js","../../../../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/schemas.js"],"sourcesContent":["import { $constructor } from \"./core.js\";\nimport * as util from \"./util.js\";\n/* Computing the message eagerly is expensive (pretty-printed JSON of all\n * issues), so defer it until first read. The accessor functions and\n * descriptors are shared across instances to keep error construction\n * cheap; the computed message is cached on the internals object. The\n * setter preserves plain assignment semantics for consumers that\n * overwrite `message`. */\nfunction _getMessage() {\n    const internals = this._zod;\n    internals.message ?? (internals.message = JSON.stringify(internals.def, util.jsonStringifyReplacer, 2));\n    return internals.message;\n}\nfunction _setMessage(value) {\n    this._zod.message = value;\n}\nconst _messageDesc = {\n    get: _getMessage,\n    set: _setMessage,\n    enumerable: true,\n    configurable: true,\n};\nconst _issuesDesc = { value: undefined, enumerable: false };\n/* Prototypes that already carry the lazy `toString`. Seeded with the\n * intrinsics so that `init` on a foreign object — it accepts any object —\n * can never install an accessor onto a prototype we do not own. */\nconst _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);\nconst initializer = (inst, def) => {\n    inst.name = \"$ZodError\";\n    // `_zod` is already non-enumerable: $constructor's init defined it with this same descriptor\n    _issuesDesc.value = def;\n    Object.defineProperty(inst, \"issues\", _issuesDesc);\n    // Clear the shared slot; a retained `value` pins the last error's issues.\n    _issuesDesc.value = undefined;\n    Object.defineProperty(inst, \"message\", _messageDesc);\n    /* `toString` lives as a non-enumerable lazy getter on the shared\n     * prototype; on first access it caches a per-instance closure so\n     * detached usage still works. */\n    const proto = Object.getPrototypeOf(inst);\n    if (!_installedToString.has(proto)) {\n        _installedToString.add(proto);\n        Object.defineProperty(proto, \"toString\", {\n            configurable: true,\n            enumerable: false,\n            get() {\n                const value = () => this.message;\n                Object.defineProperty(this, \"toString\", { value, configurable: true, writable: true });\n                return value;\n            },\n            set(value) {\n                Object.defineProperty(this, \"toString\", { value, configurable: true, writable: true });\n            },\n        });\n    }\n};\nexport const $ZodError = $constructor(\"$ZodError\", initializer);\nexport const $ZodRealError = $constructor(\"$ZodError\", initializer, undefined, {\n    Parent: Error,\n});\n/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member\n * (\"toString\", \"constructor\") would otherwise read through to the prototype, and assigning\n * \"__proto__\" would hit the setter instead of creating a key. */\nfunction node(obj, key, make) {\n    if (!Object.prototype.hasOwnProperty.call(obj, key)) {\n        if (key === \"__proto__\") {\n            Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });\n        }\n        else {\n            obj[key] = make();\n        }\n    }\n    return obj[key];\n}\nexport function flattenError(error, mapper = (issue) => issue.message) {\n    const fieldErrors = {};\n    const formErrors = [];\n    for (const sub of error.issues) {\n        if (sub.path.length > 0) {\n            node(fieldErrors, sub.path[0], () => []).push(mapper(sub));\n        }\n        else {\n            formErrors.push(mapper(sub));\n        }\n    }\n    return { formErrors, fieldErrors };\n}\nexport function formatError(error, mapper = (issue) => issue.message) {\n    const fieldErrors = { _errors: [] };\n    const processError = (error, path = []) => {\n        for (const issue of error.issues) {\n            if (issue.code === \"invalid_union\" && issue.errors.length) {\n                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));\n            }\n            else if (issue.code === \"invalid_key\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else if (issue.code === \"invalid_element\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else {\n                const fullpath = [...path, ...issue.path];\n                if (fullpath.length === 0) {\n                    fieldErrors._errors.push(mapper(issue));\n                }\n                else {\n                    let curr = fieldErrors;\n                    let i = 0;\n                    while (i < fullpath.length) {\n                        const el = fullpath[i];\n                        const terminal = i === fullpath.length - 1;\n                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.\n                        if (el === \"_errors\") {\n                            if (terminal)\n                                curr._errors.push(mapper(issue));\n                            i++;\n                            continue;\n                        }\n                        // A path element may collide with an inherited property name such as\n                        // \"__proto__\" or \"constructor\". Truthiness checks read the prototype\n                        // (so no node is created, then ._errors.push throws), and bracket\n                        // assignment of \"__proto__\" hits the setter instead of creating an\n                        // own key. Guard the read with hasOwnProperty and create the node\n                        // with defineProperty so any path element becomes a real own key.\n                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {\n                            Object.defineProperty(curr, el, {\n                                value: { _errors: [] },\n                                enumerable: true,\n                                writable: true,\n                                configurable: true,\n                            });\n                        }\n                        const node = curr[el];\n                        if (terminal) {\n                            node._errors.push(mapper(issue));\n                        }\n                        curr = node;\n                        i++;\n                    }\n                }\n            }\n        }\n    };\n    processError(error);\n    return fieldErrors;\n}\nexport function treeifyError(error, mapper = (issue) => issue.message) {\n    const result = { errors: [] };\n    const processError = (error, path = []) => {\n        var _a;\n        for (const issue of error.issues) {\n            if (issue.code === \"invalid_union\" && issue.errors.length) {\n                // regular union error\n                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));\n            }\n            else if (issue.code === \"invalid_key\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else if (issue.code === \"invalid_element\") {\n                processError({ issues: issue.issues }, [...path, ...issue.path]);\n            }\n            else {\n                const fullpath = [...path, ...issue.path];\n                if (fullpath.length === 0) {\n                    result.errors.push(mapper(issue));\n                    continue;\n                }\n                let curr = result;\n                let i = 0;\n                while (i < fullpath.length) {\n                    const el = fullpath[i];\n                    const terminal = i === fullpath.length - 1;\n                    if (typeof el === \"string\") {\n                        curr.properties ?? (curr.properties = {});\n                        // el may collide with an inherited property name (\"__proto__\",\n                        // \"constructor\", ...); ??= reads the prototype so the node is never\n                        // created and curr.errors.push throws. Guard with hasOwnProperty and\n                        // create the node with defineProperty so \"__proto__\" becomes a real\n                        // own key rather than invoking the prototype setter.\n                        if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {\n                            Object.defineProperty(curr.properties, el, {\n                                value: { errors: [] },\n                                enumerable: true,\n                                writable: true,\n                                configurable: true,\n                            });\n                        }\n                        curr = curr.properties[el];\n                    }\n                    else {\n                        curr.items ?? (curr.items = []);\n                        (_a = curr.items)[el] ?? (_a[el] = { errors: [] });\n                        curr = curr.items[el];\n                    }\n                    if (terminal) {\n                        curr.errors.push(mapper(issue));\n                    }\n                    i++;\n                }\n            }\n        }\n    };\n    processError(error);\n    return result;\n}\n/** Format a ZodError as a human-readable string in the following form.\n *\n * From\n *\n * ```ts\n * ZodError {\n *   issues: [\n *     {\n *       expected: 'string',\n *       code: 'invalid_type',\n *       path: [ 'username' ],\n *       message: 'Invalid input: expected string'\n *     },\n *     {\n *       expected: 'number',\n *       code: 'invalid_type',\n *       path: [ 'favoriteNumbers', 1 ],\n *       message: 'Invalid input: expected number'\n *     }\n *   ];\n * }\n * ```\n *\n * to\n *\n * ```\n * username\n *   ✖ Expected number, received string at \"username\n * favoriteNumbers[0]\n *   ✖ Invalid input: expected number\n * ```\n */\nexport function toDotPath(_path) {\n    const segs = [];\n    const path = _path.map((seg) => (typeof seg === \"object\" ? seg.key : seg));\n    for (const seg of path) {\n        if (typeof seg === \"number\")\n            segs.push(`[${seg}]`);\n        else if (typeof seg === \"symbol\")\n            segs.push(`[${JSON.stringify(String(seg))}]`);\n        else if (/[^\\w$]/.test(seg))\n            segs.push(`[${JSON.stringify(seg)}]`);\n        else {\n            if (segs.length)\n                segs.push(\".\");\n            segs.push(seg);\n        }\n    }\n    return segs.join(\"\");\n}\nexport function prettifyError(error) {\n    const lines = [];\n    // sort by path length\n    const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);\n    // Process each issue\n    for (const issue of issues) {\n        lines.push(`✖ ${issue.message}`);\n        if (issue.path?.length)\n            lines.push(`  → at ${toDotPath(issue.path)}`);\n    }\n    // Convert Map to formatted string\n    return lines.join(\"\\n\");\n}\n","import * as core from \"./core.js\";\nimport * as errors from \"./errors.js\";\nimport * as util from \"./util.js\";\n// Always both keys, so the `_params` read site in `_parse` sees one object shape rather than two.\nfunction finalizeParams(callee, params) {\n    return { callee: params?.callee ?? callee, Err: params?.Err };\n}\nexport const _parse = (_Err) => {\n    const fn = (schema, value, _ctx, _params) => {\n        const ctx = _ctx ? { ..._ctx, async: false } : { async: false };\n        const result = schema._zod.run({ value, issues: [] }, ctx);\n        if (result instanceof Promise) {\n            throw new core.$ZodAsyncError();\n        }\n        if (result.issues.length) {\n            const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n            util.captureStackTrace(e, _params?.callee ?? fn);\n            throw e;\n        }\n        return result.value;\n    };\n    return fn;\n};\nexport const parse = /* @__PURE__*/ _parse(errors.$ZodRealError);\nexport const _parseAsync = (_Err) => {\n    const fn = async (schema, value, _ctx, params) => {\n        const ctx = _ctx ? { ..._ctx, async: true } : { async: true };\n        let result = schema._zod.run({ value, issues: [] }, ctx);\n        if (result instanceof Promise)\n            result = await result;\n        if (result.issues.length) {\n            const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n            util.captureStackTrace(e, params?.callee ?? fn);\n            throw e;\n        }\n        return result.value;\n    };\n    return fn;\n};\nexport const parseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);\nexport const _safeParse = (_Err) => (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };\n    const result = schema._zod.run({ value, issues: [] }, ctx);\n    if (result instanceof Promise) {\n        throw new core.$ZodAsyncError();\n    }\n    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };\n};\nexport const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);\n// the error is built on the first read of `error`: finalizing the issues and constructing the instance is most of a failing parse, and a caller that only branches on `success` never pays it. a getter in the literal keeps this small; the alternative, one shared accessor descriptor plus a hidden state slot, reads ~15% faster but costs ~75 B gzipped in every bundle\nfunction failure(Err, issues, ctx) {\n    let error;\n    return {\n        success: false,\n        get error() {\n            if (!error) {\n                error = new Err(issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n                // finalizeIssue drops `input`, so the built error holds nothing; keeping the raw issues past this point pins the parsed value for the life of the result\n                issues = undefined;\n                ctx = undefined;\n            }\n            return error;\n        },\n        set error(e) {\n            error = e;\n            // a replacement makes the getter's branch unreachable, so the captures have to go here too\n            issues = undefined;\n            ctx = undefined;\n        },\n    };\n}\nexport const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };\n    let result = schema._zod.run({ value, issues: [] }, ctx);\n    if (result instanceof Promise)\n        result = await result;\n    return result.issues.length ? failure(_Err, result.issues, ctx) : { success: true, data: result.value };\n};\nexport const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);\n// registry mirrors of the compiler's sentinels, so this module never imports the compiler\nconst COMPILE_INVALID = /* @__PURE__ */ Symbol.for(\"zod.compile.invalid\");\nconst COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for(\"zod.compile.fallback\");\n// Deliberately tiny, because v8 will not inline a body carrying the fallback's object literals and throw. Everything that is not the compiled happy path lives in validateFallback, and that split is worth ~35% on a compiled schema.\nexport const validate = ((schema, value, _ctx) => {\n    const validator = schema._zod.bag.validator;\n    if (validator !== undefined) {\n        if (validator(value) !== COMPILE_INVALID)\n            return true;\n        // a definite sentinel means the runtime would reject, so skip the re-parse; a ctx can still change the answer\n        if (validator.definite === true && _ctx === undefined)\n            return false;\n    }\n    return validateFallback(schema, value, _ctx);\n});\nfunction validateFallback(schema, value, _ctx) {\n    const ctx = _ctx\n        ? { ..._ctx, async: false, abortEarly: true }\n        : { async: false, abortEarly: true };\n    const fallbackRun = schema._zod.bag.fallbackRun;\n    let result;\n    if (fallbackRun) {\n        // skip nested fast paths on the fallback, so user callbacks keep the at-most-twice bound\n        ctx[COMPILE_FALLBACK] = true;\n        result = fallbackRun({ value, issues: [] }, ctx);\n    }\n    else {\n        result = schema._zod.run({ value, issues: [] }, ctx);\n    }\n    if (result instanceof Promise) {\n        throw new core.$ZodAsyncError();\n    }\n    return result.issues.length === 0;\n}\n// no fast path: the compiler keeps async parses on the runtime, because a promise-returning callback that is not declared async compiles to a throw\nexport const validateAsync = async (schema, value, _ctx) => {\n    const ctx = _ctx\n        ? { ..._ctx, async: true, abortEarly: true }\n        : { async: true, abortEarly: true };\n    let result = schema._zod.run({ value, issues: [] }, ctx);\n    if (result instanceof Promise)\n        result = await result;\n    return result.issues.length === 0;\n};\nexport const _encode = (_Err) => {\n    const parse = _parse(_Err);\n    const fn = (schema, value, _ctx, _params) => {\n        const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n        return parse(schema, value, ctx, finalizeParams(fn, _params));\n    };\n    return fn;\n};\nexport const encode = /* @__PURE__*/ _encode(errors.$ZodRealError);\nexport const _decode = (_Err) => {\n    const parse = _parse(_Err);\n    const fn = (schema, value, _ctx, _params) => {\n        return parse(schema, value, _ctx, finalizeParams(fn, _params));\n    };\n    return fn;\n};\nexport const decode = /* @__PURE__*/ _decode(errors.$ZodRealError);\nexport const _encodeAsync = (_Err) => {\n    const parseAsync = _parseAsync(_Err);\n    const fn = async (schema, value, _ctx, _params) => {\n        const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n        return (await parseAsync(schema, value, ctx, finalizeParams(fn, _params)));\n    };\n    return fn;\n};\nexport const encodeAsync = /* @__PURE__*/ _encodeAsync(errors.$ZodRealError);\nexport const _decodeAsync = (_Err) => {\n    const parseAsync = _parseAsync(_Err);\n    const fn = async (schema, value, _ctx, _params) => {\n        return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));\n    };\n    return fn;\n};\nexport const decodeAsync = /* @__PURE__*/ _decodeAsync(errors.$ZodRealError);\nexport const _safeEncode = (_Err) => (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n    return _safeParse(_Err)(schema, value, ctx);\n};\nexport const safeEncode = /* @__PURE__*/ _safeEncode(errors.$ZodRealError);\nexport const _safeDecode = (_Err) => (schema, value, _ctx) => {\n    return _safeParse(_Err)(schema, value, _ctx);\n};\nexport const safeDecode = /* @__PURE__*/ _safeDecode(errors.$ZodRealError);\nexport const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {\n    const ctx = _ctx ? { ..._ctx, direction: \"backward\" } : { direction: \"backward\" };\n    return _safeParseAsync(_Err)(schema, value, ctx);\n};\nexport const safeEncodeAsync = /* @__PURE__*/ _safeEncodeAsync(errors.$ZodRealError);\nexport const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {\n    return _safeParseAsync(_Err)(schema, value, _ctx);\n};\nexport const safeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync(errors.$ZodRealError);\n","import * as util from \"./util.js\";\nexport class $ZodCyclicError extends Error {\n    constructor() {\n        super(`Cannot parse a reference cycle that closes through a transform`);\n        this.name = \"ZodCyclicError\";\n    }\n}\n/** Keyed off the context object every schema in one parse call already shares. */\nconst STATE = \"~memo\";\nconst NO_ISSUES = [];\n// a value a cycle can close through\nfunction isRef(value) {\n    return value !== null && typeof value === \"object\";\n}\n// Receivers prefix paths in place, so the cache and every hand-out need their own copies.\nfunction cloneIssues(issues) {\n    return issues.map((iss) => (iss.path ? { ...iss, path: iss.path.slice() } : { ...iss }));\n}\nconst recursive = /*@__PURE__*/ new WeakMap();\n/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */\nconst NONE = 0;\nconst ASSUMED = 1;\nconst PROVEN = 2;\n/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */\nfunction isRecursive(inst, stack, resolve) {\n    const cached = recursive.get(inst);\n    if (cached !== undefined)\n        return cached ? PROVEN : NONE;\n    // Relative to the walk in progress, so not cached.\n    if (stack.has(inst))\n        return PROVEN;\n    stack.add(inst);\n    let result = NONE;\n    const check = (child) => {\n        if (result !== PROVEN && child?._zod) {\n            const answer = isRecursive(child, stack, resolve);\n            if (answer > result)\n                result = answer;\n        }\n    };\n    // `Reflect.ownKeys` rather than `Object.keys`, so a cycle through a declared symbol key is still seen\n    const shape = (sh, spread) => {\n        let answer = NONE;\n        for (const key of Reflect.ownKeys(sh)) {\n            const desc = Object.getOwnPropertyDescriptor(sh, key);\n            // an object resolves its shape by spread, so a key it does not enumerate is never parsed; `z.properties` reads every own key and so keeps them all\n            if (spread && !desc.enumerable)\n                continue;\n            // resolving runs user code, and a factory mints a fresh subtree per read, so an edge the walk can't follow counts as a cycle\n            const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;\n            if (child > answer)\n                answer = child;\n        }\n        return answer;\n    };\n    const merge = (answer) => {\n        if (answer > result)\n            result = answer;\n    };\n    const def = inst._zod.def;\n    const kind = def.type;\n    switch (kind) {\n        case \"object\": {\n            const raw = util.rawShape(def);\n            // a def with no raw shape answers `shape` from an accessor of its own, and running that can mint a whole fresh subtree\n            merge(raw ? shape(raw, true) : ASSUMED);\n            check(def.catchall);\n            break;\n        }\n        case \"array\":\n            check(def.element);\n            break;\n        case \"tuple\":\n            for (const el of def.items)\n                check(el);\n            check(def.rest);\n            break;\n        case \"record\":\n        case \"map\":\n            check(def.keyType);\n            check(def.valueType);\n            break;\n        case \"set\":\n            check(def.valueType);\n            break;\n        case \"union\":\n            for (const el of def.options)\n                check(el);\n            break;\n        case \"intersection\":\n            check(def.left);\n            check(def.right);\n            break;\n        case \"optional\":\n        case \"nullable\":\n        case \"default\":\n        case \"prefault\":\n        case \"catch\":\n        case \"readonly\":\n        case \"nonoptional\":\n        case \"promise\":\n        case \"success\":\n            check(def.innerType);\n            break;\n        case \"pipe\":\n            check(def.in);\n            check(def.out);\n            break;\n        case \"function\":\n            check(def.input);\n            check(def.output);\n            break;\n        // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly\n        case \"lazy\": {\n            const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : undefined);\n            // walked with resolution off: one hop sees past the deferral, and a lazy that yields only another unresolved lazy is generative, so it stops there\n            merge(inner ? isRecursive(inner, stack, false) : ASSUMED);\n            break;\n        }\n        // a leaf by choice: `parts` are regex fragments, not data positions\n        case \"template_literal\":\n        // leaves\n        case \"string\":\n        case \"number\":\n        case \"int\":\n        case \"boolean\":\n        case \"bigint\":\n        case \"symbol\":\n        case \"undefined\":\n        case \"null\":\n        case \"void\":\n        case \"never\":\n        case \"any\":\n        case \"unknown\":\n        case \"date\":\n        case \"nan\":\n        case \"enum\":\n        case \"literal\":\n        case \"file\":\n        case \"transform\":\n        case \"custom\":\n            break;\n        default: {\n            // a new built-in kind becomes a compile error here\n            kind;\n            // a user-defined kind can still hold children, and only its author knows where, so fall back to scanning the def — skipping accessors, since reading one can run user code\n            for (const key in def) {\n                const desc = Object.getOwnPropertyDescriptor(def, key);\n                if (!desc || desc.get)\n                    continue;\n                const value = desc.value;\n                if (!value || typeof value !== \"object\")\n                    continue;\n                if (value._zod)\n                    check(value);\n                else if (Array.isArray(value))\n                    for (const el of value)\n                        check(el);\n            }\n        }\n    }\n    stack.delete(inst);\n    return settle(inst, result);\n}\n/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */\nfunction settle(inst, answer) {\n    if (answer !== ASSUMED)\n        recursive.set(inst, answer === PROVEN);\n    return answer;\n}\n/**\n * Whether one parse can re-enter this schema, i.e. its subtree contains a cycle.\n * Exported for `z.compile`, which refuses to compile such a schema: cycle\n * breaking is driven from here off state keyed on the parse context, and a\n * generated fast path has no context to key on.\n */\nexport function isRecursiveSchema(inst) {\n    // z.compile never parses, so nothing would ever resolve a lazy for it; it runs once and already treats a throw here as recursive\n    return isRecursive(inst, new Set(), true) !== NONE;\n}\nfunction bucketFor(state, inst) {\n    let bucket = state.buckets.get(inst);\n    if (!bucket) {\n        bucket = new WeakMap();\n        state.buckets.set(inst, bucket);\n    }\n    return bucket;\n}\n// Set immediately before delegating to core and cleared immediately after, so `alloc` registers only for a visit this module is driving.\nlet handoff;\n// Allocated but unfinished entries. `alloc` and the matching pop both happen in the synchronous part of a parse, so they nest even when children are async, and one stack serves every schema.\nconst open = [];\nconst memo = {\n    alloc(_inst, payload, empty) {\n        const bucket = handoff;\n        if (!bucket)\n            return empty;\n        handoff = undefined;\n        const entry = { value: empty, issues: null };\n        bucket.set(payload.value, entry);\n        open.push(entry);\n        return empty;\n    },\n    guard(inst) {\n        var _a;\n        (_a = inst._zod).deferred ?? (_a.deferred = []);\n        inst._zod.deferred.push(() => {\n            const base = inst._zod.parse;\n            const wrapped = (payload, ctx) => {\n                // The value is a placeholder a back-edge is still waiting on, so the cycle closes through this transform. Its output can't exist in time to bind.\n                if (ctx.direction !== \"backward\" && isBackEdge(ctx, payload.value))\n                    throw new $ZodCyclicError();\n                return base(payload, ctx);\n            };\n            inst._zod.parse = wrapped;\n            if (inst._zod.run === base)\n                inst._zod.run = wrapped;\n        });\n    },\n    attach(inst) {\n        var _a;\n        let isRecursiveInst;\n        let rechecked = false;\n        // a recursive schema is re-entered many times per parse and its bucket never changes\n        let lastCtx;\n        let lastBucket;\n        // Wraps `parse` in a deferred so it sees the container's final parse. Core's own deferred copies `parse` into `run` when there are no checks, and it ran first, so `run` is patched to match; with checks, `run` reads `parse` dynamically.\n        (_a = inst._zod).deferred ?? (_a.deferred = []);\n        inst._zod.deferred.push(() => {\n            const base = inst._zod.parse;\n            const wrapped = (payload, ctx) => {\n                if (isRecursiveInst === undefined) {\n                    const walked = isRecursive(inst, new Set(), false);\n                    if (walked === NONE) {\n                        // Nothing here can ever fire, so take it back out.\n                        inst._zod.parse = base;\n                        if (inst._zod.run === wrapped)\n                            inst._zod.run = base;\n                        return base(payload, ctx);\n                    }\n                    // this parse resolves the deferred edges on its own path, so ask once more before latching\n                    if (walked === PROVEN || rechecked)\n                        isRecursiveInst = true;\n                    else\n                        rechecked = true;\n                }\n                const input = payload.value;\n                if (!isRef(input))\n                    return base(payload, ctx);\n                let state = ctx[STATE];\n                if (!state) {\n                    state = { buckets: new WeakMap(), backEdges: undefined };\n                    ctx[STATE] = state;\n                }\n                let bucket;\n                if (lastCtx === ctx) {\n                    bucket = lastBucket;\n                }\n                else {\n                    bucket = bucketFor(state, inst);\n                    lastCtx = ctx;\n                    lastBucket = bucket;\n                }\n                const hit = bucket.get(input);\n                if (hit) {\n                    payload.value = hit.value;\n                    if (hit.issues) {\n                        if (hit.issues.length)\n                            payload.issues.push(...cloneIssues(hit.issues));\n                    }\n                    else {\n                        // Still being parsed: its own checks cover it, so skip them here.\n                        payload.memo = true;\n                        state.backEdges ?? (state.backEdges = new WeakSet());\n                        state.backEdges.add(hit.value);\n                    }\n                    return payload;\n                }\n                handoff = bucket;\n                const depth = open.length;\n                const result = base(payload, ctx);\n                handoff = undefined;\n                // A container that rejected its input outright allocated nothing.\n                const entry = open.length > depth ? open.pop() : undefined;\n                // Both paths written out so the sync one allocates no closure. It runs once per node, and capturing here cost more than everything else combined.\n                if (result instanceof Promise) {\n                    return result.then((r) => {\n                        if (entry)\n                            entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;\n                        return r;\n                    });\n                }\n                if (entry)\n                    entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;\n                return result;\n            };\n            inst._zod.parse = wrapped;\n            if (inst._zod.run === base)\n                inst._zod.run = wrapped;\n        });\n    },\n};\n/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */\nexport function memoizer() {\n    return memo;\n}\n/** Whether this value is a node a back-edge resolved to before it finished. */\nexport function isBackEdge(ctx, value) {\n    const backEdges = ctx[STATE]?.backEdges;\n    return backEdges !== undefined && isRef(value) && backEdges.has(value);\n}\n","import * as util from \"../core/util.js\";\nconst error = () => {\n    const Sizable = {\n        string: { unit: \"characters\", verb: \"to have\" },\n        file: { unit: \"bytes\", verb: \"to have\" },\n        array: { unit: \"items\", verb: \"to have\" },\n        set: { unit: \"items\", verb: \"to have\" },\n        map: { unit: \"entries\", verb: \"to have\" },\n    };\n    function getSizing(origin) {\n        return Sizable[origin] ?? null;\n    }\n    const FormatDictionary = {\n        regex: \"input\",\n        email: \"email address\",\n        url: \"URL\",\n        emoji: \"emoji\",\n        uuid: \"UUID\",\n        uuidv4: \"UUIDv4\",\n        uuidv6: \"UUIDv6\",\n        nanoid: \"nanoid\",\n        guid: \"GUID\",\n        cuid: \"cuid\",\n        cuid2: \"cuid2\",\n        ulid: \"ULID\",\n        xid: \"XID\",\n        ksuid: \"KSUID\",\n        datetime: \"ISO datetime\",\n        date: \"ISO date\",\n        time: \"ISO time\",\n        duration: \"ISO duration\",\n        ipv4: \"IPv4 address\",\n        ipv6: \"IPv6 address\",\n        mac: \"MAC address\",\n        cidrv4: \"IPv4 range\",\n        cidrv6: \"IPv6 range\",\n        base64: \"base64-encoded string\",\n        base64url: \"base64url-encoded string\",\n        json_string: \"JSON string\",\n        e164: \"E.164 number\",\n        currency_code: \"currency code\",\n        credit_card: \"credit card number\",\n        iban: \"IBAN\",\n        jwt: \"JWT\",\n        template_literal: \"input\",\n    };\n    // type names: missing keys = do not translate (use raw value via ?? fallback)\n    const TypeDictionary = {\n        // Compatibility: \"nan\" -> \"NaN\" for display\n        nan: \"NaN\",\n        // All other type names omitted - they fall back to raw values via ?? operator\n    };\n    function getTypeName(type, input) {\n        if (type === \"number\" && typeof input === \"number\" && !Number.isFinite(input)) {\n            return String(input);\n        }\n        return TypeDictionary[type] ?? type;\n    }\n    return (issue) => {\n        switch (issue.code) {\n            case \"invalid_type\": {\n                const expected = getTypeName(issue.expected);\n                const receivedType = util.parsedType(issue.input);\n                const received = getTypeName(receivedType, issue.input);\n                return `Invalid input: expected ${expected}, received ${received}`;\n            }\n            case \"invalid_value\":\n                if (issue.values.length === 1)\n                    return `Invalid input: expected ${util.stringifyPrimitive(issue.values[0])}`;\n                return `Invalid option: expected one of ${util.joinValues(issue.values, \"|\")}`;\n            case \"too_big\": {\n                const adj = issue.exact ? \"exactly \" : issue.inclusive ? \"<=\" : \"<\";\n                const sizing = getSizing(issue.origin);\n                if (sizing)\n                    return `Too big: expected ${issue.origin ?? \"value\"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? \"elements\"}`;\n                return `Too big: expected ${issue.origin ?? \"value\"} to be ${adj}${issue.maximum.toString()}`;\n            }\n            case \"too_small\": {\n                const adj = issue.exact ? \"exactly \" : issue.inclusive ? \">=\" : \">\";\n                const sizing = getSizing(issue.origin);\n                if (sizing) {\n                    return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;\n                }\n                return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;\n            }\n            case \"invalid_format\": {\n                const _issue = issue;\n                if (_issue.format === \"starts_with\") {\n                    return `Invalid string: must start with \"${_issue.prefix}\"`;\n                }\n                if (_issue.format === \"ends_with\")\n                    return `Invalid string: must end with \"${_issue.suffix}\"`;\n                if (_issue.format === \"includes\")\n                    return `Invalid string: must include \"${_issue.includes}\"`;\n                if (_issue.format === \"regex\")\n                    return `Invalid string: must match pattern ${_issue.pattern}`;\n                return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;\n            }\n            case \"not_multiple_of\":\n                return `Invalid number: must be a multiple of ${issue.divisor}`;\n            case \"unrecognized_keys\":\n                return `Unrecognized key${issue.keys.length > 1 ? \"s\" : \"\"}: ${util.joinValues(issue.keys, \", \")}`;\n            case \"invalid_key\":\n                return `Invalid key in ${issue.origin}`;\n            case \"invalid_union\":\n                if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) {\n                    const opts = issue.options.map((o) => `'${o}'`).join(\" | \");\n                    return `Invalid discriminator value. Expected ${opts}`;\n                }\n                if (issue.inclusive === false) {\n                    return \"Invalid input: more than one option matched\";\n                }\n                return \"Invalid input\";\n            case \"invalid_element\":\n                return `Invalid value in ${issue.origin}`;\n            default:\n                return `Invalid input`;\n        }\n    };\n};\nexport default function () {\n    return {\n        localeError: error(),\n    };\n}\n","import * as checks from \"./checks.js\";\nimport * as registries from \"./registries.js\";\nimport * as schemas from \"./schemas.js\";\nimport * as util from \"./util.js\";\nfunction snapshotChecks(def) {\n    if (def.checks)\n        def.checks = [...def.checks];\n    return def;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _string(Class, params) {\n    return new Class(snapshotChecks({ type: \"string\", ...util.normalizeParams(params) }));\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedString(Class, params) {\n    return new Class(snapshotChecks({ type: \"string\", coerce: true, ...util.normalizeParams(params) }));\n}\n// @__NO_SIDE_EFFECTS__\nexport function _email(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"email\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _guid(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"guid\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuid(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"uuid\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuidv4(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"uuid\",\n        check: \"string_format\",\n        abort: false,\n        version: \"v4\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuidv6(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"uuid\",\n        check: \"string_format\",\n        abort: false,\n        version: \"v6\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuidv7(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"uuid\",\n        check: \"string_format\",\n        abort: false,\n        version: \"v7\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _url(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"url\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _emoji(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"emoji\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nanoid(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"nanoid\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n/**\n * @deprecated CUID v1 is deprecated by its authors due to information leakage\n * (timestamps embedded in the id). Use {@link _cuid2} instead.\n * See https://github.com/paralleldrive/cuid.\n */\n// @__NO_SIDE_EFFECTS__\nexport function _cuid(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"cuid\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _cuid2(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"cuid2\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ulid(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"ulid\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _xid(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"xid\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ksuid(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"ksuid\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ipv4(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"ipv4\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ipv6(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"ipv6\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _mac(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"mac\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _cidrv4(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"cidrv4\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _cidrv6(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"cidrv6\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _base64(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"base64\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _base64url(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"base64url\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _e164(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"e164\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _creditCard(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"credit_card\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _iban(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"iban\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _jwt(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"jwt\",\n        check: \"string_format\",\n        abort: false,\n        ...util.normalizeParams(params),\n    });\n}\nexport const TimePrecision = {\n    Any: null,\n    Minute: -1,\n    Second: 0,\n    Millisecond: 3,\n    Microsecond: 6,\n};\n// @__NO_SIDE_EFFECTS__\nexport function _isoDateTime(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"datetime\",\n        check: \"string_format\",\n        offset: false,\n        local: false,\n        precision: null,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _isoDate(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"date\",\n        check: \"string_format\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _isoTime(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"time\",\n        check: \"string_format\",\n        precision: null,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _isoDuration(Class, params) {\n    return new Class({\n        type: \"string\",\n        format: \"duration\",\n        check: \"string_format\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _number(Class, params) {\n    return new Class(snapshotChecks({ type: \"number\", checks: [], ...util.normalizeParams(params) }));\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedNumber(Class, params) {\n    return new Class(snapshotChecks({ type: \"number\", coerce: true, checks: [], ...util.normalizeParams(params) }));\n}\n// @__NO_SIDE_EFFECTS__\nexport function _int(Class, params) {\n    return new Class({\n        type: \"number\",\n        check: \"number_format\",\n        abort: false,\n        format: \"safeint\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _float32(Class, params) {\n    return new Class({\n        type: \"number\",\n        check: \"number_format\",\n        abort: false,\n        format: \"float32\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _float64(Class, params) {\n    return new Class({\n        type: \"number\",\n        check: \"number_format\",\n        abort: false,\n        format: \"float64\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _int32(Class, params) {\n    return new Class({\n        type: \"number\",\n        check: \"number_format\",\n        abort: false,\n        format: \"int32\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uint32(Class, params) {\n    return new Class({\n        type: \"number\",\n        check: \"number_format\",\n        abort: false,\n        format: \"uint32\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _boolean(Class, params) {\n    return new Class({\n        type: \"boolean\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedBoolean(Class, params) {\n    return new Class({\n        type: \"boolean\",\n        coerce: true,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _bigint(Class, params) {\n    return new Class({\n        type: \"bigint\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedBigint(Class, params) {\n    return new Class({\n        type: \"bigint\",\n        coerce: true,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _int64(Class, params) {\n    return new Class({\n        type: \"bigint\",\n        check: \"bigint_format\",\n        abort: false,\n        format: \"int64\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uint64(Class, params) {\n    return new Class({\n        type: \"bigint\",\n        check: \"bigint_format\",\n        abort: false,\n        format: \"uint64\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _symbol(Class, params) {\n    return new Class({\n        type: \"symbol\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _undefined(Class, params) {\n    return new Class({\n        type: \"undefined\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _null(Class, params) {\n    return new Class({\n        type: \"null\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _any(Class) {\n    return new Class({\n        type: \"any\",\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _unknown(Class) {\n    return new Class({\n        type: \"unknown\",\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _never(Class, params) {\n    return new Class({\n        type: \"never\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _void(Class, params) {\n    return new Class({\n        type: \"void\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _date(Class, params) {\n    return new Class({\n        type: \"date\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedDate(Class, params) {\n    return new Class({\n        type: \"date\",\n        coerce: true,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nan(Class, params) {\n    return new Class({\n        type: \"nan\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lt(value, params) {\n    return new checks.$ZodCheckLessThan({\n        check: \"less_than\",\n        ...util.normalizeParams(params),\n        value,\n        inclusive: false,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lte(value, params) {\n    return new checks.$ZodCheckLessThan({\n        check: \"less_than\",\n        ...util.normalizeParams(params),\n        value,\n        inclusive: true,\n    });\n}\nexport { \n/** @deprecated Use `z.lte()` instead. */\n_lte as _max, };\n// @__NO_SIDE_EFFECTS__\nexport function _gt(value, params) {\n    return new checks.$ZodCheckGreaterThan({\n        check: \"greater_than\",\n        ...util.normalizeParams(params),\n        value,\n        inclusive: false,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _gte(value, params) {\n    return new checks.$ZodCheckGreaterThan({\n        check: \"greater_than\",\n        ...util.normalizeParams(params),\n        value,\n        inclusive: true,\n    });\n}\nexport { \n/** @deprecated Use `z.gte()` instead. */\n_gte as _min, };\n// @__NO_SIDE_EFFECTS__\nexport function _positive(params) {\n    return _gt(0, params);\n}\n// negative\n// @__NO_SIDE_EFFECTS__\nexport function _negative(params) {\n    return _lt(0, params);\n}\n// nonpositive\n// @__NO_SIDE_EFFECTS__\nexport function _nonpositive(params) {\n    return _lte(0, params);\n}\n// nonnegative\n// @__NO_SIDE_EFFECTS__\nexport function _nonnegative(params) {\n    return _gte(0, params);\n}\n// @__NO_SIDE_EFFECTS__\nexport function _multipleOf(value, params) {\n    return new checks.$ZodCheckMultipleOf({\n        check: \"multiple_of\",\n        ...util.normalizeParams(params),\n        value,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _maxSize(maximum, params) {\n    return new checks.$ZodCheckMaxSize({\n        check: \"max_size\",\n        ...util.normalizeParams(params),\n        maximum,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _minSize(minimum, params) {\n    return new checks.$ZodCheckMinSize({\n        check: \"min_size\",\n        ...util.normalizeParams(params),\n        minimum,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _size(size, params) {\n    return new checks.$ZodCheckSizeEquals({\n        check: \"size_equals\",\n        ...util.normalizeParams(params),\n        size,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _maxLength(maximum, params) {\n    const ch = new checks.$ZodCheckMaxLength({\n        check: \"max_length\",\n        ...util.normalizeParams(params),\n        maximum,\n    });\n    return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _minLength(minimum, params) {\n    return new checks.$ZodCheckMinLength({\n        check: \"min_length\",\n        ...util.normalizeParams(params),\n        minimum,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _length(length, params) {\n    return new checks.$ZodCheckLengthEquals({\n        check: \"length_equals\",\n        ...util.normalizeParams(params),\n        length,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _regex(pattern, params) {\n    return new checks.$ZodCheckRegex({\n        check: \"string_format\",\n        format: \"regex\",\n        ...util.normalizeParams(params),\n        pattern,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lowercase(params) {\n    return new checks.$ZodCheckLowerCase({\n        check: \"string_format\",\n        format: \"lowercase\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uppercase(params) {\n    return new checks.$ZodCheckUpperCase({\n        check: \"string_format\",\n        format: \"uppercase\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _includes(includes, params) {\n    return new checks.$ZodCheckIncludes({\n        check: \"string_format\",\n        format: \"includes\",\n        ...util.normalizeParams(params),\n        includes,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _startsWith(prefix, params) {\n    return new checks.$ZodCheckStartsWith({\n        check: \"string_format\",\n        format: \"starts_with\",\n        ...util.normalizeParams(params),\n        prefix,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _endsWith(suffix, params) {\n    return new checks.$ZodCheckEndsWith({\n        check: \"string_format\",\n        format: \"ends_with\",\n        ...util.normalizeParams(params),\n        suffix,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _property(property, schema, params) {\n    return new checks.$ZodCheckProperty({\n        check: \"property\",\n        property,\n        schema,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _properties(shape, params) {\n    return new checks.$ZodCheckProperties({\n        check: \"properties\",\n        shape,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _mime(types, params) {\n    return new checks.$ZodCheckMimeType({\n        check: \"mime_type\",\n        mime: types,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _overwrite(tx) {\n    return new checks.$ZodCheckOverwrite({\n        check: \"overwrite\",\n        tx,\n    });\n}\n// normalize\n// @__NO_SIDE_EFFECTS__\nexport function _normalize(form) {\n    return _overwrite((input) => input.normalize(form));\n}\n// trim\n// @__NO_SIDE_EFFECTS__\nexport function _trim() {\n    return _overwrite((input) => input.trim());\n}\n// toLowerCase\n// @__NO_SIDE_EFFECTS__\nexport function _toLowerCase() {\n    return _overwrite((input) => input.toLowerCase());\n}\n// toUpperCase\n// @__NO_SIDE_EFFECTS__\nexport function _toUpperCase() {\n    return _overwrite((input) => input.toUpperCase());\n}\n// slugify\n// @__NO_SIDE_EFFECTS__\nexport function _slugify() {\n    return _overwrite((input) => util.slugify(input));\n}\n// @__NO_SIDE_EFFECTS__\nexport function _array(Class, element, params) {\n    return new Class({\n        type: \"array\",\n        element,\n        // get element() {\n        //   return element;\n        // },\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _union(Class, options, params) {\n    return new Class({\n        type: \"union\",\n        options,\n        ...util.normalizeParams(params),\n    });\n}\nexport function _xor(Class, options, params) {\n    return new Class({\n        type: \"union\",\n        options,\n        inclusive: false,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _discriminatedUnion(Class, discriminator, options, params) {\n    return new Class({\n        type: \"union\",\n        options: options,\n        discriminator,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _intersection(Class, left, right) {\n    return new Class({\n        type: \"intersection\",\n        left,\n        right,\n    });\n}\n// export function _tuple(\n//   Class: util.SchemaClass<schemas.$ZodTuple>,\n//   items: [],\n//   params?: string | $ZodTupleParams\n// ): schemas.$ZodTuple<[], null>;\n// @__NO_SIDE_EFFECTS__\nexport function _tuple(Class, items, _paramsOrRest, _params) {\n    const hasRest = _paramsOrRest instanceof schemas.$ZodType;\n    const params = hasRest ? _params : _paramsOrRest;\n    const rest = hasRest ? _paramsOrRest : null;\n    return new Class({\n        type: \"tuple\",\n        items,\n        rest,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _record(Class, keyType, valueType, params) {\n    return new Class({\n        type: \"record\",\n        keyType,\n        valueType,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _map(Class, keyType, valueType, params) {\n    return new Class({\n        type: \"map\",\n        keyType,\n        valueType,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _set(Class, valueType, params) {\n    return new Class({\n        type: \"set\",\n        valueType,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _enum(Class, values, params) {\n    const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n    // if (Array.isArray(values)) {\n    //   for (const value of values) {\n    //     entries[value] = value;\n    //   }\n    // } else {\n    //   Object.assign(entries, values);\n    // }\n    // const entries: util.EnumLike = {};\n    // for (const val of values) {\n    //   entries[val] = val;\n    // }\n    return new Class({\n        type: \"enum\",\n        entries,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport function _nativeEnum(Class, entries, params) {\n    return new Class({\n        type: \"enum\",\n        entries,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _literal(Class, value, params) {\n    return new Class({\n        type: \"literal\",\n        values: Array.isArray(value) ? value : [value],\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _file(Class, params) {\n    return new Class({\n        type: \"file\",\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _transform(Class, fn) {\n    return new Class({\n        type: \"transform\",\n        transform: fn,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _optional(Class, innerType) {\n    return new Class({\n        type: \"optional\",\n        innerType,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nullable(Class, innerType) {\n    return new Class({\n        type: \"nullable\",\n        innerType,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _default(Class, innerType, defaultValue) {\n    return new Class({\n        type: \"default\",\n        innerType,\n        get defaultValue() {\n            return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n        },\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nonoptional(Class, innerType, params) {\n    return new Class({\n        type: \"nonoptional\",\n        innerType,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _success(Class, innerType) {\n    return new Class({\n        type: \"success\",\n        innerType,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _catch(Class, innerType, catchValue) {\n    return new Class({\n        type: \"catch\",\n        innerType,\n        catchValue: (typeof catchValue === \"function\" ? catchValue : util.constantCatch(catchValue)),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _pipe(Class, in_, out) {\n    return new Class({\n        type: \"pipe\",\n        in: in_,\n        out,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _readonly(Class, innerType) {\n    return new Class({\n        type: \"readonly\",\n        innerType,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _templateLiteral(Class, parts, params) {\n    return new Class({\n        type: \"template_literal\",\n        parts,\n        ...util.normalizeParams(params),\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lazy(Class, getter) {\n    return new Class({\n        type: \"lazy\",\n        getter,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _promise(Class, innerType) {\n    return new Class({\n        type: \"promise\",\n        innerType,\n    });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _custom(Class, fn, _params) {\n    const norm = util.normalizeParams(_params);\n    norm.abort ?? (norm.abort = true); // default to abort:false\n    const schema = new Class({\n        type: \"custom\",\n        check: \"custom\",\n        fn: fn,\n        ...norm,\n    });\n    return schema;\n}\n// same as _custom but defaults to abort:false\n// @__NO_SIDE_EFFECTS__\nexport function _refine(Class, fn, _params) {\n    const schema = new Class({\n        type: \"custom\",\n        check: \"custom\",\n        fn: fn,\n        ...util.normalizeParams(_params),\n    });\n    return schema;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _superRefine(fn, params) {\n    const ch = _check((payload) => {\n        payload.addIssue = (issue) => {\n            if (typeof issue === \"string\") {\n                payload.issues.push(util.issue(issue, payload.value, ch._zod.def));\n            }\n            else {\n                // for Zod 3 backwards compatibility\n                const _issue = issue;\n                if (_issue.fatal)\n                    _issue.continue = false;\n                _issue.code ?? (_issue.code = \"custom\");\n                if (!(\"input\" in _issue))\n                    _issue.input = payload.value;\n                _issue.inst ?? (_issue.inst = ch);\n                _issue.continue ?? (_issue.continue = !ch._zod.def.abort); // abort is always undefined, so this is always true...\n                payload.issues.push(util.issue(_issue));\n            }\n        };\n        return fn(payload.value, payload);\n    }, params);\n    return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _check(fn, params) {\n    const ch = new checks.$ZodCheck({\n        check: \"custom\",\n        ...util.normalizeParams(params),\n    });\n    ch._zod.check = fn;\n    return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function describe(description) {\n    const ch = new checks.$ZodCheck({ check: \"describe\" });\n    ch._zod.onattach = [\n        (inst) => {\n            const existing = registries.globalRegistry.get(inst) ?? {};\n            registries.globalRegistry.add(inst, { ...existing, description });\n        },\n    ];\n    ch._zod.check = () => { }; // no-op check\n    return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function meta(metadata) {\n    const ch = new checks.$ZodCheck({ check: \"meta\" });\n    ch._zod.onattach = [\n        (inst) => {\n            const existing = registries.globalRegistry.get(inst) ?? {};\n            registries.globalRegistry.add(inst, { ...existing, ...metadata });\n        },\n    ];\n    ch._zod.check = () => { }; // no-op check\n    return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _stringbool(Classes, _params) {\n    const params = util.normalizeParams(_params);\n    let truthyArray = params.truthy ?? [\"true\", \"1\", \"yes\", \"on\", \"y\", \"enabled\"];\n    let falsyArray = params.falsy ?? [\"false\", \"0\", \"no\", \"off\", \"n\", \"disabled\"];\n    if (params.case !== \"sensitive\") {\n        truthyArray = truthyArray.map((v) => (typeof v === \"string\" ? v.toLowerCase() : v));\n        falsyArray = falsyArray.map((v) => (typeof v === \"string\" ? v.toLowerCase() : v));\n    }\n    const truthySet = new Set(truthyArray);\n    const falsySet = new Set(falsyArray);\n    const _Codec = Classes.Codec ?? schemas.$ZodCodec;\n    const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;\n    const _String = Classes.String ?? schemas.$ZodString;\n    const stringSchema = new _String({ type: \"string\", error: params.error });\n    const booleanSchema = new _Boolean({ type: \"boolean\", error: params.error });\n    const codec = new _Codec({\n        type: \"pipe\",\n        in: stringSchema,\n        out: booleanSchema,\n        transform: ((input, payload) => {\n            let data = input;\n            if (params.case !== \"sensitive\")\n                data = data.toLowerCase();\n            if (truthySet.has(data)) {\n                return true;\n            }\n            else if (falsySet.has(data)) {\n                return false;\n            }\n            else {\n                payload.issues.push({\n                    code: \"invalid_value\",\n                    expected: \"stringbool\",\n                    values: [...truthySet, ...falsySet],\n                    input: payload.value,\n                    inst: codec,\n                    continue: false,\n                });\n                return {};\n            }\n        }),\n        reverseTransform: ((input, _payload) => {\n            if (input === true) {\n                return truthyArray[0] || \"true\";\n            }\n            else {\n                return falsyArray[0] || \"false\";\n            }\n        }),\n        error: params.error,\n    });\n    codec._zod.bag.truthy = truthyArray;\n    codec._zod.bag.falsy = falsyArray;\n    codec._zod.bag.case = params.case ?? \"insensitive\";\n    return codec;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _stringFormat(Class, format, fnOrRegex, _params = {}) {\n    const params = util.normalizeParams(_params);\n    const def = {\n        check: \"string_format\",\n        type: \"string\",\n        format,\n        fn: typeof fnOrRegex === \"function\" ? fnOrRegex : (val) => fnOrRegex.test(val),\n        ...params,\n    };\n    if (fnOrRegex instanceof RegExp) {\n        def.pattern = fnOrRegex;\n    }\n    const inst = new Class(def);\n    return inst;\n}\n","import * as core from \"../core/index.js\";\nimport { $ZodError } from \"../core/index.js\";\nimport * as util from \"../core/util.js\";\n/* Prototypes that already carry the lazy helper methods. Seeded with the\n * intrinsics so that `init` on a foreign object — it accepts any object —\n * can never install an accessor onto a prototype we do not own. */\nconst _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);\n/* Helper methods live as non-enumerable lazy getters on the shared\n * prototype instead of own properties on every instance. On first\n * access the getter allocates the per-instance closure and caches it\n * as a non-enumerable own property, so detached usage still works and\n * the allocation only happens for methods actually touched. */\nfunction _lazyMethod(proto, key, make) {\n    Object.defineProperty(proto, key, {\n        configurable: true,\n        enumerable: false,\n        get() {\n            const value = make(this);\n            Object.defineProperty(this, key, { value, configurable: true, writable: true });\n            return value;\n        },\n        set(value) {\n            Object.defineProperty(this, key, { value, configurable: true, writable: true });\n        },\n    });\n}\nconst initializer = (inst, issues) => {\n    $ZodError.init(inst, issues);\n    inst.name = \"ZodError\";\n    const proto = Object.getPrototypeOf(inst);\n    if (_installedErrorProtos.has(proto))\n        return;\n    _installedErrorProtos.add(proto);\n    _lazyMethod(proto, \"format\", (self) => (mapper) => core.formatError(self, mapper));\n    _lazyMethod(proto, \"flatten\", (self) => (mapper) => core.flattenError(self, mapper));\n    _lazyMethod(proto, \"addIssue\", (self) => (issue) => {\n        self.issues.push(issue);\n        self.message = JSON.stringify(self.issues, util.jsonStringifyReplacer, 2);\n    });\n    _lazyMethod(proto, \"addIssues\", (self) => (issues) => {\n        self.issues.push(...issues);\n        self.message = JSON.stringify(self.issues, util.jsonStringifyReplacer, 2);\n    });\n    Object.defineProperty(proto, \"isEmpty\", {\n        configurable: true,\n        enumerable: false,\n        get() {\n            return this.issues.length === 0;\n        },\n    });\n};\nexport const ZodError = /*@__PURE__*/ core.$constructor(\"ZodError\", initializer);\nexport const ZodRealError = /*@__PURE__*/ core.$constructor(\"ZodError\", initializer, undefined, {\n    Parent: Error,\n});\n// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */\n// export type ErrorMapCtx = core.$ZodErrorMapCtx;\n","import * as core from \"../core/index.js\";\nimport { ZodRealError } from \"./errors.js\";\nexport const parse = /* @__PURE__ */ core._parse(ZodRealError);\nexport const parseAsync = /* @__PURE__ */ core._parseAsync(ZodRealError);\nexport const safeParse = /* @__PURE__ */ core._safeParse(ZodRealError);\nexport const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodRealError);\nexport { validate, validateAsync } from \"../core/index.js\";\n// Codec functions\nexport const encode = /* @__PURE__ */ core._encode(ZodRealError);\nexport const decode = /* @__PURE__ */ core._decode(ZodRealError);\nexport const encodeAsync = /* @__PURE__ */ core._encodeAsync(ZodRealError);\nexport const decodeAsync = /* @__PURE__ */ core._decodeAsync(ZodRealError);\nexport const safeEncode = /* @__PURE__ */ core._safeEncode(ZodRealError);\nexport const safeDecode = /* @__PURE__ */ core._safeDecode(ZodRealError);\nexport const safeEncodeAsync = /* @__PURE__ */ core._safeEncodeAsync(ZodRealError);\nexport const safeDecodeAsync = /* @__PURE__ */ core._safeDecodeAsync(ZodRealError);\n","import * as core from \"../core/index.js\";\nimport { util } from \"../core/index.js\";\nimport * as processors from \"../core/json-schema-processors.js\";\nimport * as regexes from \"../core/regexes.js\";\nimport { createStandardJSONSchemaMethod, createToJSONSchemaMethod } from \"../core/to-json-schema.js\";\nimport en from \"../locales/en.js\";\nimport * as checks from \"./checks.js\";\nimport * as parse from \"./parse.js\";\n// Register English as the default locale on first ZodType construction. Hooked into the `ZodType` `$constructor` (rather than a top-level `config(en())` in `external.ts`) so bundlers honoring `sideEffects: false` can't tree-shake it out — see #5953, #5725. An explicit `z.config(z.locales.xx())` call wins regardless of order, since this only sets the default when none is present.\nfunction _ensureDefaultLocale() {\n    if (!core.globalConfig.localeError)\n        core.config(en());\n}\n// the default memoizer is read by the core container init, which runs before `ZodType.init`, so each container calls this first\nfunction _ensureDefaultMemoizer() {\n    if (!core.globalConfig.memoizer)\n        core.config({ memoizer: core.memoizer() });\n}\nexport const ZodType = /*@__PURE__*/ core.$constructor(\"ZodType\", (inst, def) => {\n    _ensureDefaultLocale();\n    core.$ZodType.init(inst, def);\n    inst.def = def;\n    inst.type = def.type;\n    return inst;\n}, {\n    check(...chks) {\n        const def = this.def;\n        return this.clone(util.mergeDefs(def, {\n            checks: [\n                ...(def.checks ?? []),\n                ...chks.map((ch) => typeof ch === \"function\" ? { _zod: { check: ch, def: { check: \"custom\" }, onattach: [] } } : ch),\n            ],\n        }), { parent: true });\n    },\n    with(...chks) {\n        return this.check(...chks);\n    },\n    clone(def, params) {\n        return core.clone(this, def, params);\n    },\n    brand() {\n        return this;\n    },\n    register(reg, meta) {\n        reg.add(this, meta);\n        return this;\n    },\n    refine(check, params) {\n        return this.check(refine(check, params));\n    },\n    superRefine(refinement, params) {\n        return this.check(superRefine(refinement, params));\n    },\n    overwrite(fn) {\n        return this.check(checks.overwrite(fn));\n    },\n    optional() {\n        return optional(this);\n    },\n    exactOptional() {\n        return exactOptional(this);\n    },\n    nullable() {\n        return nullable(this);\n    },\n    nullish() {\n        return optional(nullable(this));\n    },\n    nonoptional(params) {\n        return nonoptional(this, params);\n    },\n    array() {\n        return array(this);\n    },\n    or(arg) {\n        return union([this, arg]);\n    },\n    and(arg) {\n        return intersection(this, arg);\n    },\n    transform(tx) {\n        return pipe(this, transform(tx));\n    },\n    default(d) {\n        return _default(this, d);\n    },\n    prefault(d) {\n        return prefault(this, d);\n    },\n    catch(params) {\n        return _catch(this, params);\n    },\n    pipe(target) {\n        return pipe(this, target);\n    },\n    readonly() {\n        return readonly(this);\n    },\n    describe(description) {\n        const cl = this.clone();\n        core.globalRegistry.add(cl, { description });\n        return cl;\n    },\n    meta(...args) {\n        // overloaded: meta() returns the registered metadata, meta(data) returns a clone with `data` registered. The mapped type picks up the second overload, so we accept variadic any-args and return `any` to satisfy both at runtime.\n        if (args.length === 0)\n            return core.globalRegistry.get(this);\n        const cl = this.clone();\n        core.globalRegistry.add(cl, args[0]);\n        return cl;\n    },\n    isOptional() {\n        return this.safeParse(undefined).success;\n    },\n    isNullable() {\n        return this.safeParse(null).success;\n    },\n    apply(fn, ...args) {\n        return args.length === 0 ? fn(this) : fn(this, ...args);\n    },\n    // Overrides core's `~standard` to add `jsonSchema`. Must stay a prototype entry: redefining it per instance demotes instances to dictionary mode.\n    get \"~standard\"() {\n        return util.hide(this, \"~standard\", {\n            ...core.standardProps(this),\n            jsonSchema: {\n                input: createStandardJSONSchemaMethod(this, \"input\"),\n                output: createStandardJSONSchemaMethod(this, \"output\"),\n            },\n        });\n    },\n    set \"~standard\"(value) {\n        util.own(this, \"~standard\", value);\n    },\n    parse: function _parse(data, params) {\n        return parse.parse(this, data, params, { callee: _parse });\n    },\n    parseAsync: async function _parseAsync(data, params) {\n        return await parse.parseAsync(this, data, params, { callee: _parseAsync });\n    },\n    safeParse(data, params) {\n        return parse.safeParse(this, data, params);\n    },\n    async safeParseAsync(data, params) {\n        return parse.safeParseAsync(this, data, params);\n    },\n    // `spa` is an alias: same function object as `safeParseAsync`, as before.\n    get spa() {\n        return this?.safeParseAsync;\n    },\n    set spa(value) {\n        util.own(this, \"spa\", value);\n    },\n    validate(data, params) {\n        return parse.validate(this, data, params);\n    },\n    validateAsync(data, params) {\n        return parse.validateAsync(this, data, params);\n    },\n    encode: function _encode(data, params) {\n        return parse.encode(this, data, params, { callee: _encode });\n    },\n    decode: function _decode(data, params) {\n        return parse.decode(this, data, params, { callee: _decode });\n    },\n    encodeAsync: async function _encodeAsync(data, params) {\n        return await parse.encodeAsync(this, data, params, { callee: _encodeAsync });\n    },\n    decodeAsync: async function _decodeAsync(data, params) {\n        return await parse.decodeAsync(this, data, params, { callee: _decodeAsync });\n    },\n    safeEncode(data, params) {\n        return parse.safeEncode(this, data, params);\n    },\n    safeDecode(data, params) {\n        return parse.safeDecode(this, data, params);\n    },\n    async safeEncodeAsync(data, params) {\n        return parse.safeEncodeAsync(this, data, params);\n    },\n    async safeDecodeAsync(data, params) {\n        return parse.safeDecodeAsync(this, data, params);\n    },\n    toJSONSchema(params) {\n        return createToJSONSchemaMethod(this, {})(params);\n    },\n    // Reads through to the registry on every access, so it must not cache.\n    get description() {\n        return core.globalRegistry.get(this)?.description;\n    },\n    // No setter: `schema._def = x` throws, as it did when `_def` was a non-writable own property.\n    get _def() {\n        return this._zod.def;\n    },\n});\n/** @internal */\nexport const _ZodString = /*@__PURE__*/ core.$constructor(\"_ZodString\", (inst, def) => {\n    core.$ZodString.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.stringProcessor(inst, ctx, json, params);\n}, \n/*@__PURE__*/ util.derived({\n    format: (inst) => processors.aggregateChecks(inst).format ?? null,\n    minLength: (inst) => processors.aggregateChecks(inst).minimum ?? null,\n    maxLength: (inst) => processors.aggregateChecks(inst).maximum ?? null,\n}, {\n    regex(...args) {\n        return this.check(checks.regex(...args));\n    },\n    includes(...args) {\n        return this.check(checks.includes(...args));\n    },\n    startsWith(...args) {\n        return this.check(checks.startsWith(...args));\n    },\n    endsWith(...args) {\n        return this.check(checks.endsWith(...args));\n    },\n    min(...args) {\n        return this.check(checks.minLength(...args));\n    },\n    max(...args) {\n        return this.check(checks.maxLength(...args));\n    },\n    length(...args) {\n        return this.check(checks.length(...args));\n    },\n    nonempty(...args) {\n        return this.check(checks.minLength(1, ...args));\n    },\n    lowercase(params) {\n        return this.check(checks.lowercase(params));\n    },\n    uppercase(params) {\n        return this.check(checks.uppercase(params));\n    },\n    trim() {\n        return this.check(checks.trim());\n    },\n    normalize(...args) {\n        return this.check(checks.normalize(...args));\n    },\n    toLowerCase() {\n        return this.check(checks.toLowerCase());\n    },\n    toUpperCase() {\n        return this.check(checks.toUpperCase());\n    },\n    slugify() {\n        return this.check(checks.slugify());\n    },\n}));\nexport const ZodString = /*@__PURE__*/ core.$constructor(\"ZodString\", (inst, def) => {\n    core.$ZodString.init(inst, def);\n    _ZodString.init(inst, def);\n}, {\n    email(params) {\n        return this.check(core._email(ZodEmail, params));\n    },\n    url(params) {\n        return this.check(core._url(ZodURL, params));\n    },\n    jwt(params) {\n        return this.check(core._jwt(ZodJWT, params));\n    },\n    emoji(params) {\n        return this.check(core._emoji(ZodEmoji, params));\n    },\n    guid(params) {\n        return this.check(core._guid(ZodGUID, params));\n    },\n    uuid(params) {\n        return this.check(core._uuid(ZodUUID, params));\n    },\n    uuidv4(params) {\n        return this.check(core._uuidv4(ZodUUID, params));\n    },\n    uuidv6(params) {\n        return this.check(core._uuidv6(ZodUUID, params));\n    },\n    uuidv7(params) {\n        return this.check(core._uuidv7(ZodUUID, params));\n    },\n    nanoid(params) {\n        return this.check(core._nanoid(ZodNanoID, params));\n    },\n    cuid(params) {\n        return this.check(core._cuid(ZodCUID, params));\n    },\n    cuid2(params) {\n        return this.check(core._cuid2(ZodCUID2, params));\n    },\n    ulid(params) {\n        return this.check(core._ulid(ZodULID, params));\n    },\n    base64(params) {\n        return this.check(core._base64(ZodBase64, params));\n    },\n    base64url(params) {\n        return this.check(core._base64url(ZodBase64URL, params));\n    },\n    xid(params) {\n        return this.check(core._xid(ZodXID, params));\n    },\n    ksuid(params) {\n        return this.check(core._ksuid(ZodKSUID, params));\n    },\n    ipv4(params) {\n        return this.check(core._ipv4(ZodIPv4, params));\n    },\n    ipv6(params) {\n        return this.check(core._ipv6(ZodIPv6, params));\n    },\n    cidrv4(params) {\n        return this.check(core._cidrv4(ZodCIDRv4, params));\n    },\n    cidrv6(params) {\n        return this.check(core._cidrv6(ZodCIDRv6, params));\n    },\n    e164(params) {\n        return this.check(core._e164(ZodE164, params));\n    },\n    datetime(params) {\n        return this.check(core._isoDateTime(ZodISODateTime, params));\n    },\n    date(params) {\n        return this.check(core._isoDate(ZodISODate, params));\n    },\n    time(params) {\n        return this.check(core._isoTime(ZodISOTime, params));\n    },\n    duration(params) {\n        return this.check(core._isoDuration(ZodISODuration, params));\n    },\n});\nexport function string(params) {\n    return core._string(ZodString, params);\n}\nexport const ZodStringFormat = /*@__PURE__*/ core.$constructor(\"ZodStringFormat\", (inst, def) => {\n    core.$ZodStringFormat.init(inst, def);\n    _ZodString.init(inst, def);\n});\nexport const ZodISODateTime = /*@__PURE__*/ core.$constructor(\"ZodISODateTime\", (inst, def) => {\n    core.$ZodISODateTime.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport const ZodISODate = /*@__PURE__*/ core.$constructor(\"ZodISODate\", (inst, def) => {\n    core.$ZodISODate.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport const ZodISOTime = /*@__PURE__*/ core.$constructor(\"ZodISOTime\", (inst, def) => {\n    core.$ZodISOTime.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport const ZodISODuration = /*@__PURE__*/ core.$constructor(\"ZodISODuration\", (inst, def) => {\n    core.$ZodISODuration.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport const ZodEmail = /*@__PURE__*/ core.$constructor(\"ZodEmail\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodEmail.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function email(params) {\n    return core._email(ZodEmail, params);\n}\nexport const ZodGUID = /*@__PURE__*/ core.$constructor(\"ZodGUID\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodGUID.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function guid(params) {\n    return core._guid(ZodGUID, params);\n}\nexport const ZodUUID = /*@__PURE__*/ core.$constructor(\"ZodUUID\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodUUID.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function uuid(params) {\n    return core._uuid(ZodUUID, params);\n}\nexport function uuidv4(params) {\n    return core._uuidv4(ZodUUID, params);\n}\n// ZodUUIDv6\nexport function uuidv6(params) {\n    return core._uuidv6(ZodUUID, params);\n}\n// ZodUUIDv7\nexport function uuidv7(params) {\n    return core._uuidv7(ZodUUID, params);\n}\nexport const ZodURL = /*@__PURE__*/ core.$constructor(\"ZodURL\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodURL.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function url(params) {\n    return core._url(ZodURL, params);\n}\nexport function httpUrl(params) {\n    return core._url(ZodURL, {\n        protocol: regexes.httpProtocol,\n        hostname: regexes.domain,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodEmoji = /*@__PURE__*/ core.$constructor(\"ZodEmoji\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodEmoji.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function emoji(params) {\n    return core._emoji(ZodEmoji, params);\n}\nexport const ZodNanoID = /*@__PURE__*/ core.$constructor(\"ZodNanoID\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodNanoID.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function nanoid(params) {\n    return core._nanoid(ZodNanoID, params);\n}\n/**\n * @deprecated CUID v1 is deprecated by its authors due to information leakage\n * (timestamps embedded in the id). Use {@link ZodCUID2} instead.\n * See https://github.com/paralleldrive/cuid.\n */\nexport const ZodCUID = /*@__PURE__*/ core.$constructor(\"ZodCUID\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodCUID.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\n/**\n * Validates a CUID v1 string.\n *\n * @deprecated CUID v1 is deprecated by its authors due to information leakage\n * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.\n * See https://github.com/paralleldrive/cuid.\n */\nexport function cuid(params) {\n    return core._cuid(ZodCUID, params);\n}\nexport const ZodCUID2 = /*@__PURE__*/ core.$constructor(\"ZodCUID2\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodCUID2.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function cuid2(params) {\n    return core._cuid2(ZodCUID2, params);\n}\nexport const ZodULID = /*@__PURE__*/ core.$constructor(\"ZodULID\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodULID.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function ulid(params) {\n    return core._ulid(ZodULID, params);\n}\nexport const ZodXID = /*@__PURE__*/ core.$constructor(\"ZodXID\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodXID.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function xid(params) {\n    return core._xid(ZodXID, params);\n}\nexport const ZodKSUID = /*@__PURE__*/ core.$constructor(\"ZodKSUID\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodKSUID.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function ksuid(params) {\n    return core._ksuid(ZodKSUID, params);\n}\nexport const ZodIPv4 = /*@__PURE__*/ core.$constructor(\"ZodIPv4\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodIPv4.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function ipv4(params) {\n    return core._ipv4(ZodIPv4, params);\n}\nexport const ZodMAC = /*@__PURE__*/ core.$constructor(\"ZodMAC\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodMAC.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function mac(params) {\n    return core._mac(ZodMAC, params);\n}\nexport const ZodIPv6 = /*@__PURE__*/ core.$constructor(\"ZodIPv6\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodIPv6.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function ipv6(params) {\n    return core._ipv6(ZodIPv6, params);\n}\nexport const ZodCIDRv4 = /*@__PURE__*/ core.$constructor(\"ZodCIDRv4\", (inst, def) => {\n    core.$ZodCIDRv4.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function cidrv4(params) {\n    return core._cidrv4(ZodCIDRv4, params);\n}\nexport const ZodCIDRv6 = /*@__PURE__*/ core.$constructor(\"ZodCIDRv6\", (inst, def) => {\n    core.$ZodCIDRv6.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function cidrv6(params) {\n    return core._cidrv6(ZodCIDRv6, params);\n}\nexport const ZodBase64 = /*@__PURE__*/ core.$constructor(\"ZodBase64\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodBase64.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function base64(params) {\n    return core._base64(ZodBase64, params);\n}\nexport const ZodBase64URL = /*@__PURE__*/ core.$constructor(\"ZodBase64URL\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodBase64URL.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function base64url(params) {\n    return core._base64url(ZodBase64URL, params);\n}\nexport const ZodE164 = /*@__PURE__*/ core.$constructor(\"ZodE164\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodE164.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function e164(params) {\n    return core._e164(ZodE164, params);\n}\nexport const ZodCreditCard = /*@__PURE__*/ core.$constructor(\"ZodCreditCard\", (inst, def) => {\n    core.$ZodCreditCard.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function creditCard(params) {\n    return core._creditCard(ZodCreditCard, params);\n}\nexport const ZodIBAN = /*@__PURE__*/ core.$constructor(\"ZodIBAN\", (inst, def) => {\n    core.$ZodIBAN.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function iban(params) {\n    return core._iban(ZodIBAN, params);\n}\nexport const ZodJWT = /*@__PURE__*/ core.$constructor(\"ZodJWT\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodJWT.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function jwt(params) {\n    return core._jwt(ZodJWT, params);\n}\nexport const ZodCustomStringFormat = /*@__PURE__*/ core.$constructor(\"ZodCustomStringFormat\", (inst, def) => {\n    // ZodStringFormat.init(inst, def);\n    core.$ZodCustomStringFormat.init(inst, def);\n    ZodStringFormat.init(inst, def);\n});\nexport function stringFormat(format, fnOrRegex, _params = {}) {\n    return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);\n}\nexport function hostname(_params) {\n    return core._stringFormat(ZodCustomStringFormat, \"hostname\", regexes.hostname, _params);\n}\nexport function hex(_params) {\n    return core._stringFormat(ZodCustomStringFormat, \"hex\", regexes.hex, _params);\n}\nexport function currencyCode(_params) {\n    return core._stringFormat(ZodCustomStringFormat, \"currency_code\", regexes.currencyCode, _params);\n}\nexport function hash(alg, params) {\n    const enc = params?.enc ?? \"hex\";\n    const format = `${alg}_${enc}`;\n    const regex = core.regexes[format];\n    if (!regex)\n        throw new Error(`Unrecognized hash format: ${format}`);\n    return core._stringFormat(ZodCustomStringFormat, format, regex, params);\n}\nexport const ZodNumber = /*@__PURE__*/ core.$constructor(\"ZodNumber\", (inst, def) => {\n    core.$ZodNumber.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.numberProcessor(inst, ctx, json, params);\n    inst.isFinite = true;\n}, \n/*@__PURE__*/ util.derived({\n    minValue: (inst) => {\n        const { minimum, exclusiveMinimum } = processors.aggregateChecks(inst);\n        return Math.max(minimum ?? Number.NEGATIVE_INFINITY, exclusiveMinimum ?? Number.NEGATIVE_INFINITY);\n    },\n    maxValue: (inst) => {\n        const { maximum, exclusiveMaximum } = processors.aggregateChecks(inst);\n        return Math.min(maximum ?? Number.POSITIVE_INFINITY, exclusiveMaximum ?? Number.POSITIVE_INFINITY);\n    },\n    isInt: (inst) => {\n        const { isInt, multipleOf } = processors.aggregateChecks(inst);\n        return !!isInt || !!multipleOf?.some(Number.isSafeInteger);\n    },\n    format: (inst) => processors.aggregateChecks(inst).format ?? null,\n}, {\n    gt(value, params) {\n        return this.check(checks.gt(value, params));\n    },\n    gte(value, params) {\n        return this.check(checks.gte(value, params));\n    },\n    min(value, params) {\n        return this.check(checks.gte(value, params));\n    },\n    lt(value, params) {\n        return this.check(checks.lt(value, params));\n    },\n    lte(value, params) {\n        return this.check(checks.lte(value, params));\n    },\n    max(value, params) {\n        return this.check(checks.lte(value, params));\n    },\n    int(params) {\n        return this.check(int(params));\n    },\n    safe(params) {\n        return this.check(int(params));\n    },\n    positive(params) {\n        return this.check(checks.gt(0, params));\n    },\n    nonnegative(params) {\n        return this.check(checks.gte(0, params));\n    },\n    negative(params) {\n        return this.check(checks.lt(0, params));\n    },\n    nonpositive(params) {\n        return this.check(checks.lte(0, params));\n    },\n    multipleOf(value, params) {\n        return this.check(checks.multipleOf(value, params));\n    },\n    step(value, params) {\n        return this.check(checks.multipleOf(value, params));\n    },\n    finite() {\n        return this;\n    },\n}));\nexport function number(params) {\n    return core._number(ZodNumber, params);\n}\nexport const ZodNumberFormat = /*@__PURE__*/ core.$constructor(\"ZodNumberFormat\", (inst, def) => {\n    core.$ZodNumberFormat.init(inst, def);\n    ZodNumber.init(inst, def);\n});\nexport function int(params) {\n    return core._int(ZodNumberFormat, params);\n}\nexport function float32(params) {\n    return core._float32(ZodNumberFormat, params);\n}\nexport function float64(params) {\n    return core._float64(ZodNumberFormat, params);\n}\nexport function int32(params) {\n    return core._int32(ZodNumberFormat, params);\n}\nexport function uint32(params) {\n    return core._uint32(ZodNumberFormat, params);\n}\nexport const ZodBoolean = /*@__PURE__*/ core.$constructor(\"ZodBoolean\", (inst, def) => {\n    core.$ZodBoolean.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.booleanProcessor(inst, ctx, json, params);\n});\nexport function boolean(params) {\n    return core._boolean(ZodBoolean, params);\n}\nexport const ZodBigInt = /*@__PURE__*/ core.$constructor(\"ZodBigInt\", (inst, def) => {\n    core.$ZodBigInt.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.bigintProcessor(inst, ctx, json, params);\n}, \n/*@__PURE__*/ util.derived({\n    minValue: (inst) => processors.aggregateChecks(inst).minimum ?? null,\n    maxValue: (inst) => processors.aggregateChecks(inst).maximum ?? null,\n    format: (inst) => processors.aggregateChecks(inst).format ?? null,\n}, {\n    gte(value, params) {\n        return this.check(checks.gte(value, params));\n    },\n    min(value, params) {\n        return this.check(checks.gte(value, params));\n    },\n    gt(value, params) {\n        return this.check(checks.gt(value, params));\n    },\n    lt(value, params) {\n        return this.check(checks.lt(value, params));\n    },\n    lte(value, params) {\n        return this.check(checks.lte(value, params));\n    },\n    max(value, params) {\n        return this.check(checks.lte(value, params));\n    },\n    positive(params) {\n        return this.check(checks.gt(BigInt(0), params));\n    },\n    negative(params) {\n        return this.check(checks.lt(BigInt(0), params));\n    },\n    nonpositive(params) {\n        return this.check(checks.lte(BigInt(0), params));\n    },\n    nonnegative(params) {\n        return this.check(checks.gte(BigInt(0), params));\n    },\n    multipleOf(value, params) {\n        return this.check(checks.multipleOf(value, params));\n    },\n}));\nexport function bigint(params) {\n    return core._bigint(ZodBigInt, params);\n}\nexport const ZodBigIntFormat = /*@__PURE__*/ core.$constructor(\"ZodBigIntFormat\", (inst, def) => {\n    core.$ZodBigIntFormat.init(inst, def);\n    ZodBigInt.init(inst, def);\n});\nexport function int64(params) {\n    return core._int64(ZodBigIntFormat, params);\n}\nexport function uint64(params) {\n    return core._uint64(ZodBigIntFormat, params);\n}\nexport const ZodSymbol = /*@__PURE__*/ core.$constructor(\"ZodSymbol\", (inst, def) => {\n    core.$ZodSymbol.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.symbolProcessor(inst, ctx, json, params);\n});\nexport function symbol(params) {\n    return core._symbol(ZodSymbol, params);\n}\nexport const ZodUndefined = /*@__PURE__*/ core.$constructor(\"ZodUndefined\", (inst, def) => {\n    core.$ZodUndefined.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.undefinedProcessor(inst, ctx, json, params);\n});\nfunction _undefined(params) {\n    return core._undefined(ZodUndefined, params);\n}\nexport { _undefined as undefined };\nexport const ZodNull = /*@__PURE__*/ core.$constructor(\"ZodNull\", (inst, def) => {\n    core.$ZodNull.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.nullProcessor(inst, ctx, json, params);\n});\nfunction _null(params) {\n    return core._null(ZodNull, params);\n}\nexport { _null as null };\nexport const ZodAny = /*@__PURE__*/ core.$constructor(\"ZodAny\", (inst, def) => {\n    core.$ZodAny.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.anyProcessor(inst, ctx, json, params);\n});\nexport function any() {\n    return core._any(ZodAny);\n}\nexport const ZodUnknown = /*@__PURE__*/ core.$constructor(\"ZodUnknown\", (inst, def) => {\n    core.$ZodUnknown.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.unknownProcessor(inst, ctx, json, params);\n});\nexport function unknown() {\n    return core._unknown(ZodUnknown);\n}\nexport const ZodNever = /*@__PURE__*/ core.$constructor(\"ZodNever\", (inst, def) => {\n    core.$ZodNever.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.neverProcessor(inst, ctx, json, params);\n});\nexport function never(params) {\n    return core._never(ZodNever, params);\n}\nexport const ZodVoid = /*@__PURE__*/ core.$constructor(\"ZodVoid\", (inst, def) => {\n    core.$ZodVoid.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.voidProcessor(inst, ctx, json, params);\n});\nfunction _void(params) {\n    return core._void(ZodVoid, params);\n}\nexport { _void as void };\nexport const ZodDate = /*@__PURE__*/ core.$constructor(\"ZodDate\", (inst, def) => {\n    core.$ZodDate.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.dateProcessor(inst, ctx, json, params);\n    inst.min = (value, params) => inst.check(checks.gte(value, params));\n    inst.max = (value, params) => inst.check(checks.lte(value, params));\n}, \n/*@__PURE__*/ util.derived({\n    minDate: (inst) => {\n        const { minimum } = processors.aggregateChecks(inst);\n        return minimum ? new Date(minimum) : null;\n    },\n    maxDate: (inst) => {\n        const { maximum } = processors.aggregateChecks(inst);\n        return maximum ? new Date(maximum) : null;\n    },\n}, {}));\nexport function date(params) {\n    return core._date(ZodDate, params);\n}\nexport const ZodArray = /*@__PURE__*/ core.$constructor(\"ZodArray\", (inst, def) => {\n    _ensureDefaultMemoizer();\n    core.$ZodArray.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.arrayProcessor(inst, ctx, json, params);\n    inst.element = def.element;\n}, {\n    min(n, params) {\n        return this.check(checks.minLength(n, params));\n    },\n    nonempty(params) {\n        return this.check(checks.minLength(1, params));\n    },\n    max(n, params) {\n        return this.check(checks.maxLength(n, params));\n    },\n    length(n, params) {\n        return this.check(checks.length(n, params));\n    },\n    unwrap() {\n        return this.element;\n    },\n});\nexport function array(element, params) {\n    return core._array(ZodArray, element, params);\n}\n// .keyof\nexport function keyof(schema) {\n    const shape = schema._zod.def.shape;\n    return _enum(Object.keys(shape));\n}\nexport const ZodObject = /*@__PURE__*/ core.$constructor(\"ZodObject\", (inst, def) => {\n    _ensureDefaultMemoizer();\n    core.$ZodObjectJIT.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.objectProcessor(inst, ctx, json, params);\n    util.installLazyProp(inst, \"shape\", (self) => self._zod.def.shape, false);\n}, {\n    keyof() {\n        return _enum(Object.keys(this._zod.def.shape));\n    },\n    catchall(catchall) {\n        // `mergeDefs` rather than a spread: spreading reads `shape`, and resolving it can mint a whole fresh subtree\n        return this.clone(util.mergeDefs(this._zod.def, { catchall: catchall }));\n    },\n    passthrough() {\n        return this.clone(util.mergeDefs(this._zod.def, { catchall: unknown() }));\n    },\n    loose() {\n        return this.clone(util.mergeDefs(this._zod.def, { catchall: unknown() }));\n    },\n    strict() {\n        return this.clone(util.mergeDefs(this._zod.def, { catchall: never() }));\n    },\n    strip() {\n        return this.clone(util.mergeDefs(this._zod.def, { catchall: undefined }));\n    },\n    extend(incoming) {\n        return util.extend(this, incoming);\n    },\n    safeExtend(incoming) {\n        return util.safeExtend(this, incoming);\n    },\n    merge(other) {\n        return util.merge(this, other);\n    },\n    pick(mask) {\n        return util.pick(this, mask);\n    },\n    omit(mask) {\n        return util.omit(this, mask);\n    },\n    partial(...args) {\n        return util.partial(ZodOptional, this, args[0]);\n    },\n    exactPartial(...args) {\n        return util.partial(ZodExactOptional, this, args[0], \"exactPartial\");\n    },\n    required(...args) {\n        return util.required(ZodNonOptional, this, args[0]);\n    },\n});\nexport function object(shape, params) {\n    const def = {\n        type: \"object\",\n        shape: shape ?? {},\n        ...util.normalizeParams(params),\n    };\n    return new ZodObject(def);\n}\n// strictObject\nexport function strictObject(shape, params) {\n    return new ZodObject({\n        type: \"object\",\n        shape,\n        catchall: never(),\n        ...util.normalizeParams(params),\n    });\n}\n// looseObject\nexport function looseObject(shape, params) {\n    return new ZodObject({\n        type: \"object\",\n        shape,\n        catchall: unknown(),\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodUnion = /*@__PURE__*/ core.$constructor(\"ZodUnion\", (inst, def) => {\n    core.$ZodUnion.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);\n    inst.options = def.options;\n});\nexport function union(options, params) {\n    return new ZodUnion({\n        type: \"union\",\n        options: options,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodXor = /*@__PURE__*/ core.$constructor(\"ZodXor\", (inst, def) => {\n    ZodUnion.init(inst, def);\n    core.$ZodXor.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);\n    inst.options = def.options;\n});\n/** Creates an exclusive union (XOR) where exactly one option must match.\n * Unlike regular unions that succeed when any option matches, xor fails if\n * zero or more than one option matches the input. */\nexport function xor(options, params) {\n    return new ZodXor({\n        type: \"union\",\n        options: options,\n        inclusive: false,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodDiscriminatedUnion = /*@__PURE__*/ core.$constructor(\"ZodDiscriminatedUnion\", (inst, def) => {\n    ZodUnion.init(inst, def);\n    core.$ZodDiscriminatedUnion.init(inst, def);\n});\nexport function discriminatedUnion(discriminator, options, params) {\n    // const [options, params] = args;\n    return new ZodDiscriminatedUnion({\n        type: \"union\",\n        options: options,\n        discriminator,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodIntersection = /*@__PURE__*/ core.$constructor(\"ZodIntersection\", (inst, def) => {\n    core.$ZodIntersection.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.intersectionProcessor(inst, ctx, json, params);\n});\nexport function intersection(left, right) {\n    return new ZodIntersection({\n        type: \"intersection\",\n        left: left,\n        right: right,\n    });\n}\nexport const ZodTuple = /*@__PURE__*/ core.$constructor(\"ZodTuple\", (inst, def) => {\n    _ensureDefaultMemoizer();\n    core.$ZodTuple.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.tupleProcessor(inst, ctx, json, params);\n}, {\n    rest(rest) {\n        return this.clone({\n            ...this._zod.def,\n            rest: rest,\n        });\n    },\n    partial() {\n        const def = this._zod.def;\n        // a refinement was authored against the full arity; partialing would run it on a shorter array\n        if (def.checks?.length)\n            throw new Error(\".partial() cannot be used on tuple schemas containing refinements\");\n        return this.clone({\n            ...def,\n            items: def.items.map((item) => new ZodOptional({ type: \"optional\", innerType: item })),\n        });\n    },\n});\nexport function tuple(items, _paramsOrRest, _params) {\n    const hasRest = _paramsOrRest instanceof core.$ZodType;\n    const params = hasRest ? _params : _paramsOrRest;\n    const rest = hasRest ? _paramsOrRest : null;\n    return new ZodTuple({\n        type: \"tuple\",\n        items: items,\n        rest,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodRecord = /*@__PURE__*/ core.$constructor(\"ZodRecord\", (inst, def) => {\n    _ensureDefaultMemoizer();\n    core.$ZodRecord.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.recordProcessor(inst, ctx, json, params);\n    inst.keyType = def.keyType;\n    inst.valueType = def.valueType;\n});\nexport function record(keyType, valueType, params) {\n    // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()\n    if (!valueType || !valueType._zod) {\n        return new ZodRecord({\n            type: \"record\",\n            keyType: string(),\n            valueType: keyType,\n            ...util.normalizeParams(valueType),\n        });\n    }\n    return new ZodRecord({\n        type: \"record\",\n        keyType,\n        valueType: valueType,\n        ...util.normalizeParams(params),\n    });\n}\n// type alksjf = core.output<core.$ZodRecordKey>;\nexport function partialRecord(keyType, valueType, params) {\n    return new ZodRecord({\n        type: \"record\",\n        keyType,\n        valueType: valueType,\n        ...util.normalizeParams(params),\n        partial: true,\n    });\n}\nexport function looseRecord(keyType, valueType, params) {\n    return new ZodRecord({\n        type: \"record\",\n        keyType,\n        valueType: valueType,\n        mode: \"loose\",\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodMap = /*@__PURE__*/ core.$constructor(\"ZodMap\", (inst, def) => {\n    _ensureDefaultMemoizer();\n    core.$ZodMap.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);\n    inst.keyType = def.keyType;\n    inst.valueType = def.valueType;\n    inst.min = (...args) => inst.check(core._minSize(...args));\n    inst.nonempty = (params) => inst.check(core._minSize(1, params));\n    inst.max = (...args) => inst.check(core._maxSize(...args));\n    inst.size = (...args) => inst.check(core._size(...args));\n});\nexport function map(keyType, valueType, params) {\n    return new ZodMap({\n        type: \"map\",\n        keyType: keyType,\n        valueType: valueType,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodSet = /*@__PURE__*/ core.$constructor(\"ZodSet\", (inst, def) => {\n    _ensureDefaultMemoizer();\n    core.$ZodSet.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.setProcessor(inst, ctx, json, params);\n    inst.min = (...args) => inst.check(core._minSize(...args));\n    inst.nonempty = (params) => inst.check(core._minSize(1, params));\n    inst.max = (...args) => inst.check(core._maxSize(...args));\n    inst.size = (...args) => inst.check(core._size(...args));\n});\nexport function set(valueType, params) {\n    return new ZodSet({\n        type: \"set\",\n        valueType: valueType,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodEnum = /*@__PURE__*/ core.$constructor(\"ZodEnum\", (inst, def) => {\n    core.$ZodEnum.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.enumProcessor(inst, ctx, json, params);\n    inst.enum = def.entries;\n    // reuse the parsed value set so a numeric TS enum's reverse-mapping keys stay out\n    inst.options = [...inst._zod.values];\n    const keys = new Set(Object.keys(def.entries));\n    inst.extract = (values, params) => {\n        const newEntries = {};\n        for (const value of values) {\n            if (keys.has(value)) {\n                newEntries[value] = def.entries[value];\n            }\n            else\n                throw new Error(`Key ${value} not found in enum`);\n        }\n        return new ZodEnum({\n            ...def,\n            checks: [],\n            ...util.normalizeParams(params),\n            entries: newEntries,\n        });\n    };\n    inst.exclude = (values, params) => {\n        const newEntries = { ...def.entries };\n        for (const value of values) {\n            if (keys.has(value)) {\n                delete newEntries[value];\n            }\n            else\n                throw new Error(`Key ${value} not found in enum`);\n        }\n        return new ZodEnum({\n            ...def,\n            checks: [],\n            ...util.normalizeParams(params),\n            entries: newEntries,\n        });\n    };\n});\nfunction _enum(values, params) {\n    const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n    return new ZodEnum({\n        type: \"enum\",\n        entries,\n        ...util.normalizeParams(params),\n    });\n}\nexport { _enum as enum };\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport function nativeEnum(entries, params) {\n    return new ZodEnum({\n        type: \"enum\",\n        entries,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodLiteral = /*@__PURE__*/ core.$constructor(\"ZodLiteral\", (inst, def) => {\n    core.$ZodLiteral.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.literalProcessor(inst, ctx, json, params);\n    inst.values = new Set(def.values);\n    Object.defineProperty(inst, \"value\", {\n        get() {\n            if (def.values.length > 1) {\n                throw new Error(\"This schema contains multiple valid literal values. Use `.values` instead.\");\n            }\n            return def.values[0];\n        },\n    });\n});\nexport function literal(value, params) {\n    return new ZodLiteral({\n        type: \"literal\",\n        values: Array.isArray(value) ? value : [value],\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodFile = /*@__PURE__*/ core.$constructor(\"ZodFile\", (inst, def) => {\n    core.$ZodFile.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.fileProcessor(inst, ctx, json, params);\n    inst.min = (size, params) => inst.check(core._minSize(size, params));\n    inst.max = (size, params) => inst.check(core._maxSize(size, params));\n    inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));\n});\nexport function file(params) {\n    return core._file(ZodFile, params);\n}\nexport const ZodTransform = /*@__PURE__*/ core.$constructor(\"ZodTransform\", (inst, def) => {\n    _ensureDefaultMemoizer();\n    core.$ZodTransform.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.transformProcessor(inst, ctx, json, params);\n    inst._zod.parse = (payload, _ctx) => {\n        if (_ctx.direction === \"backward\") {\n            throw new core.$ZodEncodeError(inst.constructor.name);\n        }\n        payload.addIssue = (issue) => {\n            if (typeof issue === \"string\") {\n                payload.issues.push(util.issue(issue, payload.value, def));\n            }\n            else {\n                // for Zod 3 backwards compatibility\n                const _issue = issue;\n                if (_issue.fatal)\n                    _issue.continue = false;\n                _issue.code ?? (_issue.code = \"custom\");\n                if (!(\"input\" in _issue))\n                    _issue.input = payload.value;\n                _issue.inst ?? (_issue.inst = inst);\n                // _issue.continue ??= true;\n                payload.issues.push(util.issue(_issue));\n            }\n        };\n        const output = def.transform(payload.value, payload);\n        if (output instanceof Promise) {\n            return output.then((output) => {\n                payload.value = output;\n                return payload;\n            });\n        }\n        payload.value = output;\n        return payload;\n    };\n});\nexport function transform(fn) {\n    return new ZodTransform({\n        type: \"transform\",\n        transform: fn,\n    });\n}\nexport const ZodOptional = /*@__PURE__*/ core.$constructor(\"ZodOptional\", (inst, def) => {\n    core.$ZodOptional.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function optional(innerType) {\n    return new ZodOptional({\n        type: \"optional\",\n        innerType: innerType,\n    });\n}\nexport const ZodExactOptional = /*@__PURE__*/ core.$constructor(\"ZodExactOptional\", (inst, def) => {\n    core.$ZodExactOptional.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function exactOptional(innerType) {\n    return new ZodExactOptional({\n        type: \"optional\",\n        innerType: innerType,\n    });\n}\nexport const ZodNullable = /*@__PURE__*/ core.$constructor(\"ZodNullable\", (inst, def) => {\n    core.$ZodNullable.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.nullableProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function nullable(innerType) {\n    return new ZodNullable({\n        type: \"nullable\",\n        innerType: innerType,\n    });\n}\n// nullish\nexport function nullish(innerType) {\n    return optional(nullable(innerType));\n}\nexport const ZodDefault = /*@__PURE__*/ core.$constructor(\"ZodDefault\", (inst, def) => {\n    core.$ZodDefault.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.defaultProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n    inst.removeDefault = inst.unwrap;\n});\nexport function _default(innerType, defaultValue) {\n    return new ZodDefault({\n        type: \"default\",\n        innerType: innerType,\n        get defaultValue() {\n            return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n        },\n    });\n}\nexport const ZodPrefault = /*@__PURE__*/ core.$constructor(\"ZodPrefault\", (inst, def) => {\n    core.$ZodPrefault.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.prefaultProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function prefault(innerType, defaultValue) {\n    return new ZodPrefault({\n        type: \"prefault\",\n        innerType: innerType,\n        get defaultValue() {\n            return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n        },\n    });\n}\nexport const ZodNonOptional = /*@__PURE__*/ core.$constructor(\"ZodNonOptional\", (inst, def) => {\n    core.$ZodNonOptional.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.nonoptionalProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function nonoptional(innerType, params) {\n    return new ZodNonOptional({\n        type: \"nonoptional\",\n        innerType: innerType,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodSuccess = /*@__PURE__*/ core.$constructor(\"ZodSuccess\", (inst, def) => {\n    core.$ZodSuccess.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.successProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function success(innerType) {\n    return new ZodSuccess({\n        type: \"success\",\n        innerType: innerType,\n    });\n}\nexport const ZodCatch = /*@__PURE__*/ core.$constructor(\"ZodCatch\", (inst, def) => {\n    core.$ZodCatch.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.catchProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n    inst.removeCatch = inst.unwrap;\n});\nfunction _catch(innerType, catchValue) {\n    return new ZodCatch({\n        type: \"catch\",\n        innerType: innerType,\n        catchValue: (typeof catchValue === \"function\" ? catchValue : core.util.constantCatch(catchValue)),\n    });\n}\nexport { _catch as catch };\nexport const ZodNaN = /*@__PURE__*/ core.$constructor(\"ZodNaN\", (inst, def) => {\n    core.$ZodNaN.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.nanProcessor(inst, ctx, json, params);\n});\nexport function nan(params) {\n    return core._nan(ZodNaN, params);\n}\nexport const ZodPipe = /*@__PURE__*/ core.$constructor(\"ZodPipe\", (inst, def) => {\n    core.$ZodPipe.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.pipeProcessor(inst, ctx, json, params);\n    inst.in = def.in;\n    inst.out = def.out;\n});\nexport function pipe(in_, out) {\n    return new ZodPipe({\n        type: \"pipe\",\n        in: in_,\n        out: out,\n        // ...util.normalizeParams(params),\n    });\n}\nexport const ZodCodec = /*@__PURE__*/ core.$constructor(\"ZodCodec\", (inst, def) => {\n    ZodPipe.init(inst, def);\n    core.$ZodCodec.init(inst, def);\n});\nexport function codec(in_, out, params) {\n    return new ZodCodec({\n        type: \"pipe\",\n        in: in_,\n        out: out,\n        transform: params.decode,\n        reverseTransform: params.encode,\n    });\n}\nexport function invertCodec(codec) {\n    const def = codec._zod.def;\n    return new ZodCodec({\n        type: \"pipe\",\n        in: def.out,\n        out: def.in,\n        transform: def.reverseTransform,\n        reverseTransform: def.transform,\n    });\n}\nexport const ZodPreprocess = /*@__PURE__*/ core.$constructor(\"ZodPreprocess\", (inst, def) => {\n    ZodPipe.init(inst, def);\n    core.$ZodPreprocess.init(inst, def);\n});\nexport const ZodReadonly = /*@__PURE__*/ core.$constructor(\"ZodReadonly\", (inst, def) => {\n    core.$ZodReadonly.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.readonlyProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function readonly(innerType) {\n    return new ZodReadonly({\n        type: \"readonly\",\n        innerType: innerType,\n    });\n}\nexport const ZodTemplateLiteral = /*@__PURE__*/ core.$constructor(\"ZodTemplateLiteral\", (inst, def) => {\n    core.$ZodTemplateLiteral.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.templateLiteralProcessor(inst, ctx, json, params);\n});\nexport function templateLiteral(parts, params) {\n    return new ZodTemplateLiteral({\n        type: \"template_literal\",\n        parts,\n        ...util.normalizeParams(params),\n    });\n}\nexport const ZodLazy = /*@__PURE__*/ core.$constructor(\"ZodLazy\", (inst, def) => {\n    core.$ZodLazy.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.lazyProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.getter();\n});\nexport function lazy(getter) {\n    return new ZodLazy({\n        type: \"lazy\",\n        getter: getter,\n    });\n}\nexport const ZodPromise = /*@__PURE__*/ core.$constructor(\"ZodPromise\", (inst, def) => {\n    core.$ZodPromise.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.promiseProcessor(inst, ctx, json, params);\n    inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function promise(innerType) {\n    return new ZodPromise({\n        type: \"promise\",\n        innerType: innerType,\n    });\n}\nexport const ZodFunction = /*@__PURE__*/ core.$constructor(\"ZodFunction\", (inst, def) => {\n    core.$ZodFunction.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.functionProcessor(inst, ctx, json, params);\n});\nexport function _function(params) {\n    return new ZodFunction({\n        type: \"function\",\n        input: Array.isArray(params?.input) ? tuple(params?.input) : (params?.input ?? array(unknown())),\n        output: params?.output ?? unknown(),\n    });\n}\nexport { _function as function };\nexport const ZodCustom = /*@__PURE__*/ core.$constructor(\"ZodCustom\", (inst, def) => {\n    core.$ZodCustom.init(inst, def);\n    ZodType.init(inst, def);\n    inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);\n});\n// custom checks\nexport function check(fn) {\n    const ch = new core.$ZodCheck({\n        check: \"custom\",\n        // ...util.normalizeParams(params),\n    });\n    ch._zod.check = fn;\n    return ch;\n}\nexport function custom(fn, _params) {\n    return core._custom(ZodCustom, fn ?? (() => true), _params);\n}\nexport function refine(fn, _params = {}) {\n    return core._refine(ZodCustom, fn, _params);\n}\n// superRefine\nexport function superRefine(fn, params) {\n    return core._superRefine(fn, params);\n}\n// Re-export describe and meta from core\nexport const describe = core.describe;\nexport const meta = core.meta;\nexport const ZodInstanceOf = /*@__PURE__*/ core.$constructor(\"ZodInstanceOf\", (inst, def) => {\n    ZodCustom.init(inst, def);\n}, {\n    properties(shape, params) {\n        // asserts in place, so the narrowed output type is truthful without a wrapper\n        return this.check(core._properties(shape, params));\n    },\n});\nfunction _instanceof(cls, params = {}) {\n    const inst = new ZodInstanceOf({\n        type: \"custom\",\n        check: \"custom\",\n        fn: (data) => data instanceof cls,\n        abort: true,\n        ...util.normalizeParams(params),\n    });\n    inst._zod.bag.Class = cls;\n    // Override check to emit invalid_type instead of custom\n    inst._zod.check = (payload) => {\n        if (!(payload.value instanceof cls)) {\n            payload.issues.push({\n                code: \"invalid_type\",\n                expected: cls.name,\n                input: payload.value,\n                inst,\n                path: [...(inst._zod.def.path ?? [])],\n            });\n        }\n    };\n    return inst;\n}\nexport { _instanceof as instanceof };\n// stringbool\nexport const stringbool = (...args) => core._stringbool({\n    Codec: ZodCodec,\n    Boolean: ZodBoolean,\n    String: ZodString,\n}, ...args);\nexport function json(params) {\n    const jsonSchema = lazy(() => {\n        return union([string(params), number(), boolean(), _null(), array(jsonSchema), record(string(), jsonSchema)]);\n    });\n    return jsonSchema;\n}\n// preprocess\nexport function preprocess(fn, schema) {\n    return new ZodPreprocess({\n        type: \"pipe\",\n        in: transform(fn),\n        out: schema,\n    });\n}\n"],"ignoreList":[0,1,2,3,4,5,6,7],"mappings":"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"}

package/dist/app/server/assets/secp256k1-buM5g4AL.js

@@ -0,0 +1,2 @@
+import{r as e}from"./rolldown-runtime-B0Z9INg1.js";import{B as t,C as n,E as r,F as i,G as a,H as o,I as s,J as c,K as l,L as u,M as d,N as f,P as p,Q as m,R as h,S as g,T as _,U as v,V as y,Z as b,_ as x,a as S,b as C,c as w,et as T,f as E,g as D,h as O,i as k,j as A,l as ee,m as te,n as j,o as M,p as ne,q as N,r as re,s as P,t as F,u as I,v as L,w as ie,x as ae,y as R,z as oe}from"./utils-C4ZXZIZW.js";var se=class extends h{constructor(e,t){super(),this.finished=!1,this.destroyed=!1,y(e);let n=T(t);if(this.iHash=e.create(),typeof this.iHash.update!=`function`)throw Error(`Expected instance of class which extends utils.Hash`);this.blockLen=this.iHash.blockLen,this.outputLen=this.iHash.outputLen;let r=this.blockLen,i=new Uint8Array(r);i.set(n.length>r?e.create().update(n).digest():n);for(let e=0;e<i.length;e++)i[e]^=54;this.iHash.update(i),this.oHash=e.create();for(let e=0;e<i.length;e++)i[e]^=106;this.oHash.update(i),a(i)}update(e){return t(this),this.iHash.update(e),this}digestInto(e){t(this),oe(e,this.outputLen),this.finished=!0,this.iHash.digestInto(e),this.oHash.update(e),this.oHash.digestInto(e),this.destroy()}digest(){let e=new Uint8Array(this.oHash.outputLen);return this.digestInto(e),e}_cloneInto(e){e||=Object.create(Object.getPrototypeOf(this),{});let{oHash:t,iHash:n,finished:r,destroyed:i,blockLen:a,outputLen:o}=this;return e=e,e.finished=r,e.destroyed=i,e.blockLen=a,e.outputLen=o,e.oHash=t._cloneInto(e.oHash),e.iHash=n._cloneInto(e.iHash),e}clone(){return this._cloneInto()}destroy(){this.destroyed=!0,this.oHash.destroy(),this.iHash.destroy()}},ce=(e,t,n)=>new se(e,t).update(n).digest();ce.create=(e,t)=>new se(e,t);function le(e,t,n,r){if(typeof e.setBigUint64==`function`)return e.setBigUint64(t,n,r);let i=BigInt(32),a=BigInt(4294967295),o=Number(n>>i&a),s=Number(n&a),c=r?4:0,l=r?0:4;e.setUint32(t+c,o,r),e.setUint32(t+l,s,r)}function ue(e,t,n){return e&t^~e&n}function de(e,t,n){return e&t^e&n^t&n}var fe=class extends h{constructor(e,t,n,r){super(),this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.blockLen=e,this.outputLen=t,this.padOffset=n,this.isLE=r,this.buffer=new Uint8Array(e),this.view=c(this.buffer)}update(e){t(this),e=T(e),oe(e);let{view:n,buffer:r,blockLen:i}=this,a=e.length;for(let t=0;t<a;){let o=Math.min(i-this.pos,a-t);if(o===i){let n=c(e);for(;i<=a-t;t+=i)this.process(n,t)}else r.set(e.subarray(t,t+o),this.pos),this.pos+=o,t+=o,this.pos===i&&(this.process(n,0),this.pos=0)}return this.length+=e.length,this.roundClean(),this}digestInto(e){t(this),v(e,this),this.finished=!0;let{buffer:n,view:r,blockLen:i,isLE:o}=this,{pos:s}=this;n[s++]=128,a(this.buffer.subarray(s)),this.padOffset>i-s&&(this.process(r,0),s=0);for(let e=s;e<i;e++)n[e]=0;le(r,i-8,BigInt(this.length*8),o),this.process(r,0);let l=c(e),u=this.outputLen;if(u%4)throw Error(`_sha2: outputLen should be aligned to 32bit`);let d=u/4,f=this.get();if(d>f.length)throw Error(`_sha2: outputLen bigger than state`);for(let e=0;e<d;e++)l.setUint32(4*e,f[e],o)}digest(){let{buffer:e,outputLen:t}=this;this.digestInto(e);let n=e.slice(0,t);return this.destroy(),n}_cloneInto(e){e||=new this.constructor,e.set(...this.get());let{blockLen:t,buffer:n,length:r,finished:i,destroyed:a,pos:o}=this;return e.destroyed=a,e.finished=i,e.length=r,e.pos=o,r%t&&e.buffer.set(n),e}clone(){return this._cloneInto()}},z=Uint32Array.from([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),B=Uint32Array.from([3418070365,3238371032,1654270250,914150663,2438529370,812702999,355462360,4144912697,1731405415,4290775857,2394180231,1750603025,3675008525,1694076839,1203062813,3204075428]),V=Uint32Array.from([1779033703,4089235720,3144134277,2227873595,1013904242,4271175723,2773480762,1595750129,1359893119,2917565137,2600822924,725511199,528734635,4215389547,1541459225,327033209]),pe=Uint32Array.from([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),H=new Uint32Array(64),me=class extends fe{constructor(e=32){super(64,e,8,!1),this.A=z[0]|0,this.B=z[1]|0,this.C=z[2]|0,this.D=z[3]|0,this.E=z[4]|0,this.F=z[5]|0,this.G=z[6]|0,this.H=z[7]|0}get(){let{A:e,B:t,C:n,D:r,E:i,F:a,G:o,H:s}=this;return[e,t,n,r,i,a,o,s]}set(e,t,n,r,i,a,o,s){this.A=e|0,this.B=t|0,this.C=n|0,this.D=r|0,this.E=i|0,this.F=a|0,this.G=o|0,this.H=s|0}process(e,t){for(let n=0;n<16;n++,t+=4)H[n]=e.getUint32(t,!1);for(let e=16;e<64;e++){let t=H[e-15],n=H[e-2],r=m(t,7)^m(t,18)^t>>>3,i=m(n,17)^m(n,19)^n>>>10;H[e]=i+H[e-7]+r+H[e-16]|0}let{A:n,B:r,C:i,D:a,E:o,F:s,G:c,H:l}=this;for(let e=0;e<64;e++){let t=m(o,6)^m(o,11)^m(o,25),u=l+t+ue(o,s,c)+pe[e]+H[e]|0,d=(m(n,2)^m(n,13)^m(n,22))+de(n,r,i)|0;l=c,c=s,s=o,o=a+u|0,a=i,i=r,r=n,n=u+d|0}n=n+this.A|0,r=r+this.B|0,i=i+this.C|0,a=a+this.D|0,o=o+this.E|0,s=s+this.F|0,c=c+this.G|0,l=l+this.H|0,this.set(n,r,i,a,o,s,c,l)}roundClean(){a(H)}destroy(){this.set(0,0,0,0,0,0,0,0),a(this.buffer)}},he=u(`0x428a2f98d728ae22.0x7137449123ef65cd.0xb5c0fbcfec4d3b2f.0xe9b5dba58189dbbc.0x3956c25bf348b538.0x59f111f1b605d019.0x923f82a4af194f9b.0xab1c5ed5da6d8118.0xd807aa98a3030242.0x12835b0145706fbe.0x243185be4ee4b28c.0x550c7dc3d5ffb4e2.0x72be5d74f27b896f.0x80deb1fe3b1696b1.0x9bdc06a725c71235.0xc19bf174cf692694.0xe49b69c19ef14ad2.0xefbe4786384f25e3.0x0fc19dc68b8cd5b5.0x240ca1cc77ac9c65.0x2de92c6f592b0275.0x4a7484aa6ea6e483.0x5cb0a9dcbd41fbd4.0x76f988da831153b5.0x983e5152ee66dfab.0xa831c66d2db43210.0xb00327c898fb213f.0xbf597fc7beef0ee4.0xc6e00bf33da88fc2.0xd5a79147930aa725.0x06ca6351e003826f.0x142929670a0e6e70.0x27b70a8546d22ffc.0x2e1b21385c26c926.0x4d2c6dfc5ac42aed.0x53380d139d95b3df.0x650a73548baf63de.0x766a0abb3c77b2a8.0x81c2c92e47edaee6.0x92722c851482353b.0xa2bfe8a14cf10364.0xa81a664bbc423001.0xc24b8b70d0f89791.0xc76c51a30654be30.0xd192e819d6ef5218.0xd69906245565a910.0xf40e35855771202a.0x106aa07032bbd1b8.0x19a4c116b8d2d0c8.0x1e376c085141ab53.0x2748774cdf8eeb99.0x34b0bcb5e19b48a8.0x391c0cb3c5c95a63.0x4ed8aa4ae3418acb.0x5b9cca4f7763e373.0x682e6ff3d6b2b8a3.0x748f82ee5defb2fc.0x78a5636f43172f60.0x84c87814a1f0ab72.0x8cc702081a6439ec.0x90befffa23631e28.0xa4506cebde82bde9.0xbef9a3f7b2c67915.0xc67178f2e372532b.0xca273eceea26619c.0xd186b8c721c0c207.0xeada7dd6cde0eb1e.0xf57d4f7fee6ed178.0x06f067aa72176fba.0x0a637dc5a2c898a6.0x113f9804bef90dae.0x1b710b35131c471b.0x28db77f523047d84.0x32caab7b40c72493.0x3c9ebe0a15c9bebc.0x431d67c49c100d4c.0x4cc5d4becb3e42b6.0x597f299cfc657e2a.0x5fcb6fab3ad6faec.0x6c44198c4a475817`.split(`.`).map(e=>BigInt(e))),ge=he[0],_e=he[1],U=new Uint32Array(80),W=new Uint32Array(80),ve=class extends fe{constructor(e=64){super(128,e,16,!1),this.Ah=V[0]|0,this.Al=V[1]|0,this.Bh=V[2]|0,this.Bl=V[3]|0,this.Ch=V[4]|0,this.Cl=V[5]|0,this.Dh=V[6]|0,this.Dl=V[7]|0,this.Eh=V[8]|0,this.El=V[9]|0,this.Fh=V[10]|0,this.Fl=V[11]|0,this.Gh=V[12]|0,this.Gl=V[13]|0,this.Hh=V[14]|0,this.Hl=V[15]|0}get(){let{Ah:e,Al:t,Bh:n,Bl:r,Ch:i,Cl:a,Dh:o,Dl:s,Eh:c,El:l,Fh:u,Fl:d,Gh:f,Gl:p,Hh:m,Hl:h}=this;return[e,t,n,r,i,a,o,s,c,l,u,d,f,p,m,h]}set(e,t,n,r,i,a,o,s,c,l,u,d,f,p,m,h){this.Ah=e|0,this.Al=t|0,this.Bh=n|0,this.Bl=r|0,this.Ch=i|0,this.Cl=a|0,this.Dh=o|0,this.Dl=s|0,this.Eh=c|0,this.El=l|0,this.Fh=u|0,this.Fl=d|0,this.Gh=f|0,this.Gl=p|0,this.Hh=m|0,this.Hl=h|0}process(e,t){for(let n=0;n<16;n++,t+=4)U[n]=e.getUint32(t),W[n]=e.getUint32(t+=4);for(let e=16;e<80;e++){let t=U[e-15]|0,r=W[e-15]|0,a=f(t,r,1)^f(t,r,8)^i(t,r,7),o=p(t,r,1)^p(t,r,8)^s(t,r,7),c=U[e-2]|0,l=W[e-2]|0,u=f(c,l,19)^A(c,l,61)^i(c,l,6),m=p(c,l,19)^d(c,l,61)^s(c,l,6),h=ie(o,m,W[e-7],W[e-16]),g=n(h,a,u,U[e-7],U[e-16]);U[e]=g|0,W[e]=h|0}let{Ah:a,Al:o,Bh:c,Bl:l,Ch:u,Cl:m,Dh:h,Dl:v,Eh:y,El:b,Fh:x,Fl:S,Gh:w,Gl:T,Hh:E,Hl:D}=this;for(let e=0;e<80;e++){let t=f(y,b,14)^f(y,b,18)^A(y,b,41),n=p(y,b,14)^p(y,b,18)^d(y,b,41),i=y&x^~y&w,s=b&S^~b&T,O=r(D,n,s,_e[e],W[e]),k=_(O,E,t,i,ge[e],U[e]),ee=O|0,te=f(a,o,28)^A(a,o,34)^A(a,o,39),j=p(a,o,28)^d(a,o,34)^d(a,o,39),M=a&c^a&u^c&u,ne=o&l^o&m^l&m;E=w|0,D=T|0,w=x|0,T=S|0,x=y|0,S=b|0,{h:y,l:b}=C(h|0,v|0,k|0,ee|0),h=u|0,v=m|0,u=c|0,m=l|0,c=a|0,l=o|0;let N=g(ee,j,ne);a=ae(N,k,te,M),o=N|0}({h:a,l:o}=C(this.Ah|0,this.Al|0,a|0,o|0)),{h:c,l}=C(this.Bh|0,this.Bl|0,c|0,l|0),{h:u,l:m}=C(this.Ch|0,this.Cl|0,u|0,m|0),{h,l:v}=C(this.Dh|0,this.Dl|0,h|0,v|0),{h:y,l:b}=C(this.Eh|0,this.El|0,y|0,b|0),{h:x,l:S}=C(this.Fh|0,this.Fl|0,x|0,S|0),{h:w,l:T}=C(this.Gh|0,this.Gl|0,w|0,T|0),{h:E,l:D}=C(this.Hh|0,this.Hl|0,E|0,D|0),this.set(a,o,c,l,u,m,h,v,y,b,x,S,w,T,E,D)}roundClean(){a(U,W)}destroy(){a(this.buffer),this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)}},ye=class extends ve{constructor(){super(48),this.Ah=B[0]|0,this.Al=B[1]|0,this.Bh=B[2]|0,this.Bl=B[3]|0,this.Ch=B[4]|0,this.Cl=B[5]|0,this.Dh=B[6]|0,this.Dl=B[7]|0,this.Eh=B[8]|0,this.El=B[9]|0,this.Fh=B[10]|0,this.Fl=B[11]|0,this.Gh=B[12]|0,this.Gl=B[13]|0,this.Hh=B[14]|0,this.Hl=B[15]|0}},be=N(()=>new me),xe=N(()=>new ve),Se=N(()=>new ye),G=BigInt(0),K=BigInt(1),q=BigInt(2),Ce=BigInt(3),we=BigInt(4),Te=BigInt(5),Ee=BigInt(8);function J(e,t){let n=e%t;return n>=G?n:t+n}function Y(e,t,n){let r=e;for(;t-->G;)r*=r,r%=n;return r}function De(e,t){if(e===G)throw Error(`invert: expected non-zero number`);if(t<=G)throw Error(`invert: expected positive modulus, got `+t);let n=J(e,t),r=t,i=G,a=K,o=K,s=G;for(;n!==G;){let e=r/n,t=r%n,c=i-o*e,l=a-s*e;r=n,n=t,i=o,a=s,o=c,s=l}if(r!==K)throw Error(`invert: does not exist`);return J(i,t)}function Oe(e,t){let n=(e.ORDER+K)/we,r=e.pow(t,n);if(!e.eql(e.sqr(r),t))throw Error(`Cannot find square root`);return r}function ke(e,t){let n=(e.ORDER-Te)/Ee,r=e.mul(t,q),i=e.pow(r,n),a=e.mul(t,i),o=e.mul(e.mul(a,q),i),s=e.mul(a,e.sub(o,e.ONE));if(!e.eql(e.sqr(s),t))throw Error(`Cannot find square root`);return s}function Ae(e){if(e<BigInt(3))throw Error(`sqrt is not defined for small field`);let t=e-K,n=0;for(;t%q===G;)t/=q,n++;let r=q,i=X(e);for(;Ie(i,r)===1;)if(r++>1e3)throw Error(`Cannot find square root: probably non-prime P`);if(n===1)return Oe;let a=i.pow(r,t),o=(t+K)/q;return function(e,r){if(e.is0(r))return r;if(Ie(e,r)!==1)throw Error(`Cannot find square root`);let i=n,s=e.mul(e.ONE,a),c=e.pow(r,t),l=e.pow(r,o);for(;!e.eql(c,e.ONE);){if(e.is0(c))return e.ZERO;let t=1,n=e.sqr(c);for(;!e.eql(n,e.ONE);)if(t++,n=e.sqr(n),t===i)throw Error(`Cannot find square root`);let r=K<<BigInt(i-t-1),a=e.pow(s,r);i=t,s=e.sqr(a),c=e.mul(c,s),l=e.mul(l,a)}return l}}function je(e){return e%we===Ce?Oe:e%Ee===Te?ke:Ae(e)}var Me=[`create`,`isValid`,`is0`,`neg`,`inv`,`sqrt`,`sqr`,`eql`,`add`,`sub`,`mul`,`pow`,`div`,`addN`,`subN`,`mulN`,`sqrN`];function Ne(e){let t=Me.reduce((e,t)=>(e[t]=`function`,e),{ORDER:`bigint`,MASK:`bigint`,BYTES:`isSafeInteger`,BITS:`isSafeInteger`});return R(e,t)}function Pe(e,t,n){if(n<G)throw Error(`invalid exponent, negatives unsupported`);if(n===G)return e.ONE;if(n===K)return t;let r=e.ONE,i=t;for(;n>G;)n&K&&(r=e.mul(r,i)),i=e.sqr(i),n>>=K;return r}function Fe(e,t,n=!1){let r=Array(t.length).fill(n?e.ZERO:void 0),i=t.reduce((t,n,i)=>e.is0(n)?t:(r[i]=t,e.mul(t,n)),e.ONE),a=e.inv(i);return t.reduceRight((t,n,i)=>e.is0(n)?t:(r[i]=e.mul(t,r[i]),e.mul(t,n)),a),r}function Ie(e,t){let n=(e.ORDER-K)/q,r=e.pow(t,n),i=e.eql(r,e.ONE),a=e.eql(r,e.ZERO),o=e.eql(r,e.neg(e.ONE));if(!i&&!a&&!o)throw Error(`invalid Legendre symbol result`);return i?1:a?0:-1}function Le(e,t){t!==void 0&&o(t);let n=t===void 0?e.toString(2).length:t;return{nBitLength:n,nByteLength:Math.ceil(n/8)}}function X(e,t,n=!1,r={}){if(e<=G)throw Error(`invalid field: expected ORDER > 0, got `+e);let{nBitLength:i,nByteLength:a}=Le(e,t);if(a>2048)throw Error(`invalid field: expected ORDER of <= 2048 bytes`);let o,s=Object.freeze({ORDER:e,isLE:n,BITS:i,BYTES:a,MASK:k(i),ZERO:G,ONE:K,create:t=>J(t,e),isValid:t=>{if(typeof t!=`bigint`)throw Error(`invalid field element: expected bigint, got `+typeof t);return G<=t&&t<e},is0:e=>e===G,isOdd:e=>(e&K)===K,neg:t=>J(-t,e),eql:(e,t)=>e===t,sqr:t=>J(t*t,e),add:(t,n)=>J(t+n,e),sub:(t,n)=>J(t-n,e),mul:(t,n)=>J(t*n,e),pow:(e,t)=>Pe(s,e,t),div:(t,n)=>J(t*De(n,e),e),sqrN:e=>e*e,addN:(e,t)=>e+t,subN:(e,t)=>e-t,mulN:(e,t)=>e*t,inv:t=>De(t,e),sqrt:r.sqrt||(t=>(o||=je(e),o(s,t))),toBytes:e=>n?x(e,a):D(e,a),fromBytes:e=>{if(e.length!==a)throw Error(`Field.fromBytes: expected `+a+` bytes, got `+e.length);return n?P(e):M(e)},invertBatch:e=>Fe(s,e),cmov:(e,t,n)=>n?t:e});return Object.freeze(s)}function Re(e){if(typeof e!=`bigint`)throw Error(`field order must be bigint`);let t=e.toString(2).length;return Math.ceil(t/8)}function ze(e){let t=Re(e);return t+Math.ceil(t/2)}function Be(e,t,n=!1){let r=e.length,i=Re(t),a=ze(t);if(r<16||r<a||r>1024)throw Error(`expected `+a+`-1024 bytes of input, got `+r);let o=J(n?P(e):M(e),t-K)+K;return n?x(o,i):D(o,i)}var Ve=BigInt(0),He=BigInt(1);function Ue(e,t){let n=t.negate();return e?n:t}function We(e,t){if(!Number.isSafeInteger(e)||e<=0||e>t)throw Error(`invalid window size, expected [1..`+t+`], got W=`+e)}function Ge(e,t){We(e,t);let n=Math.ceil(t/e)+1,r=2**(e-1),i=2**e;return{windows:n,windowSize:r,mask:k(e),maxNumber:i,shiftBy:BigInt(e)}}function Ke(e,t,n){let{windowSize:r,mask:i,maxNumber:a,shiftBy:o}=n,s=Number(e&i),c=e>>o;s>r&&(s-=a,c+=He);let l=t*r,u=l+Math.abs(s)-1,d=s===0,f=s<0,p=t%2!=0;return{nextN:c,offset:u,isZero:d,isNeg:f,isNegF:p,offsetF:l}}function qe(e,t){if(!Array.isArray(e))throw Error(`array expected`);e.forEach((e,n)=>{if(!(e instanceof t))throw Error(`invalid point at index `+n)})}function Je(e,t){if(!Array.isArray(e))throw Error(`array of scalars expected`);e.forEach((e,n)=>{if(!t.isValid(e))throw Error(`invalid scalar at index `+n)})}var Ye=new WeakMap,Xe=new WeakMap;function Ze(e){return Xe.get(e)||1}function Qe(e,t){return{constTimeNegate:Ue,hasPrecomputes(e){return Ze(e)!==1},unsafeLadder(t,n,r=e.ZERO){let i=t;for(;n>Ve;)n&He&&(r=r.add(i)),i=i.double(),n>>=He;return r},precomputeWindow(e,n){let{windows:r,windowSize:i}=Ge(n,t),a=[],o=e,s=o;for(let e=0;e<r;e++){s=o,a.push(s);for(let e=1;e<i;e++)s=s.add(o),a.push(s);o=s.double()}return a},wNAF(n,r,i){let a=e.ZERO,o=e.BASE,s=Ge(n,t);for(let e=0;e<s.windows;e++){let{nextN:t,offset:n,isZero:c,isNeg:l,isNegF:u,offsetF:d}=Ke(i,e,s);i=t,c?o=o.add(Ue(u,r[d])):a=a.add(Ue(l,r[n]))}return{p:a,f:o}},wNAFUnsafe(n,r,i,a=e.ZERO){let o=Ge(n,t);for(let e=0;e<o.windows&&i!==Ve;e++){let{nextN:t,offset:n,isZero:s,isNeg:c}=Ke(i,e,o);if(i=t,!s){let e=r[n];a=a.add(c?e.negate():e)}}return a},getPrecomputes(e,t,n){let r=Ye.get(t);return r||(r=this.precomputeWindow(t,e),e!==1&&Ye.set(t,n(r))),r},wNAFCached(e,t,n){let r=Ze(e);return this.wNAF(r,this.getPrecomputes(r,e,n),t)},wNAFCachedUnsafe(e,t,n,r){let i=Ze(e);return i===1?this.unsafeLadder(e,t,r):this.wNAFUnsafe(i,this.getPrecomputes(i,e,n),t,r)},setWindowSize(e,n){We(n,t),Xe.set(e,n),Ye.delete(e)}}}function $e(e,t,n,r){qe(n,e),Je(r,t);let i=n.length,a=r.length;if(i!==a)throw Error(`arrays of points and scalars must have equal length`);let o=e.ZERO,s=re(BigInt(i)),c=1;s>12?c=s-3:s>4?c=s-2:s>0&&(c=2);let l=k(c),u=Array(Number(l)+1).fill(o),d=Math.floor((t.BITS-1)/c)*c,f=o;for(let e=d;e>=0;e-=c){u.fill(o);for(let t=0;t<a;t++){let i=r[t],a=Number(i>>BigInt(e)&l);u[a]=u[a].add(n[t])}let t=o;for(let e=u.length-1,n=o;e>0;e--)n=n.add(u[e]),t=t.add(n);if(f=f.add(t),e!==0)for(let e=0;e<c;e++)f=f.double()}return f}function et(e){return Ne(e.Fp),R(e,{n:`bigint`,h:`bigint`,Gx:`field`,Gy:`field`},{nBitLength:`isSafeInteger`,nByteLength:`isSafeInteger`}),Object.freeze({...Le(e.n,e.nBitLength),...e,p:e.Fp.ORDER})}function tt(e){e.lowS!==void 0&&j(`lowS`,e.lowS),e.prehash!==void 0&&j(`prehash`,e.prehash)}function nt(e){let t=et(e);R(t,{a:`field`,b:`field`},{allowInfinityPoint:`boolean`,allowedPrivateKeyLengths:`array`,clearCofactor:`function`,fromBytes:`function`,isTorsionFree:`function`,toBytes:`function`,wrapPrivateKey:`boolean`});let{endo:n,Fp:r,a:i}=t;if(n){if(!r.eql(i,r.ZERO))throw Error(`invalid endo: CURVE.a must be 0`);if(typeof n!=`object`||typeof n.beta!=`bigint`||typeof n.splitScalar!=`function`)throw Error(`invalid endo: expected "beta": bigint and "splitScalar": function`)}return Object.freeze({...t})}var Z={Err:class extends Error{constructor(e=``){super(e)}},_tlv:{encode:(e,t)=>{let{Err:n}=Z;if(e<0||e>256)throw new n(`tlv.encode: wrong tag`);if(t.length&1)throw new n(`tlv.encode: unpadded data`);let r=t.length/2,i=L(r);if(i.length/2&128)throw new n(`tlv.encode: long form length too big`);let a=r>127?L(i.length/2|128):``;return L(e)+a+i+t},decode(e,t){let{Err:n}=Z,r=0;if(e<0||e>256)throw new n(`tlv.encode: wrong tag`);if(t.length<2||t[r++]!==e)throw new n(`tlv.decode: wrong tlv`);let i=t[r++],a=!!(i&128),o=0;if(!a)o=i;else{let e=i&127;if(!e)throw new n(`tlv.decode(long): indefinite length not supported`);if(e>4)throw new n(`tlv.decode(long): byte length is too big`);let a=t.subarray(r,r+e);if(a.length!==e)throw new n(`tlv.decode: length bytes not complete`);if(a[0]===0)throw new n(`tlv.decode(long): zero leftmost byte`);for(let e of a)o=o<<8|e;if(r+=e,o<128)throw new n(`tlv.decode(long): not minimal encoding`)}let s=t.subarray(r,r+o);if(s.length!==o)throw new n(`tlv.decode: wrong value length`);return{v:s,l:t.subarray(r+o)}}},_int:{encode(e){let{Err:t}=Z;if(e<Q)throw new t(`integer: negative integers are not allowed`);let n=L(e);if(Number.parseInt(n[0],16)&8&&(n=`00`+n),n.length&1)throw new t(`unexpected DER parsing assertion: unpadded hex`);return n},decode(e){let{Err:t}=Z;if(e[0]&128)throw new t(`invalid signature integer: negative`);if(e[0]===0&&!(e[1]&128))throw new t(`invalid signature integer: unnecessary leading zero`);return M(e)}},toSig(e){let{Err:t,_int:n,_tlv:r}=Z,i=I(`signature`,e),{v:a,l:o}=r.decode(48,i);if(o.length)throw new t(`invalid signature: left bytes after parsing`);let{v:s,l:c}=r.decode(2,a),{v:l,l:u}=r.decode(2,c);if(u.length)throw new t(`invalid signature: left bytes after parsing`);return{r:n.decode(s),s:n.decode(l)}},hexFromSig(e){let{_tlv:t,_int:n}=Z,r=t.encode(2,n.encode(e.r))+t.encode(2,n.encode(e.s));return t.encode(48,r)}};function rt(e,t){return S(D(e,t))}var Q=BigInt(0),$=BigInt(1),it=BigInt(3),at=BigInt(4);function ot(e){let t=nt(e),{Fp:n}=t,r=X(t.n,t.nBitLength),i=t.toBytes||((e,t,r)=>{let i=t.toAffine();return w(Uint8Array.from([4]),n.toBytes(i.x),n.toBytes(i.y))}),a=t.fromBytes||(e=>{let t=e.subarray(1);return{x:n.fromBytes(t.subarray(0,n.BYTES)),y:n.fromBytes(t.subarray(n.BYTES,2*n.BYTES))}});function o(e){let{a:r,b:i}=t,a=n.sqr(e),o=n.mul(a,e);return n.add(n.add(o,n.mul(e,r)),i)}function s(e,t){let r=n.sqr(t),i=o(e);return n.eql(r,i)}if(!s(t.Gx,t.Gy))throw Error(`bad curve params: generator point`);let c=n.mul(n.pow(t.a,it),at),l=n.mul(n.sqr(t.b),BigInt(27));if(n.is0(n.add(c,l)))throw Error(`bad curve params: a or b`);function u(e){return ne(e,$,t.n)}function d(e){let{allowedPrivateKeyLengths:n,nByteLength:r,wrapPrivateKey:i,n:a}=t;if(n&&typeof e!=`bigint`){if(te(e)&&(e=S(e)),typeof e!=`string`||!n.includes(e.length))throw Error(`invalid private key`);e=e.padStart(r*2,`0`)}let o;try{o=typeof e==`bigint`?e:M(I(`private key`,e,r))}catch{throw Error(`invalid private key, expected hex or `+r+` bytes, got `+typeof e)}return i&&(o=J(o,a)),F(`private key`,o,$,a),o}function f(e){if(!(e instanceof h))throw Error(`ProjectivePoint expected`)}let p=O((e,t)=>{let{px:r,py:i,pz:a}=e;if(n.eql(a,n.ONE))return{x:r,y:i};let o=e.is0();t??=o?n.ONE:n.inv(a);let s=n.mul(r,t),c=n.mul(i,t),l=n.mul(a,t);if(o)return{x:n.ZERO,y:n.ZERO};if(!n.eql(l,n.ONE))throw Error(`invZ was invalid`);return{x:s,y:c}}),m=O(e=>{if(e.is0()){if(t.allowInfinityPoint&&!n.is0(e.py))return;throw Error(`bad point: ZERO`)}let{x:r,y:i}=e.toAffine();if(!n.isValid(r)||!n.isValid(i))throw Error(`bad point: x or y not FE`);if(!s(r,i))throw Error(`bad point: equation left != right`);if(!e.isTorsionFree())throw Error(`bad point: not in prime-order subgroup`);return!0});class h{constructor(e,t,r){if(e==null||!n.isValid(e))throw Error(`x required`);if(t==null||!n.isValid(t)||n.is0(t))throw Error(`y required`);if(r==null||!n.isValid(r))throw Error(`z required`);this.px=e,this.py=t,this.pz=r,Object.freeze(this)}static fromAffine(e){let{x:t,y:r}=e||{};if(!e||!n.isValid(t)||!n.isValid(r))throw Error(`invalid affine point`);if(e instanceof h)throw Error(`projective point not allowed`);let i=e=>n.eql(e,n.ZERO);return i(t)&&i(r)?h.ZERO:new h(t,r,n.ONE)}get x(){return this.toAffine().x}get y(){return this.toAffine().y}static normalizeZ(e){let t=Fe(n,e.map(e=>e.pz));return e.map((e,n)=>e.toAffine(t[n])).map(h.fromAffine)}static fromHex(e){let t=h.fromAffine(a(I(`pointHex`,e)));return t.assertValidity(),t}static fromPrivateKey(e){return h.BASE.multiply(d(e))}static msm(e,t){return $e(h,r,e,t)}_setWindowSize(e){v.setWindowSize(this,e)}assertValidity(){m(this)}hasEvenY(){let{y:e}=this.toAffine();if(n.isOdd)return!n.isOdd(e);throw Error(`Field doesn't support isOdd`)}equals(e){f(e);let{px:t,py:r,pz:i}=this,{px:a,py:o,pz:s}=e,c=n.eql(n.mul(t,s),n.mul(a,i)),l=n.eql(n.mul(r,s),n.mul(o,i));return c&&l}negate(){return new h(this.px,n.neg(this.py),this.pz)}double(){let{a:e,b:r}=t,i=n.mul(r,it),{px:a,py:o,pz:s}=this,c=n.ZERO,l=n.ZERO,u=n.ZERO,d=n.mul(a,a),f=n.mul(o,o),p=n.mul(s,s),m=n.mul(a,o);return m=n.add(m,m),u=n.mul(a,s),u=n.add(u,u),c=n.mul(e,u),l=n.mul(i,p),l=n.add(c,l),c=n.sub(f,l),l=n.add(f,l),l=n.mul(c,l),c=n.mul(m,c),u=n.mul(i,u),p=n.mul(e,p),m=n.sub(d,p),m=n.mul(e,m),m=n.add(m,u),u=n.add(d,d),d=n.add(u,d),d=n.add(d,p),d=n.mul(d,m),l=n.add(l,d),p=n.mul(o,s),p=n.add(p,p),d=n.mul(p,m),c=n.sub(c,d),u=n.mul(p,f),u=n.add(u,u),u=n.add(u,u),new h(c,l,u)}add(e){f(e);let{px:r,py:i,pz:a}=this,{px:o,py:s,pz:c}=e,l=n.ZERO,u=n.ZERO,d=n.ZERO,p=t.a,m=n.mul(t.b,it),g=n.mul(r,o),_=n.mul(i,s),v=n.mul(a,c),y=n.add(r,i),b=n.add(o,s);y=n.mul(y,b),b=n.add(g,_),y=n.sub(y,b),b=n.add(r,a);let x=n.add(o,c);return b=n.mul(b,x),x=n.add(g,v),b=n.sub(b,x),x=n.add(i,a),l=n.add(s,c),x=n.mul(x,l),l=n.add(_,v),x=n.sub(x,l),d=n.mul(p,b),l=n.mul(m,v),d=n.add(l,d),l=n.sub(_,d),d=n.add(_,d),u=n.mul(l,d),_=n.add(g,g),_=n.add(_,g),v=n.mul(p,v),b=n.mul(m,b),_=n.add(_,v),v=n.sub(g,v),v=n.mul(p,v),b=n.add(b,v),g=n.mul(_,b),u=n.add(u,g),g=n.mul(x,b),l=n.mul(y,l),l=n.sub(l,g),g=n.mul(y,_),d=n.mul(x,d),d=n.add(d,g),new h(l,u,d)}subtract(e){return this.add(e.negate())}is0(){return this.equals(h.ZERO)}wNAF(e){return v.wNAFCached(this,e,h.normalizeZ)}multiplyUnsafe(e){let{endo:r,n:i}=t;F(`scalar`,e,Q,i);let a=h.ZERO;if(e===Q)return a;if(this.is0()||e===$)return this;if(!r||v.hasPrecomputes(this))return v.wNAFCachedUnsafe(this,e,h.normalizeZ);let{k1neg:o,k1:s,k2neg:c,k2:l}=r.splitScalar(e),u=a,d=a,f=this;for(;s>Q||l>Q;)s&$&&(u=u.add(f)),l&$&&(d=d.add(f)),f=f.double(),s>>=$,l>>=$;return o&&(u=u.negate()),c&&(d=d.negate()),d=new h(n.mul(d.px,r.beta),d.py,d.pz),u.add(d)}multiply(e){let{endo:r,n:i}=t;F(`scalar`,e,$,i);let a,o;if(r){let{k1neg:t,k1:i,k2neg:s,k2:c}=r.splitScalar(e),{p:l,f:u}=this.wNAF(i),{p:d,f}=this.wNAF(c);l=v.constTimeNegate(t,l),d=v.constTimeNegate(s,d),d=new h(n.mul(d.px,r.beta),d.py,d.pz),a=l.add(d),o=u.add(f)}else{let{p:t,f:n}=this.wNAF(e);a=t,o=n}return h.normalizeZ([a,o])[0]}multiplyAndAddUnsafe(e,t,n){let r=h.BASE,i=(e,t)=>t===Q||t===$||!e.equals(r)?e.multiplyUnsafe(t):e.multiply(t),a=i(this,t).add(i(e,n));return a.is0()?void 0:a}toAffine(e){return p(this,e)}isTorsionFree(){let{h:e,isTorsionFree:n}=t;if(e===$)return!0;if(n)return n(h,this);throw Error(`isTorsionFree() has not been declared for the elliptic curve`)}clearCofactor(){let{h:e,clearCofactor:n}=t;return e===$?this:n?n(h,this):this.multiplyUnsafe(t.h)}toRawBytes(e=!0){return j(`isCompressed`,e),this.assertValidity(),i(h,this,e)}toHex(e=!0){return j(`isCompressed`,e),S(this.toRawBytes(e))}}h.BASE=new h(t.Gx,t.Gy,n.ONE),h.ZERO=new h(n.ZERO,n.ONE,n.ZERO);let{endo:g,nBitLength:_}=t,v=Qe(h,g?Math.ceil(_/2):_);return{CURVE:t,ProjectivePoint:h,normPrivateKeyToScalar:d,weierstrassEquation:o,isWithinCurveOrder:u}}function st(e){let t=et(e);return R(t,{hash:`hash`,hmac:`function`,randomBytes:`function`},{bits2int:`function`,bits2int_modN:`function`,lowS:`boolean`}),Object.freeze({lowS:!0,...t})}function ct(e){let t=st(e),{Fp:n,n:r,nByteLength:i,nBitLength:a}=t,o=n.BYTES+1,s=2*n.BYTES+1;function c(e){return J(e,r)}function l(e){return De(e,r)}let{ProjectivePoint:u,normPrivateKeyToScalar:d,weierstrassEquation:f,isWithinCurveOrder:p}=ot({...t,toBytes(e,t,r){let i=t.toAffine(),a=n.toBytes(i.x),o=w;return j(`isCompressed`,r),r?o(Uint8Array.from([t.hasEvenY()?2:3]),a):o(Uint8Array.from([4]),a,n.toBytes(i.y))},fromBytes(e){let t=e.length,r=e[0],i=e.subarray(1);if(t===o&&(r===2||r===3)){let e=M(i);if(!ne(e,$,n.ORDER))throw Error(`Point is not on curve`);let t=f(e),a;try{a=n.sqrt(t)}catch(e){let t=e instanceof Error?`: `+e.message:``;throw Error(`Point is not on curve`+t)}let o=(a&$)===$;return(r&1)==1!==o&&(a=n.neg(a)),{x:e,y:a}}if(t===s&&r===4)return{x:n.fromBytes(i.subarray(0,n.BYTES)),y:n.fromBytes(i.subarray(n.BYTES,2*n.BYTES))};{let e=o,n=s;throw Error(`invalid Point, expected length of `+e+`, or uncompressed `+n+`, got `+t)}}});function m(e){return e>r>>$}function h(e){return m(e)?c(-e):e}let g=(e,t,n)=>M(e.slice(t,n));class _{constructor(e,t,n){F(`r`,e,$,r),F(`s`,t,$,r),this.r=e,this.s=t,n!=null&&(this.recovery=n),Object.freeze(this)}static fromCompact(e){let t=i;return e=I(`compactSignature`,e,t*2),new _(g(e,0,t),g(e,t,2*t))}static fromDER(e){let{r:t,s:n}=Z.toSig(I(`DER`,e));return new _(t,n)}assertValidity(){}addRecoveryBit(e){return new _(this.r,this.s,e)}recoverPublicKey(e){let{r,s:i,recovery:a}=this,o=C(I(`msgHash`,e));if(a==null||![0,1,2,3].includes(a))throw Error(`recovery id invalid`);let s=a===2||a===3?r+t.n:r;if(s>=n.ORDER)throw Error(`recovery id 2 or 3 invalid`);let d=a&1?`03`:`02`,f=u.fromHex(d+rt(s,n.BYTES)),p=l(s),m=c(-o*p),h=c(i*p),g=u.BASE.multiplyAndAddUnsafe(f,m,h);if(!g)throw Error(`point at infinify`);return g.assertValidity(),g}hasHighS(){return m(this.s)}normalizeS(){return this.hasHighS()?new _(this.r,c(-this.s),this.recovery):this}toDERRawBytes(){return E(this.toDERHex())}toDERHex(){return Z.hexFromSig(this)}toCompactRawBytes(){return E(this.toCompactHex())}toCompactHex(){let e=i;return rt(this.r,e)+rt(this.s,e)}}let v={isValidPrivateKey(e){try{return d(e),!0}catch{return!1}},normPrivateKeyToScalar:d,randomPrivateKey:()=>{let e=ze(t.n);return Be(t.randomBytes(e),t.n)},precompute(e=8,t=u.BASE){return t._setWindowSize(e),t.multiply(BigInt(3)),t}};function y(e,t=!0){return u.fromPrivateKey(e).toRawBytes(t)}function b(e){if(typeof e==`bigint`)return!1;if(e instanceof u)return!0;let r=I(`key`,e).length,a=n.BYTES,o=a+1,s=2*a+1;if(!(t.allowedPrivateKeyLengths||i===o))return r===o||r===s}function x(e,t,n=!0){if(b(e)===!0)throw Error(`first arg must be private key`);if(b(t)===!1)throw Error(`second arg must be public key`);return u.fromHex(t).multiply(d(e)).toRawBytes(n)}let S=t.bits2int||function(e){if(e.length>8192)throw Error(`input is too large`);let t=M(e),n=e.length*8-a;return n>0?t>>BigInt(n):t},C=t.bits2int_modN||function(e){return c(S(e))},T=k(a);function O(e){return F(`num < 2^`+a,e,Q,T),D(e,i)}function A(e,r,i=N){if([`recovered`,`canonical`].some(e=>e in i))throw Error(`sign() legacy options not supported`);let{hash:a,randomBytes:o}=t,{lowS:s,prehash:f,extraEntropy:g}=i;s??=!0,e=I(`msgHash`,e),tt(i),f&&(e=I(`prehashed msgHash`,a(e)));let v=C(e),y=d(r),b=[O(y),O(v)];if(g!=null&&g!==!1){let e=g===!0?o(n.BYTES):g;b.push(I(`extraEntropy`,e))}let x=w(...b),T=v;function E(e){let t=S(e);if(!p(t))return;let n=l(t),r=u.BASE.multiply(t).toAffine(),i=c(r.x);if(i===Q)return;let a=c(n*c(T+i*y));if(a===Q)return;let o=(r.x===i?0:2)|Number(r.y&$),d=a;return s&&m(a)&&(d=h(a),o^=1),new _(i,d,o)}return{seed:x,k2sig:E}}let N={lowS:t.lowS,prehash:!1},re={lowS:t.lowS,prehash:!1};function P(e,n,r=N){let{seed:i,k2sig:a}=A(e,n,r),o=t;return ee(o.hash.outputLen,o.nByteLength,o.hmac)(i,a)}u.BASE._setWindowSize(8);function L(e,n,r,i=re){let a=e;n=I(`msgHash`,n),r=I(`publicKey`,r);let{lowS:o,prehash:s,format:d}=i;if(tt(i),`strict`in i)throw Error(`options.strict was renamed to lowS`);if(d!==void 0&&d!==`compact`&&d!==`der`)throw Error(`format must be compact or der`);let f=typeof a==`string`||te(a),p=!f&&!d&&typeof a==`object`&&!!a&&typeof a.r==`bigint`&&typeof a.s==`bigint`;if(!f&&!p)throw Error(`invalid signature, expected Uint8Array, hex string or Signature instance`);let m,h;try{if(p&&(m=new _(a.r,a.s)),f){try{d!==`compact`&&(m=_.fromDER(a))}catch(e){if(!(e instanceof Z.Err))throw e}!m&&d!==`der`&&(m=_.fromCompact(a))}h=u.fromHex(r)}catch{return!1}if(!m||o&&m.hasHighS())return!1;s&&(n=t.hash(n));let{r:g,s:v}=m,y=C(n),b=l(v),x=c(y*b),S=c(g*b),w=u.BASE.multiplyAndAddUnsafe(h,x,S)?.toAffine();return w?c(w.x)===g:!1}return{CURVE:t,getPublicKey:y,getSharedSecret:x,sign:P,verify:L,ProjectivePoint:u,Signature:_,utils:v}}function lt(e){return{hash:e,hmac:(t,...n)=>ce(e,t,l(...n)),randomBytes:b}}function ut(e,t){let n=t=>ct({...e,...lt(t)});return{...n(t),create:n}}var dt=e({secp256k1:()=>bt}),ft=BigInt(`0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f`),pt=BigInt(`0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141`),mt=BigInt(0),ht=BigInt(1),gt=BigInt(2),_t=(e,t)=>(e+t/gt)/t;function vt(e){let t=ft,n=BigInt(3),r=BigInt(6),i=BigInt(11),a=BigInt(22),o=BigInt(23),s=BigInt(44),c=BigInt(88),l=e*e*e%t,u=l*l*e%t,d=Y(Y(Y(u,n,t)*u%t,n,t)*u%t,gt,t)*l%t,f=Y(d,i,t)*d%t,p=Y(f,a,t)*f%t,m=Y(p,s,t)*p%t,h=Y(Y(Y(Y(Y(Y(m,c,t)*m%t,s,t)*p%t,n,t)*u%t,o,t)*f%t,r,t)*l%t,gt,t);if(!yt.eql(yt.sqr(h),e))throw Error(`Cannot find square root`);return h}var yt=X(ft,void 0,void 0,{sqrt:vt}),bt=ut({a:mt,b:BigInt(7),Fp:yt,n:pt,Gx:BigInt(`55066263022277343669578718895168534326250603453777594175500187360389116729240`),Gy:BigInt(`32670510020758816978083085130507043184471273380659243275938904335757337482424`),h:BigInt(1),lowS:!0,endo:{beta:BigInt(`0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee`),splitScalar:e=>{let t=pt,n=BigInt(`0x3086d221a7d46bcde86c90e49284eb15`),r=-ht*BigInt(`0xe4437ed6010e88286f547fa90abfe4c3`),i=BigInt(`0x114ca50f7a8e2f3f657c1108d9d44cfd8`),a=n,o=BigInt(`0x100000000000000000000000000000000`),s=_t(a*e,t),c=_t(-r*e,t),l=J(e-s*n-c*i,t),u=J(-s*r-c*a,t),d=l>o,f=u>o;if(d&&(l=t-l),f&&(u=t-u),l>o||u>o)throw Error(`splitScalar: Endomorphism failed, k=`+e);return{k1neg:d,k1:l,k2neg:f,k2:u}}}},be);export{be as a,ce as c,X as i,dt as n,Se as o,ut as r,xe as s,bt as t};
+//# sourceMappingURL=secp256k1-buM5g4AL.js.map