typia 7.0.0-dev.20240923 → 7.0.0-dev.20240924

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -9,6 +9,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -33,7 +34,7 @@ export namespace MiscCloneProgrammer {
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
-    const config = configure(props.context)(props.importer);
+    const config: FeatureProgrammer.IConfig = configure(props);
     if (props.validated === false)
       config.addition = (collection) =>
         IsProgrammer.write_function_statements(props.context)(props.importer)(
@@ -73,423 +74,468 @@ export namespace MiscCloneProgrammer {
     });
   };
 
-  const write_array_functions =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (collection: MetadataCollection): ts.VariableStatement[] =>
-      collection
-        .arrays()
-        .filter((a) => a.recursive)
-        .map((type, i) =>
-          StatementFactory.constant(
-            `${config.prefix}a${i}`,
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              FeatureProgrammer.parameterDeclarations(config)(
-                TypeFactory.keyword("any"),
-              )(ts.factory.createIdentifier("input")),
+  const write_array_functions = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    collection: MetadataCollection;
+  }): ts.VariableStatement[] =>
+    props.collection
+      .arrays()
+      .filter((a) => a.recursive)
+      .map((type, i) =>
+        StatementFactory.constant(
+          `${props.config.prefix}a${i}`,
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            FeatureProgrammer.parameterDeclarations(props.config)(
               TypeFactory.keyword("any"),
-              undefined,
-              decode_array_inline(config)(importer)(
-                ts.factory.createIdentifier("input"),
-                MetadataArray.create({
-                  type,
-                  tags: [],
-                }),
-                {
-                  tracable: config.trace,
-                  source: "function",
-                  from: "array",
-                  postfix: "",
-                },
-              ),
-            ),
+            )(ts.factory.createIdentifier("input")),
+            TypeFactory.keyword("any"),
+            undefined,
+            decode_array_inline({
+              config: props.config,
+              importer: props.importer,
+              input: ts.factory.createIdentifier("input"),
+              array: MetadataArray.create({
+                type,
+                tags: [],
+              }),
+              explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+              },
+            }),
           ),
-        );
+        ),
+      );
 
-  const write_tuple_functions =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (collection: MetadataCollection): ts.VariableStatement[] =>
-      collection
-        .tuples()
-        .filter((t) => t.recursive)
-        .map((tuple, i) =>
-          StatementFactory.constant(
-            `${config.prefix}t${i}`,
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              FeatureProgrammer.parameterDeclarations(config)(
-                TypeFactory.keyword("any"),
-              )(ts.factory.createIdentifier("input")),
+  const write_tuple_functions = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    collection: MetadataCollection;
+  }): ts.VariableStatement[] =>
+    props.collection
+      .tuples()
+      .filter((t) => t.recursive)
+      .map((tuple, i) =>
+        StatementFactory.constant(
+          `${props.config.prefix}t${i}`,
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            FeatureProgrammer.parameterDeclarations(props.config)(
               TypeFactory.keyword("any"),
-              undefined,
-              decode_tuple_inline(project)(config)(importer)(
-                ts.factory.createIdentifier("input"),
-                tuple,
-                {
-                  tracable: config.trace,
-                  source: "function",
-                  from: "array",
-                  postfix: "",
-                },
-              ),
-            ),
+            )(ts.factory.createIdentifier("input")),
+            TypeFactory.keyword("any"),
+            undefined,
+            decode_tuple_inline({
+              config: props.config,
+              context: props.context,
+              importer: props.importer,
+              input: ts.factory.createIdentifier("input"),
+              tuple,
+              explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+              },
+            }),
           ),
-        );
+        ),
+      );
 
   /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
-  const decode =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      meta: Metadata,
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      // ANY TYPE
-      if (
-        meta.any ||
-        meta.arrays.some((a) => a.type.value.any) ||
-        meta.tuples.some(
-          (t) =>
-            !!t.type.elements.length && t.type.elements.every((e) => e.any),
-        )
+  const decode = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    metadata: Metadata;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    // ANY TYPE
+    if (
+      props.metadata.any ||
+      props.metadata.arrays.some((a) => a.type.value.any) ||
+      props.metadata.tuples.some(
+        (t) => !!t.type.elements.length && t.type.elements.every((e) => e.any),
       )
-        return ts.factory.createCallExpression(importer.use("any"), undefined, [
-          input,
-        ]);
-
-      interface IUnion {
-        type: string;
-        is: () => ts.Expression;
-        value: () => ts.Expression;
-      }
-      const unions: IUnion[] = [];
-
-      //----
-      // LIST UP UNION TYPES
-      //----
-      // FUNCTIONAL
-      if (meta.functions.length)
-        unions.push({
-          type: "functional",
-          is: () =>
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("function"),
-              ts.factory.createTypeOfExpression(input),
-            ),
-          value: () => ts.factory.createIdentifier("undefined"),
-        });
+    )
+      return ts.factory.createCallExpression(
+        props.importer.use("any"),
+        undefined,
+        [props.input],
+      );
 
