elysia 1.4.28 → 2.0.0-beta.0

package/dist/type/validator/custom-error.mjs

@@ -0,0 +1,188 @@
+import { nullObject } from "../../utils.mjs";
+import { subValueAt } from "../../error.mjs";
+import { EMPTY_EXTERNALS, reconstruct } from "../../compile/aot.mjs";
+import { buildFrozenCheck } from "./frozen-check.mjs";
+import { Build, Compile } from "typebox/schema";
+
+//#region src/type/validator/custom-error.ts
+function encodePointer(segments) {
+	let out = "";
+	for (const s of segments) out += "/" + s.replace(/~/g, "~0").replace(/\//g, "~1");
+	return out;
+}
+function collectCustomErrorNodes(schema, segments, out, seen, union) {
+	if (!schema || typeof schema !== "object") return out;
+	if (seen.has(schema)) return out;
+	seen.add(schema);
+	if (schema.error !== void 0) out.push({
+		path: encodePointer(segments),
+		node: schema,
+		segments,
+		union
+	});
+	if (schema.properties) for (const k in schema.properties) collectCustomErrorNodes(schema.properties[k], [...segments, k], out, seen, union);
+	const items = schema.items;
+	if (Array.isArray(items)) for (let i = 0; i < items.length; i++) collectCustomErrorNodes(items[i], [...segments, String(i)], out, seen, union);
+	else if (items && typeof items === "object") {
+		const inner = [];
+		collectCustomErrorNodes(items, [], inner, seen, union);
+		for (const child of inner) out.push({
+			path: encodePointer(segments) + "/[]" + child.path,
+			node: child.node,
+			segments,
+			each: { itemSegments: child.segments },
+			union: child.union
+		});
+	}
+	const branches = schema.anyOf ?? schema.oneOf;
+	if (Array.isArray(branches)) for (let i = 0; i < branches.length; i++) collectCustomErrorNodes(branches[i], segments, out, seen, {
+		node: schema,
+		segments,
+		branchIndex: i
+	});
+	seen.delete(schema);
+	return out;
+}
+const literalOf = (propSchema) => {
+	if (!propSchema || typeof propSchema !== "object") return;
+	if ("const" in propSchema) return { value: propSchema.const };
+	if (Array.isArray(propSchema.enum) && propSchema.enum.length === 1) return { value: propSchema.enum[0] };
+};
+function computeDiscriminators(branches) {
+	let candidates;
+	for (const branch of branches) {
+		if (!branch || !branch.properties) return;
+		const keys = /* @__PURE__ */ new Set();
+		for (const k in branch.properties) if (literalOf(branch.properties[k])) keys.add(k);
+		if (!keys.size) return;
+		if (!candidates) candidates = keys;
+		else for (const c of [...candidates]) if (!keys.has(c)) candidates.delete(c);
+		if (!candidates.size) return;
+	}
+	if (!candidates || !candidates.size) return;
+	const perBranch = branches.map(nullObject);
+	let hasDisambiguating = false;
+	for (const key of candidates) {
+		const seenValues = [];
+		for (let i = 0; i < branches.length; i++) {
+			const lit = literalOf(branches[i].properties[key]);
+			perBranch[i][key] = lit.value;
+			seenValues.push(lit.value);
+		}
+		if (new Set(seenValues).size === branches.length) hasDisambiguating = true;
+	}
+	return hasDisambiguating ? perBranch : void 0;
+}
+function buildFindCustomError(schema, frozen) {
+	const nodes = collectCustomErrorNodes(schema, [], [], /* @__PURE__ */ new WeakSet());
+	if (!nodes.length) return;
+	const frozenByPath = frozen?.ce ? new Map(frozen.ce.map((e) => [e.p, e])) : void 0;
+	const unionCheckCache = /* @__PURE__ */ new WeakMap();
+	const discriminatorCache = /* @__PURE__ */ new WeakMap();
+	const compileUnion = (node) => {
+		const cached = unionCheckCache.get(node);
+		if (cached) return cached;
+		try {
+			const uc = Compile(node);
+			const fn = (v) => uc.Check(v);
+			unionCheckCache.set(node, fn);
+			return fn;
+		} catch {
+			return;
+		}
+	};
+	const discriminatorsOf = (node, branches) => {
+		if (discriminatorCache.has(node)) return discriminatorCache.get(node) ?? void 0;
+		const d = computeDiscriminators(branches) ?? null;
+		discriminatorCache.set(node, d);
+		return d ?? void 0;
+	};
+	const checks = [];
+	for (const { path, node, each, segments, union } of nodes) {
+		let check;
+		const fe = union ? void 0 : frozenByPath?.get(path);
+		if (fe) try {
+			check = fe.c(fe.e ? reconstruct().collectExternals(node) : EMPTY_EXTERNALS);
+		} catch {}
+		else try {
+			const c = Compile(node);
+			check = (v) => c.Check(v);
+		} catch {}
+		if (!check) continue;
+		if (each) {
+			const leafCheck = check;
+			const itemSegments = each.itemSegments;
+			check = (v) => !Array.isArray(v) || v.every((x) => leafCheck(subValueAt(x, itemSegments)));
+		}
+		let gate;
+		if (union) {
+			const branches = union.node.anyOf ?? union.node.oneOf ?? [];
+			const discriminators = discriminatorsOf(union.node, branches);
+			if (!discriminators) gate = () => true;
+			else {
+				const unionCheck = compileUnion(union.node);
+				if (!unionCheck) continue;
+				const unionSegments = union.segments;
+				const branchIndex = union.branchIndex;
+				gate = (root) => {
+					const unionValue = subValueAt(root, unionSegments);
+					if (unionCheck(unionValue)) return true;
+					if (unionValue === null || typeof unionValue !== "object") return true;
+					let matches = 0;
+					let selected = -1;
+					for (let i = 0; i < discriminators.length; i++) {
+						const req = discriminators[i];
+						let ok = true;
+						for (const k in req) if (unionValue[k] !== req[k]) {
+							ok = false;
+							break;
+						}
+						if (ok) {
+							matches++;
+							selected = i;
+						}
+					}
+					return !(matches === 1 && selected === branchIndex);
+				};
+			}
+		}
+		checks.push({
+			segments,
+			each,
+			check,
+			gate,
+			path,
+			error: node.error
+		});
+	}
+	if (!checks.length) return;
+	checks.sort((a, b) => b.segments.length - a.segments.length || 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.segments))) return {
+				instancePath: c.path,
+				error: c.error
+			};
+		}
+	};
+}
+function captureCustomErrors(schema) {
+	const ceNodes = collectCustomErrorNodes(schema, [], [], /* @__PURE__ */ new WeakSet());
+	if (!ceNodes.length) return;
+	const entries = [];
+	for (const { path, node, union, each } of ceNodes) {
+		if (union || each) continue;
+		try {
+			const cf = buildFrozenCheck(Build(node), node);
+			if (cf) entries.push({
+				path,
+				...cf
+			});
+		} catch {}
+	}
+	return entries.length ? entries : void 0;
+}
+
+//#endregion
+export { buildFindCustomError, captureCustomErrors };

