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

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

@@ -0,0 +1,110 @@
+import { EMPTY_EXTERNALS, collectExternals } from "../../compile/aot.mjs";
+import { buildFrozenCheck } from "./frozen-check.mjs";
+import { Build, Compile } from "typebox/schema";
+
+//#region src/type/validator/custom-error.ts
+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 buildFindCustomError(schema, frozen) {
+	const nodes = collectCustomErrorNodes(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
+			};
+		}
+	};
+}
+function captureCustomErrors(schema) {
+	const ceNodes = collectCustomErrorNodes(schema, "", []);
+	if (!ceNodes.length) return;
+	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 {}
+	}
+	return entries.length ? entries : void 0;
+}
+
+//#endregion
+export { buildFindCustomError, captureCustomErrors };

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

@@ -0,0 +1,22 @@
+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 isPrecomputeSafe(schema: any, depth?: number): boolean;
+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;
+declare function buildMergeSource(schema: any): string | undefined;
+declare function verifyPreallocatableDefault(schema: TSchema, validate?: boolean): {
+  pd: unknown;
+  pn: boolean;
+  pod: Record<string, unknown> | undefined;
+  ms: string | undefined;
+} | undefined;
+//#endregion
+export { applyPrecomputed, buildDefaultClonerSource, buildMergeSource, buildObjectDefaultMergeSource, createDefaultCloner, createMergerFromSource, createObjectDefaultMerger, isEmittable, isPrecomputeSafe, verifyPreallocatableDefault };

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

@@ -0,0 +1,476 @@
+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);
+	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;`;
+				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;`;
+		} else body += `${write}=x===undefined?${value}:x;`;
+	}
+	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";
+	helpers[+name.slice(2)] = `function ${name}(v){${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 mergeExpression(schema, varName, helpers) {
+	const full = (0, typebox_value.Default)(schema, void 0);
+	const child = emitMerger(schema, helpers);
+	if (child === void 0) return;
+	const absent = full === void 0 ? void 0 : cloneExpression(full);
+	if (full !== void 0 && absent === void 0) return;
+	let present;
+	if (child === "") present = varName;
+	else present = mergeCategory(schema) === "object" ? `(${varName}!==null&&typeof ${varName}==='object'&&!Array.isArray(${varName})?${child}(${varName}):${varName})` : `(Array.isArray(${varName})?${child}(${varName}):${varName})`;
+	return {
+		absent,
+		present
+	};
+}
+function emitMerger(node, helpers) {
+	const category = mergeCategory(node);
+	if (category === "identity") return "";
+	if (category === "bail") return;
+	const name = `_d${helpers.length}`;
+	helpers.push("");
+	if (category === "object") {
+		const props = node.properties ?? {};
+		const handled = [];
+		let body = "if(v===null||typeof v!=='object'||Array.isArray(v))return v;const out=Object.create(null);let x;";
+		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);
+			if (!expr) return;
+			handled.push(key);
+			const access = JSON.stringify(key);
+			body += `x=v[${access}];`;
+			body += expr.absent === void 0 ? `if(x!==undefined)out[${access}]=${expr.present};` : `out[${access}]=x===undefined?${expr.absent}:${expr.present};`;
+		}
+		if (!handled.length) {
+			helpers.pop();
+			return "";
+		}
+		body += "for(const k in v){x=v[k];if(x!==undefined";
+		for (const key of handled) body += `&&k!==${JSON.stringify(key)}`;
+		body += ")out[k]=x}return out";
+		helpers[+name.slice(2)] = `function ${name}(v){${body}}`;
+		return name;
+	}
+	const expr = mergeExpression(node.items, "e", helpers);
+	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);
+	if (!root) return;
+	return `(function(){${helpers.join(";")};return ${root}})()`;
+}
+function emptyContainers(node, depth) {
+	if (depth <= 0 || !node || typeof node !== "object") return;
+	const kind = node["~kind"];
+	if (kind === "Object" || node.type === "object") {
+		const out = require_utils.nullObject();
+		const props = node.properties ?? {};
+		for (const key in props) if (Object.hasOwn(props, key)) {
+			const child = emptyContainers(props[key], depth - 1);
+			if (child !== void 0) out[key] = child;
+		}
+		return out;
+	}
+	if ((kind === "Array" || node.type === "array") && node.items && !Array.isArray(node.items)) {
+		const element = emptyContainers(node.items, depth - 1);
+		return element === void 0 ? [] : [element];
+	}
+}
+function* mergeProbes(schema) {
+	yield {};
+	yield [];
+	const filled = emptyContainers(schema, 6);
+	if (filled !== void 0) yield filled;
+	const kind = schema["~kind"];
+	if (kind === "Object" || schema.type === "object") {
+		const props = schema.properties ?? {};
+		for (const key in props) if (Object.hasOwn(props, key)) {
+			yield { [key]: PROBE_SENTINEL };
+			const child = emptyContainers(props[key], 6);
+			if (child !== void 0) yield { [key]: child };
+		}
+	} else if ((kind === "Array" || schema.type === "array") && schema.items && !Array.isArray(schema.items)) {
+		yield [PROBE_SENTINEL];
+		const element = emptyContainers(schema.items, 6);
+		if (element !== void 0) yield [element, element];
+	}
+}
+function validateMergeSource(schema, source) {
+	const merger = fromSource(source);
+	if (!merger) return false;
+	for (const probe of mergeProbes(schema)) {
+		if (probe === null || typeof probe !== "object") continue;
+		let expected;
+		try {
+			expected = (0, typebox_value.Default)(schema, structuredClone(probe));
+		} catch {
+			return false;
+		}
+		let actual;
+		try {
+			actual = merger(structuredClone(probe));
+		} catch {
+			return false;
+		}
+		if (canonical(expected) !== canonical(actual)) return false;
+	}
+	return true;
+}
+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, 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) ? 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 && !validateMergeSource(schema, ms)) ms = void 0;
+	if (!nullDefault && ms === void 0) {
+		if (!rootIsObject) return;
+		if (!structuralPreallocatable(schema)) return;
+		if (validate) for (const probe of defaultProbes(pod)) {
+			let expected;
+			try {
+				expected = (0, typebox_value.Default)(schema, structuredClone(probe));
+			} catch {
+				return;
+			}
+			const actual = applyPrecomputed(pod, structuredClone(probe));
+			if (canonical(expected) !== canonical(actual)) return;
+		}
+	}
+	return {
+		pd,
+		pn: nullDefault,
+		pod,
+		ms
+	};
+}
+
+//#endregion
+exports.applyPrecomputed = applyPrecomputed;
+exports.buildDefaultClonerSource = buildDefaultClonerSource;
+exports.buildMergeSource = buildMergeSource;
+exports.buildObjectDefaultMergeSource = buildObjectDefaultMergeSource;
+exports.createDefaultCloner = createDefaultCloner;
+exports.createMergerFromSource = createMergerFromSource;
+exports.createObjectDefaultMerger = createObjectDefaultMerger;
+exports.isEmittable = isEmittable;
+exports.isPrecomputeSafe = isPrecomputeSafe;
+exports.verifyPreallocatableDefault = verifyPreallocatableDefault;