-      // TUPLES
-      for (const tuple of meta.tuples)
-        unions.push({
-          type: "tuple",
-          is: () =>
-            IsProgrammer.decode(project)(importer)(
-              input,
-              (() => {
-                const partial = Metadata.initialize();
-                partial.tuples.push(tuple);
-                return partial;
-              })(),
-              explore,
-            ),
-          value: () =>
-            decode_tuple(project)(config)(importer)(input, tuple, explore),
-        });
+    interface IUnion {
+      type: string;
+      is: () => ts.Expression;
+      value: () => ts.Expression;
+    }
+    const unions: IUnion[] = [];
+
+    //----
+    // LIST UP UNION TYPES
+    //----
+    // FUNCTIONAL
+    if (props.metadata.functions.length)
+      unions.push({
+        type: "functional",
+        is: () =>
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("function"),
+            ts.factory.createTypeOfExpression(props.input),
+          ),
+        value: () => ts.factory.createIdentifier("undefined"),
+      });
 
-      // ARRAYS
-      if (meta.arrays.length)
-        unions.push({
-          type: "array",
-          is: () => ExpressionFactory.isArray(input),
-          value: () =>
-            explore_arrays(project)(config)(importer)(input, meta.arrays, {
-              ...explore,
+    // TUPLES
+    for (const tuple of props.metadata.tuples)
+      unions.push({
+        type: "tuple",
+        is: () =>
+          IsProgrammer.decode(props.context)(props.importer)(
+            props.input,
+            (() => {
+              const partial = Metadata.initialize();
+              partial.tuples.push(tuple);
+              return partial;
+            })(),
+            props.explore,
+          ),
+        value: () =>
+          decode_tuple({
+            ...props,
+            tuple,
+          }),
+      });
+
+    // ARRAYS
+    if (props.metadata.arrays.length)
+      unions.push({
+        type: "array",
+        is: () => ExpressionFactory.isArray(props.input),
+        value: () =>
+          explore_arrays({
+            ...props,
+            arrays: props.metadata.arrays,
+            explore: {
+              ...props.explore,
               from: "array",
-            }),
-        });
+            },
+          }),
+      });
 
-      // NATIVE TYPES
-      if (meta.sets.length)
-        unions.push({
-          type: "set",
-          is: () => ExpressionFactory.isInstanceOf("Set")(input),
-          value: () =>
-            explore_sets(project)(config)(importer)(input, meta.sets, {
-              ...explore,
+    // NATIVE TYPES
+    if (props.metadata.sets.length)
+      unions.push({
+        type: "set",
+        is: () => ExpressionFactory.isInstanceOf("Set")(props.input),
+        value: () =>
+          explore_sets({
+            ...props,
+            sets: props.metadata.sets,
+            explore: {
+              ...props.explore,
               from: "array",
-            }),
-        });
-      if (meta.maps.length)
-        unions.push({
-          type: "map",
-          is: () => ExpressionFactory.isInstanceOf("Map")(input),
-          value: () =>
-            explore_maps(project)(config)(importer)(input, meta.maps, {
-              ...explore,
+            },
+          }),
+      });
+    if (props.metadata.maps.length)
+      unions.push({
+        type: "map",
+        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        value: () =>
+          explore_maps({
+            ...props,
+            maps: props.metadata.maps,
+            explore: {
+              ...props.explore,
               from: "array",
-            }),
-        });
-      for (const native of meta.natives)
-        unions.push({
-          type: "native",
-          is: () => ExpressionFactory.isInstanceOf(native)(input),
-          value: () =>
-            native === "Boolean" || native === "Number" || native === "String"
-              ? ts.factory.createCallExpression(
-                  IdentifierFactory.access(input)("valueOf"),
-                  undefined,
-                  undefined,
-                )
-              : decode_native(native)(input),
-        });
-
-      // OBJECTS
-      if (meta.objects.length)
-        unions.push({
-          type: "object",
-          is: () =>
-            ExpressionFactory.isObject({
-              checkNull: true,
-              checkArray: false,
-            })(input),
-          value: () =>
-            explore_objects(config)(importer)(input, meta, {
-              ...explore,
-              from: "object",
-            }),
-        });
-
-      // COMPOSITION
-      if (unions.length === 0) return input;
-      else if (unions.length === 1 && meta.size() === 1) {
-        const value: ts.Expression =
-          (meta.nullable || meta.isRequired() === false) && is_instance(meta)
-            ? ts.factory.createConditionalExpression(
-                input,
+            },
+          }),
+      });
+    for (const native of props.metadata.natives)
+      unions.push({
+        type: "native",
+        is: () => ExpressionFactory.isInstanceOf(native)(props.input),
+        value: () =>
+          native === "Boolean" || native === "Number" || native === "String"
+            ? ts.factory.createCallExpression(
+                IdentifierFactory.access(props.input)("valueOf"),
                 undefined,
-                unions[0]!.value(),
                 undefined,
-                input,
               )
-            : unions[0]!.value();
-        return ts.factory.createAsExpression(value, TypeFactory.keyword("any"));
-      } else {
-        let last: ts.Expression = input;
-        for (const u of unions.reverse())
-          last = ts.factory.createConditionalExpression(
-            u.is(),
-            undefined,
-            u.value(),
-            undefined,
-            last,
-          );
-        return ts.factory.createAsExpression(last, TypeFactory.keyword("any"));
-      }
-    };
+            : decode_native({
+                type: native,
+                input: props.input,
+              }),
+      });
+
+    // OBJECTS
+    if (props.metadata.objects.length)
+      unions.push({
+        type: "object",
+        is: () =>
+          ExpressionFactory.isObject({
+            checkNull: true,
+            checkArray: false,
+          })(props.input),
+        value: () =>
+          explore_objects({
+            ...props,
+            explore: {
+              ...props.explore,
+              from: "object",
+            },
+          }),
+      });
 