package/dist/type/validator/default-precompute.d.ts

@@ -0,0 +1,26 @@
+import { TSchema } from "typebox/type";
+
+//#region src/type/validator/default-precompute.d.ts
+type DefaultCloner = () => unknown;
+type ObjectDefaultMerger = (value: Record<string, unknown>) => Record<string, unknown>;
+declare function applyPrecomputed(defaults: Record<string, unknown>, value: Record<string, unknown>): Record<string, unknown>;
+declare function isEmittable(v: unknown, seen: Set<unknown>, top?: boolean): boolean;
+declare function buildDefaultClonerSource(value: unknown): string | undefined;
+declare function buildObjectDefaultMergeSource(defaults: Record<string, unknown>): string | undefined;
+declare function createDefaultCloner(value: unknown): DefaultCloner | undefined;
+declare function createObjectDefaultMerger(defaults: Record<string, unknown>): ObjectDefaultMerger | undefined;
+declare function createMergerFromSource(source: string): ((value: any) => any) | undefined;
+interface DefaultProbeImpl {
+  validateMergeSource(schema: TSchema, source: string): boolean;
+  validateObjectDefault(schema: TSchema, pod: Record<string, unknown>): boolean;
+}
+declare function setDefaultProbeImpl(impl: DefaultProbeImpl): void;
+declare function canonical(v: unknown): string;
+declare function verifyPreallocatableDefault(schema: TSchema, validate?: boolean): {
+  pd: unknown;
+  pn: boolean;
+  pod: Record<string, unknown> | undefined;
+  ms: string | undefined;
+} | undefined;
+//#endregion
+export { DefaultProbeImpl, applyPrecomputed, buildDefaultClonerSource, buildObjectDefaultMergeSource, canonical, createDefaultCloner, createMergerFromSource, createObjectDefaultMerger, isEmittable, setDefaultProbeImpl, verifyPreallocatableDefault };

