typia 5.0.0-dev.20230814 → 5.0.0-dev.20230818

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -143,7 +143,10 @@ export namespace ProtobufMessageProgrammer {
                 const type = tags.find((t) => t.kind === "type") as
                     | IMetadataTag.INumberType
                     | undefined;
-                return type?.value ?? "double";
+                if (type?.value === undefined) return "double";
+                else if (type.value === "int") return "int32";
+                else if (type.value === "uint") return "uint32";
+                else return type.value;
             }
             return literal;
         };

package/src/protobuf.ts

@@ -1,3 +1,5 @@
+import { Namespace } from "./functional/Namespace";
+
 import { IValidation } from "./IValidation";
 import { Primitive } from "./Primitive";
 
@@ -34,6 +36,7 @@ export function decode<T>(input: Uint8Array): Primitive<T>;
 export function decode(): never {
     halt("decode");
 }
+Object.assign(decode, Namespace.protobuf.decode("decode"));
 
 export function isDecode(input: Uint8Array): never;
 
@@ -45,6 +48,8 @@ export function isDecode<T>(input: Uint8Array): Primitive<T> | null;
 export function isDecode(): never {
     halt("isDecode");
 }
+Object.assign(isDecode, Namespace.is());
+Object.assign(isDecode, Namespace.protobuf.decode("isDecode"));
 
 export function assertDecode(input: Uint8Array): never;
 
@@ -56,6 +61,8 @@ export function assertDecode<T>(input: Uint8Array): Primitive<T>;
 export function assertDecode(): never {
     halt("assertDecode");
 }
+Object.assign(assertDecode, Namespace.assert("assertDecode"));
+Object.assign(assertDecode, Namespace.protobuf.decode("assertDecode"));
 
 export function validateDecode(input: Uint8Array): never;
 
@@ -67,22 +74,12 @@ export function validateDecode<T>(input: Uint8Array): IValidation<Primitive<T>>;
 export function validateDecode(): never {
     halt("validateDecode");
 }
+Object.assign(validateDecode, Namespace.validate());
+Object.assign(validateDecode, Namespace.protobuf.decode("validateDecode"));
 
 /* -----------------------------------------------------------
     ENCODE
 ----------------------------------------------------------- */
-/**
- * @internal
- */
-export function size<T>(input: T): number;
-
-/**
- * @internal
- */
-export function size(): never {
-    halt("size");
-}
-
 export function encode<T>(input: T): Uint16Array;
 
 /**
@@ -91,6 +88,7 @@ export function encode<T>(input: T): Uint16Array;
 export function encode(): never {
     halt("encode");
 }
+Object.assign(encode, Namespace.protobuf.encode("encode"));
 
 export function isEncode<T>(input: T): Uint16Array | null;
 
@@ -100,6 +98,8 @@ export function isEncode<T>(input: T): Uint16Array | null;
 export function isEncode(): never {
     halt("isEncode");
 }
+Object.assign(isEncode, Namespace.is());
+Object.assign(isEncode, Namespace.protobuf.encode("isEncode"));
 
 export function assertEncode<T>(input: T): Uint16Array;
 
@@ -109,6 +109,8 @@ export function assertEncode<T>(input: T): Uint16Array;
 export function assertEncode(): never {
     halt("assertEncode");
 }
+Object.assign(assertEncode, Namespace.assert("assertEncode"));
+Object.assign(assertEncode, Namespace.protobuf.encode("assertEncode"));
 
 export function validateEncode<T>(input: T): IValidation<Uint16Array>;
 
@@ -118,6 +120,8 @@ export function validateEncode<T>(input: T): IValidation<Uint16Array>;
 export function validateEncode(): never {
     halt("validateEncode");
 }
+Object.assign(validateEncode, Namespace.validate());
+Object.assign(validateEncode, Namespace.protobuf.encode("validateEncode"));
 
 /* -----------------------------------------------------------
     FACTORY FUNCTIONS
@@ -168,23 +172,6 @@ export function createValidateDecode<T>(): (
     halt("createValidateDecode");
 }
 
-/**
- * @internal
- */
-export function createSize(): never;
-
-/**
- * @internal
- */
-export function createSize<T>(): (input: T) => number;
-
-/**
- * @internal
- */
-export function createSize<T>(): (input: T) => number {
-    halt("createEncode");
-}
-
 export function createEncode(): never;
 export function createEncode<T>(): (input: T) => Uint8Array;
 