-  const decode_object = (importer: FunctionImporter) =>
+    // COMPOSITION
+    if (unions.length === 0) return props.input;
+    else if (unions.length === 1 && props.metadata.size() === 1) {
+      const value: ts.Expression =
+        (props.metadata.nullable || props.metadata.isRequired() === false) &&
+        is_instance(props.metadata)
+          ? ts.factory.createConditionalExpression(
+              props.input,
+              undefined,
+              unions[0]!.value(),
+              undefined,
+              props.input,
+            )
+          : unions[0]!.value();
+      return ts.factory.createAsExpression(value, TypeFactory.keyword("any"));
+    } else {
+      let last: ts.Expression = props.input;
+      for (const u of unions.reverse())
+        last = ts.factory.createConditionalExpression(
+          u.is(),
+          undefined,
+          u.value(),
+          undefined,
+          last,
+        );
+      return ts.factory.createAsExpression(last, TypeFactory.keyword("any"));
+    }
+  };
+
+  const decode_object = (props: {
+    importer: FunctionImporter;
+    input: ts.Expression;
+    object: MetadataObject;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
     FeatureProgrammer.decode_object({
       trace: false,
       path: false,
       prefix: PREFIX,
-    })(importer);
-
-  const decode_array =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      array: MetadataArray,
-      explore: FeatureProgrammer.IExplore,
-    ) =>
-      array.type.recursive
-        ? ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              importer.useLocal(`${config.prefix}a${array.type.index}`),
-            ),
-            undefined,
-            FeatureProgrammer.argumentsArray(config)({
-              ...explore,
-              source: "function",
-              from: "array",
-            })(input),
-          )
-        : decode_array_inline(config)(importer)(input, array, explore);
-
-  const decode_array_inline =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      array: MetadataArray,
-      explore: FeatureProgrammer.IExplore,
-    ) =>
-      FeatureProgrammer.decode_array(config)(importer)(CloneJoiner.array)(
-        input,
-        array,
-        explore,
-      );
+    })(props.importer)(props.input, props.object, props.explore);
 
-  const decode_tuple =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      tuple: MetadataTuple,
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression =>
-      tuple.type.recursive
-        ? ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              importer.useLocal(`${config.prefix}t${tuple.type.index}`),
+  const decode_array = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    array: MetadataArray;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    props.array.type.recursive
+      ? ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            props.importer.useLocal(
+              `${props.config.prefix}a${props.array.type.index}`,
             ),