package/dist/type/validator/default-precompute.js

@@ -0,0 +1,432 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_constants = require('../../constants.js');
+const require_utils = require('../../utils.js');
+let typebox_value = require("typebox/value");
+
+//#region src/type/validator/default-precompute.ts
+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 key in schema.properties) if (Object.hasOwn(schema.properties, key) && !isPrecomputeSafe(schema.properties[key], 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 key in schema.patternProperties) if (Object.hasOwn(schema.patternProperties, key) && !isPrecomputeSafe(schema.patternProperties[key], 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 = require_utils.nullObject();
+	for (const k in defaults) {
+		const d = defaults[k];
+		const v = value[k];
+		if (v === void 0) out[k] = d !== null && typeof d === "object" ? structuredClone(d) : d;
+		else if (!Object.hasOwn(value, k)) out[k] = v;
+		else out[k] = 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 hasUnemittableDefaultValue(node) {
+	if (!node || typeof node !== "object") return false;
+	if ("default" in node && !isEmittable(node.default, /* @__PURE__ */ new Set(), true)) return true;
+	return childSchemaSome(node, hasUnemittableDefaultValue);
+}
+function containsRefLike(node, seen = /* @__PURE__ */ new WeakSet()) {
+	if (!node || typeof node !== "object" || seen.has(node)) return false;
+	seen.add(node);
+	if (node.$ref !== void 0 || node["~kind"] === "Ref" || node["~kind"] === "This" || node["~kind"] === "Cyclic") return true;
+	return childSchemaSome(node, (child) => containsRefLike(child, seen));
+}
+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)) return bad = 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 emittableObjectKeys(v) {
+	if (Object.getOwnPropertySymbols(v).length) return;
+	const keys = Object.keys(v);
+	if (Object.getOwnPropertyNames(v).length !== keys.length) return;
+	for (const k of keys) {
+		const descriptor = Object.getOwnPropertyDescriptor(v, k);
+		if (!descriptor || descriptor.get || descriptor.set || !descriptor.enumerable) return;
+	}
+	return keys;
+}
+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)) {
+		if (Object.getOwnPropertySymbols(v).length) ok = false;
+		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 {
+			const keys = emittableObjectKeys(v);
+			if (!keys) ok = false;
+			else for (const k of keys) {
+				if (require_constants.dangerousKeys.has(k)) {
+					ok = false;
+					break;
+				}
+				if (!isEmittable(v[k], seen)) {
+					ok = false;
+					break;
+				}
+			}
+		}
+	}
+	seen.delete(v);
+	return ok;
+}
+function cloneExpression(v) {
+	if (v === void 0) return "undefined";
+	if (v === null) return "null";
+	const t = typeof v;
+	if (t === "number" || t === "string" || t === "boolean") return JSON.stringify(v);
+	if (t !== "object") return;
+	if (Array.isArray(v)) {
+		if (Object.getOwnPropertySymbols(v).length) return;
+		const values = [];
+		for (const x of v) {
+			const value = cloneExpression(x);
+			if (value === void 0) return;
+			values.push(value);
+		}
+		return "[" + values.join(",") + "]";
+	}
+	const proto = Object.getPrototypeOf(v);
+	if (proto !== Object.prototype && proto !== null) return;
+	const keys = emittableObjectKeys(v);
+	if (!keys) return;
+	const entries = [];
+	for (const k of keys) {
+		if (require_constants.dangerousKeys.has(k)) return;
+		const value = cloneExpression(v[k]);
+		if (value === void 0) return;
+		entries.push(JSON.stringify(k) + ":" + value);
+	}
+	return "{" + entries.join(",") + "}";
+}
+function buildDefaultClonerSource(value) {
+	if (!isEmittable(value, /* @__PURE__ */ new Set(), true)) return;
+	const expression = cloneExpression(value);
+	if (expression === void 0) return;
+	return `function(){return ${expression}}`;
+}
+function buildObjectMergeFunction(defaults, helpers) {
+	const name = `_m${helpers.length}`;
+	helpers.push("");
+	const keys = Object.keys(defaults);
+	const guard = [];
+	let body = "if(v===null||typeof v!=='object'||Array.isArray(v))return v;const out=Object.create(null);let x;";
+	for (const key of keys) {
+		const access = `v[${JSON.stringify(key)}]`;
+		const write = `out[${JSON.stringify(key)}]`;
+		const d = defaults[key];
+		const value = cloneExpression(d);
+		if (value === void 0) return;
+		body += `x=${access};`;
+		if (d !== null && typeof d === "object") {
+			if (Array.isArray(d)) {
+				body += `if(x===undefined)${write}=${value};else ${write}=x;`;
+				guard.push(`${access}===undefined`);
+				continue;
+			}
+			const nested = buildObjectMergeFunction(d, helpers);
+			if (!nested) return;
+			body += `if(x===undefined)${write}=${value};else if(x&&typeof x==='object'&&!Array.isArray(x))${write}=${nested}(x);else ${write}=x;`;
+			guard.push(`(${access}===undefined||(typeof ${access}==='object'&&${access}!==null&&!Array.isArray(${access})&&${nested}(${access})!==${access}))`);
+		} else {
+			body += `${write}=x===undefined?${value}:x;`;
+			guard.push(`${access}===undefined`);
+		}
+	}
+	body += "for(const k in v){x=v[k];if(x!==undefined";
+	for (const key of keys) body += `&&k!==${JSON.stringify(key)}`;
+	body += ")out[k]=x}return out";
+	const fastPath = guard.length ? `if(v!==null&&typeof v==='object'&&!Array.isArray(v)&&!(${guard.join("||")}))return v;` : "";
+	helpers[+name.slice(2)] = `function ${name}(v){${fastPath}${body}}`;
+	return name;
+}
+function buildObjectDefaultMergeSource(defaults) {
+	if (!isEmittable(defaults, /* @__PURE__ */ new Set(), true)) return;
+	const helpers = [];
+	const root = buildObjectMergeFunction(defaults, helpers);
+	if (!root) return;
+	return `(function(){${helpers.join(";")};return ${root}})()`;
+}
+function fromSource(source) {
+	try {
+		return Function(`return ${source}`)();
+	} catch {
+		return;
+	}
+}
+function createDefaultCloner(value) {
+	const source = buildDefaultClonerSource(value);
+	return source ? fromSource(source) : void 0;
+}
+function createObjectDefaultMerger(defaults) {
+	const source = buildObjectDefaultMergeSource(defaults);
+	return source ? fromSource(source) : void 0;
+}
+function createMergerFromSource(source) {
+	return fromSource(source);
+}
+function mergeCategory(node) {
+	if (!node || typeof node !== "object") return "identity";
+	if (!subtreeHasDefault(node)) return "identity";
+	if (node["~codec"] || node["~refine"]) return "bail";
+	const kind = node["~kind"];
+	if (kind === "Union" || kind === "Intersect" || kind === "Ref" || kind === "This" || kind === "Cyclic") return "bail";
+	if (kind === "Object" || node.type === "object") return "object";
+	if ((kind === "Array" || node.type === "array") && node.items) return !Array.isArray(node.items) && subtreeHasDefault(node.items) ? "array" : "identity";
+	return "identity";
+}
+function presentExpr(child, isObject, varName) {
+	if (child === "") return varName;
+	return isObject ? `(${varName}!==null&&typeof ${varName}==='object'&&!Array.isArray(${varName})?${child}(${varName}):${varName})` : `(Array.isArray(${varName})?${child}(${varName}):${varName})`;
+}
+function mergeExpression(schema, varName, helpers, memo) {
+	const full = (0, typebox_value.Default)(schema, void 0);
+	const child = emitMerger(schema, helpers, memo);
+	if (child === void 0) return;
+	const absent = full === void 0 ? void 0 : cloneExpression(full);
+	if (full !== void 0 && absent === void 0) return;
+	const isObject = mergeCategory(schema) === "object";
+	return {
+		absent,
+		present: presentExpr(child, isObject, varName),
+		child,
+		isObject
+	};
+}
+function emitMerger(node, helpers, memo = /* @__PURE__ */ new WeakMap()) {
+	if (memo.has(node)) return memo.get(node);
+	const category = mergeCategory(node);
+	if (category === "identity") return "";
+	if (category === "bail") return;
+	const name = `_d${helpers.length}`;
+	helpers.push("");
+	memo.set(node, name);
+	if (category === "object") {
+		const props = node.properties ?? require_utils.nullObject();
+		const handled = [];
+		const typeGuard = "if(v===null||typeof v!=='object'||Array.isArray(v))return v;";
+		let tempDecls = "let x;";
+		const guard = [];
+		let mergeBody = "const out=Object.create(null);";
+		let tempCount = 0;
+		for (const key in props) {
+			if (!Object.hasOwn(props, key)) continue;
+			const ps = props[key];
+			if (!subtreeHasDefault(ps)) continue;
+			if (require_constants.dangerousKeys.has(key)) return;
+			const expr = mergeExpression(ps, "x", helpers, memo);
+			if (!expr) return;
+			handled.push(key);
+			const access = JSON.stringify(key);
+			const vk = `v[${access}]`;
+			const absentTest = expr.absent === void 0 ? void 0 : `${vk}===undefined`;
+			if (expr.child !== "") {
+				const tmp = `_t${tempCount++}`;
+				const typeCheck = expr.isObject ? `${vk}!==null&&typeof ${vk}==='object'&&!Array.isArray(${vk})` : `Array.isArray(${vk})`;
+				tempDecls += `let ${tmp}=${typeCheck}?${expr.child}(${vk}):${vk};`;
+				const test = [absentTest, `(${vk}!==undefined&&${tmp}!==${vk})`].filter(Boolean).join("||");
+				if (test) guard.push(test);
+				mergeBody += expr.absent === void 0 ? `if(${vk}!==undefined)out[${access}]=${tmp};` : `out[${access}]=${vk}===undefined?${expr.absent}:${tmp};`;
+			} else {
+				mergeBody += `x=${vk};`;
+				mergeBody += expr.absent === void 0 ? `if(x!==undefined)out[${access}]=${expr.present};` : `out[${access}]=x===undefined?${expr.absent}:${expr.present};`;
+				if (absentTest) guard.push(absentTest);
+			}
+		}
+		if (!handled.length) {
+			helpers.pop();
+			return "";
+		}
+		mergeBody += "for(const k in v){x=v[k];if(x!==undefined";
+		for (const key of handled) mergeBody += `&&k!==${JSON.stringify(key)}`;
+		mergeBody += ")out[k]=x}return out";
+		const fastPath = guard.length ? `if(!(${guard.join("||")}))return v;` : "";
+		helpers[+name.slice(2)] = `function ${name}(v){${typeGuard}${tempDecls}${fastPath}${mergeBody}}`;
+		return name;
+	}
+	const expr = mergeExpression(node.items, "e", helpers, memo);
+	if (!expr) return;
+	if (expr.absent === void 0 && expr.present === "e") {
+		helpers.pop();
+		return "";
+	}
+	const assign = expr.absent === void 0 ? `e===undefined?undefined:${expr.present}` : `e===undefined?${expr.absent}:${expr.present}`;
+	helpers[+name.slice(2)] = `function ${name}(v){if(!Array.isArray(v))return v;const o=new Array(v.length);let e;for(let i=0;i<v.length;i++){e=v[i];o[i]=${assign}}return o}`;
+	return name;
+}
+function buildMergeSource(schema) {
+	const category = mergeCategory(schema);
+	if (category !== "object" && category !== "array") return;
+	const helpers = [];
+	const root = emitMerger(schema, helpers, /* @__PURE__ */ new WeakMap());
+	if (!root) return;
+	return `(function(){${helpers.join(";")};return ${root}})()`;
+}
+let probeImpl;
+function setDefaultProbeImpl(impl) {
+	probeImpl = impl;
+}
+function probe() {
+	if (!probeImpl) throw new Error("[Elysia] validating a preallocatable default requires the build-only AOT capture module (src/compile/aot-capture)");
+	return probeImpl;
+}
+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, validate = true) {
+	if (hasUnemittableDefaultValue(schema)) return;
+	let pd;
+	let podRaw;
+	try {
+		pd = (0, typebox_value.Default)(schema, void 0);
+		podRaw = (0, typebox_value.Default)(schema, require_utils.nullObject());
+	} catch {
+		return;
+	}
+	const s = schema;
+	const rootIsObject = s.type === "object" || s["~kind"] === "Object";
+	const pod = rootIsObject && podRaw && typeof podRaw === "object" && !Array.isArray(podRaw) && Object.keys(podRaw).length !== 0 ? podRaw : void 0;
+	if (containsRefLike(schema)) return;
+	if (!isEmittable(pd, /* @__PURE__ */ new Set(), true) || pod !== void 0 && !isEmittable(pod, /* @__PURE__ */ new Set(), true)) return;
+	const nullDefault = isPrecomputeSafe(schema);
+	let ms = buildMergeSource(schema);
+	if (ms !== void 0 && validate && !probe().validateMergeSource(schema, ms)) ms = void 0;
+	if (!nullDefault && ms === void 0) {
+		if (!rootIsObject) return;
+		if (!structuralPreallocatable(schema)) return;
+		if (validate && pod !== void 0 && !probe().validateObjectDefault(schema, pod)) return;
+	}
+	return {
+		pd,
+		pn: nullDefault,
+		pod,
+		ms
+	};
+}
+
+//#endregion
+exports.applyPrecomputed = applyPrecomputed;
+exports.buildDefaultClonerSource = buildDefaultClonerSource;
+exports.buildObjectDefaultMergeSource = buildObjectDefaultMergeSource;
+exports.canonical = canonical;
+exports.createDefaultCloner = createDefaultCloner;
+exports.createMergerFromSource = createMergerFromSource;
+exports.createObjectDefaultMerger = createObjectDefaultMerger;
+exports.isEmittable = isEmittable;
+exports.setDefaultProbeImpl = setDefaultProbeImpl;
+exports.verifyPreallocatableDefault = verifyPreallocatableDefault;