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

package/dist/type/validator/index.js

@@ -0,0 +1,572 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_utils = require('../../utils.js');
+const require_error = require('../../error.js');
+const require_compile_aot = require('../../compile/aot.js');
+const require_validator_index = require('../../validator/index.js');
+const require_type_constants = require('../constants.js');
+const require_compile_utils = require('../../compile/utils.js');
+const require_type_coerce = require('../coerce.js');
+const require_type_utils = require('../utils.js');
+const require_type_elysia_file_type = require('../elysia/file-type.js');
+const require_type_validator_default_precompute = require('./default-precompute.js');
+const require_type_validator_frozen_check = require('./frozen-check.js');
+const require_type_validator_custom_error = require('./custom-error.js');
+const require_type_validator_string_codec_aot = require('./string-codec-aot.js');
+const require_type_validator_validator_cache = require('./validator-cache.js');
+let typebox_type = require("typebox/type");
+let typebox_value = require("typebox/value");
+let typebox_schema = require("typebox/schema");
+let exact_mirror = require("exact-mirror");
+exact_mirror = require_runtime.__toESM(exact_mirror);
+
+//#region src/type/validator/index.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;
+}
+function divergesFromEvaluate(node, seen) {
+	if (!node || typeof node !== "object" || seen.has(node)) return false;
+	seen.add(node);
+	for (const k in node) {
+		if (!Object.hasOwn(node, k)) return true;
+		const v = node[k];
+		if (typeof v === "object" && v && divergesFromEvaluate(v, seen)) return true;
+	}
+	return false;
+}
+const SIMPLE_OBJECT_KEYS = new Set([
+	"type",
+	"properties",
+	"required"
+]);
+function shallowMergeObjects(members) {
+	const properties = {};
+	let required;
+	for (const m of members) {
+		if (!m || m["~kind"] !== "Object" || m["~elyTyp"] !== void 0 || !m.properties || divergesFromEvaluate(m, /* @__PURE__ */ new WeakSet())) return null;
+		for (const k of Object.keys(m)) if (!SIMPLE_OBJECT_KEYS.has(k)) return null;
+		for (const k in m.properties) {
+			if (k in properties) return null;
+			properties[k] = m.properties[k];
+		}
+		if (Array.isArray(m.required) && m.required.length) (required ??= []).push(...m.required);
+	}
+	const out = {
+		type: "object",
+		properties
+	};
+	if (required) out.required = required;
+	return Object.defineProperty(out, "~kind", {
+		value: "Object",
+		enumerable: false
+	});
+}
+let inlineRefId = 0;
+const isAsyncPredicate = (v) => Array.isArray(v) ? v.some((x) => typeof x.check === "function" ? require_compile_utils.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 require_error.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 externalsShape(schema) {
+	let out = "";
+	for (const e of require_compile_aot.collectExternals(schema)) out += e instanceof RegExp ? "r" : typeof e === "function" ? "f" : "v";
+	return out;
+}
+function sourceOnlyValidator(schema) {
+	const buildResult = (0, typebox_schema.Build)(schema);
+	let full;
+	return new Proxy({}, { get(_, prop) {
+		if (prop === "buildResult") return buildResult;
+		const f = full ??= (0, typebox_schema.Compile)(schema);
+		const value = f[prop];
+		return typeof value === "function" ? value.bind(f) : value;
+	} });
+}
+var TypeBoxValidator = class extends require_validator_index.Validator {
+	#decodeMirror;
+	#encodeMirror;
+	#findCustomError;
+	#defaultFastPath;
+	#noValidate;
+	#isForm;
+	#hasOptional;
+	constructor(schema, options, name, isIntersectable) {
+		super();
+		this.precomputeSafe = false;
+		this.#isForm = false;
+		this.#hasOptional = false;
+		if (isIntersectable) {
+			const members = [schema, ...options.schemas];
+			schema = shallowMergeObjects(members) ?? (0, typebox_type.Evaluate)((0, typebox_type.Intersect)(members));
+		}
+		const originalElyTyp = schema?.["~elyTyp"];
+		const frozen = options?.aot && options.slot ? require_compile_aot.Compiled.getValidator(options.aot.method, options.aot.path, options.slot) : void 0;
+		let schemaHasRef = false;
+		if (name && options?.models) schema = moduleCache.getOrInsertComputed(options.models, () => (0, typebox_type.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 = (0, typebox_type.Module)({
+					...options.models,
+					[id]: schema
+				})[id];
+			}
+		}
+		const isFrozen = this.#reconstruct(options, frozen);
+		this.schema = isFrozen && frozen.cp ? require_type_coerce.buildCoercedFromPlan(schema, frozen.cp) : isFrozen && !this.hasCodec ? schema : require_type_coerce.applyCoercions(schema, options?.coerces);
+		if (options?.normalize === false && options.slot !== "headers" && options.slot !== "cookie") this.schema = require_type_coerce.nonAdditionalProperties(this.schema);
+		if (!isFrozen) {
+			const capturing = require_compile_aot.Capture.isCapturing();
+			this.tb = capturing ? sourceOnlyValidator(this.schema) : (0, typebox_schema.Compile)(this.schema);
+			this.hasCodec = (0, typebox_value.HasCodec)(this.schema);
+			this.isAsync = this.tb.buildResult.external.variables.some(isAsyncPredicate) ?? false;
+			this.hasDefault = require_type_utils.hasProperty("default", this.schema);
+			if (capturing) this.#maybeCapture(options, schemaHasRef, schema);
+			else this.#dropCompiledSource();
+		}
+		if (frozen?.ps === 1) {
+			const objectTemplate = frozen.pod !== void 0 ? Object.freeze(frozen.pod) : void 0;
+			this.precomputeSafe = true;
+			this.#defaultFastPath = {
+				value: frozen.pd,
+				appliesToNull: frozen.pn === 1,
+				objectTemplate,
+				clone: frozen.dc,
+				merge: frozen.pm
+			};
+		} else {
+			const defaults = this.hasDefault ? require_type_validator_default_precompute.verifyPreallocatableDefault(this.schema, require_compile_aot.Capture.isCapturing()) : void 0;
+			if (defaults) {
+				this.precomputeSafe = true;
+				const objectTemplate = defaults.pod !== void 0 ? Object.freeze(defaults.pod) : void 0;
+				this.#defaultFastPath = {
+					value: defaults.pd,
+					appliesToNull: defaults.pn,
+					objectTemplate,
+					clone: defaults.pd !== void 0 ? require_type_validator_default_precompute.createDefaultCloner(defaults.pd) : void 0,
+					merge: defaults.ms ? require_type_validator_default_precompute.createMergerFromSource(defaults.ms) : objectTemplate !== void 0 ? require_type_validator_default_precompute.createObjectDefaultMerger(objectTemplate) : void 0
+				};
+			} else {
+				this.precomputeSafe = false;
+				this.#defaultFastPath = void 0;
+			}
+		}
+		this.#noValidate = originalElyTyp === require_type_constants.ELYSIA_TYPES.NoValidate;
+		this.#isForm = originalElyTyp === require_type_constants.ELYSIA_TYPES.Form;
+		this.#hasOptional = !!this.schema?.["~optional"];
+		if (frozen?.ic) require_type_validator_string_codec_aot.reconstructInnerCodecs(frozen.ic, this.schema);
+		if (isFrozen && frozen.cm) {
+			const both = require_compile_aot.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 ? require_compile_aot.collectExternals(this.schema) : require_compile_aot.EMPTY_EXTERNALS);
+			try {
+				this.Clean = options?.normalize === false ? void 0 : options?.normalize === "typebox" ? (value) => (0, 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) => (0, typebox_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 = require_type_validator_custom_error.buildFindCustomError(this.schema, frozen);
+	}
+	#error(value, type) {
+		return new require_error.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 = require_compile_aot.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 (require_compile_aot.Capture.isCapturing()) try {
+				const emitted = (0, exact_mirror.default)(schema, {
+					Compile: typebox_schema.Compile,
+					sanitize: options?.sanitize,
+					emit: true
+				});
+				if (typeof emitted?.source === "string") {
+					const ext = emitted.externals;
+					if (!ext) require_compile_aot.Capture.set({
+						method: aot.method,
+						path: aot.path,
+						slot
+					}, { mirror: {
+						source: emitted.source,
+						hasExternals: false
+					} });
+					else if (ext.unions && !ext.hof) {
+						const u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
+						if (u) require_compile_aot.Capture.set({
+							method: aot.method,
+							path: aot.path,
+							slot
+						}, { mirror: {
+							source: emitted.source,
+							hasExternals: true,
+							u
+						} });
+					}
+				}
+			} catch {}
+		}
+		return (0, exact_mirror.default)(schema, {
+			Compile: typebox_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 = require_compile_aot.instantiateFrozenDecodeMirror(m, schema, dir);
+				} catch {
+					run = dir === "decode" ? (v) => {
+						const decoded = (0, typebox_value.DecodeUnsafe)(require_utils.nullObject(), schema, v);
+						return this.Clean ? this.Clean(decoded) : decoded;
+					} : (v) => {
+						const out = (0, typebox_value.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 && require_compile_aot.Capture.isCapturing() && captureSlot) try {
+			const emitted = (0, exact_mirror.default)(schema, {
+				Compile: typebox_schema.Compile,
+				sanitize: options?.sanitize,
+				...dirOpt,
+				emit: true
+			});
+			if (typeof emitted?.source === "string") {
+				const ext = emitted.externals;
+				if (ext?.codecs && !ext.hof && require_compile_aot.Capture.mirrorCodecs(schema, ext.codecs, dir)) {
+					let u;
+					let freezable = true;
+					if (ext.unions && ext.unions.length) {
+						u = require_compile_aot.Capture.mirrorUnions(schema, ext.unions);
+						if (!u) freezable = false;
+					}
+					if (freezable) {
+						const mirror = {
+							source: emitted.source,
+							hasExternals: true,
+							u
+						};
+						require_compile_aot.Capture.set({
+							method: aot.method,
+							path: aot.path,
+							slot
+						}, dir === "decode" ? { decodeMirror: mirror } : { encodeMirror: mirror });
+					}
+				}
+			}
+		} catch {}
+		try {
+			return (0, exact_mirror.default)(schema, {
+				Compile: typebox_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, originalSchema) {
+		const aot = options?.aot;
+		const slot = options?.slot;
+		if (!aot || !slot || !require_compile_aot.Capture.isCapturing()) return;
+		if (this.hasCodec && !hasRef && options.coerces && options.normalize !== false && options.normalize !== "typebox") {
+			const plan = require_type_coerce.captureCoercePlan(originalSchema, this.schema);
+			if (plan && externalsShape(require_type_coerce.buildCoercedFromPlan(originalSchema, plan)) === externalsShape(this.schema)) require_compile_aot.Capture.set({
+				method: aot.method,
+				path: aot.path,
+				slot
+			}, { coercePlan: plan });
+		}
+		const defaultFastPathCapture = {
+			precomputeSafe: void 0,
+			precomputedDefault: void 0,
+			precomputeNull: void 0,
+			precomputedObjectDefault: void 0,
+			defaultCloner: void 0,
+			objectDefaultMerger: void 0
+		};
+		if (this.hasDefault) {
+			const defaults = require_type_validator_default_precompute.verifyPreallocatableDefault(this.schema);
+			if (defaults) {
+				defaultFastPathCapture.precomputeSafe = true;
+				defaultFastPathCapture.precomputedDefault = defaults.pd;
+				defaultFastPathCapture.precomputeNull = defaults.pn;
+				defaultFastPathCapture.precomputedObjectDefault = defaults.pod;
+				defaultFastPathCapture.defaultCloner = defaults.pd !== void 0 ? require_type_validator_default_precompute.buildDefaultClonerSource(defaults.pd) : void 0;
+				defaultFastPathCapture.objectDefaultMerger = defaults.ms ?? (defaults.pod !== void 0 ? require_type_validator_default_precompute.buildObjectDefaultMergeSource(defaults.pod) : void 0);
+			}
+		}
+		require_compile_aot.Capture.set({
+			method: aot.method,
+			path: aot.path,
+			slot
+		}, defaultFastPathCapture);
+		const customErrors = require_type_validator_custom_error.captureCustomErrors(this.schema);
+		if (customErrors) require_compile_aot.Capture.set({
+			method: aot.method,
+			path: aot.path,
+			slot
+		}, { customErrors });
+		const innerCodecs = require_type_validator_string_codec_aot.captureStringCodecEntries(this.schema, options?.sanitize);
+		if (innerCodecs) require_compile_aot.Capture.set({
+			method: aot.method,
+			path: aot.path,
+			slot
+		}, { innerCodecs });
+		const build = this.tb.buildResult;
+		const cf = require_type_validator_frozen_check.buildFrozenCheck(build, this.schema);
+		if (!cf) return;
+		require_compile_aot.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 (0, typebox_value.Errors)(this.schema, value);
+	}
+	Decode(value) {
+		return (0, typebox_value.Decode)(this.schema, value);
+	}
+	Encode(value) {
+		return this.hasCodec ? (0, typebox_value.Encode)(this.schema, value) : value;
+	}
+	EncodeFrom(value, type) {
+		if (this.#isForm) {
+			if (!this.#noValidate && !this.Check(value)) throw this.#error(value, type);
+			return value;
+		}
+		if (!this.hasCodec) {
+			if (!this.#noValidate && !this.Check(value)) throw this.#error(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 require_error.ValidationError(type, out, () => this.Errors(out), this.schema);
+				return out;
+			}
+			const out = this.#noValidate ? (0, typebox_value.EncodeUnsafe)(require_utils.nullObject(), this.schema, value) : (0, typebox_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 require_error.ValidationError) throw e;
+			if (e?.error) throw e.error;
+			if (e?.status) throw e;
+			throw new require_error.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 defaults = this.#defaultFastPath;
+		const value = defaults.value;
+		if (value === null || typeof value !== "object") return value;
+		return defaults.clone ? defaults.clone() : structuredClone(value);
+	}
+	#applyPrecomputedObjectDefault(value) {
+		const defaults = this.#defaultFastPath;
+		if (defaults.merge) return defaults.merge(value);
+		if (Array.isArray(value)) return value;
+		return require_type_validator_default_precompute.applyPrecomputed(defaults.objectTemplate, value);
+	}
+	optionalBypass(value) {
+		const schema = this.schema;
+		if (!schema?.["~optional"]) return;
+		if (value === void 0 || value === null) return {
+			bypass: true,
+			value: schema["~kind"] === "Object" ? require_utils.nullObject() : value
+		};
+		if (schema["~kind"] === "Object" && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return {
+			bypass: true,
+			value: require_utils.nullObject()
+		};
+	}
+	async FromAsync(value, type) {
+		if (this.hasDefault) {
+			const defaults = this.#defaultFastPath;
+			if (defaults) {
+				if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
+				else if (value !== null && typeof value === "object" && (defaults.merge !== void 0 || defaults.objectTemplate !== void 0)) value = this.#applyPrecomputedObjectDefault(value);
+			} else value = (0, typebox_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) {
+				require_type_elysia_file_type.collectFileTypeChecks();
+				const valid = this.Check(value);
+				const pendingFile = require_type_elysia_file_type.takeFileTypeChecks();
+				if (!valid) throw this.#error(value, type);
+				if (pendingFile) await enforceFileTypeChecks(pendingFile, type, value, this.schema);
+			}
+			if (this.#decodeMirror) value = this.#decodeMirror(value);
+			else try {
+				value = (0, typebox_value.DecodeUnsafe)(require_utils.nullObject(), this.schema, value);
+			} catch (e) {
+				if (e instanceof require_error.ValidationError) throw e;
+				if (e?.error) throw e.error;
+				if (e?.status) throw e;
+				throw new require_error.ValidationError(type, value, () => this.Errors(value), this.schema);
+			}
+		} else if (!this.#noValidate) {
+			require_type_elysia_file_type.collectFileTypeChecks();
+			const valid = this.Check(value);
+			const pendingFile = require_type_elysia_file_type.takeFileTypeChecks();
+			if (!valid) throw this.#error(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) {
+			const defaults = this.#defaultFastPath;
+			if (defaults) {
+				if (value === void 0 || value === null && defaults.appliesToNull) value = this.#cloneSharedDefault();
+				else if (value !== null && typeof value === "object" && (defaults.merge !== void 0 || defaults.objectTemplate !== void 0)) value = this.#applyPrecomputedObjectDefault(value);
+			} else value = (0, typebox_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.#error(value, type);
+			if (this.#decodeMirror) value = this.#decodeMirror(value);
+			else try {
+				value = (0, typebox_value.DecodeUnsafe)(require_utils.nullObject(), this.schema, value);
+			} catch (e) {
+				if (e instanceof require_error.ValidationError) throw e;
+				if (e?.error) throw e.error;
+				if (e?.status) throw e;
+				throw new require_error.ValidationError(type, value, () => this.Errors(value), this.schema);
+			}
+		} else if (!this.#noValidate && !this.Check(value)) throw this.#error(value, type);
+		if (this.Clean && !this.#decodeMirror) value = this.Clean(value);
+		if (this.#isForm) this.#unmarkForm(value);
+		return value;
+	}
+};
+
+//#endregion
+exports.TypeBoxValidator = TypeBoxValidator;
+exports.TypeBoxValidatorCache = require_type_validator_validator_cache.TypeBoxValidatorCache;
+exports.shallowMergeObjects = shallowMergeObjects;