-            undefined,
-            FeatureProgrammer.argumentsArray(config)({
-              ...explore,
-              source: "function",
-            })(input),
-          )
-        : decode_tuple_inline(project)(config)(importer)(
-            input,
-            tuple.type,
-            explore,
-          );
-
-  const decode_tuple_inline =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      tuple: MetadataTupleType,
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      const elements: ts.Expression[] = tuple.elements
-        .filter((m) => m.rest === null)
-        .map((elem, index) =>
-          decode(project)(config)(importer)(
-            ts.factory.createElementAccessExpression(input, index),
-            elem,
-            {
-              ...explore,
-              from: "array",
-              postfix: explore.postfix.length
-                ? `${postfix_of_tuple(explore.postfix)}[${index}]"`
-                : `"[${index}]"`,
-            },
           ),
-        );
-      const rest = (() => {
-        if (tuple.elements.length === 0) return null;
-
-        const last: Metadata = tuple.elements.at(-1)!;
-        const rest: Metadata | null = last.rest;
-        if (rest === null) return null;
+          undefined,
+          FeatureProgrammer.argumentsArray(props.config)({
+            ...props.explore,
+            source: "function",
+            from: "array",
+          })(props.input),
+        )
+      : decode_array_inline(props);
 
-        return decode(project)(config)(importer)(
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("slice"),
-            undefined,
-            [ExpressionFactory.number(tuple.elements.length - 1)],
+  const decode_array_inline = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    array: MetadataArray;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    FeatureProgrammer.decode_array(props.config)(props.importer)(
+      CloneJoiner.array,
+    )(props.input, props.array, props.explore);
+
+  const decode_tuple = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    tuple: MetadataTuple;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression =>
+    props.tuple.type.recursive
+      ? ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            props.importer.useLocal(
+              `${props.config.prefix}t${props.tuple.type.index}`,
+            ),
           ),
-          wrap_metadata_rest_tuple(tuple.elements.at(-1)!.rest!),
-          {
-            ...explore,
-            start: tuple.elements.length - 1,
+          undefined,
+          FeatureProgrammer.argumentsArray(props.config)({
+            ...props.explore,
+            source: "function",
+          })(props.input),
+        )
+      : decode_tuple_inline({
+          ...props,
+          tuple: props.tuple.type,
+        });
+
+  const decode_tuple_inline = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    tuple: MetadataTupleType;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    const elements: ts.Expression[] = props.tuple.elements
+      .filter((m) => m.rest === null)
+      .map((elem, index) =>
+        decode({
+          context: props.context,
+          config: props.config,
+          importer: props.importer,
+          input: ts.factory.createElementAccessExpression(props.input, index),
+          metadata: elem,
+          explore: {
+            ...props.explore,
+            from: "array",
+            postfix: props.explore.postfix.length
+              ? `${postfix_of_tuple(props.explore.postfix)}[${index}]"`
+              : `"[${index}]"`,
           },
-        );
-      })();
-      return CloneJoiner.tuple({
-        elements,
-        rest,
+        }),
+      );
+    const rest = (() => {
+      if (props.tuple.elements.length === 0) return null;
+
+      const last: Metadata = props.tuple.elements.at(-1)!;
+      const rest: Metadata | null = last.rest;
+      if (rest === null) return null;
+
+      return decode({
+        context: props.context,
+        config: props.config,
+        importer: props.importer,
+        input: ts.factory.createCallExpression(
+          IdentifierFactory.access(props.input)("slice"),
+          undefined,
+          [ExpressionFactory.number(props.tuple.elements.length - 1)],
+        ),
+        metadata: wrap_metadata_rest_tuple(props.tuple.elements.at(-1)!.rest!),
+        explore: {
+          ...props.explore,
+          start: props.tuple.elements.length - 1,
+        },
       });
-    };
+    })();
+    return CloneJoiner.tuple({
+      elements,
+      rest,
+    });
+  };
 
   /* -----------------------------------------------------------
         NATIVE CLASSES
     ----------------------------------------------------------- */
-  const decode_native = (type: string) => (input: ts.Expression) =>
-    type === "Date" ||
-    type === "Uint8Array" ||
-    type === "Uint8ClampedArray" ||
-    type === "Uint16Array" ||
-    type === "Uint32Array" ||
-    type === "BigUint64Array" ||
-    type === "Int8Array" ||
-    type === "Int16Array" ||
-    type === "Int32Array" ||
-    type === "BigInt64Array" ||
-    type === "Float32Array" ||
-    type === "Float64Array" ||
-    type === "RegExp"
-      ? decode_native_copyable(type)(input)
-      : type === "ArrayBuffer" || type === "SharedArrayBuffer"
-        ? decode_native_buffer(type)(input)
-        : type === "DataView"
-          ? decode_native_data_view(input)
+  const decode_native = (props: { type: string; input: ts.Expression }) =>
+    props.type === "Date" ||
+    props.type === "Uint8Array" ||
+    props.type === "Uint8ClampedArray" ||
+    props.type === "Uint16Array" ||
+    props.type === "Uint32Array" ||
+    props.type === "BigUint64Array" ||
+    props.type === "Int8Array" ||
+    props.type === "Int16Array" ||
+    props.type === "Int32Array" ||
+    props.type === "BigInt64Array" ||
+    props.type === "Float32Array" ||
+    props.type === "Float64Array" ||
+    props.type === "RegExp"
+      ? decode_native_copyable(props)
+      : props.type === "ArrayBuffer" || props.type === "SharedArrayBuffer"
+        ? decode_native_buffer({
+            type: props.type,
+            input: props.input,
+          })
+        : props.type === "DataView"
+          ? decode_native_data_view(props.input)
           : ts.factory.createCallExpression(
-              ts.factory.createIdentifier(type),
+              ts.factory.createIdentifier(props.type),
               undefined,
               [],
             );
 
