exact-mirror 1.1.1 → 1.2.0

package/README.md

@@ -50,3 +50,34 @@ const mirror = createMirror(shape)
 
 console.log(mirror(value)) // {"id":0,"name":"saltyaom"}
 ```
+
+## Decode / Encode
+
+By default `createMirror` only **cleans** a value to the model's shape. Opt into `decode` or `encode` to also apply a TypeBox codec's transform at codec leaves during the same walk — a fast replacement for `Value.Decode` / `Value.Encode` (~350x faster on a nested + array schema).
+
+```typescript
+import { Type as t } from 'typebox'
+import { Compile } from 'typebox/compile'
+import { createMirror } from 'exact-mirror'
+
+const Numeric = t.Union([
+	t.Number(),
+	t
+		.Codec(t.String())
+		.Decode((v) => +v)
+		.Encode((v) => '' + v)
+])
+
+const shape = t.Object({ id: Numeric })
+
+const decode = createMirror(shape, { decode: true, Compile })
+
+decode({ id: '2' }) // { id: 2 } — parsed + cleaned in one pass
+decode({ id: 2 }) //  { id: 2 } — already-numeric branch, untouched
+```
+
+- `decode: true` applies each codec's `~codec.decode` (parse input).
+- `encode: true` applies each codec's `~codec.encode` (the reverse).
+- Both default **off** — output is byte-identical to the pure clean.
+
+> Decode/encode is a pure transform: the value is assumed to have already passed `Check`. Validate the input first, then mirror.

package/dist/index.d.ts

@@ -1,103 +1,145 @@
-import type { TSchema, TModule, Static } from 'typebox';
-import type { Compile, Validator } from 'typebox/compile';
+import { Static, TModule, TSchema } from "typebox";
+import { Compile, Validator } from "typebox/compile";
+
+//#region src/index.d.ts
 interface BaseSchema {
-    '~kind': string;
-    id?: string;
-    $id?: string;
-    type?: string;
-    $schema?: string;
-    const?: unknown[];
-    pattern?: string;
-    additionalItems?: boolean | AnySchema;
-    items?: AnySchema | AnySchema[];
-    required?: string[];
-    additionalProperties?: boolean | AnySchema;
-    definitions?: {
-        [name: string]: AnySchema;
-    };
-    properties?: {
-        [name: string]: AnySchema;
-    };
-    patternProperties?: {
-        [name: string]: AnySchema;
-    };
-    dependencies?: {
-        [name: string]: AnySchema | string[];
-    };
-    enum?: any[];
-    allOf?: AnySchema[];
-    anyOf?: AnySchema[];
-    oneOf?: AnySchema[];
-    not?: AnySchema;
-    $ref?: string;
-    $defs?: Record<string, AnySchema>;
+  '~kind': string;
+  id?: string;
+  $id?: string;
+  type?: string;
+  $schema?: string;
+  const?: unknown[];
+  pattern?: string;
+  additionalItems?: boolean | AnySchema;
+  items?: AnySchema | AnySchema[];
+  required?: string[];
+  additionalProperties?: boolean | AnySchema;
+  definitions?: {
+    [name: string]: AnySchema;
+  };
+  properties?: {
+    [name: string]: AnySchema;
+  };
+  patternProperties?: {
+    [name: string]: AnySchema;
+  };
+  dependencies?: {
+    [name: string]: AnySchema | string[];
+  };
+  enum?: any[];
+  allOf?: AnySchema[];
+  anyOf?: AnySchema[];
+  oneOf?: AnySchema[];
+  not?: AnySchema;
+  $ref?: string;
+  $defs?: Record<string, AnySchema>;
 }
 type AnySchema = TSchema & BaseSchema;
-export declare const mergeObjectIntersection: (schema: AnySchema) => AnySchema;
+declare const mergeObjectIntersection: (schema: AnySchema) => AnySchema;
 type MaybeArray<T> = T | T[];
-export interface Instruction<Emit extends boolean = false> {
-    optionals: string[];
-    optionalsInArray: string[][];
-    parentIsOptional: boolean;
-    array: number;
-    unions: Validator<any>[][];
-    unionKeys: Record<string, 1>;
-    sanitize: MaybeArray<(v: string) => string> | undefined;
-    fromUnion?: boolean;
-    emit?: Emit;
-    /**
-     * TypeCompiler is required when using Union
-     *
-     * Left as opt-in to reduce bundle size
-     * many end-user doesn't use Union
-     *
-     * @default undefined
-     */
-    Compile?: typeof Compile;
-    typeCompilerWanred?: boolean;
-    modules?: TModule<{}>;
-    definitions: Record<string, AnySchema>;
-    /**
-     * Shared cyclic codegen state: generated per-definition mirror
-     * functions, grouped by `$defs` object identity
-     */
-    cyclic: CyclicContext;
-    /**
-     * `$defs` group the current cyclic definition body is generated
-     * against, used to resolve `Ref` nodes to function calls
-     */
-    cyclicDefs?: CyclicGroup;
-    recursion: number;
-    /**
-     * @default 8
-     */
-    recursionLimit: number;
-    /**
-     * If incorrect type is passed to Union value, should it be removed?
-     *
-     * If you check a value later, it's recommended to set this to `false`
-     * otherwise, set this to true
-     *
-     * @default false
-     */
-    removeUnknownUnionType: boolean;
+interface Instruction<Emit extends boolean = false> {
+  optionals: string[];
+  optionalsInArray: string[][];
+  parentIsOptional: boolean;
+  array: number;
+  unions: Validator<any>[][];
+  unionKeys: Record<string, 1>;
+  sanitize: MaybeArray<(v: string) => string> | undefined;
+  fromUnion?: boolean;
+  emit?: Emit;
+  /**
+   * Apply a TypeBox codec's `~codec` transform at codec leaves during the
+   * mirror walk, instead of only cleaning the value.
+   *
+   * @default undefined — pure clean, no transform
+   */
+  transform?: 'decode' | 'encode';
+  /**
+   * Codec transform functions collected during codegen, referenced from the
+   * generated source by index as `d.codecs[i]`
+   */
+  codecs: Function[];
+  /**
+   * TypeCompiler is required when using Union
+   *
+   * Left as opt-in to reduce bundle size
+   * many end-user doesn't use Union
+   *
+   * @default undefined
+   */
+  Compile?: typeof Compile;
+  typeCompilerWanred?: boolean;
+  modules?: TModule<{}>;
+  definitions: Record<string, AnySchema>;
+  /**
+   * Shared cyclic codegen state: generated per-definition mirror
+   * functions, grouped by `$defs` object identity
+   */
+  cyclic: CyclicContext;
+  /**
+   * `$defs` group the current cyclic definition body is generated
+   * against, used to resolve `Ref` nodes to function calls
+   */
+  cyclicDefs?: CyclicGroup;
+  recursion: number;
+  /**
+   * @default 8
+   */
+  recursionLimit: number;
+  /**
+   * If incorrect type is passed to Union value, should it be removed?
+   *
+   * If you check a value later, it's recommended to set this to `false`
+   * otherwise, set this to true
+   *
+   * @default false
+   */
+  removeUnknownUnionType: boolean;
 }
-export declare function deepClone<T>(source: T, weak?: WeakMap<object, any>): T;
+declare function deepClone<T>(source: T, weak?: WeakMap<object, any>): T;
 interface CyclicGroup {
-    defs: Record<string, AnySchema>;
-    names: Record<string, string>;
+  defs: Record<string, AnySchema>;
+  names: Record<string, string>;
 }
 interface CyclicContext {
-    groups: Map<object, CyclicGroup>;
-    fns: string[];
-    count: number;
+  groups: Map<object, CyclicGroup>;
+  fns: string[];
+  count: number;
 }
-export interface Manifest {
-    source: string;
-    externals: {
-        unions: Validator<any, TSchema, unknown, unknown>[][];
-        hof?: Record<string, Function>;
-    };
+interface Manifest {
+  source: string;
+  externals: {
+    unions: Validator<any, TSchema, unknown, unknown>[][];
+    codecs?: Function[];
+    hof?: Record<string, Function>;
+  };
 }
-export declare const createMirror: <T extends TSchema, Emit extends boolean = false>(schema: T, { Compile, modules, definitions, sanitize, recursionLimit, removeUnknownUnionType, emit }?: Partial<Pick<Instruction<Emit>, "Compile" | "definitions" | "sanitize" | "modules" | "recursionLimit" | "removeUnknownUnionType" | "emit">>) => Emit extends true ? Manifest : (v: Static<T>) => Static<T>;
-export default createMirror;
+declare const createMirror: <T extends TSchema, Emit extends boolean = false>(schema: T, {
+  Compile,
+  modules,
+  definitions,
+  sanitize,
+  recursionLimit,
+  removeUnknownUnionType,
+  emit,
+  decode,
+  encode
+}?: Partial<Pick<Instruction<Emit>, "Compile" | "definitions" | "sanitize" | "modules" | "recursionLimit" | "removeUnknownUnionType" | "emit">> & {
+  /**
+   * Apply each codec's `~codec.decode` at codec leaves (parse input,
+   * e.g. numeric string → number) on top of the clean walk
+   *
+   * The value is assumed to have already passed `Check`
+   *
+   * @default false
+   */
+  decode?: boolean;
+  /**
+   * Apply each codec's `~codec.encode` at codec leaves
+   *
+   * @default false
+   */
+  encode?: boolean;
+}) => Emit extends true ? Manifest : (v: Static<T>) => Static<T>;
+//#endregion
+export { Instruction, Manifest, createMirror, createMirror as default, deepClone, mergeObjectIntersection };

package/dist/index.js

@@ -0,0 +1,367 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+//#region src/index.ts
+const Kind = "~kind";
+const Hint = "~hint";
+const Codec = "~codec";
+const isSpecialProperty = (name) => !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+const joinProperty = (v1, v2, isOptional = false) => {
+	if (typeof v2 === "number") return `${v1}[${v2}]`;
+	if (isSpecialProperty(v2)) return `${v1}${isOptional ? "?." : ""}[${JSON.stringify(v2)}]`;
+	return `${v1}${isOptional ? "?" : ""}.${v2}`;
+};
+const encodeProperty = (v) => isSpecialProperty(v) ? JSON.stringify(v) : v;
+const sanitize = (key, sanitize = 0, schema) => {
+	if (schema.type !== "string" || schema.const || schema.trusted) return key;
+	let hof = "";
+	for (let i = sanitize - 1; i >= 0; i--) hof += `d.h${i}(`;
+	return hof + key + ")".repeat(sanitize);
+};
+const mergeObjectIntersection = (schema) => {
+	if (!schema.allOf || Kind in schema && (schema[Kind] !== "Intersect" || schema.type !== "object")) return schema;
+	const { allOf, ...newSchema } = schema;
+	newSchema.properties = {};
+	if (Kind in newSchema) newSchema[Kind] = "Object";
+	for (const type of allOf) {
+		if (type.type !== "object") continue;
+		const { properties, required, type: _, [Kind]: __, ...rest } = type;
+		if (required) newSchema.required = newSchema.required ? newSchema.required.concat(required) : required;
+		Object.assign(newSchema, rest);
+		for (const property in type.properties) newSchema.properties[property] = mergeObjectIntersection(type.properties[property]);
+	}
+	return newSchema;
+};
+const handleRecord = (schema, property, instruction) => {
+	const child = schema.patternProperties["^(.*)$"] ?? schema.patternProperties[Object.keys(schema.patternProperties)[0]];
+	if (!child) return property;
+	const i = instruction.array;
+	instruction.array++;
+	let v = `(()=>{const ar${i}s=Object.keys(${property}),ar${i}v={};for(let i=0;i<ar${i}s.length;i++){const ar${i}p=${property}[ar${i}s[i]];ar${i}v[ar${i}s[i]]=${mirror(child, `ar${i}p`, instruction)}`;
+	const optionals = instruction.optionalsInArray[i + 1];
+	if (optionals) {
+		for (let oi = 0; oi < optionals.length; oi++) {
+			const target = `ar${i}v[ar${i}s[i]]${optionals[oi]}`;
+			v += `;if(${target}===undefined)delete ${target}`;
+		}
+		instruction.optionalsInArray[i + 1] = [];
+	}
+	v += `}return ar${i}v})()`;
+	return v;
+};
+const handleTuple = (schema, property, instruction) => {
+	const i = instruction.array;
+	instruction.array++;
+	const isRoot = property === "v" && !instruction.fromUnion;
+	let v = "";
+	if (!isRoot) v = `(()=>{`;
+	v += `const ar${i}v=[`;
+	for (let i = 0; i < schema.length; i++) {
+		if (i !== 0) v += ",";
+		v += mirror(schema[i], joinProperty(property, i, instruction.parentIsOptional || instruction.fromUnion), instruction);
+	}
+	v += `];`;
+	if (!isRoot) v += `return ar${i}v})()`;
+	return v;
+};
+function deepClone(source, weak = /* @__PURE__ */ new WeakMap()) {
+	if (source === null || typeof source !== "object" || typeof source === "function") return source;
+	if (weak.has(source)) return weak.get(source);
+	if (Array.isArray(source)) {
+		const copy = new Array(source.length);
+		weak.set(source, copy);
+		for (let i = 0; i < source.length; i++) copy[i] = deepClone(source[i], weak);
+		return copy;
+	}
+	const keys = Object.keys(source).concat(Object.getOwnPropertySymbols(source));
+	const cloned = Object.create(null);
+	weak.set(source, cloned);
+	for (const key of keys) cloned[key] = deepClone(source[key], weak);
+	return cloned;
+}
+const handleCyclic = (schema, property, instruction) => {
+	const defs = schema.$defs;
+	let group = instruction.cyclic.groups.get(defs);
+	if (!group) {
+		group = {
+			defs,
+			names: {}
+		};
+		instruction.cyclic.groups.set(defs, group);
+		for (const name in defs) group.names[name] = `cy${instruction.cyclic.count++}`;
+		for (const name in defs) instruction.cyclic.fns.push(`function ${group.names[name]}(v){${mirror(defs[name], "v", {
+			...instruction,
+			cyclicDefs: group,
+			fromUnion: false,
+			parentIsOptional: false,
+			optionals: [],
+			optionalsInArray: [],
+			unionKeys: {},
+			array: 0,
+			recursion: 0
+		})}}`);
+	}
+	const fn = group.names[schema.$ref];
+	if (!fn) throw new Error(`[exact-mirror] cyclic reference "${schema.$ref}" is not found in $defs`);
+	return `(${property}==null?${property}:${fn}(${property}))`;
+};
+const withDefs = (type, group) => {
+	if (Kind in type) {
+		if (type[Kind] === "Cyclic") return type;
+		if (type[Kind] === "Ref" && type.$ref in group.defs) return Object.defineProperty({
+			$defs: group.defs,
+			$ref: type.$ref
+		}, Kind, { value: "Cyclic" });
+	}
+	let entry = "~check";
+	while (entry in group.defs) entry += "~";
+	const def = Object.create(Object.getPrototypeOf(type), Object.getOwnPropertyDescriptors(type));
+	def.$id = entry;
+	return Object.defineProperty({
+		$defs: {
+			...group.defs,
+			[entry]: def
+		},
+		$ref: entry
+	}, Kind, { value: "Cyclic" });
+};
+const handleUnion = (schemas, property, instruction) => {
+	if (instruction.Compile === void 0) {
+		if (!instruction.typeCompilerWanred) {
+			console.warn(/* @__PURE__ */ new Error("[exact-mirror] TypeBox's TypeCompiler is required to use Union"));
+			instruction.typeCompilerWanred = true;
+		}
+		return property;
+	}
+	instruction.unionKeys[property] = 1;
+	const ui = instruction.unions.length;
+	const typeChecks = instruction.unions[ui] = [];
+	let v = `(()=>{\n`;
+	const unwrapRef = (type) => {
+		if (!(Kind in type) || !type.$ref) return type;
+		if (type[Kind] === "This") return deepClone(instruction.definitions[type.$ref]);
+		return type;
+	};
+	let cleanThenCheck = "";
+	for (let i = 0; i < schemas.length; i++) {
+		let type = unwrapRef(schemas[i]);
+		if (Array.isArray(type.anyOf)) for (let i = 0; i < type.anyOf.length; i++) type.anyOf[i] = unwrapRef(type.anyOf[i]);
+		else if (type.items) if (Array.isArray(type.items)) for (let i = 0; i < type.items.length; i++) type.items[i] = unwrapRef(type.items[i]);
+		else type.items = unwrapRef(type.items);
+		typeChecks.push(instruction.Compile(instruction.cyclicDefs ? withDefs(type, instruction.cyclicDefs) : type));
+		v += `if(d.unions[${ui}][${i}].Check(${property})){return ${mirror(type, property, {
+			...instruction,
+			recursion: instruction.recursion + 1,
+			parentIsOptional: true,
+			fromUnion: true
+		})}}\n`;
+		cleanThenCheck += (i ? "" : "let ") + "tmp=" + mirror(type, property, {
+			...instruction,
+			recursion: instruction.recursion + 1,
+			parentIsOptional: true,
+			fromUnion: true
+		}) + `\nif(d.unions[${ui}][${i}].Check(tmp))return tmp\n`;
+	}
+	if (cleanThenCheck) v += cleanThenCheck;
+	v += `return ${instruction.removeUnknownUnionType ? "undefined" : property}`;
+	return v + `})()`;
+};
+const mirror = (schema, property, instruction) => {
+	if (!schema) return "";
+	const isRoot = property === "v" && !instruction.fromUnion;
+	const optionalsLength = instruction.optionals.length;
+	try {
+		if (instruction.transform && Codec in schema) {
+			const codec = schema[Codec][instruction.transform];
+			let ci = instruction.codecs.indexOf(codec);
+			if (ci === -1) ci = instruction.codecs.push(codec) - 1;
+			const body = mirrorNode(schema, `d.codecs[${ci}](${property})`, instruction);
+			return isRoot ? `return ${body}` : body;
+		}
+		if (Kind in schema && schema[Kind] === "Cyclic") {
+			const call = handleCyclic(schema, property, instruction);
+			return isRoot ? `return ${call}` : call;
+		}
+		return mirrorNode(schema, property, instruction);
+	} catch (error) {
+		instruction.optionals.length = optionalsLength;
+		console.warn(/* @__PURE__ */ new Error("[exact-mirror] failed to generate mirror for a schema node, the node is passed through as-is. Please report this issue to https://github.com/elysiajs/exact-mirror/issues"), error);
+		return isRoot ? "return v" : property;
+	}
+};
+const mirrorNode = (schema, property, instruction) => {
+	const isRoot = property === "v" && !instruction.fromUnion;
+	if (instruction.cyclicDefs && Kind in schema && schema[Kind] === "Ref" && schema.$ref && schema.$ref in instruction.cyclicDefs.names) {
+		const call = `(${property}==null?${property}:${instruction.cyclicDefs.names[schema.$ref]}(${property}))`;
+		return isRoot ? `return ${call}` : call;
+	}
+	if (isRoot && schema.type !== "object" && schema.type !== "array" && !schema.anyOf) return `return ${sanitize("v", instruction.sanitize?.length, schema)}`;
+	if (instruction.recursion >= instruction.recursionLimit) return property;
+	let v = "";
+	if (schema.$id && Hint in schema) instruction.definitions[schema.$id] = schema;
+	switch (schema.type) {
+		case "object":
+			if (schema[Kind] === "Record") {
+				v = handleRecord(schema, property, instruction);
+				break;
+			}
+			schema = mergeObjectIntersection(schema);
+			if (!schema.properties) {
+				v = property;
+				break;
+			}
+			v += "{";
+			if (schema.additionalProperties) v += `...${property},`;
+			const keys = Object.keys(schema.properties);
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				let isOptional = !schema.required || schema.required && !schema.required.includes(key) || Array.isArray(schema.properties[key].anyOf);
+				const name = joinProperty(property, key, instruction.parentIsOptional || instruction.fromUnion);
+				if (isOptional) {
+					const index = instruction.array;
+					if (property.startsWith("ar")) {
+						const dotIndex = name.indexOf(".");
+						let refName;
+						if (dotIndex >= 0) refName = name.slice(dotIndex);
+						else refName = name.slice(property.length);
+						const array = instruction.optionalsInArray;
+						if (array[index]) array[index].push(refName);
+						else array[index] = [refName];
+					} else instruction.optionals.push(name);
+				}
+				const child = schema.properties[key];
+				if (i !== 0) v += ",";
+				v += `${encodeProperty(key)}:${isOptional ? `${name}===undefined?undefined:` : ""}${mirror(child, name, {
+					...instruction,
+					recursion: instruction.recursion + 1,
+					parentIsOptional: isOptional
+				})}`;
+			}
+			v += "}";
+			break;
+		case "array":
+			if (!schema.items) {
+				v = property;
+				break;
+			}
+			if (schema.items.type !== "object" && schema.items.type !== "array") {
+				const cyclicItems = instruction.cyclicDefs !== void 0 && !Array.isArray(schema.items) && Kind in schema.items && schema.items[Kind] === "Ref" && schema.items.$ref !== void 0 && schema.items.$ref in instruction.cyclicDefs.names;
+				const codecItems = instruction.transform !== void 0 && !Array.isArray(schema.items) && Codec in schema.items;
+				if (Array.isArray(schema.items)) {
+					v = handleTuple(schema.items, property, instruction);
+					break;
+				} else if (!cyclicItems && !codecItems) {
+					if (isRoot && !Array.isArray(schema.items.anyOf)) return "return v";
+					else if (Kind in schema.items && schema.items.$ref && (schema.items[Kind] === "Ref" || schema.items[Kind] === "This")) v = mirror(deepClone(instruction.definitions[schema.items.$ref]), property, {
+						...instruction,
+						parentIsOptional: true,
+						recursion: instruction.recursion + 1
+					});
+					else if (!Array.isArray(schema.items.anyOf)) {
+						v = property;
+						break;
+					}
+				}
+			}
+			const i = instruction.array;
+			instruction.array++;
+			let reference = property;
+			if (isRoot) v = `const ar${i}v=new Array(${property}.length);`;
+			else {
+				reference = `ar${i}s`;
+				v = `((${reference})=>{const ar${i}v=new Array(${reference}.length);`;
+			}
+			v += `for(let i=0;i<${reference}.length;i++){const ar${i}p=${reference}[i];ar${i}v[i]=${mirror(schema.items, `ar${i}p`, instruction)}`;
+			const optionals = instruction.optionalsInArray[i + 1];
+			if (optionals) {
+				for (let oi = 0; oi < optionals.length; oi++) {
+					const target = `ar${i}v[i]${optionals[oi]}`;
+					v += `;if(${target}===undefined)delete ${target}`;
+				}
+				instruction.optionalsInArray[i + 1] = [];
+			}
+			v += `}`;
+			if (!isRoot) v += `return ar${i}v})(${property})`;
+			break;
+		default:
+			if (schema.$ref && schema.$ref in instruction.definitions) return mirror(instruction.definitions[schema.$ref], property, instruction);
+			if (Array.isArray(schema.anyOf)) {
+				v = handleUnion(schema.anyOf, property, instruction);
+				break;
+			}
+			v = sanitize(property, instruction.sanitize?.length, schema);
+			break;
+	}
+	if (!isRoot) return v;
+	if (schema.type === "array") v = `${v}const x=ar0v;`;
+	else v = `const x=${v}\n`;
+	for (let i = 0; i < instruction.optionals.length; i++) {
+		const key = instruction.optionals[i];
+		const prop = key.slice(1);
+		v += `if(${key}===undefined`;
+		if (instruction.unionKeys[key]) v += `||x${prop}===undefined`;
+		const shouldQuestion = prop.charCodeAt(0) !== 63 && schema.type !== "array";
+		v += `)delete x${shouldQuestion ? prop.charCodeAt(0) === 91 ? "?." : "?" : ""}${prop}\n`;
+	}
+	return `${v}return x`;
+};
+const createMirror = (schema, { Compile, modules, definitions, sanitize, recursionLimit = 8, removeUnknownUnionType = false, emit, decode, encode } = Object.create(null)) => {
+	const unions = [];
+	const codecs = [];
+	const cyclic = {
+		groups: /* @__PURE__ */ new Map(),
+		fns: [],
+		count: 0
+	};
+	if (typeof sanitize === "function") sanitize = [sanitize];
+	const f = mirror(schema, "v", {
+		optionals: [],
+		optionalsInArray: [],
+		array: 0,
+		parentIsOptional: false,
+		unions,
+		unionKeys: Object.create(null),
+		Compile,
+		modules,
+		definitions: definitions ?? modules?.$defs ?? Object.create(null),
+		cyclic,
+		sanitize,
+		recursion: 0,
+		recursionLimit,
+		removeUnknownUnionType,
+		transform: decode ? "decode" : encode ? "encode" : void 0,
+		codecs
+	});
+	const fns = cyclic.fns.length ? cyclic.fns.join("\n") + "\n" : "";
+	if (!unions.length && !sanitize?.length && !codecs.length) {
+		if (emit) return {
+			source: fns + f,
+			externals: void 0
+		};
+		return Function("v", fns + f);
+	}
+	let hof;
+	if (sanitize?.length) {
+		hof = Object.create(null);
+		for (let i = 0; i < sanitize.length; i++) hof[`h${i}`] = sanitize[i];
+	}
+	const source = `${fns}return function mirror(v){${f}}`;
+	if (emit) return {
+		source,
+		externals: {
+			unions,
+			codecs: codecs.length ? codecs : void 0,
+			hof
+		}
+	};
+	const d = Object.create(null);
+	if (unions.length) d.unions = unions;
+	if (codecs.length) d.codecs = codecs;
+	if (hof) Object.assign(d, hof);
+	return Function("d", source)(d);
+};
+
+//#endregion
+exports.createMirror = createMirror;
+exports.default = createMirror;
+exports.deepClone = deepClone;
+exports.mergeObjectIntersection = mergeObjectIntersection;