elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/type/validator.mjs

@@ -1,1029 +0,0 @@
-import { isCloudflareWorker } from "../universal/constants.mjs";
-import { nullObject } from "../utils.mjs";
-import { ValidationError } from "../error.mjs";
-import { Capture, Compiled, EMPTY_EXTERNALS, collectExternals, externalsMatch, instantiateFrozenBoth, instantiateFrozenDecodeMirror, instantiateFrozenMirror, reconstructCheck } from "../compile/aot.mjs";
-import { Validator as Validator$1 } from "../validator/index.mjs";
-import { ELYSIA_TYPES } from "./constants.mjs";
-import { isAsyncFunction } from "../compile/utils.mjs";
-import { applyCoercions, deferCoercions, nonAdditionalProperties } from "./coerce.mjs";
-import { hasProperty } from "./utils.mjs";
-import { ASYNC_REFINE, collectFileTypeChecks, takeFileTypeChecks } from "./elysia/file-type.mjs";
-import { Evaluate, Intersect, Module } from "typebox/type";
-import { Clean, Decode as Decode$1, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
-import { Build, Compile } from "typebox/schema";
-import createMirror from "exact-mirror";
-
-//#region src/type/validator.ts
-const moduleCache = /* @__PURE__ */ new WeakMap();
-function schemaContainsRef(node, seen = /* @__PURE__ */ new WeakSet()) {
-	if (!node || typeof node !== "object" || seen.has(node)) return false;
-	seen.add(node);
-	if (node.$ref) return true;
-	const props = node.properties;
-	if (props) {
-		for (const k in props) if (schemaContainsRef(props[k], seen)) return true;
-	}
-	const items = node.items;
-	if (Array.isArray(items)) {
-		for (const it of items) if (schemaContainsRef(it, seen)) return true;
-	} else if (items && schemaContainsRef(items, seen)) return true;
-	for (const key of [
-		"anyOf",
-		"allOf",
-		"oneOf"
-	]) {
-		const arr = node[key];
-		if (Array.isArray(arr)) {
-			for (const x of arr) if (schemaContainsRef(x, seen)) return true;
-		}
-	}
-	if (node.additionalProperties && typeof node.additionalProperties === "object" && schemaContainsRef(node.additionalProperties, seen)) return true;
-	if (node.not && schemaContainsRef(node.not, seen)) return true;
-	const pp = node.patternProperties;
-	if (pp) {
-		for (const k in pp) if (schemaContainsRef(pp[k], seen)) return true;
-	}
-	return false;
-}
-let inlineRefId = 0;
-const isAsyncPredicate = (v) => Array.isArray(v) ? v.some((x) => typeof x.check === "function" ? isAsyncFunction(x.check) || x.check["~elyAsyncRefine"] === true : false) : false;
-async function enforceFileTypeChecks(pending, type, value, schema) {
-	const results = await Promise.all(pending.map((x) => x.check));
-	for (let i = 0; i < results.length; i++) if (results[i] !== true) throw new ValidationError(type, value, [{
-		instancePath: findInstancePath(value, pending[i].file) ?? "",
-		message: results[i]
-	}], schema);
-}
-function findInstancePath(value, target, path = "") {
-	if (value === target) return path;
-	if (!value || typeof value !== "object") return;
-	if (Array.isArray(value)) {
-		for (let i = 0; i < value.length; i++) {
-			const found = findInstancePath(value[i], target, `${path}/${i}`);
-			if (found !== void 0) return found;
-		}
-		return;
-	}
-	for (const key in value) {
-		const found = findInstancePath(value[key], target, `${path}/${key}`);
-		if (found !== void 0) return found;
-	}
-}
-function isPrecomputeSafe(schema, depth = 0) {
-	if (!schema || typeof schema !== "object") return true;
-	const kind = schema["~kind"];
-	if (kind === "Union" || kind === "Intersect" || kind === "Ref" || kind === "This" || kind === "Cyclic") return false;
-	if (schema["~codec"] || schema["~refine"]) return false;
-	if (depth > 0 && (kind === "Object" || schema.type === "object")) {
-		if (schema.default === void 0 || nestedOwnDefaultDiverges(schema)) return false;
-	}
-	if (schema.properties) {
-		for (const v of Object.values(schema.properties)) if (!isPrecomputeSafe(v, depth + 1)) return false;
-	}
-	if (schema.items) {
-		if (Array.isArray(schema.items)) {
-			for (const v of schema.items) if (!isPrecomputeSafe(v, depth + 1)) return false;
-		} else if (!isPrecomputeSafe(schema.items, depth + 1)) return false;
-	}
-	if (typeof schema.additionalProperties === "object" && !isPrecomputeSafe(schema.additionalProperties, depth + 1)) return false;
-	if (schema.patternProperties) {
-		for (const v of Object.values(schema.patternProperties)) if (!isPrecomputeSafe(v, depth + 1)) return false;
-	}
-	return true;
-}
-function nestedOwnDefaultDiverges(objectSchema) {
-	const own = objectSchema.default;
-	if (own === null || typeof own !== "object" || Array.isArray(own)) return false;
-	const props = objectSchema.properties;
-	if (!props) return false;
-	for (const key in props) {
-		const child = props[key];
-		if (!child || typeof child !== "object") continue;
-		if ("default" in child) {
-			if (!(key in own) || canonical(own[key]) !== canonical(child.default)) return true;
-		} else if (child["~kind"] === "Object" || child.type === "object") {
-			if (key in own) {
-				if (nestedOwnDefaultDiverges({
-					...child,
-					default: own[key]
-				})) return true;
-			} else if (hasDefaultBelow(child)) return true;
-		}
-	}
-	return false;
-}
-function applyPrecomputed(defaults, value) {
-	const out = nullObject();
-	for (const k in defaults) {
-		const d = defaults[k];
-		out[k] = value[k] === void 0 && d !== null && typeof d === "object" ? structuredClone(d) : d;
-	}
-	for (const k in value) {
-		const v = value[k];
-		if (v === void 0) continue;
-		const d = out[k];
-		if (v && typeof v === "object" && !Array.isArray(v) && d && typeof d === "object" && !Array.isArray(d)) out[k] = applyPrecomputed(d, v);
-		else out[k] = v;
-	}
-	return out;
-}
-const subtreeHasDefault = (n) => !!n && typeof n === "object" && ("default" in n || childSchemaSome(n, subtreeHasDefault));
-function childSchemaSome(n, f) {
-	if (!n || typeof n !== "object") return false;
-	if (n.properties) {
-		for (const k in n.properties) if (f(n.properties[k])) return true;
-	}
-	const items = n.items;
-	if (Array.isArray(items)) {
-		for (const it of items) if (f(it)) return true;
-	} else if (items && f(items)) return true;
-	for (const key of [
-		"anyOf",
-		"allOf",
-		"oneOf"
-	]) {
-		const arr = n[key];
-		if (Array.isArray(arr)) {
-			for (const s of arr) if (f(s)) return true;
-		}
-	}
-	if (typeof n.additionalProperties === "object" && f(n.additionalProperties)) return true;
-	if (n.patternProperties) {
-		for (const k in n.patternProperties) if (f(n.patternProperties[k])) return true;
-	}
-	for (const key of [
-		"not",
-		"if",
-		"then",
-		"else"
-	]) if (n[key] && f(n[key])) return true;
-	return false;
-}
-const hasDefaultBelow = (node) => childSchemaSome(node, subtreeHasDefault);
-function hasDivergentDefaultBelow(node) {
-	const ownKey = "default" in node ? canonical(node.default) : void 0;
-	let bad = false;
-	const visit = (n) => {
-		if (!n || typeof n !== "object") return false;
-		if ("default" in n && (ownKey === void 0 || canonical(n.default) !== ownKey)) {
-			bad = true;
-			return true;
-		}
-		return childSchemaSome(n, visit);
-	};
-	childSchemaSome(node, visit);
-	return bad;
-}
-function structuralPreallocatable(schema, depth = 0) {
-	if (!schema || typeof schema !== "object") return true;
-	if (!((schema["~kind"] === "Object" || schema.type === "object") && !schema["~codec"] && !schema["~refine"] && !Array.isArray(schema.anyOf) && !Array.isArray(schema.allOf) && !Array.isArray(schema.oneOf) && schema.$ref === void 0 && schema.if === void 0 && schema.not === void 0)) return !hasDivergentDefaultBelow(schema);
-	if (depth > 0 && schema.default === void 0 && hasDefaultBelow(schema)) return false;
-	if (typeof schema.additionalProperties === "object" && subtreeHasDefault(schema.additionalProperties)) return false;
-	if (schema.patternProperties) {
-		for (const k in schema.patternProperties) if (subtreeHasDefault(schema.patternProperties[k])) return false;
-	}
-	if (schema.properties) {
-		for (const k in schema.properties) if (!structuralPreallocatable(schema.properties[k], depth + 1)) return false;
-	}
-	return true;
-}
-function isEmittable(v, seen, top = false) {
-	if (v === void 0) return top;
-	if (v === null) return true;
-	const t = typeof v;
-	if (t === "number") return Number.isFinite(v) && !Object.is(v, -0);
-	if (t === "string" || t === "boolean") return true;
-	if (t !== "object") return false;
-	if (seen.has(v)) return false;
-	seen.add(v);
-	let ok = true;
-	if (Array.isArray(v)) {
-		for (const x of v) if (!isEmittable(x, seen)) {
-			ok = false;
-			break;
-		}
-	} else {
-		const proto = Object.getPrototypeOf(v);
-		if (proto !== Object.prototype && proto !== null) ok = false;
-		else for (const k in v) {
-			if (k === "__proto__") {
-				ok = false;
-				break;
-			}
-			if (!Object.prototype.hasOwnProperty.call(v, k)) continue;
-			if (!isEmittable(v[k], seen)) {
-				ok = false;
-				break;
-			}
-		}
-	}
-	seen.delete(v);
-	return ok;
-}
-const PROBE_SENTINEL = "__elysia_default_probe__";
-function* defaultProbes(pod) {
-	if (!pod) return;
-	yield {};
-	for (const k in pod) {
-		yield { [k]: PROBE_SENTINEL };
-		const d = pod[k];
-		if (d && typeof d === "object" && !Array.isArray(d)) {
-			yield { [k]: {} };
-			for (const k2 in d) {
-				yield { [k]: { [k2]: PROBE_SENTINEL } };
-				break;
-			}
-		}
-	}
-}
-function canonical(v) {
-	if (v === void 0) return "\0u";
-	if (Object.is(v, -0)) return "-0";
-	if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "\0u";
-	if (Array.isArray(v)) return "[" + v.map(canonical).join(",") + "]";
-	return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + canonical(v[k])).join(",") + "}";
-}
-function verifyPreallocatableDefault(schema) {
-	let pd;
-	let podRaw;
-	try {
-		pd = Default(schema, void 0);
-		podRaw = Default(schema, nullObject());
-	} catch {
-		return;
-	}
-	const pod = podRaw && typeof podRaw === "object" && !Array.isArray(podRaw) ? podRaw : void 0;
-	if (!isEmittable(pd, /* @__PURE__ */ new Set(), true) || pod !== void 0 && !isEmittable(pod, /* @__PURE__ */ new Set(), true)) return;
-	if (!isPrecomputeSafe(schema)) {
-		const s = schema;
-		if (s.type !== "object" && s["~kind"] !== "Object") return;
-		if (!structuralPreallocatable(schema)) return;
-		for (const probe of defaultProbes(pod)) {
-			let expected;
-			try {
-				expected = Default(schema, structuredClone(probe));
-			} catch {
-				return;
-			}
-			const actual = applyPrecomputed(pod, structuredClone(probe));
-			if (canonical(expected) !== canonical(actual)) return;
-		}
-	}
-	return {
-		pd,
-		pod
-	};
-}
-function collectCustomErrorNodes(schema, path, out, union) {
-	if (!schema || typeof schema !== "object") return out;
-	if (schema.error !== void 0) out.push({
-		path,
-		node: schema,
-		union
-	});
-	if (schema.properties) for (const k in schema.properties) collectCustomErrorNodes(schema.properties[k], path + "/" + k, out, union);
-	const items = schema.items;
-	if (Array.isArray(items)) for (let i = 0; i < items.length; i++) collectCustomErrorNodes(items[i], path + "/" + i, out, union);
-	else if (items && items.error !== void 0) out.push({
-		path,
-		node: items,
-		each: true,
-		union
-	});
-	const branches = schema.anyOf ?? schema.oneOf;
-	if (Array.isArray(branches)) {
-		const gate = {
-			node: schema,
-			path
-		};
-		for (const branch of branches) collectCustomErrorNodes(branch, path, out, gate);
-	}
-	return out;
-}
-function subValueAt(value, path) {
-	if (!path) return value;
-	let cur = value;
-	for (const part of path.split("/")) {
-		if (!part) continue;
-		if (cur === null || typeof cur !== "object") return;
-		cur = cur[part];
-	}
-	return cur;
-}
-function collectStringCodecNodes(schema, out = []) {
-	if (!schema || typeof schema !== "object") return out;
-	const ely = schema["~elyTyp"];
-	if (ely === ELYSIA_TYPES.ObjectString || ely === ELYSIA_TYPES.ArrayString) {
-		const inner = schema.anyOf?.[0];
-		const codec = schema.anyOf?.[1];
-		if (inner && codec?.["~codec"] && codec["~refine"]) out.push({
-			inner,
-			codec,
-			open: ely === ELYSIA_TYPES.ObjectString ? 123 : 91
-		});
-	}
-	if (schema.properties) for (const k in schema.properties) collectStringCodecNodes(schema.properties[k], out);
-	const items = schema.items;
-	if (Array.isArray(items)) for (const it of items) collectStringCodecNodes(it, out);
-	else if (items) collectStringCodecNodes(items, out);
-	if (Array.isArray(schema.anyOf)) for (const b of schema.anyOf) collectStringCodecNodes(b, out);
-	return out;
-}
-function reconstructInnerCodecs(ic, schema) {
-	const nodes = collectStringCodecNodes(schema);
-	for (let i = nodes.length - 1; i >= 0; i--) {
-		const entry = ic[i];
-		const node = nodes[i];
-		if (!entry || !node) continue;
-		const innerSchema = node.inner;
-		const innerCheck = entry.c(entry.e ? collectExternals(innerSchema) : []);
-		const innerMirror = entry.d.x ? instantiateFrozenDecodeMirror(entry.d, innerSchema) : entry.d.s;
-		const open = entry.o;
-		node.codec["~refine"][0].check = (v) => {
-			if (v.charCodeAt(0) !== open) return false;
-			try {
-				return innerCheck(JSON.parse(v));
-			} catch {
-				return false;
-			}
-		};
-		node.codec["~codec"].decode = (v) => innerMirror(JSON.parse(v));
-	}
-}
-function buildFrozenCheck(build, node) {
-	if (!build?.functions?.length || !build.entry) return;
-	const vars = build.external.variables;
-	if (!externalsMatch(collectExternals(node), vars)) return;
-	const cr = reconstructCheck(build);
-	return {
-		identifier: build.external.identifier,
-		checkDefs: cr.defs,
-		checkValue: cr.value,
-		external: vars.length > 0
-	};
-}
-function captureInnerCodec(inner, open, sanitize) {
-	let cf;
-	try {
-		cf = buildFrozenCheck(Build(inner), inner);
-		if (!cf) return;
-	} catch {
-		return;
-	}
-	let decode;
-	try {
-		const emitted = createMirror(inner, {
-			Compile,
-			sanitize,
-			decode: true,
-			emit: true
-		});
-		if (typeof emitted?.source !== "string") return;
-		const ext = emitted.externals;
-		if (ext?.hof) return;
-		if (ext?.codecs && !Capture.mirrorCodecs(inner, ext.codecs)) return;
-		let u;
-		if (ext?.unions && ext.unions.length) {
-			u = Capture.mirrorUnions(inner, ext.unions);
-			if (!u) return;
-		}
-		decode = {
-			source: emitted.source,
-			hasExternals: !!(ext?.codecs || u),
-			u
-		};
-	} catch {
-		return;
-	}
-	if (hasProperty("default", inner)) return;
-	return {
-		open,
-		...cf,
-		decode
-	};
-}
-function sourceOnlyValidator(schema) {
-	const buildResult = Build(schema);
-	let full;
-	return new Proxy({}, { get(_, prop) {
-		if (prop === "buildResult") return buildResult;
-		const f = full ??= Compile(schema);
-		const value = f[prop];
-		return typeof value === "function" ? value.bind(f) : value;
-	} });
-}
-var TypeBoxValidator = class extends Validator$1 {
-	#decodeMirror;
-	#encodeMirror;
-	#findCustomError;
-	#precomputedDefault;
-	#precomputedObjectDefault;
-	#noValidate;
-	#isForm;
-	#hasOptional;
-	constructor(schema, options, name, isIntersectable) {
-		super();
-		this.precomputeSafe = false;
-		this.#isForm = false;
-		this.#hasOptional = false;
-		if (isIntersectable) schema = Evaluate(Intersect([schema, ...options.schemas]));
-		const originalElyTyp = schema?.["~elyTyp"];
-		const frozen = options?.aot && options.slot ? Compiled.getValidator(options.aot.method, options.aot.path, options.slot) : void 0;
-		let schemaHasRef = false;
-		if (name && options?.models) schema = moduleCache.getOrInsertComputed(options.models, () => Module(options.models))[name];
-		else if (options?.models && typeof name !== "string") {
-			schemaHasRef = frozen ? frozen.r === 1 : schemaContainsRef(schema);
-			if (schemaHasRef) {
-				const id = `inline@${++inlineRefId}`;
-				schema = Module({
-					...options.models,
-					[id]: schema
-				})[id];
-			}
-		}
-		const isFrozen = this.#reconstruct(options, frozen);
-		this.schema = isFrozen && !this.hasCodec ? schema : applyCoercions(schema, options?.coerces);
-		if (options?.normalize === false && options.slot !== "headers" && options.slot !== "cookie") this.schema = nonAdditionalProperties(this.schema);
-		if (!isFrozen) {
-			const capturing = Capture.isCapturing();
-			this.tb = capturing ? sourceOnlyValidator(this.schema) : Compile(this.schema);
-			this.hasCodec = HasCodec(this.schema);
-			this.isAsync = this.tb.buildResult.external.variables.some(isAsyncPredicate) ?? false;
-			this.hasDefault = hasProperty("default", this.schema);
-			if (capturing) this.#maybeCapture(options, schemaHasRef);
-			else this.#dropCompiledSource();
-		}
-		if (frozen?.ps === 1) {
-			this.precomputeSafe = true;
-			this.#precomputedDefault = frozen.pd;
-			this.#precomputedObjectDefault = frozen.pod !== void 0 ? Object.freeze(frozen.pod) : void 0;
-		} else {
-			this.precomputeSafe = this.hasDefault && isPrecomputeSafe(this.schema);
-			if (this.precomputeSafe) {
-				this.#precomputedDefault = Default(this.schema, void 0);
-				const obj = Default(this.schema, nullObject());
-				this.#precomputedObjectDefault = obj && typeof obj === "object" && !Array.isArray(obj) ? Object.freeze(obj) : void 0;
-			} else {
-				this.#precomputedDefault = void 0;
-				this.#precomputedObjectDefault = void 0;
-			}
-		}
-		this.#noValidate = originalElyTyp === ELYSIA_TYPES.NoValidate;
-		this.#isForm = originalElyTyp === ELYSIA_TYPES.Form;
-		this.#hasOptional = !!this.schema?.["~optional"];
-		if (frozen?.ic) reconstructInnerCodecs(frozen.ic, this.schema);
-		if (isFrozen && frozen.cm) {
-			const both = instantiateFrozenBoth(frozen, this.schema, schema);
-			this.reconstructedCheck = both.check;
-			this.Clean = options?.normalize === false ? void 0 : both.clean;
-		} else {
-			if (isFrozen) this.reconstructedCheck = frozen.c(frozen.e ? collectExternals(this.schema) : EMPTY_EXTERNALS);
-			try {
-				this.Clean = options?.normalize === false ? void 0 : options?.normalize === "typebox" ? (value) => Clean(this.schema, value) : this.#setupMirror(schema, options, frozen);
-			} catch (error) {
-				console.warn("Failed to create exactMirror. Please report the following code to https://github.com/elysiajs/elysia/issues");
-				console.warn(schema);
-				console.warn(error);
-				if (options?.normalize !== false) this.Clean = (value) => Clean(this.schema, value);
-			}
-		}
-		if (this.hasCodec && !this.#isForm && !this.#noValidate && !options?.slot?.startsWith("r") && options?.normalize !== false && options?.normalize !== "typebox") this.#decodeMirror = this.#setupCodecMirror(this.schema, options, frozen, "decode");
-		if (this.hasCodec && !this.#isForm && !this.#noValidate && options?.slot?.startsWith("r") && options?.normalize !== false && options?.normalize !== "typebox") this.#encodeMirror = this.#setupCodecMirror(this.schema, options, frozen, "encode");
-		if (!this.#noValidate) this.#findCustomError = this.#buildFindCustomError(frozen);
-	}
-	#buildFindCustomError(frozen) {
-		const nodes = collectCustomErrorNodes(this.schema, "", []);
-		if (!nodes.length) return;
-		const frozenByPath = frozen?.ce ? new Map(frozen.ce.map((e) => [e.p, e])) : void 0;
-		const checks = [];
-		for (const { path, node, each, union } of nodes) {
-			let check;
-			const fe = union ? void 0 : frozenByPath?.get(path);
-			if (fe) try {
-				check = fe.c(fe.e ? collectExternals(node) : EMPTY_EXTERNALS);
-			} catch {}
-			else try {
-				const c = Compile(node);
-				check = (v) => c.Check(v);
-			} catch {}
-			if (check && each) {
-				const elementCheck = check;
-				check = (v) => !Array.isArray(v) || v.every((x) => elementCheck(x));
-			}
-			if (!check) continue;
-			let gate;
-			if (union) {
-				let unionCheck;
-				try {
-					const uc = Compile(union.node);
-					unionCheck = (v) => uc.Check(v);
-				} catch {}
-				if (!unionCheck) continue;
-				const unionPath = union.path;
-				gate = (root) => unionCheck(subValueAt(root, unionPath));
-			}
-			checks.push({
-				path,
-				check,
-				gate,
-				error: node.error
-			});
-		}
-		if (!checks.length) return;
-		checks.sort((a, b) => b.path.length - a.path.length);
-		return (value) => {
-			for (const c of checks) {
-				if (c.gate && c.gate(value)) continue;
-				if (!c.check(subValueAt(value, c.path))) return {
-					instancePath: c.path,
-					error: c.error
-				};
-			}
-		};
-	}
-	#verr(value, type) {
-		return new ValidationError(type, value, () => this.Errors(value), this.schema, this.#findCustomError);
-	}
-	#setupMirror(schema, options, frozen) {
-		const aot = options?.aot;
-		const slot = options?.slot;
-		if (aot && slot && frozen?.m) {
-			const m = frozen.m;
-			let clean;
-			return (value) => {
-				if (clean === void 0) try {
-					clean = instantiateFrozenMirror(m, schema);
-				} catch (error) {
-					console.warn("Failed to create exactMirror. Please report the following code to https://github.com/elysiajs/elysia/issues");
-					console.warn(schema);
-					console.warn(error);
-					clean = (v) => v;
-				}
-				return clean(value);
-			};
-		}
-		if (aot && slot) {
-			if (Capture.isCapturing()) try {
-				const emitted = createMirror(schema, {
-					Compile,
-					sanitize: options?.sanitize,
-					emit: true
-				});
-				if (typeof emitted?.source === "string") {
-					const ext = emitted.externals;
-					if (!ext) Capture.set({
-						method: aot.method,
-						path: aot.path,
-						slot
-					}, { mirror: {
-						source: emitted.source,
-						hasExternals: false
-					} });
-					else if (ext.unions && !ext.hof) {
-						const u = Capture.mirrorUnions(schema, ext.unions);
-						if (u) Capture.set({
-							method: aot.method,
-							path: aot.path,
-							slot
-						}, { mirror: {
-							source: emitted.source,
-							hasExternals: true,
-							u
-						} });
-					}
-				}
-			} catch {}
-		}
-		return createMirror(schema, {
-			Compile,
-			sanitize: options?.sanitize
-		});
-	}
-	#setupCodecMirror(schema, options, frozen, dir) {
-		const aot = options?.aot;
-		const slot = options?.slot;
-		const frozenMirror = dir === "decode" ? frozen?.dm : frozen?.em;
-		if (aot && slot && frozenMirror) {
-			const m = frozenMirror;
-			let run;
-			return (value) => {
-				if (run === void 0) try {
-					run = instantiateFrozenDecodeMirror(m, schema, dir);
-				} catch {
-					run = dir === "decode" ? (v) => {
-						const decoded = DecodeUnsafe(nullObject(), schema, v);
-						return this.Clean ? this.Clean(decoded) : decoded;
-					} : (v) => {
-						const out = Encode(schema, v);
-						return this.Clean ? this.Clean(out) : out;
-					};
-				}
-				return run(value);
-			};
-		}
-		const dirOpt = dir === "decode" ? { decode: true } : { encode: true };
-		const captureSlot = dir === "decode" ? !slot?.startsWith("response") : !!slot?.startsWith("response");
-		if (aot && slot && Capture.isCapturing() && captureSlot) try {
-			const emitted = createMirror(schema, {
-				Compile,
-				sanitize: options?.sanitize,
-				...dirOpt,
-				emit: true
-			});
-			if (typeof emitted?.source === "string") {
-				const ext = emitted.externals;
-				if (ext?.codecs && !ext.hof && Capture.mirrorCodecs(schema, ext.codecs, dir)) {
-					let u;
-					let freezable = true;
-					if (ext.unions && ext.unions.length) {
-						u = Capture.mirrorUnions(schema, ext.unions);
-						if (!u) freezable = false;
-					}
-					if (freezable) {
-						const mirror = {
-							source: emitted.source,
-							hasExternals: true,
-							u
-						};
-						Capture.set({
-							method: aot.method,
-							path: aot.path,
-							slot
-						}, dir === "decode" ? { decodeMirror: mirror } : { encodeMirror: mirror });
-					}
-				}
-			}
-		} catch {}
-		try {
-			return createMirror(schema, {
-				Compile,
-				sanitize: options?.sanitize,
-				...dirOpt
-			});
-		} catch {}
-	}
-	Check(value) {
-		if (this.reconstructedCheck) return this.reconstructedCheck(value);
-		return this.tb.Check(value);
-	}
-	#reconstruct(options, frozen) {
-		if (!options?.aot || !options.slot || options.normalize === "typebox") return false;
-		if (!frozen?.c && !frozen?.cm) return false;
-		this.isAsync = frozen.a === 1;
-		this.hasDefault = frozen.d === 1;
-		this.hasCodec = frozen.k === 1;
-		return true;
-	}
-	#maybeCapture(options, hasRef) {
-		const aot = options?.aot;
-		const slot = options?.slot;
-		if (!aot || !slot || !Capture.isCapturing()) return;
-		if (this.hasDefault) {
-			const pre = verifyPreallocatableDefault(this.schema);
-			if (pre) Capture.set({
-				method: aot.method,
-				path: aot.path,
-				slot
-			}, {
-				precomputeSafe: true,
-				precomputedDefault: pre.pd,
-				precomputedObjectDefault: pre.pod
-			});
-		}
-		const ceNodes = collectCustomErrorNodes(this.schema, "", []);
-		if (ceNodes.length) {
-			const entries = [];
-			for (const { path, node, union } of ceNodes) {
-				if (union) continue;
-				try {
-					const cf = buildFrozenCheck(Build(node), node);
-					if (cf) entries.push({
-						path,
-						...cf
-					});
-				} catch {}
-			}
-			if (entries.length) Capture.set({
-				method: aot.method,
-				path: aot.path,
-				slot
-			}, { customErrors: entries });
-		}
-		const stringCodecs = collectStringCodecNodes(this.schema);
-		if (stringCodecs.length) {
-			const entries = [];
-			for (const { inner, open } of stringCodecs) {
-				const entry = captureInnerCodec(inner, open, options?.sanitize);
-				if (!entry) break;
-				entries.push(entry);
-			}
-			if (entries.length === stringCodecs.length) Capture.set({
-				method: aot.method,
-				path: aot.path,
-				slot
-			}, { innerCodecs: entries });
-		}
-		const build = this.tb.buildResult;
-		const cf = buildFrozenCheck(build, this.schema);
-		if (!cf) return;
-		Capture.set({
-			method: aot.method,
-			path: aot.path,
-			slot
-		}, {
-			...cf,
-			async: build.external.variables.some(isAsyncPredicate),
-			hasDefault: this.hasDefault,
-			hasCodec: this.hasCodec,
-			hasRef
-		});
-	}
-	#dropCompiledSource() {
-		const tb = this.tb;
-		if (!tb) return;
-		if (tb.evaluateResult) tb.evaluateResult.code = void 0;
-		if (tb.buildResult) tb.buildResult.functions = void 0;
-	}
-	Errors(value) {
-		return Errors(this.schema, value);
-	}
-	Decode(value) {
-		return Decode$1(this.schema, value);
-	}
-	Encode(value) {
-		return this.hasCodec ? Encode(this.schema, value) : value;
-	}
-	EncodeFrom(value, type) {
-		if (this.#isForm) {
-			if (!this.#noValidate && !this.Check(value)) throw this.#verr(value, type);
-			return value;
-		}
-		if (!this.hasCodec) {
-			if (!this.#noValidate && !this.Check(value)) throw this.#verr(value, type);
-			if (this.Clean) value = this.Clean(value);
-			return value;
-		}
-		try {
-			if (this.#encodeMirror) {
-				const out = this.#encodeMirror(value);
-				if (!this.#noValidate && !this.Check(out)) throw new ValidationError(type, out, () => this.Errors(out), this.schema);
-				return out;
-			}
-			const out = this.#noValidate ? EncodeUnsafe(nullObject(), this.schema, value) : Encode(this.schema, value);
-			return this.Clean ? this.Clean(out) : out;
-		} catch (e) {
-			if (this.#noValidate) return this.Clean ? this.Clean(value) : value;
-			if (e instanceof ValidationError) throw e;
-			if (e?.error) throw e.error;
-			if (e?.status) throw e;
-			throw new ValidationError(type, value, () => this.Errors(value), this.schema);
-		}
-	}
-	#markForm(value) {
-		if (this.#isForm && value !== null && typeof value === "object" && !("~ely-form" in value)) Object.defineProperty(value, "~ely-form", {
-			value: 1,
-			configurable: true
-		});
-	}
-	#unmarkForm(value) {
-		if (this.#isForm && value !== null && typeof value === "object" && "~ely-form" in value && Object.getOwnPropertyDescriptor(value, "~ely-form")?.configurable) delete value["~ely-form"];
-	}
-	From(value, type) {
-		return this.isAsync ? this.FromAsync(value, type) : this.FromSync(value, type);
-	}
-	#cloneSharedDefault() {
-		const value = this.#precomputedDefault;
-		if (value === null || typeof value !== "object") return value;
-		return structuredClone(value);
-	}
-	optionalBypass(value) {
-		const schema = this.schema;
-		if (!schema?.["~optional"]) return;
-		if (value === void 0 || value === null) return {
-			bypass: true,
-			value: schema["~kind"] === "Object" ? nullObject() : value
-		};
-		if (schema["~kind"] === "Object" && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return {
-			bypass: true,
-			value: nullObject()
-		};
-	}
-	async FromAsync(value, type) {
-		if (this.hasDefault) if (this.precomputeSafe) {
-			if (value === void 0 || value === null) value = this.#cloneSharedDefault();
-			else if (this.#precomputedObjectDefault !== void 0 && typeof value === "object" && !Array.isArray(value)) value = applyPrecomputed(this.#precomputedObjectDefault, value);
-		} else value = Default(this.schema, value);
-		if (this.#hasOptional) {
-			const bypass = this.optionalBypass(value);
-			if (bypass) return bypass.value;
-		}
-		if (this.#isForm) this.#markForm(value);
-		if (this.hasCodec) {
-			if (!this.#noValidate) {
-				collectFileTypeChecks();
-				const valid = this.Check(value);
-				const pendingFile = takeFileTypeChecks();
-				if (!valid) throw this.#verr(value, type);
-				if (pendingFile) await enforceFileTypeChecks(pendingFile, type, value, this.schema);
-			}
-			if (this.#decodeMirror) value = this.#decodeMirror(value);
-			else try {
-				value = DecodeUnsafe(nullObject(), this.schema, value);
-			} catch (e) {
-				if (e instanceof ValidationError) throw e;
-				if (e?.error) throw e.error;
-				if (e?.status) throw e;
-				throw new ValidationError(type, value, () => this.Errors(value), this.schema);
-			}
-		} else if (!this.#noValidate) {
-			collectFileTypeChecks();
-			const valid = this.Check(value);
-			const pendingFile = takeFileTypeChecks();
-			if (!valid) throw this.#verr(value, type);
-			if (pendingFile) await enforceFileTypeChecks(pendingFile, type, value, this.schema);
-		}
-		if (this.Clean && !this.#decodeMirror) value = this.Clean(value);
-		if (this.#isForm) this.#unmarkForm(value);
-		return value;
-	}
-	FromSync(value, type) {
-		if (this.hasDefault) if (this.precomputeSafe) {
-			if (value === void 0 || value === null) value = this.#cloneSharedDefault();
-			else if (this.#precomputedObjectDefault !== void 0 && typeof value === "object" && !Array.isArray(value)) value = applyPrecomputed(this.#precomputedObjectDefault, value);
-		} else value = Default(this.schema, value);
-		if (this.#hasOptional) {
-			const bypass = this.optionalBypass(value);
-			if (bypass) return bypass.value;
-		}
-		if (this.#isForm) this.#markForm(value);
-		if (this.hasCodec) {
-			if (!this.#noValidate && !this.Check(value)) throw this.#verr(value, type);
-			if (this.#decodeMirror) value = this.#decodeMirror(value);
-			else try {
-				value = DecodeUnsafe(nullObject(), this.schema, value);
-			} catch (e) {
-				if (e instanceof ValidationError) throw e;
-				if (e?.error) throw e.error;
-				if (e?.status) throw e;
-				throw new ValidationError(type, value, () => this.Errors(value), this.schema);
-			}
-		} else if (!this.#noValidate && !this.Check(value)) throw this.#verr(value, type);
-		if (this.Clean && !this.#decodeMirror) value = this.Clean(value);
-		if (this.#isForm) this.#unmarkForm(value);
-		return value;
-	}
-};
-const DEFAULT_CACHE_LIMIT = 1024;
-const DEFAULT_GC_TIME = 60 * 1e3;
-var TypeBoxValidatorCache = class TypeBoxValidatorCache {
-	static {
-		this.EMPTY = nullObject();
-	}
-	static {
-		this.ignoreKeys = new Set([
-			"title",
-			"description",
-			"tags",
-			"examples",
-			"defaultValue"
-		]);
-	}
-	static {
-		this.fnIds = /* @__PURE__ */ new WeakMap();
-	}
-	static {
-		this.nextFnId = 0;
-	}
-	static fnKey(fn) {
-		let id = TypeBoxValidatorCache.fnIds.get(fn);
-		if (id === void 0) {
-			id = ++TypeBoxValidatorCache.nextFnId;
-			TypeBoxValidatorCache.fnIds.set(fn, id);
-		}
-		return `<fn:${id}>`;
-	}
-	static ignoreMeta(k, v) {
-		if (TypeBoxValidatorCache.ignoreKeys.has(k)) return;
-		if (typeof v === "function") return TypeBoxValidatorCache.fnKey(v);
-		if (v && typeof v === "object" && v["~optional"] === true) {
-			const out = nullObject();
-			for (const key in v) out[key] = v[key];
-			out["~optional"] = true;
-			return out;
-		}
-		return v;
-	}
-	static #isOpaqueType(schema, seen = /* @__PURE__ */ new WeakSet()) {
-		if (!schema || typeof schema !== "object" || seen.has(schema)) return false;
-		seen.add(schema);
-		if (schema["~refine"] || schema["~elyTyp"] === ELYSIA_TYPES.NoValidate) return true;
-		const props = schema.properties;
-		if (props) {
-			for (const k in props) if (TypeBoxValidatorCache.#isOpaqueType(props[k], seen)) return true;
-		}
-		const items = schema.items;
-		if (Array.isArray(items)) {
-			for (const it of items) if (TypeBoxValidatorCache.#isOpaqueType(it, seen)) return true;
-		} else if (items && TypeBoxValidatorCache.#isOpaqueType(items, seen)) return true;
-		for (const k of [
-			"anyOf",
-			"allOf",
-			"oneOf"
-		]) {
-			const arr = schema[k];
-			if (Array.isArray(arr)) {
-				for (const x of arr) if (TypeBoxValidatorCache.#isOpaqueType(x, seen)) return true;
-			}
-		}
-		if (schema.additionalProperties && typeof schema.additionalProperties === "object" && TypeBoxValidatorCache.#isOpaqueType(schema.additionalProperties, seen)) return true;
-		if (schema.not && TypeBoxValidatorCache.#isOpaqueType(schema.not, seen)) return true;
-		const pp = schema.patternProperties;
-		if (pp) {
-			for (const k in pp) if (TypeBoxValidatorCache.#isOpaqueType(pp[k], seen)) return true;
-		}
-		return false;
-	}
-	#cache = /* @__PURE__ */ new Map();
-	#referenceCache = /* @__PURE__ */ new WeakMap();
-	#gc;
-	#gcTime;
-	#lastSchema;
-	#lastMeta;
-	#meta(schema) {
-		if (this.#lastSchema === schema && this.#lastMeta) return this.#lastMeta;
-		const special = HasCodec(schema) || TypeBoxValidatorCache.#isOpaqueType(schema);
-		const meta = {
-			special,
-			key: special ? "" : JSON.stringify(schema, TypeBoxValidatorCache.ignoreMeta)
-		};
-		this.#lastSchema = schema;
-		this.#lastMeta = meta;
-		return meta;
-	}
-	constructor(gcTime) {
-		this.#gcTime = gcTime;
-	}
-	#scheduleClear() {
-		if (isCloudflareWorker) return;
-		if (this.#gc) clearTimeout(this.#gc);
-		this.#gc = setTimeout(() => this.clear(), this.#gcTime ?? DEFAULT_GC_TIME);
-		this.#gc.unref?.();
-	}
-	get(schema, coercions = TypeBoxValidatorCache.EMPTY, normalize = "") {
-		const refBucket = this.#referenceCache.get(schema)?.get(normalize);
-		if (refBucket?.has(coercions)) return refBucket.get(coercions);
-		const meta = this.#meta(schema);
-		if (meta.special) return;
-		const key = meta.key + "\0" + normalize;
-		if (this.#cache.has(key)) {
-			const coercionsCache = this.#cache.get(key);
-			this.#cache.delete(key);
-			this.#cache.set(key, coercionsCache);
-			if (coercionsCache.has(coercions)) return coercionsCache.get(coercions);
-		}
-	}
-	#refBucket(schema) {
-		let byNormalize = this.#referenceCache.get(schema);
-		if (!byNormalize) {
-			byNormalize = /* @__PURE__ */ new Map();
-			this.#referenceCache.set(schema, byNormalize);
-		}
-		return byNormalize;
-	}
-	set(schema, coercions = TypeBoxValidatorCache.EMPTY, validator, normalize = "") {
-		this.#scheduleClear();
-		const meta = this.#meta(schema);
-		if (meta.special) {
-			const cache = (/* @__PURE__ */ new WeakMap()).set(coercions, validator);
-			this.#refBucket(schema).set(normalize, cache);
-			return;
-		}
-		const key = meta.key + "\0" + normalize;
-		if (this.#cache.has(key)) {
-			const cache = this.#cache.get(key).set(coercions, validator);
-			const byNormalize = this.#refBucket(schema);
-			if (byNormalize.has(normalize)) byNormalize.get(normalize).set(coercions, validator);
-			else byNormalize.set(normalize, cache);
-			return;
-		}
-		if (this.#cache.size >= DEFAULT_CACHE_LIMIT) {
-			const oldest = this.#cache.keys().next().value;
-			if (oldest !== void 0) this.#cache.delete(oldest);
-		}
-		const cache = (/* @__PURE__ */ new WeakMap()).set(coercions, validator);
-		this.#cache.set(key, cache);
-		this.#refBucket(schema).set(normalize, cache);
-	}
-	clear() {
-		if (this.#gc) {
-			clearTimeout(this.#gc);
-			this.#gc = void 0;
-		}
-		this.#cache.clear();
-		this.#referenceCache = /* @__PURE__ */ new WeakMap();
-		deferCoercions();
-	}
-};
-
-//#endregion
-export { TypeBoxValidator, TypeBoxValidatorCache };