typia 7.2.1 → 7.3.0-dev.20241213

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -1,945 +1,945 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { NumericRangeFactory } from "../../factories/NumericRangeFactory";
-import { ProtobufFactory } from "../../factories/ProtobufFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataMap } from "../../schemas/metadata/MetadataMap";
-import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
-import { IProtobufProperty } from "../../schemas/protobuf/IProtobufProperty";
-import { IProtobufPropertyType } from "../../schemas/protobuf/IProtobufPropertyType";
-import { IProtobufSchema } from "../../schemas/protobuf/IProtobufSchema";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { ProtobufUtil } from "../helpers/ProtobufUtil";
-import { ProtobufWire } from "../helpers/ProtobufWire";
-import { UnionPredicator } from "../helpers/UnionPredicator";
-import { decode_union_object } from "../internal/decode_union_object";
-
-export namespace ProtobufEncodeProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const collection: MetadataCollection = new MetadataCollection();
-    const metadata: Metadata = ProtobufFactory.metadata({
-      method: props.modulo.getText(),
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      collection,
-      type: props.type,
-    });
-
-    const callEncoder = (writer: string, factory: ts.NewExpression) =>
-      StatementFactory.constant({
-        name: writer,
-        value: ts.factory.createCallExpression(
-          ts.factory.createIdentifier("encoder"),
-          undefined,
-          [factory, ts.factory.createIdentifier("input")],
-        ),
-      });
-    return {
-      functions: {
-        encoder: StatementFactory.constant({
-          name: props.functor.useLocal("encoder"),
-          value: write_encoder({
-            context: props.context,
-            functor: props.functor,
-            collection,
-            metadata,
-          }),
-        }),
-      },
-      statements: [],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "input",
-            ts.factory.createTypeReferenceNode(
-              props.name ??
-                TypeFactory.getFullName({
-                  checker: props.context.checker,
-                  type: props.type,
-                }),
-            ),
-          ),
-        ],
-        ts.factory.createTypeReferenceNode("Uint8Array"),
-        undefined,
-        ts.factory.createBlock(
-          [
-            callEncoder(
-              "sizer",
-              ts.factory.createNewExpression(
-                props.context.importer.internal("ProtobufSizer"),
-                undefined,
-                [],
-              ),
-            ),
-            callEncoder(
-              "writer",
-              ts.factory.createNewExpression(
-                props.context.importer.internal("ProtobufWriter"),
-                undefined,
-                [ts.factory.createIdentifier("sizer")],
-              ),
-            ),
-            ts.factory.createReturnStatement(callWriter("buffer")),
-          ],
-          true,
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-
-  const write_encoder = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    collection: MetadataCollection;
-    metadata: Metadata;
-  }): ts.ArrowFunction => {
-    const functors = props.collection
-      .objects()
-      .filter((obj) => ProtobufUtil.isStaticObject(obj))
-      .map((object) =>
-        StatementFactory.constant({
-          name: `${PREFIX}o${object.index}`,
-          value: write_object_function({
-            context: props.context,
-            functor: props.functor,
-            input: ts.factory.createIdentifier("input"),
-            object,
-            explore: {
-              source: "function",
-              from: "object",
-              tracable: false,
-              postfix: "",
-            },
-          }),
-        }),
-      );
-    return ts.factory.createArrowFunction(
-      undefined,
-      [
-        ts.factory.createTypeParameterDeclaration(
-          undefined,
-          "Writer",
-          props.context.importer.type({
-            file: "typia/lib/internal/_IProtobufWriter.js",
-            name: "_IProtobufWriter",
-          }),
-        ),
-      ],
-      [
-        IdentifierFactory.parameter(
-          "writer",
-          ts.factory.createTypeReferenceNode("Writer"),
-        ),
-        IdentifierFactory.parameter("input"),
-      ],
-      ts.factory.createTypeReferenceNode("Writer"),
-      undefined,
-      ts.factory.createBlock(
-        [
-          ...props.functor.declareUnions(),
-          ...functors,
-          ...IsProgrammer.write_function_statements(props),
-          ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
-                props.functor.useLocal(
-                  `${PREFIX}o${props.metadata.objects[0]?.type.index ?? 0}`,
-                ),
-              ),
-              [],
-              [ts.factory.createIdentifier("input")],
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("writer"),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  const write_object_function = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    input: ts.Expression;
-    object: MetadataObjectType;
-    explore: FeatureProgrammer.IExplore;
-  }): ts.ArrowFunction => {
-    const body: ts.Statement[] = props.object.properties
-      .map((p) => {
-        const block = decode_property({
-          context: props.context,
-          functor: props.functor,
-          explore: props.explore,
-          metadata: p.value,
-          protobuf: p.of_protobuf_!,
-          input: IdentifierFactory.access(props.input, p.key.getSoleLiteral()!),
-        });
-        return [
-          ts.factory.createExpressionStatement(
-            ts.factory.createIdentifier(
-              `// property ${JSON.stringify(p.key.getSoleLiteral())}: ${p.value.getName()}`,
-            ),
-          ),
-          ...block.statements,
-        ];
-      })
-      .flat();
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("input")],
-      TypeFactory.keyword("any"),
-      undefined,
-      ts.factory.createBlock(body, true),
-    );
-  };
-
-  /* -----------------------------------------------------------
-    DECODER STATION
-  ----------------------------------------------------------- */
-  const decode_property = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    metadata: Metadata;
-    protobuf: IProtobufProperty;
-    input: ts.Expression;
-    explore: FeatureProgrammer.IExplore;
-  }): ts.Block => {
-    const union: IUnion[] = [];
-    for (const schema of props.protobuf.union) {
-      //----
-      // ATOMICS
-      //----
-      if (schema.type === "bool")
-        union.push({
-          is: () =>
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("boolean"),
-              ts.factory.createTypeOfExpression(props.input),
-            ),
-          value: () =>
-            decode_bool({
-              input: props.input,
-              index: schema.index,
-            }),
-        });
-      else if (schema.type === "bigint")
-        union.push(
-          decode_bigint({
-            input: props.input,
-            type: schema.name,
-            candidates: props.protobuf.union
-              .filter((s) => s.type === "bigint")
-              .map((s) => s.name),
-            index: schema.index,
-          }),
-        );
-      else if (schema.type === "number")
-        union.push(
-          decode_number({
-            input: props.input,
-            type: schema.name,
-            candidates: props.protobuf.union
-              .filter((s) => s.type === "number")
-              .map((s) => s.name),
-            index: schema.index,
-          }),
-        );
-      else if (schema.type === "string")
-        union.push({
-          is: () =>
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("string"),
-              ts.factory.createTypeOfExpression(props.input),
-            ),
-          value: () =>
-            decode_bytes({
-              method: "string",
-              index: schema.index,
-              input: props.input,
-            }),
-        });
-      //----
-      // INSTANCES
-      //----
-      else if (schema.type === "bytes")
-        union.push({
-          is: () => ExpressionFactory.isInstanceOf("Uint8Array", props.input),
-          value: () =>
-            decode_bytes({
-              method: "bytes",
-              index: schema.index,
-              input: props.input,
-            }),
-        });
-      else if (schema.type === "array")
-        union.push({
-          is: () => ExpressionFactory.isArray(props.input),
-          value: () =>
-            decode_array({
-              context: props.context,
-              functor: props.functor,
-              input: props.input,
-              schema,
-            }),
-        });
-      else if (schema.type === "map" && schema.map instanceof MetadataMap) {
-        union.push({
-          is: () => ExpressionFactory.isInstanceOf("Map", props.input),
-          value: () =>
-            decode_map({
-              context: props.context,
-              functor: props.functor,
-              schema,
-              input: props.input,
-            }),
-        });
-      }
-      const objectSchemas: Array<
-        IProtobufPropertyType.IObject | IProtobufPropertyType.IMap
-      > = props.protobuf.union
-        .filter((schema) => schema.type === "object" || schema.type === "map")
-        .filter(
-          (schema) =>
-            schema.type === "object" ||
-            (schema.type === "map" && schema.map instanceof MetadataObjectType),
-        );
-      if (objectSchemas.length !== 0)
-        union.push({
-          is: () =>
-            ExpressionFactory.isObject({
-              checkNull: true,
-              checkArray: false,
-              input: props.input,
-            }),
-          value: () =>
-            explore_objects({
-              context: props.context,
-              functor: props.functor,
-              level: 0,
-              schemas: objectSchemas,
-              explore: {
-                ...props.explore,
-                from: "object",
-              },
-              input: props.input,
-            }),
-        });
-    }
-
-    // RETURNS
-    const wrapper: (block: ts.Block) => ts.Block =
-      props.metadata.isRequired() && props.metadata.nullable === false
-        ? (block) => block
-        : props.metadata.isRequired() === false &&
-            props.metadata.nullable === true
-          ? (block) =>
-              ts.factory.createBlock(
-                [
-                  ts.factory.createIfStatement(
-                    ts.factory.createLogicalAnd(
-                      ts.factory.createStrictInequality(
-                        ts.factory.createIdentifier("undefined"),
-                        props.input,
-                      ),
-                      ts.factory.createStrictInequality(
-                        ts.factory.createNull(),
-                        props.input,
-                      ),
-                    ),
-                    block,
-                  ),
-                ],
-                true,
-              )
-          : props.metadata.isRequired() === false
-            ? (block) =>
-                ts.factory.createBlock(
-                  [
-                    ts.factory.createIfStatement(
-                      ts.factory.createStrictInequality(
-                        ts.factory.createIdentifier("undefined"),
-                        props.input,
-                      ),
-                      block,
-                    ),
-                  ],
-                  true,
-                )
-            : (block) =>
-                ts.factory.createBlock(
-                  [
-                    ts.factory.createIfStatement(
-                      ts.factory.createStrictInequality(
-                        ts.factory.createNull(),
-                        props.input,
-                      ),
-                      block,
-                    ),
-                  ],
-                  true,
-                );
-    if (union.length === 1) return wrapper(union[0]!.value());
-    return wrapper(
-      ts.factory.createBlock(
-        [
-          union
-            .map((u, i) =>
-              ts.factory.createIfStatement(
-                u.is(),
-                u.value(),
-                i === union.length - 1
-                  ? create_throw_error({
-                      context: props.context,
-                      functor: props.functor,
-                      input: props.input,
-                      expected: props.metadata.getName(),
-                    })
-                  : undefined,
-              ),
-            )
-            .reverse()
-            .reduce((a, b) =>
-              ts.factory.createIfStatement(b.expression, b.thenStatement, a),
-            ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  /* -----------------------------------------------------------
-    ATOMIC DECODERS
-  ----------------------------------------------------------- */
-  const decode_bool = (props: {
-    input: ts.Expression;
-    index: number | null;
-  }): ts.Block =>
-    ts.factory.createBlock(
-      [
-        ...(props.index !== null
-          ? [
-              decode_tag({
-                wire: ProtobufWire.VARIANT,
-                index: props.index,
-              }),
-            ]
-          : []),
-        callWriter("bool", [props.input]),
-      ].map((exp) => ts.factory.createExpressionStatement(exp)),
-      true,
-    );
-
-  const decode_bigint = (props: {
-    candidates: ProtobufAtomic.BigNumeric[];
-    type: ProtobufAtomic.BigNumeric;
-    input: ts.Expression;
-    index: number | null;
-  }): IUnion => ({
-    is: () =>
-      props.candidates.length === 1
-        ? ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("bigint"),
-            ts.factory.createTypeOfExpression(props.input),
-          )
-        : ts.factory.createLogicalAnd(
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("bigint"),
-              ts.factory.createTypeOfExpression(props.input),
-            ),
-            NumericRangeFactory.bigint(props.type, props.input),
-          ),
-    value: () =>
-      ts.factory.createBlock(
-        [
-          ...(props.index !== null
-            ? [
-                decode_tag({
-                  wire: ProtobufWire.VARIANT,
-                  index: props.index,
-                }),
-              ]
-            : []),
-          callWriter(props.type, [props.input]),
-        ].map((exp) => ts.factory.createExpressionStatement(exp)),
-        true,
-      ),
-  });
-
-  const decode_number = (props: {
-    candidates: ProtobufAtomic.Numeric[];
-    type: ProtobufAtomic.Numeric;
-    input: ts.Expression;
-    index: number | null;
-  }): IUnion => ({
-    is: () =>
-      props.candidates.length === 1
-        ? ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("number"),
-            ts.factory.createTypeOfExpression(props.input),
-          )
-        : ts.factory.createLogicalAnd(
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("number"),
-              ts.factory.createTypeOfExpression(props.input),
-            ),
-            NumericRangeFactory.number(props.type, props.input),
-          ),
-    value: () =>
-      ts.factory.createBlock(
-        [
-          ...(props.index !== null
-            ? [
-                decode_tag({
-                  wire: get_numeric_wire(props.type),
-                  index: props.index,
-                }),
-              ]
-            : []),
-          callWriter(props.type, [props.input]),
-        ].map((exp) => ts.factory.createExpressionStatement(exp)),
-        true,
-      ),
-  });
-
-  const decode_container_value = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    schema: IProtobufPropertyType.IArray["value"];
-    index: number;
-    kind: "array" | "map";
-    input: ts.Expression;
-  }): ts.Block => {
-    if (props.schema.type === "bool")
-      return decode_bool({
-        input: props.input,
-        index: props.kind === "array" ? null : props.index,
-      });
-    else if (props.schema.type === "bigint")
-      return decode_bigint({
-        input: props.input,
-        type: props.schema.name,
-        candidates: [props.schema.name],
-        index: props.kind === "array" ? null : props.index,
-      }).value();
-    else if (props.schema.type === "number")
-      return decode_number({
-        input: props.input,
-        type: props.schema.name,
-        candidates: [props.schema.name],
-        index: props.kind === "array" ? null : props.index,
-      }).value();
-    else if (props.schema.type === "string" || props.schema.type === "bytes")
-      return decode_bytes({
-        method: props.schema.type,
-        input: props.input,
-        index: props.index,
-      });
-    return decode_object({
-      context: props.context,
-      functor: props.functor,
-      schema: props.schema,
-      input: props.input,
-      index: props.index,
-    });
-  };
-
-  /* -----------------------------------------------------------
-    INSTANCE DECODERS
-  ----------------------------------------------------------- */
-  const decode_bytes = (props: {
-    method: "bytes" | "string";
-    index: number;
-    input: ts.Expression;
-  }): ts.Block =>
-    ts.factory.createBlock(
-      [
-        decode_tag({
-          wire: ProtobufWire.LEN,
-          index: props.index,
-        }),
-        callWriter(props.method, [props.input]),
-      ].map((expr) => ts.factory.createExpressionStatement(expr)),
-      true,
-    );
-
-  const decode_array = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    schema: IProtobufPropertyType.IArray;
-    input: ts.Expression;
-  }): ts.Block => {
-    const value: IProtobufPropertyType.IArray["value"] = props.schema.value;
-    const wire: ProtobufWire = (() => {
-      if (
-        value.type === "object" ||
-        value.type === "bytes" ||
-        value.type === "string"
-      )
-        return ProtobufWire.LEN;
-      else if (value.type === "number" && value.name === "float")
-        return ProtobufWire.I32;
-      return ProtobufWire.VARIANT;
-    })();
-    const forLoop = () =>
-      ts.factory.createForOfStatement(
-        undefined,
-        ts.factory.createVariableDeclarationList(
-          [ts.factory.createVariableDeclaration("elem")],
-          ts.NodeFlags.Const,
-        ),
-        props.input,
-        decode_container_value({
-          kind: "array",
-          context: props.context,
-          functor: props.functor,
-          input: ts.factory.createIdentifier("elem"),
-          index: props.schema.index,
-          schema: props.schema.value,
-        }),
-      );
-    const length = (block: ts.Block) =>
-      ts.factory.createBlock(
-        [
-          ts.factory.createIfStatement(
-            ts.factory.createStrictInequality(
-              ExpressionFactory.number(0),
-              IdentifierFactory.access(props.input, "length"),
-            ),
-            block,
-          ),
-        ],
-        true,
-      );
-    if (wire === ProtobufWire.LEN)
-      return length(ts.factory.createBlock([forLoop()], true));
-    return length(
-      ts.factory.createBlock(
-        [
-          ts.factory.createExpressionStatement(
-            decode_tag({
-              wire: ProtobufWire.LEN,
-              index: props.schema.index,
-            }),
-          ),
-          ts.factory.createExpressionStatement(callWriter("fork")),
-          forLoop(),
-          ts.factory.createExpressionStatement(callWriter("ldelim")),
-        ],
-        true,
-      ),
-    );
-  };
-
-  const decode_object = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    schema: IProtobufSchema.IObject;
-    index: number;
-    input: ts.Expression;
-  }): ts.Block =>
-    ts.factory.createBlock(
-      [
-        decode_tag({
-          wire: ProtobufWire.LEN,
-          index: props.index,
-        }),
-        callWriter("fork"),
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier(
-            props.functor.useLocal(`${PREFIX}o${props.schema.object.index}`),
-          ),
-          [],
-          [props.input],
-        ),
-        callWriter("ldelim"),
-      ].map(ts.factory.createExpressionStatement),
-      true,
-    );
-
-  const decode_map = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    schema: IProtobufPropertyType.IMap;
-    input: ts.Expression;
-  }): ts.Block => {
-    const each: ts.Statement[] = [
-      ts.factory.createExpressionStatement(
-        decode_tag({
-          wire: ProtobufWire.LEN,
-          index: props.schema.index,
-        }),
-      ),
-      ts.factory.createExpressionStatement(callWriter("fork")),
-      ...decode_container_value({
-        kind: "map",
-        context: props.context,
-        functor: props.functor,
-        index: 1,
-        input: ts.factory.createIdentifier("key"),
-        schema: props.schema.key,
-      }).statements,
-      ...decode_container_value({
-        kind: "map",
-        context: props.context,
-        functor: props.functor,
-        index: 2,
-        input: ts.factory.createIdentifier("value"),
-        schema: props.schema.value,
-      }).statements,
-      ts.factory.createExpressionStatement(callWriter("ldelim")),
-    ];
-    return ts.factory.createBlock(
-      [
-        ts.factory.createForOfStatement(
-          undefined,
-          StatementFactory.entry({
-            key: "key",
-            value: "value",
-          }),
-          props.input,
-          ts.factory.createBlock(each),
-        ),
-      ],
-      true,
-    );
-  };
-
-  const explore_objects = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    level: number;
-    input: ts.Expression;
-    schemas: Array<IProtobufPropertyType.IObject | IProtobufPropertyType.IMap>;
-    explore: FeatureProgrammer.IExplore;
-  }): ts.Block => {
-    const out = (
-      schema: IProtobufPropertyType.IObject | IProtobufPropertyType.IMap,
-    ) =>
-      schema.type === "object"
-        ? decode_object({
-            context: props.context,
-            functor: props.functor,
-            schema,
-            index: schema.index,
-            input: props.input,
-          })
-        : decode_map({
-            context: props.context,
-            functor: props.functor,
-            schema,
-            input: ts.factory.createCallExpression(
-              IdentifierFactory.access(
-                ts.factory.createIdentifier("Object"),
-                "entries",
-              ),
-              undefined,
-              [props.input],
-            ),
-          });
-    if (props.schemas.length === 1) return out(props.schemas[0]!);
-
-    const objects: MetadataObjectType[] = props.schemas.map((s) =>
-      s.type === "map" ? (s.map as MetadataObjectType) : s.object,
-    );
-    const expected: string = `(${objects.map((t) => t.name).join(" | ")})`;
-    const indexes: WeakMap<
-      MetadataObjectType,
-      IProtobufPropertyType.IObject | IProtobufPropertyType.IMap
-    > = new WeakMap(objects.map((o, i) => [o, props.schemas[i]!]));
-    const specifications: UnionPredicator.ISpecialized[] =
-      UnionPredicator.object(objects);
-
-    if (specifications.length === 0) {
-      const condition: ts.Expression = decode_union_object({
-        checker: (v) =>
-          IsProgrammer.decode_object({
-            context: props.context,
-            functor: props.functor,
-            object: v.object,
-            input: v.input,
-            explore: v.explore,
-          }),
-        decoder: (v) => ExpressionFactory.selfCall(out(indexes.get(v.object)!)),
-        success: (expr) => expr,
-        escaper: (v) =>
-          create_throw_error({
-            context: props.context,
-            functor: props.functor,
-            expected: v.expected,
-            input: v.input,
-          }),
-        input: props.input,
-        explore: props.explore,
-        objects,
-      });
-      return StatementFactory.block(condition);
-    }
-    const remained: MetadataObjectType[] = objects.filter(
-      (o) => specifications.find((s) => s.object === o) === undefined,
-    );
-
-    // DO SPECIALIZE
-    const condition: ts.IfStatement = specifications
-      .filter((spec) => spec.property.key.getSoleLiteral() !== null)
-      .map((spec, i, array) => {
-        const key: string = spec.property.key.getSoleLiteral()!;
-        const accessor: ts.Expression = IdentifierFactory.access(
-          props.input,
-          key,
-        );
-        const pred: ts.Expression = spec.neighbour
-          ? IsProgrammer.decode({
-              context: props.context,
-              functor: props.functor,
-              input: accessor,
-              metadata: spec.property.value,
-              explore: {
-                ...props.explore,
-                tracable: false,
-                postfix: IdentifierFactory.postfix(key),
-              },
-            })
-          : ExpressionFactory.isRequired(accessor);
-        const schema = indexes.get(spec.object)!;
-        return ts.factory.createIfStatement(
-          pred,
-          ts.factory.createExpressionStatement(
-            ExpressionFactory.selfCall(out(schema)),
-          ),
-          i === array.length - 1
-            ? remained.length
-              ? ts.factory.createExpressionStatement(
-                  ExpressionFactory.selfCall(
-                    explore_objects({
-                      context: props.context,
-                      functor: props.functor,
-                      level: props.level + 1,
-                      input: props.input,
-                      schemas: remained.map((r) => indexes.get(r)!),
-                      explore: props.explore,
-                    }),
-                  ),
-                )
-              : create_throw_error({
-                  context: props.context,
-                  functor: props.functor,
-                  input: props.input,
-                  expected,
-                })
-            : undefined,
-        );
-      })
-      .reverse()
-      .reduce((a, b) =>
-        ts.factory.createIfStatement(b.expression, b.thenStatement, a),
-      );
-
-    // RETURNS WITH CONDITIONS
-    return ts.factory.createBlock([condition], true);
-  };
-
-  /* -----------------------------------------------------------
-    BACKGROUND FUNCTIONS
-  ----------------------------------------------------------- */
-  const PREFIX = "_pe";
-
-  const decode_tag = (props: {
-    wire: ProtobufWire;
-    index: number;
-  }): ts.CallExpression =>
-    callWriter("uint32", [
-      ExpressionFactory.number((props.index << 3) | props.wire),
-    ]);
-
-  const get_numeric_wire = (type: ProtobufAtomic.Numeric) =>
-    type === "double"
-      ? ProtobufWire.I64
-      : type === "float"
-        ? ProtobufWire.I32
-        : ProtobufWire.VARIANT;
-
-  const create_throw_error = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    expected: string;
-    input: ts.Expression;
-  }) =>
-    ts.factory.createExpressionStatement(
-      ts.factory.createCallExpression(
-        props.context.importer.internal("throwTypeGuardError"),
-        [],
-        [
-          ts.factory.createObjectLiteralExpression(
-            [
-              ts.factory.createPropertyAssignment(
-                "method",
-                ts.factory.createStringLiteral(props.functor.method),
-              ),
-              ts.factory.createPropertyAssignment(
-                "expected",
-                ts.factory.createStringLiteral(props.expected),
-              ),
-              ts.factory.createPropertyAssignment("value", props.input),
-            ],
-            true,
-          ),
-        ],
-      ),
-    );
-}
-
-const callWriter = (
-  method: string,
-  args?: ts.Expression[],
-): ts.CallExpression =>
-  ts.factory.createCallExpression(
-    IdentifierFactory.access(ts.factory.createIdentifier("writer"), method),
-    undefined,
-    args,
-  );
-
-interface IUnion {
-  is: () => ts.Expression;
-  value: () => ts.Block;
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { NumericRangeFactory } from "../../factories/NumericRangeFactory";
+import { ProtobufFactory } from "../../factories/ProtobufFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { IProtobufProperty } from "../../schemas/protobuf/IProtobufProperty";
+import { IProtobufPropertyType } from "../../schemas/protobuf/IProtobufPropertyType";
+import { IProtobufSchema } from "../../schemas/protobuf/IProtobufSchema";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { ProtobufUtil } from "../helpers/ProtobufUtil";
+import { ProtobufWire } from "../helpers/ProtobufWire";
+import { UnionPredicator } from "../helpers/UnionPredicator";
+import { decode_union_object } from "../internal/decode_union_object";
+
+export namespace ProtobufEncodeProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const collection: MetadataCollection = new MetadataCollection();
+    const metadata: Metadata = ProtobufFactory.metadata({
+      method: props.modulo.getText(),
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      collection,
+      type: props.type,
+    });
+
+    const callEncoder = (writer: string, factory: ts.NewExpression) =>
+      StatementFactory.constant({
+        name: writer,
+        value: ts.factory.createCallExpression(
+          ts.factory.createIdentifier("encoder"),
+          undefined,
+          [factory, ts.factory.createIdentifier("input")],
+        ),
+      });
+    return {
+      functions: {
+        encoder: StatementFactory.constant({
+          name: props.functor.useLocal("encoder"),
+          value: write_encoder({
+            context: props.context,
+            functor: props.functor,
+            collection,
+            metadata,
+          }),
+        }),
+      },
+      statements: [],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "input",
+            ts.factory.createTypeReferenceNode(
+              props.name ??
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
+            ),
+          ),
+        ],
+        ts.factory.createTypeReferenceNode("Uint8Array"),
+        undefined,
+        ts.factory.createBlock(
+          [
+            callEncoder(
+              "sizer",
+              ts.factory.createNewExpression(
+                props.context.importer.internal("ProtobufSizer"),
+                undefined,
+                [],
+              ),
+            ),
+            callEncoder(
+              "writer",
+              ts.factory.createNewExpression(
+                props.context.importer.internal("ProtobufWriter"),
+                undefined,
+                [ts.factory.createIdentifier("sizer")],
+              ),
+            ),
+            ts.factory.createReturnStatement(callWriter("buffer")),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+
+  const write_encoder = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    collection: MetadataCollection;
+    metadata: Metadata;
+  }): ts.ArrowFunction => {
+    const functors = props.collection
+      .objects()
+      .filter((obj) => ProtobufUtil.isStaticObject(obj))
+      .map((object) =>
+        StatementFactory.constant({
+          name: `${PREFIX}o${object.index}`,
+          value: write_object_function({
+            context: props.context,
+            functor: props.functor,
+            input: ts.factory.createIdentifier("input"),
+            object,
+            explore: {
+              source: "function",
+              from: "object",
+              tracable: false,
+              postfix: "",
+            },
+          }),
+        }),
+      );
+    return ts.factory.createArrowFunction(
+      undefined,
+      [
+        ts.factory.createTypeParameterDeclaration(
+          undefined,
+          "Writer",
+          props.context.importer.type({
+            file: "typia/lib/internal/_IProtobufWriter.js",
+            name: "_IProtobufWriter",
+          }),
+        ),
+      ],
+      [
+        IdentifierFactory.parameter(
+          "writer",
+          ts.factory.createTypeReferenceNode("Writer"),
+        ),
+        IdentifierFactory.parameter("input"),
+      ],
+      ts.factory.createTypeReferenceNode("Writer"),
+      undefined,
+      ts.factory.createBlock(
+        [
+          ...props.functor.declareUnions(),
+          ...functors,
+          ...IsProgrammer.write_function_statements(props),
+          ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(
+                props.functor.useLocal(
+                  `${PREFIX}o${props.metadata.objects[0]?.type.index ?? 0}`,
+                ),
+              ),
+              [],
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("writer"),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  const write_object_function = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    input: ts.Expression;
+    object: MetadataObjectType;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.ArrowFunction => {
+    const body: ts.Statement[] = props.object.properties
+      .map((p) => {
+        const block = decode_property({
+          context: props.context,
+          functor: props.functor,
+          explore: props.explore,
+          metadata: p.value,
+          protobuf: p.of_protobuf_!,
+          input: IdentifierFactory.access(props.input, p.key.getSoleLiteral()!),
+        });
+        return [
+          ts.factory.createExpressionStatement(
+            ts.factory.createIdentifier(
+              `// property ${JSON.stringify(p.key.getSoleLiteral())}: ${p.value.getName()}`,
+            ),
+          ),
+          ...block.statements,
+        ];
+      })
+      .flat();
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("input")],
+      TypeFactory.keyword("any"),
+      undefined,
+      ts.factory.createBlock(body, true),
+    );
+  };
+
+  /* -----------------------------------------------------------
+    DECODER STATION
+  ----------------------------------------------------------- */
+  const decode_property = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    metadata: Metadata;
+    protobuf: IProtobufProperty;
+    input: ts.Expression;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Block => {
+    const union: IUnion[] = [];
+    for (const schema of props.protobuf.union) {
+      //----
+      // ATOMICS
+      //----
+      if (schema.type === "bool")
+        union.push({
+          is: () =>
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("boolean"),
+              ts.factory.createTypeOfExpression(props.input),
+            ),
+          value: () =>
+            decode_bool({
+              input: props.input,
+              index: schema.index,
+            }),
+        });
+      else if (schema.type === "bigint")
+        union.push(
+          decode_bigint({
+            input: props.input,
+            type: schema.name,
+            candidates: props.protobuf.union
+              .filter((s) => s.type === "bigint")
+              .map((s) => s.name),
+            index: schema.index,
+          }),
+        );
+      else if (schema.type === "number")
+        union.push(
+          decode_number({
+            input: props.input,
+            type: schema.name,
+            candidates: props.protobuf.union
+              .filter((s) => s.type === "number")
+              .map((s) => s.name),
+            index: schema.index,
+          }),
+        );
+      else if (schema.type === "string")
+        union.push({
+          is: () =>
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("string"),
+              ts.factory.createTypeOfExpression(props.input),
+            ),
+          value: () =>
+            decode_bytes({
+              method: "string",
+              index: schema.index,
+              input: props.input,
+            }),
+        });
+      //----
+      // INSTANCES
+      //----
+      else if (schema.type === "bytes")
+        union.push({
+          is: () => ExpressionFactory.isInstanceOf("Uint8Array", props.input),
+          value: () =>
+            decode_bytes({
+              method: "bytes",
+              index: schema.index,
+              input: props.input,
+            }),
+        });
+      else if (schema.type === "array")
+        union.push({
+          is: () => ExpressionFactory.isArray(props.input),
+          value: () =>
+            decode_array({
+              context: props.context,
+              functor: props.functor,
+              input: props.input,
+              schema,
+            }),
+        });
+      else if (schema.type === "map" && schema.map instanceof MetadataMap) {
+        union.push({
+          is: () => ExpressionFactory.isInstanceOf("Map", props.input),
+          value: () =>
+            decode_map({
+              context: props.context,
+              functor: props.functor,
+              schema,
+              input: props.input,
+            }),
+        });
+      }
+      const objectSchemas: Array<
+        IProtobufPropertyType.IObject | IProtobufPropertyType.IMap
+      > = props.protobuf.union
+        .filter((schema) => schema.type === "object" || schema.type === "map")
+        .filter(
+          (schema) =>
+            schema.type === "object" ||
+            (schema.type === "map" && schema.map instanceof MetadataObjectType),
+        );
+      if (objectSchemas.length !== 0)
+        union.push({
+          is: () =>
+            ExpressionFactory.isObject({
+              checkNull: true,
+              checkArray: false,
+              input: props.input,
+            }),
+          value: () =>
+            explore_objects({
+              context: props.context,
+              functor: props.functor,
+              level: 0,
+              schemas: objectSchemas,
+              explore: {
+                ...props.explore,
+                from: "object",
+              },
+              input: props.input,
+            }),
+        });
+    }
+
+    // RETURNS
+    const wrapper: (block: ts.Block) => ts.Block =
+      props.metadata.isRequired() && props.metadata.nullable === false
+        ? (block) => block
+        : props.metadata.isRequired() === false &&
+            props.metadata.nullable === true
+          ? (block) =>
+              ts.factory.createBlock(
+                [
+                  ts.factory.createIfStatement(
+                    ts.factory.createLogicalAnd(
+                      ts.factory.createStrictInequality(
+                        ts.factory.createIdentifier("undefined"),
+                        props.input,
+                      ),
+                      ts.factory.createStrictInequality(
+                        ts.factory.createNull(),
+                        props.input,
+                      ),
+                    ),
+                    block,
+                  ),
+                ],
+                true,
+              )
+          : props.metadata.isRequired() === false
+            ? (block) =>
+                ts.factory.createBlock(
+                  [
+                    ts.factory.createIfStatement(
+                      ts.factory.createStrictInequality(
+                        ts.factory.createIdentifier("undefined"),
+                        props.input,
+                      ),
+                      block,
+                    ),
+                  ],
+                  true,
+                )
+            : (block) =>
+                ts.factory.createBlock(
+                  [
+                    ts.factory.createIfStatement(
+                      ts.factory.createStrictInequality(
+                        ts.factory.createNull(),
+                        props.input,
+                      ),
+                      block,
+                    ),
+                  ],
+                  true,
+                );
+    if (union.length === 1) return wrapper(union[0]!.value());
+    return wrapper(
+      ts.factory.createBlock(
+        [
+          union
+            .map((u, i) =>
+              ts.factory.createIfStatement(
+                u.is(),
+                u.value(),
+                i === union.length - 1
+                  ? create_throw_error({
+                      context: props.context,
+                      functor: props.functor,
+                      input: props.input,
+                      expected: props.metadata.getName(),
+                    })
+                  : undefined,
+              ),
+            )
+            .reverse()
+            .reduce((a, b) =>
+              ts.factory.createIfStatement(b.expression, b.thenStatement, a),
+            ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  /* -----------------------------------------------------------
+    ATOMIC DECODERS
+  ----------------------------------------------------------- */
+  const decode_bool = (props: {
+    input: ts.Expression;
+    index: number | null;
+  }): ts.Block =>
+    ts.factory.createBlock(
+      [
+        ...(props.index !== null
+          ? [
+              decode_tag({
+                wire: ProtobufWire.VARIANT,
+                index: props.index,
+              }),
+            ]
+          : []),
+        callWriter("bool", [props.input]),
+      ].map((exp) => ts.factory.createExpressionStatement(exp)),
+      true,
+    );
+
+  const decode_bigint = (props: {
+    candidates: ProtobufAtomic.BigNumeric[];
+    type: ProtobufAtomic.BigNumeric;
+    input: ts.Expression;
+    index: number | null;
+  }): IUnion => ({
+    is: () =>
+      props.candidates.length === 1
+        ? ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("bigint"),
+            ts.factory.createTypeOfExpression(props.input),
+          )
+        : ts.factory.createLogicalAnd(
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("bigint"),
+              ts.factory.createTypeOfExpression(props.input),
+            ),
+            NumericRangeFactory.bigint(props.type, props.input),
+          ),
+    value: () =>
+      ts.factory.createBlock(
+        [
+          ...(props.index !== null
+            ? [
+                decode_tag({
+                  wire: ProtobufWire.VARIANT,
+                  index: props.index,
+                }),
+              ]
+            : []),
+          callWriter(props.type, [props.input]),
+        ].map((exp) => ts.factory.createExpressionStatement(exp)),
+        true,
+      ),
+  });
+
+  const decode_number = (props: {
+    candidates: ProtobufAtomic.Numeric[];
+    type: ProtobufAtomic.Numeric;
+    input: ts.Expression;
+    index: number | null;
+  }): IUnion => ({
+    is: () =>
+      props.candidates.length === 1
+        ? ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("number"),
+            ts.factory.createTypeOfExpression(props.input),
+          )
+        : ts.factory.createLogicalAnd(
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("number"),
+              ts.factory.createTypeOfExpression(props.input),
+            ),
+            NumericRangeFactory.number(props.type, props.input),
+          ),
+    value: () =>
+      ts.factory.createBlock(
+        [
+          ...(props.index !== null
+            ? [
+                decode_tag({
+                  wire: get_numeric_wire(props.type),
+                  index: props.index,
+                }),
+              ]
+            : []),
+          callWriter(props.type, [props.input]),
+        ].map((exp) => ts.factory.createExpressionStatement(exp)),
+        true,
+      ),
+  });
+
+  const decode_container_value = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    schema: IProtobufPropertyType.IArray["value"];
+    index: number;
+    kind: "array" | "map";
+    input: ts.Expression;
+  }): ts.Block => {
+    if (props.schema.type === "bool")
+      return decode_bool({
+        input: props.input,
+        index: props.kind === "array" ? null : props.index,
+      });
+    else if (props.schema.type === "bigint")
+      return decode_bigint({
+        input: props.input,
+        type: props.schema.name,
+        candidates: [props.schema.name],
+        index: props.kind === "array" ? null : props.index,
+      }).value();
+    else if (props.schema.type === "number")
+      return decode_number({
+        input: props.input,
+        type: props.schema.name,
+        candidates: [props.schema.name],
+        index: props.kind === "array" ? null : props.index,
+      }).value();
+    else if (props.schema.type === "string" || props.schema.type === "bytes")
+      return decode_bytes({
+        method: props.schema.type,
+        input: props.input,
+        index: props.index,
+      });
+    return decode_object({
+      context: props.context,
+      functor: props.functor,
+      schema: props.schema,
+      input: props.input,
+      index: props.index,
+    });
+  };
+
+  /* -----------------------------------------------------------
+    INSTANCE DECODERS
+  ----------------------------------------------------------- */
+  const decode_bytes = (props: {
+    method: "bytes" | "string";
+    index: number;
+    input: ts.Expression;
+  }): ts.Block =>
+    ts.factory.createBlock(
+      [
+        decode_tag({
+          wire: ProtobufWire.LEN,
+          index: props.index,
+        }),
+        callWriter(props.method, [props.input]),
+      ].map((expr) => ts.factory.createExpressionStatement(expr)),
+      true,
+    );
+
+  const decode_array = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    schema: IProtobufPropertyType.IArray;
+    input: ts.Expression;
+  }): ts.Block => {
+    const value: IProtobufPropertyType.IArray["value"] = props.schema.value;
+    const wire: ProtobufWire = (() => {
+      if (
+        value.type === "object" ||
+        value.type === "bytes" ||
+        value.type === "string"
+      )
+        return ProtobufWire.LEN;
+      else if (value.type === "number" && value.name === "float")
+        return ProtobufWire.I32;
+      return ProtobufWire.VARIANT;
+    })();
+    const forLoop = () =>
+      ts.factory.createForOfStatement(
+        undefined,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration("elem")],
+          ts.NodeFlags.Const,
+        ),
+        props.input,
+        decode_container_value({
+          kind: "array",
+          context: props.context,
+          functor: props.functor,
+          input: ts.factory.createIdentifier("elem"),
+          index: props.schema.index,
+          schema: props.schema.value,
+        }),
+      );
+    const length = (block: ts.Block) =>
+      ts.factory.createBlock(
+        [
+          ts.factory.createIfStatement(
+            ts.factory.createStrictInequality(
+              ExpressionFactory.number(0),
+              IdentifierFactory.access(props.input, "length"),
+            ),
+            block,
+          ),
+        ],
+        true,
+      );
+    if (wire === ProtobufWire.LEN)
+      return length(ts.factory.createBlock([forLoop()], true));
+    return length(
+      ts.factory.createBlock(
+        [
+          ts.factory.createExpressionStatement(
+            decode_tag({
+              wire: ProtobufWire.LEN,
+              index: props.schema.index,
+            }),
+          ),
+          ts.factory.createExpressionStatement(callWriter("fork")),
+          forLoop(),
+          ts.factory.createExpressionStatement(callWriter("ldelim")),
+        ],
+        true,
+      ),
+    );
+  };
+
+  const decode_object = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    schema: IProtobufSchema.IObject;
+    index: number;
+    input: ts.Expression;
+  }): ts.Block =>
+    ts.factory.createBlock(
+      [
+        decode_tag({
+          wire: ProtobufWire.LEN,
+          index: props.index,
+        }),
+        callWriter("fork"),
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            props.functor.useLocal(`${PREFIX}o${props.schema.object.index}`),
+          ),
+          [],
+          [props.input],
+        ),
+        callWriter("ldelim"),
+      ].map(ts.factory.createExpressionStatement),
+      true,
+    );
+
+  const decode_map = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    schema: IProtobufPropertyType.IMap;
+    input: ts.Expression;
+  }): ts.Block => {
+    const each: ts.Statement[] = [
+      ts.factory.createExpressionStatement(
+        decode_tag({
+          wire: ProtobufWire.LEN,
+          index: props.schema.index,
+        }),
+      ),
+      ts.factory.createExpressionStatement(callWriter("fork")),
+      ...decode_container_value({
+        kind: "map",
+        context: props.context,
+        functor: props.functor,
+        index: 1,
+        input: ts.factory.createIdentifier("key"),
+        schema: props.schema.key,
+      }).statements,
+      ...decode_container_value({
+        kind: "map",
+        context: props.context,
+        functor: props.functor,
+        index: 2,
+        input: ts.factory.createIdentifier("value"),
+        schema: props.schema.value,
+      }).statements,
+      ts.factory.createExpressionStatement(callWriter("ldelim")),
+    ];
+    return ts.factory.createBlock(
+      [
+        ts.factory.createForOfStatement(
+          undefined,
+          StatementFactory.entry({
+            key: "key",
+            value: "value",
+          }),
+          props.input,
+          ts.factory.createBlock(each),
+        ),
+      ],
+      true,
+    );
+  };
+
+  const explore_objects = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    level: number;
+    input: ts.Expression;
+    schemas: Array<IProtobufPropertyType.IObject | IProtobufPropertyType.IMap>;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Block => {
+    const out = (
+      schema: IProtobufPropertyType.IObject | IProtobufPropertyType.IMap,
+    ) =>
+      schema.type === "object"
+        ? decode_object({
+            context: props.context,
+            functor: props.functor,
+            schema,
+            index: schema.index,
+            input: props.input,
+          })
+        : decode_map({
+            context: props.context,
+            functor: props.functor,
+            schema,
+            input: ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createIdentifier("Object"),
+                "entries",
+              ),
+              undefined,
+              [props.input],
+            ),
+          });
+    if (props.schemas.length === 1) return out(props.schemas[0]!);
+
+    const objects: MetadataObjectType[] = props.schemas.map((s) =>
+      s.type === "map" ? (s.map as MetadataObjectType) : s.object,
+    );
+    const expected: string = `(${objects.map((t) => t.name).join(" | ")})`;
+    const indexes: WeakMap<
+      MetadataObjectType,
+      IProtobufPropertyType.IObject | IProtobufPropertyType.IMap
+    > = new WeakMap(objects.map((o, i) => [o, props.schemas[i]!]));
+    const specifications: UnionPredicator.ISpecialized[] =
+      UnionPredicator.object(objects);
+
+    if (specifications.length === 0) {
+      const condition: ts.Expression = decode_union_object({
+        checker: (v) =>
+          IsProgrammer.decode_object({
+            context: props.context,
+            functor: props.functor,
+            object: v.object,
+            input: v.input,
+            explore: v.explore,
+          }),
+        decoder: (v) => ExpressionFactory.selfCall(out(indexes.get(v.object)!)),
+        success: (expr) => expr,
+        escaper: (v) =>
+          create_throw_error({
+            context: props.context,
+            functor: props.functor,
+            expected: v.expected,
+            input: v.input,
+          }),
+        input: props.input,
+        explore: props.explore,
+        objects,
+      });
+      return StatementFactory.block(condition);
+    }
+    const remained: MetadataObjectType[] = objects.filter(
+      (o) => specifications.find((s) => s.object === o) === undefined,
+    );
+
+    // DO SPECIALIZE
+    const condition: ts.IfStatement = specifications
+      .filter((spec) => spec.property.key.getSoleLiteral() !== null)
+      .map((spec, i, array) => {
+        const key: string = spec.property.key.getSoleLiteral()!;
+        const accessor: ts.Expression = IdentifierFactory.access(
+          props.input,
+          key,
+        );
+        const pred: ts.Expression = spec.neighbour
+          ? IsProgrammer.decode({
+              context: props.context,
+              functor: props.functor,
+              input: accessor,
+              metadata: spec.property.value,
+              explore: {
+                ...props.explore,
+                tracable: false,
+                postfix: IdentifierFactory.postfix(key),
+              },
+            })
+          : ExpressionFactory.isRequired(accessor);
+        const schema = indexes.get(spec.object)!;
+        return ts.factory.createIfStatement(
+          pred,
+          ts.factory.createExpressionStatement(
+            ExpressionFactory.selfCall(out(schema)),
+          ),
+          i === array.length - 1
+            ? remained.length
+              ? ts.factory.createExpressionStatement(
+                  ExpressionFactory.selfCall(
+                    explore_objects({
+                      context: props.context,
+                      functor: props.functor,
+                      level: props.level + 1,
+                      input: props.input,
+                      schemas: remained.map((r) => indexes.get(r)!),
+                      explore: props.explore,
+                    }),
+                  ),
+                )
+              : create_throw_error({
+                  context: props.context,
+                  functor: props.functor,
+                  input: props.input,
+                  expected,
+                })
+            : undefined,
+        );
+      })
+      .reverse()
+      .reduce((a, b) =>
+        ts.factory.createIfStatement(b.expression, b.thenStatement, a),
+      );
+
+    // RETURNS WITH CONDITIONS
+    return ts.factory.createBlock([condition], true);
+  };
+
+  /* -----------------------------------------------------------
+    BACKGROUND FUNCTIONS
+  ----------------------------------------------------------- */
+  const PREFIX = "_pe";
+
+  const decode_tag = (props: {
+    wire: ProtobufWire;
+    index: number;
+  }): ts.CallExpression =>
+    callWriter("uint32", [
+      ExpressionFactory.number((props.index << 3) | props.wire),
+    ]);
+
+  const get_numeric_wire = (type: ProtobufAtomic.Numeric) =>
+    type === "double"
+      ? ProtobufWire.I64
+      : type === "float"
+        ? ProtobufWire.I32
+        : ProtobufWire.VARIANT;
+
+  const create_throw_error = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    expected: string;
+    input: ts.Expression;
+  }) =>
+    ts.factory.createExpressionStatement(
+      ts.factory.createCallExpression(
+        props.context.importer.internal("throwTypeGuardError"),
+        [],
+        [
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createPropertyAssignment(
+                "method",
+                ts.factory.createStringLiteral(props.functor.method),
+              ),
+              ts.factory.createPropertyAssignment(
+                "expected",
+                ts.factory.createStringLiteral(props.expected),
+              ),
+              ts.factory.createPropertyAssignment("value", props.input),
+            ],
+            true,
+          ),
+        ],
+      ),
+    );
+}
+
+const callWriter = (
+  method: string,
+  args?: ts.Expression[],
+): ts.CallExpression =>
+  ts.factory.createCallExpression(
+    IdentifierFactory.access(ts.factory.createIdentifier("writer"), method),
+    undefined,
+    args,
+  );
+
+interface IUnion {
+  is: () => ts.Expression;
+  value: () => ts.Block;
+}