-  const decode_native_copyable = (type: string) => (input: ts.Expression) =>
+  const decode_native_copyable = (props: {
+    type: string;
+    input: ts.Expression;
+  }) =>
     ts.factory.createNewExpression(
-      ts.factory.createIdentifier(type),
+      ts.factory.createIdentifier(props.type),
       undefined,
-      [input],
+      [props.input],
     );
 
-  const decode_native_buffer =
-    (type: "ArrayBuffer" | "SharedArrayBuffer") => (input: ts.Expression) =>
-      ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            StatementFactory.constant(
-              "buffer",
-              ts.factory.createNewExpression(
-                ts.factory.createIdentifier(type),
-                undefined,
-                [IdentifierFactory.access(input)("byteLength")],
-              ),
-            ),
-            ts.factory.createExpressionStatement(
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(
-                  ts.factory.createNewExpression(
-                    ts.factory.createIdentifier("Uint8Array"),
-                    undefined,
-                    [ts.factory.createIdentifier("buffer")],
-                  ),
-                )("set"),
-                undefined,
-                [
-                  ts.factory.createNewExpression(
-                    ts.factory.createIdentifier("Uint8Array"),
-                    undefined,
-                    [input],
-                  ),
-                ],
-              ),
+  const decode_native_buffer = (props: {
+    type: "ArrayBuffer" | "SharedArrayBuffer";
+    input: ts.Expression;
+  }) =>
+    ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          StatementFactory.constant(
+            "buffer",
+            ts.factory.createNewExpression(
+              ts.factory.createIdentifier(props.type),
+              undefined,
+              [IdentifierFactory.access(props.input)("byteLength")],
             ),
-            ts.factory.createReturnStatement(
-              ts.factory.createIdentifier("buffer"),
+          ),
+          ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createNewExpression(
+                  ts.factory.createIdentifier("Uint8Array"),
+                  undefined,
+                  [ts.factory.createIdentifier("buffer")],
+                ),
+              )("set"),
+              undefined,
+              [
+                ts.factory.createNewExpression(
+                  ts.factory.createIdentifier("Uint8Array"),
+                  undefined,
+                  [props.input],
+                ),
+              ],
             ),