@@ -194,6 +181,7 @@ export function createEncode<T>(): (input: T) => Uint8Array;
 export function createEncode<T>(): (input: T) => Uint8Array {
     halt("createEncode");
 }
+Object.assign(createEncode, Namespace.protobuf.encode("createEncode"));
 
 export function createIsEncode(): never;
 export function createIsEncode<T>(): (input: T) => Uint8Array | null;
@@ -204,6 +192,8 @@ export function createIsEncode<T>(): (input: T) => Uint8Array | null;
 export function createIsEncode<T>(): (input: T) => Uint8Array | null {
     halt("createIsEncode");
 }
+Object.assign(createIsEncode, Namespace.is);
+Object.assign(createIsEncode, Namespace.protobuf.encode);
 
 export function createAssertEncode(): never;
 export function createAssertEncode<T>(): (input: T) => Uint8Array;
@@ -214,6 +204,8 @@ export function createAssertEncode<T>(): (input: T) => Uint8Array;
 export function createAssertEncode<T>(): (input: T) => Uint8Array {
     halt("createAssertEncode");
 }
+Object.assign(createAssertEncode, Namespace.assert);
+Object.assign(createAssertEncode, Namespace.protobuf.encode);
 
 export function createValidateEncode(): never;
 export function createValidateEncode<T>(): (
@@ -228,6 +220,8 @@ export function createValidateEncode<T>(): (
 ) => IValidation<Uint8Array> {
     halt("createValidateEncode");
 }
+Object.assign(createValidateEncode, Namespace.validate);
+Object.assign(createValidateEncode, Namespace.protobuf.encode);
 
 /**
  * @internal

package/src/schemas/metadata/MetadataObject.ts

@@ -70,6 +70,16 @@ export class MetadataObject {
         });
     }
 
+    /**
+     * @internal
+     */
+    public _Messagable(): boolean {
+        return (
+            this.properties.length >= 1 &&
+            this.properties.every((p) => p.key.isSoleLiteral())
+        );
+    }
+
     /**
      * @internal
      */

package/src/transformers/CallExpressionTransformer.ts

@@ -49,7 +49,6 @@ import { CreateProtobufDecodeTransformer } from "./features/protobuf/CreateProto
 import { CreateProtobufEncodeTransformer } from "./features/protobuf/CreateProtobufEncodeTransformer";
 import { CreateProtobufIsDecodeTransformer } from "./features/protobuf/CreateProtobufIsDecodeTransformer";
 import { CreateProtobufIsEncodeTransformer } from "./features/protobuf/CreateProtobufIsEncodeTransformer";
-import { CreateProtobufSizeTransformer } from "./features/protobuf/CreateProtobufSizeTransformer";
 import { CreateProtobufValidateDecodeTransformer } from "./features/protobuf/CreateProtobufValidateDecodeTransformer";
 import { CreateProtobufValidateEncodeTransformer } from "./features/protobuf/CreateProtobufValidateEncodeTransformer";
 import { ProtobufAssertDecodeTransformer } from "./features/protobuf/ProtobufAssertDecodeTransformer";
@@ -59,7 +58,6 @@ import { ProtobufEncodeTransformer } from "./features/protobuf/ProtobufEncodeTra
 import { ProtobufIsDecodeTransformer } from "./features/protobuf/ProtobufIsDecodeTransformer";
 import { ProtobufIsEncodeTransformer } from "./features/protobuf/ProtobufIsEncodeTransformer";
 import { ProtobufMessageTransformer } from "./features/protobuf/ProtobufMessageTransformer";
-import { ProtobufSizeTransformer } from "./features/protobuf/ProtobufSizeTransformer";
 import { ProtobufValidateDecodeTransformer } from "./features/protobuf/ProtobufValidateDecodeTransformer";
 import { ProtobufValidateEncodeTransformer } from "./features/protobuf/ProtobufValidateEncodeTransformer";
 
@@ -188,7 +186,6 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
         message: () => ProtobufMessageTransformer.transform,
 
         // ENCODE
-        size: () => ProtobufSizeTransformer.transform,
         encode: () => ProtobufEncodeTransformer.transform,
         assertEncode: () => ProtobufAssertEncodeTransformer.transform,
         isEncode: () => ProtobufIsEncodeTransformer.transform,
@@ -201,7 +198,6 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
         validateDecode: () => ProtobufValidateDecodeTransformer.transform,
 
         // FACTORIES
-        createSize: () => CreateProtobufSizeTransformer.transform,
         createEncode: () => CreateProtobufEncodeTransformer.transform,
         createAssertEncode: () =>
             CreateProtobufAssertEncodeTransformer.transform,

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -56,6 +56,12 @@ export namespace JsonApplicationTransformer {
                     validate: (meta) => {
                         if (meta.atomics.find((str) => str === "bigint"))
                             throw new Error(NO_BIGIT);
+                        else if (
+                            meta.arrays.some(
+                                (array) => array.value.isRequired() === false,
+                            )
+                        )
+                            throw new Error(NO_UNDEFINED_IN_ARRAY);
                     },
                 })(collection)(type),
             );
