typia 6.7.0 → 6.7.1

package/src/programmers/CheckerProgrammer.ts

@@ -1,1138 +1,1138 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../factories/ExpressionFactory";
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { MetadataCollection } from "../factories/MetadataCollection";
-import { MetadataFactory } from "../factories/MetadataFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { TypeFactory } from "../factories/TypeFactory";
-import { ValueFactory } from "../factories/ValueFactory";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataArray } from "../schemas/metadata/MetadataArray";
-import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
-import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
-
-import { IProject } from "../transformers/IProject";
-import { TransformerError } from "../transformers/TransformerError";
-
-import { FeatureProgrammer } from "./FeatureProgrammer";
-import { IsProgrammer } from "./IsProgrammer";
-import { AtomicPredicator } from "./helpers/AtomicPredicator";
-import { FunctionImporter } from "./helpers/FunctionImporter";
-import { ICheckEntry } from "./helpers/ICheckEntry";
-import { IExpressionEntry } from "./helpers/IExpressionEntry";
-import { OptionPredicator } from "./helpers/OptionPredicator";
-import { UnionExplorer } from "./helpers/UnionExplorer";
-import { check_array_length } from "./internal/check_array_length";
-import { check_bigint } from "./internal/check_bigint";
-import { check_native } from "./internal/check_native";
-import { check_number } from "./internal/check_number";
-import { check_string } from "./internal/check_string";
-import { check_template } from "./internal/check_template";
-import { decode_union_object } from "./internal/decode_union_object";
-import { postfix_of_tuple } from "./internal/postfix_of_tuple";
-import { wrap_metadata_rest_tuple } from "./internal/wrap_metadata_rest_tuple";
-
-export namespace CheckerProgrammer {
-  export interface IConfig {
-    prefix: string;
-    path: boolean;
-    trace: boolean;
-    equals: boolean;
-    numeric: boolean;
-    addition?: () => ts.Statement[];
-    decoder?: () => FeatureProgrammer.Decoder<Metadata, ts.Expression>;
-    combiner: IConfig.Combiner;
-    atomist: (
-      explore: IExplore,
-    ) => (check: ICheckEntry) => (input: ts.Expression) => ts.Expression;
-    joiner: IConfig.IJoiner;
-    success: ts.Expression;
-  }
-  export namespace IConfig {
-    export interface Combiner {
-      (explorer: IExplore): {
-        (logic: "and" | "or"): {
-          (
-            input: ts.Expression,
-            binaries: IBinary[],
-            expected: string,
-          ): ts.Expression;
-        };
-      };
-    }
-    export interface IJoiner {
-      object(input: ts.Expression, entries: IExpressionEntry[]): ts.Expression;
-      array(input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression;
-      tuple?: undefined | ((exprs: ts.Expression[]) => ts.Expression);
-
-      failure(
-        value: ts.Expression,
-        expected: string,
-        explore?: undefined | FeatureProgrammer.IExplore,
-      ): ts.Expression;
-      is?(expression: ts.Expression): ts.Expression;
-      required?(exp: ts.Expression): ts.Expression;
-      full?:
-        | undefined
-        | ((
-            condition: ts.Expression,
-          ) => (
-            input: ts.Expression,
-            expected: string,
-            explore: IExplore,
-          ) => ts.Expression);
-    }
-  }
-  export type IExplore = FeatureProgrammer.IExplore;
-
-  export interface IBinary {
-    expression: ts.Expression;
-    combined: boolean;
-  }
-
-  /* -----------------------------------------------------------
-        WRITERS
-    ----------------------------------------------------------- */
-  export const compose = (props: {
-    project: IProject;
-    config: IConfig;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name?: string;
-  }) =>
-    FeatureProgrammer.compose({
-      ...props,
-      config: configure(props.project)(props.config)(props.importer),
-    });
-
-  export const write =
-    (project: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-      FeatureProgrammer.write(project)(configure(project)(config)(importer))(
-        importer,
-      );
-
-  export const write_object_functions =
-    (project: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-      FeatureProgrammer.write_object_functions(
-        configure(project)(config)(importer),
-      )(importer);
-
-  export const write_union_functions =
-    (project: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-      FeatureProgrammer.write_union_functions(
-        configure(project)({ ...config, numeric: false })(importer),
-      );
-
-  export const write_array_functions =
-    (project: IProject) =>
-    (config: 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")),
-              TypeFactory.keyword("any"),
-              undefined,
-              decode_array_inline(project)(config)(importer)(
-                ts.factory.createIdentifier("input"),
-                MetadataArray.create({
-                  type,
-                  tags: [],
-                }),
-                {
-                  tracable: config.trace,
-                  source: "function",
-                  from: "array",
-                  postfix: "",
-                },
-              ),
-            ),
-          ),
-        );
-
-  export const write_tuple_functions =
-    (project: IProject) =>
-    (config: 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")),
-              TypeFactory.keyword("any"),
-              undefined,
-              decode_tuple_inline(project)(config)(importer)(
-                ts.factory.createIdentifier("input"),
-                tuple,
-                {
-                  tracable: config.trace,
-                  source: "function",
-                  from: "array",
-                  postfix: "",
-                },
-              ),
-            ),
-          ),
-        );
-
-  const configure =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
-      types: {
-        input: () => TypeFactory.keyword("any"),
-        output: (type, name) =>
-          ts.factory.createTypePredicateNode(
-            undefined,
-            "input",
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
-            ),
-          ),
-      },
-      trace: config.trace,
-      path: config.path,
-      prefix: config.prefix,
-      initializer: (project) => (importer) => (type) => {
-        const collection: MetadataCollection = new MetadataCollection();
-        const result = MetadataFactory.analyze(
-          project.checker,
-          project.context,
-        )({
-          escape: false,
-          constant: true,
-          absorb: true,
-        })(collection)(type);
-        if (result.success === false)
-          throw TransformerError.from(`typia.${importer.method}`)(
-            result.errors,
-          );
-        return [collection, result.data];
-      },
-      addition: config.addition,
-      decoder: () => config.decoder?.() ?? decode(project)(config)(importer),
-      objector: {
-        checker: () => config.decoder?.() ?? decode(project)(config)(importer),
-        decoder: () => decode_object(config)(importer),
-        joiner: config.joiner.object,
-        unionizer: config.equals
-          ? decode_union_object(decode_object(config)(importer))(
-              (input, obj, explore) =>
-                decode_object(config)(importer)(input, obj, {
-                  ...explore,
-                  tracable: true,
-                }),
-            )(config.joiner.is ?? ((expr) => expr))((value, expected) =>
-              ts.factory.createReturnStatement(
-                config.joiner.failure(value, expected),
-              ),
-            )
-          : (input, targets, explore) =>
-              config.combiner(explore)("or")(
-                input,
-                targets.map((obj) => ({
-                  expression: decode_object(config)(importer)(
-                    input,
-                    obj,
-                    explore,
-                  ),
-                  combined: true,
-                })),
-                `(${targets.map((t) => t.name).join(" | ")})`,
-              ),
-        failure: (value, expected) =>
-          ts.factory.createReturnStatement(
-            config.joiner.failure(value, expected),
-          ),
-        is: config.joiner.is,
-        required: config.joiner.required,
-        full: config.joiner.full,
-        type: TypeFactory.keyword("boolean"),
-      },
-      generator: {
-        unions: config.numeric
-          ? () =>
-              FeatureProgrammer.write_union_functions(
-                configure(project)({ ...config, numeric: false })(importer),
-              )
-          : undefined,
-        arrays: () => write_array_functions(project)(config)(importer),
-        tuples: () => write_tuple_functions(project)(config)(importer),
-      },
-    });
-
-  /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-  /**
-   * @internal
-   */
-  export const decode =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      meta: Metadata,
-      explore: IExplore,
-    ): ts.Expression => {
-      if (meta.any) return config.success;
-
-      const top: IBinary[] = [];
-      const binaries: IBinary[] = [];
-      const add = create_add(binaries)(input);
-      const getConstantValue = (value: number | string | bigint | boolean) => {
-        if (typeof value === "string")
-          return ts.factory.createStringLiteral(value);
-        else if (typeof value === "bigint")
-          return ExpressionFactory.bigint(value);
-        return ts.factory.createIdentifier(value.toString());
-      };
-
-      //----
-      // CHECK OPTIONAL
-      //----
-      // @todo -> should be elaborated
-      const checkOptional: boolean = meta.empty() || meta.isUnionBucket();
-
-      // NULLABLE
-      if (checkOptional || meta.nullable)
-        (meta.nullable ? add : create_add(top)(input))(
-          meta.nullable,
-          ValueFactory.NULL(),
-        );
-
-      // UNDEFINDABLE
-      if (checkOptional || !meta.isRequired())
-        (meta.isRequired() ? create_add(top)(input) : add)(
-          !meta.isRequired(),
-          ValueFactory.UNDEFINED(),
-        );
-
-      // FUNCTIONAL
-      if (meta.functional === true)
-        if (OptionPredicator.functional(project.options) || meta.size() !== 1)
-          add(
-            true,
-            ts.factory.createStringLiteral("function"),
-            ValueFactory.TYPEOF(input),
-          );
-        else
-          binaries.push({
-            combined: false,
-            expression: config.success,
-          });
-
-      //----
-      // VALUES
-      //----
-      // CONSTANT VALUES
-      const constants: MetadataConstant[] = meta.constants.filter((c) =>
-        AtomicPredicator.constant(meta)(c.type),
-      );
-      const constantLength: number = constants
-        .map((c) => c.values.length)
-        .reduce((a, b) => a + b, 0);
-      if (constantLength >= 10) {
-        const values: Array<boolean | number | string | bigint> = constants
-          .map((c) => c.values.map((v) => v.value))
-          .flat();
-        add(
-          true,
-          ts.factory.createTrue(),
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              importer.emplaceVariable(
-                `${config.prefix}v${importer.increment()}`,
-                ts.factory.createNewExpression(
-                  ts.factory.createIdentifier("Set"),
-                  undefined,
-                  [
-                    ts.factory.createArrayLiteralExpression(
-                      values.map((v) =>
-                        typeof v === "boolean"
-                          ? v === true
-                            ? ts.factory.createTrue()
-                            : ts.factory.createFalse()
-                          : typeof v === "bigint"
-                            ? ExpressionFactory.bigint(v)
-                            : typeof v === "number"
-                              ? ExpressionFactory.number(v)
-                              : ts.factory.createStringLiteral(v.toString()),
-                      ),
-                    ),
-                  ],
-                ),
-              ),
-            )("has"),
-            undefined,
-            [input],
-          ),
-        );
-      } else
-        for (const c of constants)
-          if (AtomicPredicator.constant(meta)(c.type))
-            for (const v of c.values) add(true, getConstantValue(v.value));
-
-      // ATOMIC VALUES
-      for (const atom of meta.atomics)
-        if (AtomicPredicator.atomic(meta)(atom.type) === false) continue;
-        else if (atom.type === "number")
-          binaries.push({
-            expression: config.atomist(explore)(
-              check_number(project, config.numeric)(atom)(input),
-            )(input),
-            combined: false,
-          });
-        else if (atom.type === "bigint")
-          binaries.push({
-            expression: config.atomist(explore)(
-              check_bigint(project)(atom)(input),
-            )(input),
-            combined: false,
-          });
-        else if (atom.type === "string")
-          binaries.push({
-            expression: config.atomist(explore)(
-              check_string(project)(atom)(input),
-            )(input),
-            combined: false,
-          });
-        else
-          add(
-            true,
-            ts.factory.createStringLiteral(atom.type),
-            ValueFactory.TYPEOF(input),
-          );
-
-      // TEMPLATE LITERAL VALUES
-      if (meta.templates.length)
-        if (AtomicPredicator.template(meta))
-          binaries.push({
-            expression: config.atomist(explore)(
-              check_template(meta.templates)(input),
-            )(input),
-            combined: false,
-          });
-
-      // NATIVE CLASSES
-      for (const native of meta.natives)
-        binaries.push({
-          expression: check_native(native)(input),
-          combined: false,
-        });
-
-      //----
-      // INSTANCES
-      //----
-      interface IInstance {
-        pre: ts.Expression;
-        body: ts.Expression | null;
-        expected: string;
-      }
-      const instances: IInstance[] = [];
-      const prepare =
-        (pre: ts.Expression, expected: string) =>
-        (body: ts.Expression | null) =>
-          instances.push({
-            pre,
-            expected,
-            body,
-          });
-
-      // SETS
-      if (meta.sets.length) {
-        const install = prepare(
-          check_native("Set")(input),
-          meta.sets.map((elem) => `Set<${elem.getName()}>`).join(" | "),
-        );
-        if (meta.sets.some((elem) => elem.any)) install(null);
-        else
-          install(
-            explore_sets(project)(config)(importer)(input, meta.sets, {
-              ...explore,
-              from: "array",
-            }),
-          );
-      }
-
-      // MAPS
-      if (meta.maps.length) {
-        const install = prepare(
-          check_native("Map")(input),
-          meta.maps
-            .map(({ key, value }) => `Map<${key}, ${value}>`)
-            .join(" | "),
-        );
-        if (meta.maps.some((elem) => elem.key.any && elem.value.any))
-          install(null);
-        else
-          install(
-            explore_maps(project)(config)(importer)(input, meta.maps, {
-              ...explore,
-              from: "array",
-            }),
-          );
-      }
-
-      // ARRAYS AND TUPLES
-      if (meta.tuples.length + meta.arrays.length > 0) {
-        const install = prepare(
-          config.atomist(explore)({
-            expected: [
-              ...meta.tuples.map((t) => t.type.name),
-              ...meta.arrays.map((a) => a.getName()),
-            ].join(" | "),
-            expression: ExpressionFactory.isArray(input),
-            conditions: [],
-          })(input),
-          [...meta.tuples, ...meta.arrays]
-            .map((elem) => elem.type.name)
-            .join(" | "),
-        );
-        if (meta.arrays.length === 0)
-          if (meta.tuples.length === 1)
-            install(
-              decode_tuple(project)(config)(importer)(input, meta.tuples[0]!, {
-                ...explore,
-                from: "array",
-              }),
-            );
-          // TUPLE ONLY
-          else
-            install(
-              explore_tuples(project)(config)(importer)(input, meta.tuples, {
-                ...explore,
-                from: "array",
-              }),
-            );
-        else if (meta.arrays.some((elem) => elem.type.value.any)) install(null);
-        else if (meta.tuples.length === 0)
-          if (meta.arrays.length === 1)
-            // ARRAY ONLY
-            install(
-              decode_array(project)(config)(importer)(input, meta.arrays[0]!, {
-                ...explore,
-                from: "array",
-              }),
-            );
-          else
-            install(
-              explore_arrays(project)(config)(importer)(input, meta.arrays, {
-                ...explore,
-                from: "array",
-              }),
-            );
-        else
-          install(
-            explore_arrays_and_tuples(project)(config)(importer)(
-              input,
-              [...meta.tuples, ...meta.arrays],
-              explore,
-            ),
-          );
-      }
-
-      // OBJECT
-      if (meta.objects.length > 0)
-        prepare(
-          ExpressionFactory.isObject({
-            checkNull: true,
-            checkArray: meta.objects.some((obj) =>
-              obj.properties.every(
-                (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
-              ),
-            ),
-          })(input),
-          meta.objects.map((obj) => obj.name).join(" | "),
-        )(
-          explore_objects(config)(importer)(input, meta, {
-            ...explore,
-            from: "object",
-          }),
-        );
-
-      if (instances.length) {
-        const transformer =
-          (merger: (x: ts.Expression, y: ts.Expression) => ts.Expression) =>
-          (ins: IInstance) =>
-            ins.body
-              ? {
-                  expression: merger(ins.pre, ins.body),
-                  combined: true,
-                }
-              : {
-                  expression: ins.pre,
-                  combined: false,
-                };
-        if (instances.length === 1)
-          binaries.push(
-            transformer((pre, body) =>
-              config.combiner(explore)("and")(
-                input,
-                [pre, body].map((expression) => ({
-                  expression,
-                  combined: expression !== pre,
-                })),
-                meta.getName(),
-              ),
-            )(instances[0]!),
-          );
-        else
-          binaries.push({
-            expression: config.combiner(explore)("or")(
-              input,
-              instances.map(transformer(ts.factory.createLogicalAnd)),
-              meta.getName(),
-            ),
-            combined: true,
-          });
-      }
-
-      // ESCAPED CASE
-      if (meta.escaped !== null)
-        binaries.push({
-          combined: false,
-          expression:
-            meta.escaped.original.size() === 1 &&
-            meta.escaped.original.natives.length === 1
-              ? check_native(meta.escaped.original.natives[0]!)(input)
-              : ts.factory.createLogicalAnd(
-                  decode(project)(config)(importer)(
-                    input,
-                    meta.escaped.original,
-                    explore,
-                  ),
-                  ts.factory.createLogicalAnd(
-                    IsProgrammer.decode_to_json(false)(input),
-                    decode_escaped(project)(config)(importer)(
-                      input,
-                      meta.escaped.returns,
-                      explore,
-                    ),
-                  ),
-                ),
-        });
-
-      //----
-      // COMBINE CONDITIONS
-      //----
-      return top.length && binaries.length
-        ? config.combiner(explore)("and")(
-            input,
-            [
-              ...top,
-              {
-                expression: config.combiner(explore)("or")(
-                  input,
-                  binaries,
-                  meta.getName(),
-                ),
-                combined: true,
-              },
-            ],
-            meta.getName(),
-          )
-        : binaries.length
-          ? config.combiner(explore)("or")(input, binaries, meta.getName())
-          : config.success;
-    };
-
-  export const decode_object =
-    (config: IConfig) => (importer: FunctionImporter) => {
-      const func = FeatureProgrammer.decode_object(config)(importer);
-      return (input: ts.Expression, obj: MetadataObject, explore: IExplore) => {
-        obj.validated = true;
-        return func(input, obj, explore);
-      };
-    };
-
-  const decode_array =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, array: MetadataArray, explore: IExplore) => {
-      if (array.type.recursive === false)
-        return decode_array_inline(project)(config)(importer)(
-          input,
-          array,
-          explore,
-        );
-
-      explore = {
-        ...explore,
-        source: "function",
-        from: "array",
-      };
-      return ts.factory.createLogicalOr(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier(
-            importer.useLocal(`${config.prefix}a${array.type.index}`),
-          ),
-          undefined,
-          FeatureProgrammer.argumentsArray(config)({
-            ...explore,
-            source: "function",
-            from: "array",
-          })(input),
-        ),
-        config.joiner.failure(input, array.type.name, explore),
-      );
-    };
-
-  const decode_array_inline =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      array: MetadataArray,
-      explore: IExplore,
-    ): ts.Expression => {
-      const length = check_array_length(project)(array)(input);
-      const main = FeatureProgrammer.decode_array({
-        prefix: config.prefix,
-        trace: config.trace,
-        path: config.path,
-        decoder: () => decode(project)(config)(importer),
-      })(importer)(config.joiner.array)(input, array, explore);
-      return length.expression === null && length.conditions.length === 0
-        ? main
-        : ts.factory.createLogicalAnd(
-            config.atomist(explore)(length)(input),
-            main,
-          );
-    };
-
-  const decode_tuple =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      tuple: MetadataTuple,
-      explore: IExplore,
-    ): ts.Expression => {
-      if (tuple.type.recursive === false)
-        return decode_tuple_inline(project)(config)(importer)(
-          input,
-          tuple.type,
-          explore,
-        );
-      explore = {
-        ...explore,
-        source: "function",
-        from: "array",
-      };
-      return ts.factory.createLogicalOr(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier(
-            importer.useLocal(`${config.prefix}t${tuple.type.index}`),
-          ),
-          undefined,
-          FeatureProgrammer.argumentsArray(config)({
-            ...explore,
-            source: "function",
-          })(input),
-        ),
-        config.joiner.failure(input, tuple.type.name, explore),
-      );
-    };
-
-  const decode_tuple_inline =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      tuple: MetadataTupleType,
-      explore: IExplore,
-    ): ts.Expression => {
-      const binaries: ts.Expression[] = tuple.elements
-        .filter((meta) => meta.rest === null)
-        .map((meta, index) =>
-          decode(project)(config)(importer)(
-            ts.factory.createElementAccessExpression(input, index),
-            meta,
-            {
-              ...explore,
-              from: "array",
-              postfix: explore.postfix.length
-                ? `${postfix_of_tuple(explore.postfix)}[${index}]"`
-                : `"[${index}]"`,
-            },
-          ),
-        );
-      const rest: ts.Expression | null =
-        tuple.elements.length && tuple.elements.at(-1)!.rest !== null
-          ? decode(project)(config)(importer)(
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(input)("slice"),
-                undefined,
-                [ExpressionFactory.number(tuple.elements.length - 1)],
-              ),
-              wrap_metadata_rest_tuple(tuple.elements.at(-1)!.rest!),
-              {
-                ...explore,
-                start: tuple.elements.length - 1,
-              },
-            )
-          : null;
-
-      const arrayLength = ts.factory.createPropertyAccessExpression(
-        input,
-        "length",
-      );
-      return config.combiner(explore)("and")(
-        input,
-        [
-          ...(rest === null
-            ? tuple.elements.every((t) => t.optional === false)
-              ? [
-                  {
-                    combined: false,
-                    expression: ts.factory.createStrictEquality(
-                      arrayLength,
-                      ExpressionFactory.number(tuple.elements.length),
-                    ),
-                  },
-                ]
-              : [
-                  {
-                    combined: false,
-                    expression: ts.factory.createLogicalAnd(
-                      ts.factory.createLessThanEquals(
-                        ExpressionFactory.number(
-                          tuple.elements.filter((t) => t.optional === false)
-                            .length,
-                        ),
-                        arrayLength,
-                      ),
-                      ts.factory.createGreaterThanEquals(
-                        ExpressionFactory.number(tuple.elements.length),
-                        arrayLength,
-                      ),
-                    ),
-                  },
-                ]
-            : []),
-          ...(config.joiner.tuple
-            ? [
-                {
-                  expression: config.joiner.tuple(binaries),
-                  combined: true,
-                },
-              ]
-            : binaries.map((expression) => ({
-                expression,
-                combined: true,
-              }))),
-          ...(rest !== null
-            ? [
-                {
-                  expression: rest,
-                  combined: true,
-                },
-              ]
-            : []),
-        ],
-        `[${tuple.elements.map((t) => t.getName()).join(", ")}]`,
-      );
-    };
-
-  const decode_escaped =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, meta: Metadata, explore: IExplore): ts.Expression =>
-      ts.factory.createCallExpression(
-        ts.factory.createParenthesizedExpression(
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-            undefined,
-            undefined,
-            decode(project)(config)(importer)(
-              ts.factory.createIdentifier("input"),
-              meta,
-              explore,
-            ),
-          ),
-        ),
-        undefined,
-        [
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("toJSON"),
-            undefined,
-            [],
-          ),
-        ],
-      );
-
-  /* -----------------------------------------------------------
-        UNION TYPE EXPLORERS
-    ----------------------------------------------------------- */
-  const explore_sets =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      sets: Metadata[],
-      explore: IExplore,
-    ): ts.Expression =>
-      ts.factory.createCallExpression(
-        UnionExplorer.set({
-          checker: decode(project)(config)(importer),
-          decoder: decode_array(project)(config)(importer),
-          empty: config.success,
-          success: config.success,
-          failure: (input, expected, explore) =>
-            ts.factory.createReturnStatement(
-              config.joiner.failure(input, expected, explore),
-            ),
-        })([])(input, sets, explore),
-        undefined,
-        undefined,
-      );
-
-  const explore_maps =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      maps: Metadata.Entry[],
-      explore: IExplore,
-    ): ts.Expression =>
-      ts.factory.createCallExpression(
-        UnionExplorer.map({
-          checker: (input, entry, explore) => {
-            const func = decode(project)(config)(importer);
-            return ts.factory.createLogicalAnd(
-              func(
-                ts.factory.createElementAccessExpression(input, 0),
-                entry[0],
-                {
-                  ...explore,
-                  postfix: `${explore.postfix}[0]`,
-                },
-              ),
-              func(
-                ts.factory.createElementAccessExpression(input, 1),
-                entry[1],
-                {
-                  ...explore,
-                  postfix: `${explore.postfix}[1]`,
-                },
-              ),
-            );
-          },
-          decoder: decode_array(project)(config)(importer),
-          empty: config.success,
-          success: config.success,
-          failure: (input, expected, explore) =>
-            ts.factory.createReturnStatement(
-              config.joiner.failure(input, expected, explore),
-            ),
-        })([])(input, maps, explore),
-        undefined,
-        undefined,
-      );
-
-  const explore_tuples =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      tuples: MetadataTuple[],
-      explore: IExplore,
-    ): ts.Expression =>
-      explore_array_like_union_types(config)(importer)(
-        UnionExplorer.tuple({
-          checker: decode_tuple(project)(config)(importer),
-          decoder: decode_tuple(project)(config)(importer),
-          empty: config.success,
-          success: config.success,
-          failure: (input, expected, explore) =>
-            ts.factory.createReturnStatement(
-              config.joiner.failure(input, expected, explore),
-            ),
-        }),
-      )(input, tuples, explore);
-
-  const explore_arrays =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      arrays: MetadataArray[],
-      explore: IExplore,
-    ): ts.Expression =>
-      explore_array_like_union_types(config)(importer)(
-        UnionExplorer.array({
-          checker: decode(project)(config)(importer),
-          decoder: decode_array(project)(config)(importer),
-          empty: config.success,
-          success: config.success,
-          failure: (input, expected, explore) =>
-            ts.factory.createReturnStatement(
-              config.joiner.failure(input, expected, explore),
-            ),
-        }),
-      )(input, arrays, explore);
-
-  const explore_arrays_and_tuples =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      elements: Array<MetadataArray | MetadataTuple>,
-      explore: IExplore,
-    ): ts.Expression =>
-      explore_array_like_union_types(config)(importer)(
-        UnionExplorer.array_or_tuple({
-          checker: (front, target, explore, array) =>
-            target instanceof MetadataTuple
-              ? decode_tuple(project)(config)(importer)(front, target, explore)
-              : config.atomist(explore)({
-                  expected: elements
-                    .map((elem) =>
-                      elem instanceof MetadataArray
-                        ? elem.getName()
-                        : elem.type.name,
-                    )
-                    .join(" | "),
-                  expression: decode(project)(config)(importer)(
-                    front,
-                    target,
-                    explore,
-                  ),
-                  conditions: [],
-                })(array),
-          decoder: (input, target, explore) =>
-            target instanceof MetadataTuple
-              ? decode_tuple(project)(config)(importer)(input, target, explore)
-              : decode_array(project)(config)(importer)(input, target, explore),
-          empty: config.success,
-          success: config.success,
-          failure: (input, expected, explore) =>
-            ts.factory.createReturnStatement(
-              config.joiner.failure(input, expected, explore),
-            ),
-        }),
-      )(input, elements, explore);
-
-  const explore_array_like_union_types =
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    <T extends MetadataArray | MetadataTuple>(
-      factory: (
-        parameters: ts.ParameterDeclaration[],
-      ) => (
-        input: ts.Expression,
-        elements: T[],
-        explore: IExplore,
-      ) => ts.ArrowFunction,
-    ) =>
-    (input: ts.Expression, elements: T[], explore: IExplore): ts.Expression => {
-      const arrow =
-        (parameters: ts.ParameterDeclaration[]) =>
-        (explore: 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,
-          [],
-        );
-      explore = {
-        ...explore,
-        source: "function",
-        from: "array",
-      };
-      return ts.factory.createLogicalOr(
-        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")),
-                )({
-                  ...explore,
-                  postfix: "",
-                })(ts.factory.createIdentifier("input")),
-            ),
-          ),
-          undefined,
-          FeatureProgrammer.argumentsArray(config)(explore)(input),
-        ),
-        config.joiner.failure(
-          input,
-          elements.map((e) => e.type.name).join(" | "),
-          explore,
-        ),
-      );
-    };
-
-  const explore_objects =
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, meta: Metadata, explore: IExplore) =>
-      meta.objects.length === 1
-        ? decode_object(config)(importer)(input, meta.objects[0]!, explore)
-        : ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              importer.useLocal(`${config.prefix}u${meta.union_index!}`),
-            ),
-            undefined,
-            FeatureProgrammer.argumentsArray(config)(explore)(input),
-          );
-}
-
-const create_add =
-  (binaries: CheckerProgrammer.IBinary[]) =>
-  (defaultInput: ts.Expression) =>
-  (
-    exact: boolean,
-    left: ts.Expression,
-    right: ts.Expression = defaultInput,
-  ) => {
-    const factory = exact
-      ? ts.factory.createStrictEquality
-      : ts.factory.createStrictInequality;
-    binaries.push({
-      expression: factory(left, right),
-      combined: false,
-    });
-  };
+import ts from "typescript";
+
+import { ExpressionFactory } from "../factories/ExpressionFactory";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { MetadataFactory } from "../factories/MetadataFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+import { ValueFactory } from "../factories/ValueFactory";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataArray } from "../schemas/metadata/MetadataArray";
+import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
+
+import { IProject } from "../transformers/IProject";
+import { TransformerError } from "../transformers/TransformerError";
+
+import { FeatureProgrammer } from "./FeatureProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
+import { AtomicPredicator } from "./helpers/AtomicPredicator";
+import { FunctionImporter } from "./helpers/FunctionImporter";
+import { ICheckEntry } from "./helpers/ICheckEntry";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+import { OptionPredicator } from "./helpers/OptionPredicator";
+import { UnionExplorer } from "./helpers/UnionExplorer";
+import { check_array_length } from "./internal/check_array_length";
+import { check_bigint } from "./internal/check_bigint";
+import { check_native } from "./internal/check_native";
+import { check_number } from "./internal/check_number";
+import { check_string } from "./internal/check_string";
+import { check_template } from "./internal/check_template";
+import { decode_union_object } from "./internal/decode_union_object";
+import { postfix_of_tuple } from "./internal/postfix_of_tuple";
+import { wrap_metadata_rest_tuple } from "./internal/wrap_metadata_rest_tuple";
+
+export namespace CheckerProgrammer {
+  export interface IConfig {
+    prefix: string;
+    path: boolean;
+    trace: boolean;
+    equals: boolean;
+    numeric: boolean;
+    addition?: () => ts.Statement[];
+    decoder?: () => FeatureProgrammer.Decoder<Metadata, ts.Expression>;
+    combiner: IConfig.Combiner;
+    atomist: (
+      explore: IExplore,
+    ) => (check: ICheckEntry) => (input: ts.Expression) => ts.Expression;
+    joiner: IConfig.IJoiner;
+    success: ts.Expression;
+  }
+  export namespace IConfig {
+    export interface Combiner {
+      (explorer: IExplore): {
+        (logic: "and" | "or"): {
+          (
+            input: ts.Expression,
+            binaries: IBinary[],
+            expected: string,
+          ): ts.Expression;
+        };
+      };
+    }
+    export interface IJoiner {
+      object(input: ts.Expression, entries: IExpressionEntry[]): ts.Expression;
+      array(input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression;
+      tuple?: undefined | ((exprs: ts.Expression[]) => ts.Expression);
+
+      failure(
+        value: ts.Expression,
+        expected: string,
+        explore?: undefined | FeatureProgrammer.IExplore,
+      ): ts.Expression;
+      is?(expression: ts.Expression): ts.Expression;
+      required?(exp: ts.Expression): ts.Expression;
+      full?:
+        | undefined
+        | ((
+            condition: ts.Expression,
+          ) => (
+            input: ts.Expression,
+            expected: string,
+            explore: IExplore,
+          ) => ts.Expression);
+    }
+  }
+  export type IExplore = FeatureProgrammer.IExplore;
+
+  export interface IBinary {
+    expression: ts.Expression;
+    combined: boolean;
+  }
+
+  /* -----------------------------------------------------------
+        WRITERS
+    ----------------------------------------------------------- */
+  export const compose = (props: {
+    project: IProject;
+    config: IConfig;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+  }) =>
+    FeatureProgrammer.compose({
+      ...props,
+      config: configure(props.project)(props.config)(props.importer),
+    });
+
+  export const write =
+    (project: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
+      FeatureProgrammer.write(project)(configure(project)(config)(importer))(
+        importer,
+      );
+
+  export const write_object_functions =
+    (project: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
+      FeatureProgrammer.write_object_functions(
+        configure(project)(config)(importer),
+      )(importer);
+
+  export const write_union_functions =
+    (project: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
+      FeatureProgrammer.write_union_functions(
+        configure(project)({ ...config, numeric: false })(importer),
+      );
+
+  export const write_array_functions =
+    (project: IProject) =>
+    (config: 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")),
+              TypeFactory.keyword("any"),
+              undefined,
+              decode_array_inline(project)(config)(importer)(
+                ts.factory.createIdentifier("input"),
+                MetadataArray.create({
+                  type,
+                  tags: [],
+                }),
+                {
+                  tracable: config.trace,
+                  source: "function",
+                  from: "array",
+                  postfix: "",
+                },
+              ),
+            ),
+          ),
+        );
+
+  export const write_tuple_functions =
+    (project: IProject) =>
+    (config: 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")),
+              TypeFactory.keyword("any"),
+              undefined,
+              decode_tuple_inline(project)(config)(importer)(
+                ts.factory.createIdentifier("input"),
+                tuple,
+                {
+                  tracable: config.trace,
+                  source: "function",
+                  from: "array",
+                  postfix: "",
+                },
+              ),
+            ),
+          ),
+        );
+
+  const configure =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
+      types: {
+        input: () => TypeFactory.keyword("any"),
+        output: (type, name) =>
+          ts.factory.createTypePredicateNode(
+            undefined,
+            "input",
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ),
+      },
+      trace: config.trace,
+      path: config.path,
+      prefix: config.prefix,
+      initializer: (project) => (importer) => (type) => {
+        const collection: MetadataCollection = new MetadataCollection();
+        const result = MetadataFactory.analyze(
+          project.checker,
+          project.context,
+        )({
+          escape: false,
+          constant: true,
+          absorb: true,
+        })(collection)(type);
+        if (result.success === false)
+          throw TransformerError.from(`typia.${importer.method}`)(
+            result.errors,
+          );
+        return [collection, result.data];
+      },
+      addition: config.addition,
+      decoder: () => config.decoder?.() ?? decode(project)(config)(importer),
+      objector: {
+        checker: () => config.decoder?.() ?? decode(project)(config)(importer),
+        decoder: () => decode_object(config)(importer),
+        joiner: config.joiner.object,
+        unionizer: config.equals
+          ? decode_union_object(decode_object(config)(importer))(
+              (input, obj, explore) =>
+                decode_object(config)(importer)(input, obj, {
+                  ...explore,
+                  tracable: true,
+                }),
+            )(config.joiner.is ?? ((expr) => expr))((value, expected) =>
+              ts.factory.createReturnStatement(
+                config.joiner.failure(value, expected),
+              ),
+            )
+          : (input, targets, explore) =>
+              config.combiner(explore)("or")(
+                input,
+                targets.map((obj) => ({
+                  expression: decode_object(config)(importer)(
+                    input,
+                    obj,
+                    explore,
+                  ),
+                  combined: true,
+                })),
+                `(${targets.map((t) => t.name).join(" | ")})`,
+              ),
+        failure: (value, expected) =>
+          ts.factory.createReturnStatement(
+            config.joiner.failure(value, expected),
+          ),
+        is: config.joiner.is,
+        required: config.joiner.required,
+        full: config.joiner.full,
+        type: TypeFactory.keyword("boolean"),
+      },
+      generator: {
+        unions: config.numeric
+          ? () =>
+              FeatureProgrammer.write_union_functions(
+                configure(project)({ ...config, numeric: false })(importer),
+              )
+          : undefined,
+        arrays: () => write_array_functions(project)(config)(importer),
+        tuples: () => write_tuple_functions(project)(config)(importer),
+      },
+    });
+
+  /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+  /**
+   * @internal
+   */
+  export const decode =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      meta: Metadata,
+      explore: IExplore,
+    ): ts.Expression => {
+      if (meta.any) return config.success;
+
+      const top: IBinary[] = [];
+      const binaries: IBinary[] = [];
+      const add = create_add(binaries)(input);
+      const getConstantValue = (value: number | string | bigint | boolean) => {
+        if (typeof value === "string")
+          return ts.factory.createStringLiteral(value);
+        else if (typeof value === "bigint")
+          return ExpressionFactory.bigint(value);
+        return ts.factory.createIdentifier(value.toString());
+      };
+
+      //----
+      // CHECK OPTIONAL
+      //----
+      // @todo -> should be elaborated
+      const checkOptional: boolean = meta.empty() || meta.isUnionBucket();
+
+      // NULLABLE
+      if (checkOptional || meta.nullable)
+        (meta.nullable ? add : create_add(top)(input))(
+          meta.nullable,
+          ValueFactory.NULL(),
+        );
+
+      // UNDEFINDABLE
+      if (checkOptional || !meta.isRequired())
+        (meta.isRequired() ? create_add(top)(input) : add)(
+          !meta.isRequired(),
+          ValueFactory.UNDEFINED(),
+        );
+
+      // FUNCTIONAL
+      if (meta.functional === true)
+        if (OptionPredicator.functional(project.options) || meta.size() !== 1)
+          add(
+            true,
+            ts.factory.createStringLiteral("function"),
+            ValueFactory.TYPEOF(input),
+          );
+        else
+          binaries.push({
+            combined: false,
+            expression: config.success,
+          });
+
+      //----
+      // VALUES
+      //----
+      // CONSTANT VALUES
+      const constants: MetadataConstant[] = meta.constants.filter((c) =>
+        AtomicPredicator.constant(meta)(c.type),
+      );
+      const constantLength: number = constants
+        .map((c) => c.values.length)
+        .reduce((a, b) => a + b, 0);
+      if (constantLength >= 10) {
+        const values: Array<boolean | number | string | bigint> = constants
+          .map((c) => c.values.map((v) => v.value))
+          .flat();
+        add(
+          true,
+          ts.factory.createTrue(),
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              importer.emplaceVariable(
+                `${config.prefix}v${importer.increment()}`,
+                ts.factory.createNewExpression(
+                  ts.factory.createIdentifier("Set"),
+                  undefined,
+                  [
+                    ts.factory.createArrayLiteralExpression(
+                      values.map((v) =>
+                        typeof v === "boolean"
+                          ? v === true
+                            ? ts.factory.createTrue()
+                            : ts.factory.createFalse()
+                          : typeof v === "bigint"
+                            ? ExpressionFactory.bigint(v)
+                            : typeof v === "number"
+                              ? ExpressionFactory.number(v)
+                              : ts.factory.createStringLiteral(v.toString()),
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            )("has"),
+            undefined,
+            [input],
+          ),
+        );
+      } else
+        for (const c of constants)
+          if (AtomicPredicator.constant(meta)(c.type))
+            for (const v of c.values) add(true, getConstantValue(v.value));
+
+      // ATOMIC VALUES
+      for (const atom of meta.atomics)
+        if (AtomicPredicator.atomic(meta)(atom.type) === false) continue;
+        else if (atom.type === "number")
+          binaries.push({
+            expression: config.atomist(explore)(
+              check_number(project, config.numeric)(atom)(input),
+            )(input),
+            combined: false,
+          });
+        else if (atom.type === "bigint")
+          binaries.push({
+            expression: config.atomist(explore)(
+              check_bigint(project)(atom)(input),
+            )(input),
+            combined: false,
+          });
+        else if (atom.type === "string")
+          binaries.push({
+            expression: config.atomist(explore)(
+              check_string(project)(atom)(input),
+            )(input),
+            combined: false,
+          });
+        else
+          add(
+            true,
+            ts.factory.createStringLiteral(atom.type),
+            ValueFactory.TYPEOF(input),
+          );
+
+      // TEMPLATE LITERAL VALUES
+      if (meta.templates.length)
+        if (AtomicPredicator.template(meta))
+          binaries.push({
+            expression: config.atomist(explore)(
+              check_template(meta.templates)(input),
+            )(input),
+            combined: false,
+          });
+
+      // NATIVE CLASSES
+      for (const native of meta.natives)
+        binaries.push({
+          expression: check_native(native)(input),
+          combined: false,
+        });
+
+      //----
+      // INSTANCES
+      //----
+      interface IInstance {
+        pre: ts.Expression;
+        body: ts.Expression | null;
+        expected: string;
+      }
+      const instances: IInstance[] = [];
+      const prepare =
+        (pre: ts.Expression, expected: string) =>
+        (body: ts.Expression | null) =>
+          instances.push({
+            pre,
+            expected,
+            body,
+          });
+
+      // SETS
+      if (meta.sets.length) {
+        const install = prepare(
+          check_native("Set")(input),
+          meta.sets.map((elem) => `Set<${elem.getName()}>`).join(" | "),
+        );
+        if (meta.sets.some((elem) => elem.any)) install(null);
+        else
+          install(
+            explore_sets(project)(config)(importer)(input, meta.sets, {
+              ...explore,
+              from: "array",
+            }),
+          );
+      }
+
+      // MAPS
+      if (meta.maps.length) {
+        const install = prepare(
+          check_native("Map")(input),
+          meta.maps
+            .map(({ key, value }) => `Map<${key}, ${value}>`)
+            .join(" | "),
+        );
+        if (meta.maps.some((elem) => elem.key.any && elem.value.any))
+          install(null);
+        else
+          install(
+            explore_maps(project)(config)(importer)(input, meta.maps, {
+              ...explore,
+              from: "array",
+            }),
+          );
+      }
+
+      // ARRAYS AND TUPLES
+      if (meta.tuples.length + meta.arrays.length > 0) {
+        const install = prepare(
+          config.atomist(explore)({
+            expected: [
+              ...meta.tuples.map((t) => t.type.name),
+              ...meta.arrays.map((a) => a.getName()),
+            ].join(" | "),
+            expression: ExpressionFactory.isArray(input),
+            conditions: [],
+          })(input),
+          [...meta.tuples, ...meta.arrays]
+            .map((elem) => elem.type.name)
+            .join(" | "),
+        );
+        if (meta.arrays.length === 0)
+          if (meta.tuples.length === 1)
+            install(
+              decode_tuple(project)(config)(importer)(input, meta.tuples[0]!, {
+                ...explore,
+                from: "array",
+              }),
+            );
+          // TUPLE ONLY
+          else
+            install(
+              explore_tuples(project)(config)(importer)(input, meta.tuples, {
+                ...explore,
+                from: "array",
+              }),
+            );
+        else if (meta.arrays.some((elem) => elem.type.value.any)) install(null);
+        else if (meta.tuples.length === 0)
+          if (meta.arrays.length === 1)
+            // ARRAY ONLY
+            install(
+              decode_array(project)(config)(importer)(input, meta.arrays[0]!, {
+                ...explore,
+                from: "array",
+              }),
+            );
+          else
+            install(
+              explore_arrays(project)(config)(importer)(input, meta.arrays, {
+                ...explore,
+                from: "array",
+              }),
+            );
+        else
+          install(
+            explore_arrays_and_tuples(project)(config)(importer)(
+              input,
+              [...meta.tuples, ...meta.arrays],
+              explore,
+            ),
+          );
+      }
+
+      // OBJECT
+      if (meta.objects.length > 0)
+        prepare(
+          ExpressionFactory.isObject({
+            checkNull: true,
+            checkArray: meta.objects.some((obj) =>
+              obj.properties.every(
+                (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
+              ),
+            ),
+          })(input),
+          meta.objects.map((obj) => obj.name).join(" | "),
+        )(
+          explore_objects(config)(importer)(input, meta, {
+            ...explore,
+            from: "object",
+          }),
+        );
+
+      if (instances.length) {
+        const transformer =
+          (merger: (x: ts.Expression, y: ts.Expression) => ts.Expression) =>
+          (ins: IInstance) =>
+            ins.body
+              ? {
+                  expression: merger(ins.pre, ins.body),
+                  combined: true,
+                }
+              : {
+                  expression: ins.pre,
+                  combined: false,
+                };
+        if (instances.length === 1)
+          binaries.push(
+            transformer((pre, body) =>
+              config.combiner(explore)("and")(
+                input,
+                [pre, body].map((expression) => ({
+                  expression,
+                  combined: expression !== pre,
+                })),
+                meta.getName(),
+              ),
+            )(instances[0]!),
+          );
+        else
+          binaries.push({
+            expression: config.combiner(explore)("or")(
+              input,
+              instances.map(transformer(ts.factory.createLogicalAnd)),
+              meta.getName(),
+            ),
+            combined: true,
+          });
+      }
+
+      // ESCAPED CASE
+      if (meta.escaped !== null)
+        binaries.push({
+          combined: false,
+          expression:
+            meta.escaped.original.size() === 1 &&
+            meta.escaped.original.natives.length === 1
+              ? check_native(meta.escaped.original.natives[0]!)(input)
+              : ts.factory.createLogicalAnd(
+                  decode(project)(config)(importer)(
+                    input,
+                    meta.escaped.original,
+                    explore,
+                  ),
+                  ts.factory.createLogicalAnd(
+                    IsProgrammer.decode_to_json(false)(input),
+                    decode_escaped(project)(config)(importer)(
+                      input,
+                      meta.escaped.returns,
+                      explore,
+                    ),
+                  ),
+                ),
+        });
+
+      //----
+      // COMBINE CONDITIONS
+      //----
+      return top.length && binaries.length
+        ? config.combiner(explore)("and")(
+            input,
+            [
+              ...top,
+              {
+                expression: config.combiner(explore)("or")(
+                  input,
+                  binaries,
+                  meta.getName(),
+                ),
+                combined: true,
+              },
+            ],
+            meta.getName(),
+          )
+        : binaries.length
+          ? config.combiner(explore)("or")(input, binaries, meta.getName())
+          : config.success;
+    };
+
+  export const decode_object =
+    (config: IConfig) => (importer: FunctionImporter) => {
+      const func = FeatureProgrammer.decode_object(config)(importer);
+      return (input: ts.Expression, obj: MetadataObject, explore: IExplore) => {
+        obj.validated = true;
+        return func(input, obj, explore);
+      };
+    };
+
+  const decode_array =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, array: MetadataArray, explore: IExplore) => {
+      if (array.type.recursive === false)
+        return decode_array_inline(project)(config)(importer)(
+          input,
+          array,
+          explore,
+        );
+
+      explore = {
+        ...explore,
+        source: "function",
+        from: "array",
+      };
+      return ts.factory.createLogicalOr(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            importer.useLocal(`${config.prefix}a${array.type.index}`),
+          ),
+          undefined,
+          FeatureProgrammer.argumentsArray(config)({
+            ...explore,
+            source: "function",
+            from: "array",
+          })(input),
+        ),
+        config.joiner.failure(input, array.type.name, explore),
+      );
+    };
+
+  const decode_array_inline =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      array: MetadataArray,
+      explore: IExplore,
+    ): ts.Expression => {
+      const length = check_array_length(project)(array)(input);
+      const main = FeatureProgrammer.decode_array({
+        prefix: config.prefix,
+        trace: config.trace,
+        path: config.path,
+        decoder: () => decode(project)(config)(importer),
+      })(importer)(config.joiner.array)(input, array, explore);
+      return length.expression === null && length.conditions.length === 0
+        ? main
+        : ts.factory.createLogicalAnd(
+            config.atomist(explore)(length)(input),
+            main,
+          );
+    };
+
+  const decode_tuple =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      tuple: MetadataTuple,
+      explore: IExplore,
+    ): ts.Expression => {
+      if (tuple.type.recursive === false)
+        return decode_tuple_inline(project)(config)(importer)(
+          input,
+          tuple.type,
+          explore,
+        );
+      explore = {
+        ...explore,
+        source: "function",
+        from: "array",
+      };
+      return ts.factory.createLogicalOr(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            importer.useLocal(`${config.prefix}t${tuple.type.index}`),
+          ),
+          undefined,
+          FeatureProgrammer.argumentsArray(config)({
+            ...explore,
+            source: "function",
+          })(input),
+        ),
+        config.joiner.failure(input, tuple.type.name, explore),
+      );
+    };
+
+  const decode_tuple_inline =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      tuple: MetadataTupleType,
+      explore: IExplore,
+    ): ts.Expression => {
+      const binaries: ts.Expression[] = tuple.elements
+        .filter((meta) => meta.rest === null)
+        .map((meta, index) =>
+          decode(project)(config)(importer)(
+            ts.factory.createElementAccessExpression(input, index),
+            meta,
+            {
+              ...explore,
+              from: "array",
+              postfix: explore.postfix.length
+                ? `${postfix_of_tuple(explore.postfix)}[${index}]"`
+                : `"[${index}]"`,
+            },
+          ),
+        );
+      const rest: ts.Expression | null =
+        tuple.elements.length && tuple.elements.at(-1)!.rest !== null
+          ? decode(project)(config)(importer)(
+              ts.factory.createCallExpression(
+                IdentifierFactory.access(input)("slice"),
+                undefined,
+                [ExpressionFactory.number(tuple.elements.length - 1)],
+              ),
+              wrap_metadata_rest_tuple(tuple.elements.at(-1)!.rest!),
+              {
+                ...explore,
+                start: tuple.elements.length - 1,
+              },
+            )
+          : null;
+
+      const arrayLength = ts.factory.createPropertyAccessExpression(
+        input,
+        "length",
+      );
+      return config.combiner(explore)("and")(
+        input,
+        [
+          ...(rest === null
+            ? tuple.elements.every((t) => t.optional === false)
+              ? [
+                  {
+                    combined: false,
+                    expression: ts.factory.createStrictEquality(
+                      arrayLength,
+                      ExpressionFactory.number(tuple.elements.length),
+                    ),
+                  },
+                ]
+              : [
+                  {
+                    combined: false,
+                    expression: ts.factory.createLogicalAnd(
+                      ts.factory.createLessThanEquals(
+                        ExpressionFactory.number(
+                          tuple.elements.filter((t) => t.optional === false)
+                            .length,
+                        ),
+                        arrayLength,
+                      ),
+                      ts.factory.createGreaterThanEquals(
+                        ExpressionFactory.number(tuple.elements.length),
+                        arrayLength,
+                      ),
+                    ),
+                  },
+                ]
+            : []),
+          ...(config.joiner.tuple
+            ? [
+                {
+                  expression: config.joiner.tuple(binaries),
+                  combined: true,
+                },
+              ]
+            : binaries.map((expression) => ({
+                expression,
+                combined: true,
+              }))),
+          ...(rest !== null
+            ? [
+                {
+                  expression: rest,
+                  combined: true,
+                },
+              ]
+            : []),
+        ],
+        `[${tuple.elements.map((t) => t.getName()).join(", ")}]`,
+      );
+    };
+
+  const decode_escaped =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, meta: Metadata, explore: IExplore): ts.Expression =>
+      ts.factory.createCallExpression(
+        ts.factory.createParenthesizedExpression(
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+            undefined,
+            undefined,
+            decode(project)(config)(importer)(
+              ts.factory.createIdentifier("input"),
+              meta,
+              explore,
+            ),
+          ),
+        ),
+        undefined,
+        [
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(input)("toJSON"),
+            undefined,
+            [],
+          ),
+        ],
+      );
+
+  /* -----------------------------------------------------------
+        UNION TYPE EXPLORERS
+    ----------------------------------------------------------- */
+  const explore_sets =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      sets: Metadata[],
+      explore: IExplore,
+    ): ts.Expression =>
+      ts.factory.createCallExpression(
+        UnionExplorer.set({
+          checker: decode(project)(config)(importer),
+          decoder: decode_array(project)(config)(importer),
+          empty: config.success,
+          success: config.success,
+          failure: (input, expected, explore) =>
+            ts.factory.createReturnStatement(
+              config.joiner.failure(input, expected, explore),
+            ),
+        })([])(input, sets, explore),
+        undefined,
+        undefined,
+      );
+
+  const explore_maps =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      maps: Metadata.Entry[],
+      explore: IExplore,
+    ): ts.Expression =>
+      ts.factory.createCallExpression(
+        UnionExplorer.map({
+          checker: (input, entry, explore) => {
+            const func = decode(project)(config)(importer);
+            return ts.factory.createLogicalAnd(
+              func(
+                ts.factory.createElementAccessExpression(input, 0),
+                entry[0],
+                {
+                  ...explore,
+                  postfix: `${explore.postfix}[0]`,
+                },
+              ),
+              func(
+                ts.factory.createElementAccessExpression(input, 1),
+                entry[1],
+                {
+                  ...explore,
+                  postfix: `${explore.postfix}[1]`,
+                },
+              ),
+            );
+          },
+          decoder: decode_array(project)(config)(importer),
+          empty: config.success,
+          success: config.success,
+          failure: (input, expected, explore) =>
+            ts.factory.createReturnStatement(
+              config.joiner.failure(input, expected, explore),
+            ),
+        })([])(input, maps, explore),
+        undefined,
+        undefined,
+      );
+
+  const explore_tuples =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      tuples: MetadataTuple[],
+      explore: IExplore,
+    ): ts.Expression =>
+      explore_array_like_union_types(config)(importer)(
+        UnionExplorer.tuple({
+          checker: decode_tuple(project)(config)(importer),
+          decoder: decode_tuple(project)(config)(importer),
+          empty: config.success,
+          success: config.success,
+          failure: (input, expected, explore) =>
+            ts.factory.createReturnStatement(
+              config.joiner.failure(input, expected, explore),
+            ),
+        }),
+      )(input, tuples, explore);
+
+  const explore_arrays =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      arrays: MetadataArray[],
+      explore: IExplore,
+    ): ts.Expression =>
+      explore_array_like_union_types(config)(importer)(
+        UnionExplorer.array({
+          checker: decode(project)(config)(importer),
+          decoder: decode_array(project)(config)(importer),
+          empty: config.success,
+          success: config.success,
+          failure: (input, expected, explore) =>
+            ts.factory.createReturnStatement(
+              config.joiner.failure(input, expected, explore),
+            ),
+        }),
+      )(input, arrays, explore);
+
+  const explore_arrays_and_tuples =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+      input: ts.Expression,
+      elements: Array<MetadataArray | MetadataTuple>,
+      explore: IExplore,
+    ): ts.Expression =>
+      explore_array_like_union_types(config)(importer)(
+        UnionExplorer.array_or_tuple({
+          checker: (front, target, explore, array) =>
+            target instanceof MetadataTuple
+              ? decode_tuple(project)(config)(importer)(front, target, explore)
+              : config.atomist(explore)({
+                  expected: elements
+                    .map((elem) =>
+                      elem instanceof MetadataArray
+                        ? elem.getName()
+                        : elem.type.name,
+                    )
+                    .join(" | "),
+                  expression: decode(project)(config)(importer)(
+                    front,
+                    target,
+                    explore,
+                  ),
+                  conditions: [],
+                })(array),
+          decoder: (input, target, explore) =>
+            target instanceof MetadataTuple
+              ? decode_tuple(project)(config)(importer)(input, target, explore)
+              : decode_array(project)(config)(importer)(input, target, explore),
+          empty: config.success,
+          success: config.success,
+          failure: (input, expected, explore) =>
+            ts.factory.createReturnStatement(
+              config.joiner.failure(input, expected, explore),
+            ),
+        }),
+      )(input, elements, explore);
+
+  const explore_array_like_union_types =
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    <T extends MetadataArray | MetadataTuple>(
+      factory: (
+        parameters: ts.ParameterDeclaration[],
+      ) => (
+        input: ts.Expression,
+        elements: T[],
+        explore: IExplore,
+      ) => ts.ArrowFunction,
+    ) =>
+    (input: ts.Expression, elements: T[], explore: IExplore): ts.Expression => {
+      const arrow =
+        (parameters: ts.ParameterDeclaration[]) =>
+        (explore: 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,
+          [],
+        );
+      explore = {
+        ...explore,
+        source: "function",
+        from: "array",
+      };
+      return ts.factory.createLogicalOr(
+        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")),
+                )({
+                  ...explore,
+                  postfix: "",
+                })(ts.factory.createIdentifier("input")),
+            ),
+          ),
+          undefined,
+          FeatureProgrammer.argumentsArray(config)(explore)(input),
+        ),
+        config.joiner.failure(
+          input,
+          elements.map((e) => e.type.name).join(" | "),
+          explore,
+        ),
+      );
+    };
+
+  const explore_objects =
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, meta: Metadata, explore: IExplore) =>
+      meta.objects.length === 1
+        ? decode_object(config)(importer)(input, meta.objects[0]!, explore)
+        : ts.factory.createCallExpression(
+            ts.factory.createIdentifier(
+              importer.useLocal(`${config.prefix}u${meta.union_index!}`),
+            ),
+            undefined,
+            FeatureProgrammer.argumentsArray(config)(explore)(input),
+          );
+}
+
+const create_add =
+  (binaries: CheckerProgrammer.IBinary[]) =>
+  (defaultInput: ts.Expression) =>
+  (
+    exact: boolean,
+    left: ts.Expression,
+    right: ts.Expression = defaultInput,
+  ) => {
+    const factory = exact
+      ? ts.factory.createStrictEquality
+      : ts.factory.createStrictInequality;
+    binaries.push({
+      expression: factory(left, right),
+      combined: false,
+    });
+  };