-          ],
-          true,
-        ),
-      );
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("buffer"),
+          ),
+        ],
+        true,
+      ),
+    );
 
   const decode_native_data_view = (input: ts.Expression) =>
     ts.factory.createNewExpression(
@@ -501,242 +547,332 @@ export namespace MiscCloneProgrammer {
   /* -----------------------------------------------------------
         EXPLORERS FOR UNION TYPES
     ----------------------------------------------------------- */
-  const explore_sets =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      sets: Metadata[],
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression =>
-      ts.factory.createCallExpression(
-        UnionExplorer.set({
-          checker: IsProgrammer.decode(project)(importer),
-          decoder: (input, array, explore) =>
-            ts.factory.createNewExpression(
-              ts.factory.createIdentifier("Set"),
-              [TypeFactory.keyword("any")],
-              [decode_array(config)(importer)(input, array, explore)],
-            ),
-          empty: ts.factory.createNewExpression(
+  const explore_sets = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    sets: Metadata[];
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression =>
+    ts.factory.createCallExpression(
+      UnionExplorer.set({
+        checker: IsProgrammer.decode(props.context)(props.importer),
+        decoder: (input, array, explore) =>
+          ts.factory.createNewExpression(
             ts.factory.createIdentifier("Set"),
             [TypeFactory.keyword("any")],
-            [],
+            [
+              decode_array({
+                config: props.config,
+                importer: props.importer,
+                input,
+                array,
+                explore,
+              }),
+            ],
           ),
-          success: ts.factory.createTrue(),
-          failure: (input, expected) =>
-            create_throw_error(importer)(expected)(input),
-        })([])(input, sets, explore),
-        undefined,
-        undefined,
-      );
+        empty: ts.factory.createNewExpression(
+          ts.factory.createIdentifier("Set"),
+          [TypeFactory.keyword("any")],
+          [],
+        ),
+        success: ts.factory.createTrue(),
+        failure: (input, expected) =>
+          create_throw_error({
+            importer: props.importer,
+            expected,
+            input,
+          }),
+      })([])(props.input, props.sets, props.explore),
+      undefined,
+      undefined,
+    );
 
-  const explore_maps =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      maps: Metadata.Entry[],
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression =>
-      ts.factory.createCallExpression(
-        UnionExplorer.map({
-          checker: (top, entry, explore) => {
-            const func = IsProgrammer.decode(project)(importer);
-            return ts.factory.createLogicalAnd(
-              func(ts.factory.createElementAccessExpression(top, 0), entry[0], {
-                ...explore,
-                postfix: `${explore.postfix}[0]`,
-              }),
-              func(ts.factory.createElementAccessExpression(top, 1), entry[1], {
-                ...explore,
-                postfix: `${explore.postfix}[1]`,
-              }),
-            );
-          },
-          decoder: (input, array, explore) =>
-            ts.factory.createNewExpression(
-              ts.factory.createIdentifier("Map"),
-              [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
-              [decode_array(config)(importer)(input, array, explore)],
-            ),
-          empty: ts.factory.createNewExpression(
+  const explore_maps = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    maps: Metadata.Entry[];
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression =>
+    ts.factory.createCallExpression(
+      UnionExplorer.map({
+        checker: (top, entry, explore) => {
+          const func = IsProgrammer.decode(props.context)(props.importer);
+          return ts.factory.createLogicalAnd(
+            func(ts.factory.createElementAccessExpression(top, 0), entry[0], {
+              ...explore,
+              postfix: `${explore.postfix}[0]`,
+            }),
+            func(ts.factory.createElementAccessExpression(top, 1), entry[1], {
+              ...explore,
+              postfix: `${explore.postfix}[1]`,
+            }),
+          );
+        },
+        decoder: (input, array, explore) =>
+          ts.factory.createNewExpression(
             ts.factory.createIdentifier("Map"),
             [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
-            [],
+            [
+              decode_array({
+                config: props.config,
+                importer: props.importer,
+                input,
+                array,
+                explore,
+              }),
+            ],
           ),
-          success: ts.factory.createTrue(),
-          failure: (input, expected) =>
-            create_throw_error(importer)(expected)(input),
-        })([])(input, maps, explore),
-        undefined,
-        undefined,
-      );
+        empty: ts.factory.createNewExpression(
+          ts.factory.createIdentifier("Map"),
+          [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
+          [],
+        ),
+        success: ts.factory.createTrue(),
+        failure: (input, expected) =>
+          create_throw_error({
+            importer: props.importer,
+            expected,
+            input,
+          }),
+      })([])(props.input, props.maps, props.explore),
+      undefined,
+      undefined,
+    );
 
-  const explore_objects =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      meta: Metadata,
-      explore: FeatureProgrammer.IExplore,
-    ) =>
-      meta.objects.length === 1
-        ? decode_object(importer)(input, meta.objects[0]!, explore)
-        : ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              importer.useLocal(`${PREFIX}u${meta.union_index!}`),
-            ),
-            undefined,
-            FeatureProgrammer.argumentsArray(config)(explore)(input),
-          );
+  const explore_objects = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    metadata: Metadata;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    props.metadata.objects.length === 1
+      ? decode_object({
+          ...props,
+          object: props.metadata.objects[0]!,
+        })
+      : ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            props.importer.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
+          ),
+          undefined,
+          FeatureProgrammer.argumentsArray(props.config)(props.explore)(
+            props.input,
+          ),
+        );
 
-  const explore_arrays =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      elements: MetadataArray[],
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression =>
-      explore_array_like_union_types(config)(importer)(
+  const explore_arrays = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    arrays: MetadataArray[];
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression =>
+    explore_array_like_union_types({
+      ...props,
+      elements: props.arrays,
+      factory: (next) =>
         UnionExplorer.array({
-          checker: IsProgrammer.decode(project)(importer),
-          decoder: decode_array(config)(importer),
+          checker: IsProgrammer.decode(props.context)(props.importer),
+          decoder: (input, array, explore) =>
+            decode_array({
+              config: props.config,
+              importer: props.importer,
+              input,
+              array,
+              explore,
+            }),
           empty: ts.factory.createIdentifier("[]"),
           success: ts.factory.createTrue(),
           failure: (input, expected) =>
-            create_throw_error(importer)(expected)(input),
+            create_throw_error({
+              importer: props.importer,
+              expected,
+              input,
+            }),
+        })(next.parameters)(next.input, next.elements, next.explore),
+    });
+
+  const explore_array_like_union_types = <
+    T extends MetadataArray | MetadataTuple,
+  >(props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    factory: (next: {
+      parameters: ts.ParameterDeclaration[];
+      input: ts.Expression;
+      elements: T[];
+      explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
+    input: ts.Expression;
+    elements: T[];
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    const arrow = (next: {
+      parameters: ts.ParameterDeclaration[];
+      explore: FeatureProgrammer.IExplore;
+      input: ts.Expression;
+    }): ts.ArrowFunction =>
+      props.factory({
+        elements: props.elements,
+        parameters: next.parameters,
+        input: next.input,
+        explore: next.explore,
+      });
+    if (props.elements.every((e) => e.type.recursive === false))
+      ts.factory.createCallExpression(
+        arrow({
+          parameters: [],
+          explore: props.explore,
+          input: props.input,
         }),
-      )(input, elements, explore);
-
-  const explore_array_like_union_types =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    <T extends MetadataArray | MetadataTuple>(
-      factory: (
-        parameters: ts.ParameterDeclaration[],
-      ) => (
-        input: ts.Expression,
-        elements: T[],
-        explore: FeatureProgrammer.IExplore,
-      ) => ts.ArrowFunction,
-    ) =>
-    (
-      input: ts.Expression,
-      elements: T[],
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      const arrow =
-        (parameters: ts.ParameterDeclaration[]) =>
-        (explore: FeatureProgrammer.IExplore) =>
-        (input: ts.Expression): ts.ArrowFunction =>
-          factory(parameters)(input, elements, explore);
-      if (elements.every((e) => e.type.recursive === false))
-        ts.factory.createCallExpression(
-          arrow([])(explore)(input),
-          undefined,
-          [],
-        );
+        undefined,
+        [],
+      );
 
-      explore = {
-        ...explore,
-        source: "function",
-        from: "array",
-      };
-      return ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          importer.emplaceUnion(
-            config.prefix,
-            elements.map((e) => e.type.name).join(" | "),
-            () =>
-              arrow(
-                FeatureProgrammer.parameterDeclarations(config)(
-                  TypeFactory.keyword("any"),
-                )(ts.factory.createIdentifier("input")),
-              )({
+    const explore: FeatureProgrammer.IExplore = {
+      ...props.explore,
+      source: "function",
+      from: "array",
+    };
+    return ts.factory.createCallExpression(
+      ts.factory.createIdentifier(
+        props.importer.emplaceUnion(
+          props.config.prefix,
+          props.elements.map((e) => e.type.name).join(" | "),
+          () =>
+            arrow({
+              parameters: FeatureProgrammer.parameterDeclarations(props.config)(
+                TypeFactory.keyword("any"),
+              )(ts.factory.createIdentifier("input")),
+              explore: {
                 ...explore,
                 postfix: "",
-              })(ts.factory.createIdentifier("input")),
-          ),
+              },
+              input: ts.factory.createIdentifier("input"),
+            }),
         ),
-        undefined,
-        FeatureProgrammer.argumentsArray(config)(explore)(input),
-      );
-    };
+      ),
+      undefined,
+      FeatureProgrammer.argumentsArray(props.config)(explore)(props.input),
+    );
+  };
 
   /* -----------------------------------------------------------
         CONFIGURATIONS
     ----------------------------------------------------------- */
   const PREFIX = "$c";
 
-  const configure =
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter): FeatureProgrammer.IConfig => {
-      const config: FeatureProgrammer.IConfig = {
-        types: {
-          input: (type, name) =>
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
+  const configure = (props: {
+    context: ITypiaContext;
+    importer: FunctionImporter;
+  }): FeatureProgrammer.IConfig => {
+    const config: FeatureProgrammer.IConfig = {
+      types: {
+        input: (type, name) =>
+          ts.factory.createTypeReferenceNode(
+            name ?? TypeFactory.getFullName(props.context.checker)(type),
+          ),
+        output: (type, name) =>
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
             ),
-          output: (type, name) =>
-            ts.factory.createImportTypeNode(
-              ts.factory.createLiteralTypeNode(
-                ts.factory.createStringLiteral("typia"),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(props.context.checker)(type),
               ),
-              undefined,
-              ts.factory.createIdentifier("Resolved"),
-              [
-                ts.factory.createTypeReferenceNode(
-                  name ?? TypeFactory.getFullName(project.checker)(type),
-                ),
-              ],
-              false,
-            ),
-        },
-        prefix: PREFIX,
-        trace: false,
-        path: false,
-        initializer,
-        decoder: () => decode(project)(config)(importer),
-        objector: {
-          checker: () => IsProgrammer.decode(project)(importer),
-          decoder: () => decode_object(importer),
-          joiner: CloneJoiner.object,
-          unionizer: decode_union_object(
-            IsProgrammer.decode_object(project)(importer),
-          )(decode_object(importer))((exp) => exp)((input, expected) =>
-            create_throw_error(importer)(expected)(input),
+            ],
+            false,
           ),
-          failure: (input, expected) =>
-            create_throw_error(importer)(expected)(input),
-        },
-        generator: {
-          arrays: () => write_array_functions(config)(importer),
-          tuples: () => write_tuple_functions(project)(config)(importer),
-        },
-      };
-      return config;
+      },
+      prefix: PREFIX,
+      trace: false,
+      path: false,
+      initializer,
+      decoder: () => (input, metadata, explore) =>
+        decode({
+          context: props.context,
+          importer: props.importer,
+          config,
+          input,
+          metadata,
+          explore,
+        }),
+      objector: {
+        checker: () => IsProgrammer.decode(props.context)(props.importer),
+        decoder: () => (input, object, explore) =>
+          decode_object({
+            importer: props.importer,
+            input,
+            object,
+            explore,
+          }),
+        joiner: CloneJoiner.object,
+        unionizer: decode_union_object(
+          IsProgrammer.decode_object(props.context)(props.importer),
+        )((input, object, explore) =>
+          decode_object({
+            importer: props.importer,
+            input,
+            object,
+            explore,
+          }),
+        )((exp) => exp)((input, expected) =>
+          create_throw_error({
+            importer: props.importer,
+            expected,
+            input,
+          }),
+        ),
+        failure: (input, expected) =>
+          create_throw_error({
+            importer: props.importer,
+            expected,
+            input,
+          }),
+      },
+      generator: {
+        arrays: () => (collection) =>
+          write_array_functions({
+            importer: props.importer,
+            config,
+            collection,
+          }),
+        tuples: () => (collection) =>
+          write_tuple_functions({
+            context: props.context,
+            importer: props.importer,
+            config,
+            collection,
+          }),
+      },
     };
+    return config;
+  };
 
   const initializer: FeatureProgrammer.IConfig["initializer"] =
-    (project) => (importer) => (type) => {
+    (context) => (importer) => (type) => {
       const collection = new MetadataCollection();
       const result = MetadataFactory.analyze({
-        checker: project.checker,
-        transformer: project.transformer,
+        checker: context.checker,
+        transformer: context.transformer,
         options: {
           escape: false,
           constant: true,
           absorb: true,
-          validate: (meta) => {
+          validate: (metadata) => {
             const output: string[] = [];
-            if (meta.natives.some((n) => n === "WeakSet"))
+            if (metadata.natives.some((n) => n === "WeakSet"))
               output.push("unable to clone WeakSet");
-            else if (meta.natives.some((n) => n === "WeakMap"))
+            else if (metadata.natives.some((n) => n === "WeakMap"))
               output.push("unable to clone WeakMap");
             return output;
           },
@@ -751,35 +887,36 @@ export namespace MiscCloneProgrammer {
       return [collection, result.data];
     };
 
-  const create_throw_error =
-    (importer: FunctionImporter) =>
-    (expected: string) =>
-    (value: ts.Expression) =>
-      ts.factory.createExpressionStatement(
-        ts.factory.createCallExpression(
-          importer.use("throws"),
-          [],
-          [
-            ts.factory.createObjectLiteralExpression(
-              [
-                ts.factory.createPropertyAssignment(
-                  "expected",
-                  ts.factory.createStringLiteral(expected),
-                ),
-                ts.factory.createPropertyAssignment("value", value),
-              ],
-              true,
-            ),
-          ],
-        ),
-      );
+  const create_throw_error = (props: {
+    importer: FunctionImporter;
+    expected: string;
+    input: ts.Expression;
+  }) =>
+    ts.factory.createExpressionStatement(
+      ts.factory.createCallExpression(
+        props.importer.use("throws"),
+        [],
+        [
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createPropertyAssignment(
+                "expected",
+                ts.factory.createStringLiteral(props.expected),
+              ),
+              ts.factory.createPropertyAssignment("value", props.input),
+            ],
+            true,
+          ),
+        ],
+      ),
+    );
 
-  const is_instance = (meta: Metadata): boolean =>
-    !!meta.objects.length ||
-    !!meta.arrays.length ||
-    !!meta.tuples.length ||
-    !!meta.sets.length ||
-    !!meta.maps.length ||
-    !!meta.natives.length ||
-    (meta.rest !== null && is_instance(meta.rest));
+  const is_instance = (metadata: Metadata): boolean =>
+    !!metadata.objects.length ||
+    !!metadata.arrays.length ||
+    !!metadata.tuples.length ||
+    !!metadata.sets.length ||
+    !!metadata.maps.length ||
+    !!metadata.natives.length ||
+    (metadata.rest !== null && is_instance(metadata.rest));
 }