@@ -96,7 +102,10 @@ export namespace JsonApplicationTransformer {
 }
 
 const NO_GENERIC_ARGUMENT =
-    "Error on typia.application(): no generic argument.";
+    "Error on typia.json.application(): no generic argument.";
 const GENERIC_ARGUMENT =
-    "Error on typia.application(): non-specified generic argument(s).";
-const NO_BIGIT = "Error on typia.application(): does not allow bigint type.";
+    "Error on typia.json.application(): non-specified generic argument(s).";
+const NO_BIGIT =
+    "Error on typia.json.application(): does not allow bigint type.";
+const NO_UNDEFINED_IN_ARRAY =
+    "Error on typia.json.application(): does not allow undefined type in array.";

package/lib/programmers/protobuf/ProtobufSizeProgrammer.d.ts

@@ -1,5 +0,0 @@
-import ts from "typescript";
-import { IProject } from "../../transformers/IProject";
-export declare namespace ProtobufSizeProgrammer {
-    const write: (project: IProject) => (modulo: ts.LeftHandSideExpression) => (type: ts.Type, name?: string | undefined) => ts.ArrowFunction;
-}

package/lib/programmers/protobuf/ProtobufSizeProgrammer.js

@@ -1,409 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtobufSizeProgrammer = void 0;
-var typescript_1 = __importDefault(require("typescript"));
-var ExpressionFactory_1 = require("../../factories/ExpressionFactory");
-var IdentifierFactory_1 = require("../../factories/IdentifierFactory");
-var MetadataCollection_1 = require("../../factories/MetadataCollection");
-var ProtobufFactory_1 = require("../../factories/ProtobufFactory");
-var StatementFactory_1 = require("../../factories/StatementFactory");
-var TypeFactory_1 = require("../../factories/TypeFactory");
-var _strlen_1 = require("../../functional/$strlen");
-var FeatureProgrammer_1 = require("../FeatureProgrammer");
-var IsProgrammer_1 = require("../IsProgrammer");
-var FunctionImporeter_1 = require("../helpers/FunctionImporeter");
-var ProtobufUtil_1 = require("../helpers/ProtobufUtil");
-var UnionExplorer_1 = require("../helpers/UnionExplorer");
-var check_native_1 = require("../internal/check_native");
-var decode_union_object_1 = require("../internal/decode_union_object");
-var ProtobufSizeProgrammer;
-(function (ProtobufSizeProgrammer) {
-    ProtobufSizeProgrammer.write = function (project) { return function (modulo) {
-        var importer = new FunctionImporeter_1.FunctionImporter();
-        var copnfig = configure(modulo.getText())(project)(importer);
-        return FeatureProgrammer_1.FeatureProgrammer.write(project)(__assign(__assign({}, copnfig), { addition: function (collection) { return __spreadArray(__spreadArray([], __read(IsProgrammer_1.IsProgrammer.write_function_statements(project)(importer)(collection)), false), __read(importer.declare(modulo)), false); } }))(importer);
-    }; };
-    var write_object_function_body = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (obj) {
-                    var explore = {
-                        tracable: false,
-                        source: "function",
-                        from: "object",
-                        postfix: "",
-                    };
-                    if (obj.properties.some(function (p) { return !p.key.isSoleLiteral(); })) {
-                        var p = obj.properties[0];
-                        return write_map_function_body(project)(config)(importer)(typescript_1.default.factory.createIdentifier("input"), p, explore, p.tags);
-                    }
-                    var zero = typescript_1.default.factory.createNumericLiteral(0);
-                    var compute = function (p) {
-                        var input = IdentifierFactory_1.IdentifierFactory.access(typescript_1.default.factory.createIdentifier("input"))(p.key.getSoleLiteral());
-                        var output = typescript_1.default.factory.createAdd(typescript_1.default.factory.createNumericLiteral(4), decode(project)(config)(importer)(input, p.value, explore, p.tags));
-                        if (p.value.isRequired() === true && p.value.nullable === false)
-                            return output;
-                        else if (p.value.isRequired() === true &&
-                            p.value.nullable === true)
-                            return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createNull(), input), undefined, output, undefined, zero);
-                        else if (p.value.isRequired() === false &&
-                            p.value.nullable === false)
-                            return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createIdentifier("undefined"), input), undefined, output, undefined, zero);
-                        else
-                            return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createIdentifier("undefined"), input), typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createNull(), input)), undefined, output, undefined, zero);
-                    };
-                    return obj.properties
-                        .map(function (p) { return compute(p); })
-                        .reduce(function (a, b) { return typescript_1.default.factory.createAdd(a, b); });
-                };
-            };
-        };
-    };
-    var write_map_function_body = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, entry, explore, tags) {
-                    var key = typescript_1.default.factory.createIdentifier("key");
-                    var value = typescript_1.default.factory.createIdentifier("value");
-                    var tuple = typescript_1.default.factory.createVariableDeclarationList([
-                        typescript_1.default.factory.createVariableDeclaration(typescript_1.default.factory.createArrayBindingPattern([
-                            typescript_1.default.factory.createBindingElement(undefined, undefined, key),
-                            typescript_1.default.factory.createBindingElement(undefined, undefined, value),
-                        ])),
-                    ], typescript_1.default.NodeFlags.Const);
-                    var block = typescript_1.default.factory.createBlock([
-                        decode_atomic(importer)(key, "string", []),
-                        decode(project)(config)(importer)(value, entry.value, explore, tags),
-                    ].map(function (expr) {
-                        return typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createIdentifier("size"), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.PlusEqualsToken), expr));
-                    }), true);
-                    return typescript_1.default.factory.createBlock([
-                        StatementFactory_1.StatementFactory.mut("size", typescript_1.default.factory.createNumericLiteral(0)),
-                        typescript_1.default.factory.createForOfStatement(undefined, tuple, input, block),
-                        typescript_1.default.factory.createReturnStatement(typescript_1.default.factory.createIdentifier("size")),
-                    ]);
-                };
-            };
-        };
-    };
-    var decode = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, meta, explore, tags) {
-                    var unions = ProtobufUtil_1.ProtobufUtil.atomics(meta).map(function (type) { return ({
-                        type: type,
-                        is: function () {
-                            return typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createStringLiteral(type), typescript_1.default.factory.createTypeOfExpression(input));
-                        },
-                        value: function () { return decode_atomic(importer)(input, type, tags); },
-                    }); });
-                    if (meta.arrays.length) {
-                        var value = meta.arrays.length === 1
-                            ? function () {
-                                return decode_array(project)(config)(importer)(input, meta.arrays[0], explore, tags);
-                            }
-                            : function () {
-                                return explore_arrays(project)(config)(importer)(input, meta.arrays, explore, tags);
-                            };
-                        unions.push({
-                            type: "array",
-                            is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(input); },
-                            value: value,
-                        });
-                    }
-                    if (meta.objects.length)
-                        unions.push({
-                            type: "object",
-                            is: function () {
-                                return ExpressionFactory_1.ExpressionFactory.isObject({
-                                    checkNull: true,
-                                    checkArray: false,
-                                })(input);
-                            },
-                            value: function () {
-                                return explore_objects(project)(config)(importer)(input, meta, explore);
-                            },
-                        });
-                    if (meta.maps.length)
-                        unions.push({
-                            type: "map",
-                            is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map")(input); },
-                            value: function () {
-                                return decode_map(project)(config)(importer)(input, meta.maps[0], explore, tags);
-                            },
-                        });
-                    if (meta.natives.length && meta.natives[0] === "Uint8Array")
-                        unions.push({
-                            type: "native",
-                            is: function () { return (0, check_native_1.check_native)("Uint8Array")(input); },
-                            value: function () { return decode_binary(input); },
-                        });
-                    return unions.length === 1
-                        ? unions[0].value()
-                        : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, iterate(importer, input, unions, meta.getName())), undefined, undefined);
-                };
-            };
-        };
-    };
-    var iterate = function (importer, input, unions, expected) {
-        return typescript_1.default.factory.createBlock(__spreadArray(__spreadArray([], __read(unions.map(function (u) {
-            return typescript_1.default.factory.createIfStatement(u.is(), typescript_1.default.factory.createReturnStatement(u.value()));
-        })), false), [
-            create_throw_error(importer)(expected)(input),
-        ], false), true);
-    };
-    var decode_atomic = function (importer) {
-        return function (input, type, tags) {
-            return type === "string"
-                ? typescript_1.default.factory.createAdd(typescript_1.default.factory.createNumericLiteral(4), typescript_1.default.factory.createCallExpression(importer.use("strlen"), undefined, [input]))
-                : typescript_1.default.factory.createNumericLiteral(computeAtomicLength(type)(tags));
-        };
-    };
-    var decode_array = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, array, explore, tags) {
-                    var header = function (expr) {
-                        return typescript_1.default.factory.createAdd(typescript_1.default.factory.createNumericLiteral(4), expr);
-                    };
-                    if (array.value.isBinaryUnion() === false) {
-                        var length_1 = computeFixedLength(array.value)(tags);
-                        if (length_1 !== null)
-                            return header(typescript_1.default.factory.createMultiply(IdentifierFactory_1.IdentifierFactory.access(input)("length"), typescript_1.default.factory.createNumericLiteral(length_1)));
-                    }
-                    return header(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("map"), undefined, [
-                        typescript_1.default.factory.createArrowFunction(undefined, undefined, [IdentifierFactory_1.IdentifierFactory.parameter("elem")], undefined, undefined, decode(project)(config)(importer)(typescript_1.default.factory.createIdentifier("elem"), array.value, explore, tags)),
-                    ]), undefined, [
-                        typescript_1.default.factory.createArrowFunction(undefined, undefined, [
-                            IdentifierFactory_1.IdentifierFactory.parameter("a"),
-                            IdentifierFactory_1.IdentifierFactory.parameter("b"),
-                        ], undefined, undefined, typescript_1.default.factory.createAdd(typescript_1.default.factory.createIdentifier("a"), typescript_1.default.factory.createIdentifier("b"))),
-                        typescript_1.default.factory.createNumericLiteral(0),
-                    ]));
-                };
-            };
-        };
-    };
-    var decode_object = function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_object({
-            trace: false,
-            path: false,
-            prefix: PREFIX,
-        })(importer);
-    };
-    var decode_binary = function (input) {
-        return typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("writeBytes"), undefined, [input]);
-    };
-    var decode_map = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, entry, explore, tags) {
-                    return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createArrowFunction(undefined, undefined, [], TypeFactory_1.TypeFactory.keyword("any"), undefined, write_map_function_body(project)(config)(importer)(input, entry, explore, tags)), undefined, undefined);
-                };
-            };
-        };
-    };
-    var explore_objects = function (_project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, meta, explore) {
-                    return meta.objects.length === 1
-                        ? decode_object(importer)(input, meta.objects[0], explore)
-                        : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "u").concat(meta.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input));
-                };
-            };
-        };
-    };
-    var explore_arrays = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, elements, explore, tags) {
-                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array({
-                        checker: IsProgrammer_1.IsProgrammer.decode(project)(importer),
-                        decoder: decode_array(project)(config)(importer),
-                        empty: typescript_1.default.factory.createStringLiteral("[]"),
-                        success: typescript_1.default.factory.createTrue(),
-                        failure: function (input, expected) {
-                            return create_throw_error(importer)(expected)(input);
-                        },
-                    }))(input, elements, explore, tags);
-                };
-            };
-        };
-    };
-    var explore_array_like_union_types = function (config) {
-        return function (importer) {
-            return function (factory) {
-                return function (input, elements, explore, tags) {
-                    var arrow = function (parameters) {
-                        return function (explore) {
-                            return function (input) {
-                                return factory(parameters)(input, elements, explore, tags, []);
-                            };
-                        };
-                    };
-                    if (elements.every(function (e) { return e.recursive === false; }))
-                        typescript_1.default.factory.createCallExpression(arrow([])(explore)(input), undefined, []);
-                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
-                    return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.emplaceUnion(config.prefix, elements.map(function (e) { return e.name; }).join(" | "), function () {
-                        return arrow(FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")))(__assign(__assign({}, explore), { postfix: "" }))(typescript_1.default.factory.createIdentifier("input"));
-                    })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input));
-                };
-            };
-        };
-    };
-    var PREFIX = "$ps";
-    var configure = function (method) {
-        return function (project) {
-            return function (importer) {
-                var config = {
-                    types: {
-                        input: function (type, name) {
-                            return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(project.checker)(type));
-                        },
-                        output: function (type, name) {
-                            return typescript_1.default.factory.createTypeReferenceNode("typia.Primitive<".concat(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(project.checker)(type), ">"));
-                        },
-                    },
-                    prefix: PREFIX,
-                    trace: false,
-                    path: false,
-                    initializer: initializer(method),
-                    decoder: function () { return decode(project)(config)(importer); },
-                    objector: {
-                        checker: function () { return IsProgrammer_1.IsProgrammer.decode(project)(importer); },
-                        decoder: function () { return decode_object(importer); },
-                        joiner: function (_input, _entries, obj) {
-                            return write_object_function_body(project)(config)(importer)(obj);
-                        },
-                        unionizer: (0, decode_union_object_1.decode_union_object)(IsProgrammer_1.IsProgrammer.decode_object(importer))(decode_object(importer))(function (exp) { return exp; })(function (input, expected) {
-                            return create_throw_error(importer)(expected)(input);
-                        }),
-                        failure: function (input, expected) {
-                            return create_throw_error(importer)(expected)(input);
-                        },
-                    },
-                    generator: {
-                        arrays: function () { return function () { return []; }; },
-                        tuples: function () { return function () { return []; }; },
-                    },
-                };
-                return config;
-            };
-        };
-    };
-    var initializer = function (method) {
-        return function (_a) {
-            var checker = _a.checker;
-            return function (type) {
-                var collection = new MetadataCollection_1.MetadataCollection();
-                var meta = ProtobufFactory_1.ProtobufFactory.metadata(method)(checker)(collection)(type);
-                return [collection, meta];
-            };
-        };
-    };
-    var create_throw_error = function (importer) {
-        return function (expected) {
-            return function (value) {
-                return typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(importer.use("throws"), [], [
-                    typescript_1.default.factory.createObjectLiteralExpression([
-                        typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(expected)),
-                        typescript_1.default.factory.createPropertyAssignment("value", value),
-                    ], true),
-                ]));
-            };
-        };
-    };
-})(ProtobufSizeProgrammer || (exports.ProtobufSizeProgrammer = ProtobufSizeProgrammer = {}));
-var computeFixedLength = function (meta) {
-    return function (tags) {
-        if (meta.fixed_ !== undefined)
-            return meta.fixed_;
-        return (meta.fixed_ = (function () {
-            if (meta.isRequired() === false ||
-                meta.nullable ||
-                meta.natives.length ||
-                meta.maps.length ||
-                meta.isBinaryUnion())
-                return null;
-            else if (meta.arrays.length)
-                return computeFixedLength(meta.arrays[0].value)(tags);
-            var atomics = new Set(__spreadArray(__spreadArray(__spreadArray([], __read(meta.atomics), false), __read(meta.constants.map(function (c) { return c.type; })), false), __read(meta.templates.map(function () { return "string"; })), false));
-            if (atomics.size)
-                return computeAtomicLength(Array.from(atomics)[0])(tags);
-            else if (meta.objects.length) {
-                var obj = meta.objects[0];
-                if (obj.properties.some(function (p) { return !p.key.isSoleLiteral(); }))
-                    return null;
-                else if (obj.properties.some(function (p) { return computeFixedLength(p.value)(p.tags) === null; }))
-                    return null;
-                return obj.properties
-                    .map(function (p) {
-                    return (0, _strlen_1.$strlen)(p.key.getSoleLiteral()) +
-                        computeFixedLength(p.value)(p.tags);
-                })
-                    .reduce(function (a, b) { return a + b; }, 0);
-            }
-            return null;
-        })());
-    };
-};
-var computeAtomicLength = function (type) {
-    return function (tags) {
-        if (type === "string")
-            return null;
-        else if (type === "boolean")
-            return 1;
-        else if (type === "bigint")
-            return 8;
-        var shorter = tags.find(function (tag) { return tag.kind === "type"; });
-        return shorter &&
-            (shorter.value === "int" ||
-                shorter.value === "uint" ||
-                shorter.value === "int32" ||
-                shorter.value === "uint32" ||
-                shorter.value === "float")
-            ? 4
-            : 8;
-    };
-};
-//# sourceMappingURL=ProtobufSizeProgrammer.js.map