typia 7.0.0-dev.20241112 → 7.0.0-dev.20241114

package/lib/programmers/misc/MiscPruneProgrammer.js

@@ -1,329 +1,221 @@
 "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 __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MiscPruneProgrammer = 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 MetadataFactory_1 = require("../../factories/MetadataFactory");
-var StatementFactory_1 = require("../../factories/StatementFactory");
-var TypeFactory_1 = require("../../factories/TypeFactory");
-var Metadata_1 = require("../../schemas/metadata/Metadata");
-var MetadataArray_1 = require("../../schemas/metadata/MetadataArray");
-var TransformerError_1 = require("../../transformers/TransformerError");
-var FeatureProgrammer_1 = require("../FeatureProgrammer");
-var IsProgrammer_1 = require("../IsProgrammer");
-var FunctionProgrammer_1 = require("../helpers/FunctionProgrammer");
-var PruneJoiner_1 = require("../helpers/PruneJoiner");
-var UnionExplorer_1 = require("../helpers/UnionExplorer");
-var decode_union_object_1 = require("../internal/decode_union_object");
-var postfix_of_tuple_1 = require("../internal/postfix_of_tuple");
-var wrap_metadata_rest_tuple_1 = require("../internal/wrap_metadata_rest_tuple");
+const typescript_1 = __importDefault(require("typescript"));
+const ExpressionFactory_1 = require("../../factories/ExpressionFactory");
+const IdentifierFactory_1 = require("../../factories/IdentifierFactory");
+const MetadataCollection_1 = require("../../factories/MetadataCollection");
+const MetadataFactory_1 = require("../../factories/MetadataFactory");
+const StatementFactory_1 = require("../../factories/StatementFactory");
+const TypeFactory_1 = require("../../factories/TypeFactory");
+const Metadata_1 = require("../../schemas/metadata/Metadata");
+const MetadataArray_1 = require("../../schemas/metadata/MetadataArray");
+const TransformerError_1 = require("../../transformers/TransformerError");
+const FeatureProgrammer_1 = require("../FeatureProgrammer");
+const IsProgrammer_1 = require("../IsProgrammer");
+const FunctionProgrammer_1 = require("../helpers/FunctionProgrammer");
+const PruneJoiner_1 = require("../helpers/PruneJoiner");
+const UnionExplorer_1 = require("../helpers/UnionExplorer");
+const decode_union_object_1 = require("../internal/decode_union_object");
+const postfix_of_tuple_1 = require("../internal/postfix_of_tuple");
+const wrap_metadata_rest_tuple_1 = require("../internal/wrap_metadata_rest_tuple");
 var MiscPruneProgrammer;
 (function (MiscPruneProgrammer) {
-    MiscPruneProgrammer.decompose = function (props) {
-        var config = configure(props);
+    MiscPruneProgrammer.decompose = (props) => {
+        const config = configure(props);
         if (props.validated === false)
-            config.addition = function (collection) {
-                return IsProgrammer_1.IsProgrammer.write_function_statements({
-                    context: props.context,
-                    functor: props.functor,
-                    collection: collection,
-                });
-            };
-        var composed = FeatureProgrammer_1.FeatureProgrammer.compose(__assign(__assign({}, props), { config: config }));
+            config.addition = (collection) => IsProgrammer_1.IsProgrammer.write_function_statements({
+                context: props.context,
+                functor: props.functor,
+                collection,
+            });
+        const composed = FeatureProgrammer_1.FeatureProgrammer.compose(Object.assign(Object.assign({}, props), { config }));
         return {
             functions: composed.functions,
             statements: composed.statements,
             arrow: typescript_1.default.factory.createArrowFunction(undefined, undefined, composed.parameters, composed.response, undefined, composed.body),
         };
     };
-    MiscPruneProgrammer.write = function (props) {
-        var functor = new FunctionProgrammer_1.FunctionProgrammer(props.modulo.getText());
-        var result = MiscPruneProgrammer.decompose(__assign(__assign({}, props), { validated: false, functor: functor }));
+    MiscPruneProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer_1.FunctionProgrammer(props.modulo.getText());
+        const result = MiscPruneProgrammer.decompose(Object.assign(Object.assign({}, props), { validated: false, functor }));
         return FeatureProgrammer_1.FeatureProgrammer.writeDecomposed({
             modulo: props.modulo,
-            functor: functor,
-            result: result,
-        });
-    };
-    var write_array_functions = function (props) {
-        return props.collection
-            .arrays()
-            .filter(function (a) { return a.recursive; })
-            .map(function (type, i) {
-            return StatementFactory_1.StatementFactory.constant({
-                name: "".concat(props.config.prefix, "a").concat(i),
-                value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
-                    config: props.config,
-                    type: TypeFactory_1.TypeFactory.keyword("any"),
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline({
-                    config: props.config,
-                    functor: props.functor,
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                    array: MetadataArray_1.MetadataArray.create({
-                        type: type,
-                        tags: [],
-                    }),
-                    explore: {
-                        tracable: props.config.trace,
-                        source: "function",
-                        from: "array",
-                        postfix: "",
-                    },
-                })),
-            });
-        });
-    };
-    var write_tuple_functions = function (props) {
-        return props.collection
-            .tuples()
-            .filter(function (t) { return t.recursive; })
-            .map(function (tuple, i) {
-            return StatementFactory_1.StatementFactory.constant({
-                name: "".concat(props.config.prefix, "t").concat(i),
-                value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
-                    config: props.config,
-                    type: TypeFactory_1.TypeFactory.keyword("any"),
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
-                    context: props.context,
-                    config: props.config,
-                    functor: props.functor,
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                    tuple: tuple,
-                    explore: {
-                        tracable: props.config.trace,
-                        source: "function",
-                        from: "array",
-                        postfix: "",
-                    },
-                })),
-            });
+            functor,
+            result,
         });
     };
+    const write_array_functions = (props) => props.collection
+        .arrays()
+        .filter((a) => a.recursive)
+        .map((type, i) => StatementFactory_1.StatementFactory.constant({
+        name: `${props.config.prefix}a${i}`,
+        value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory_1.TypeFactory.keyword("any"),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline({
+            config: props.config,
+            functor: props.functor,
+            input: typescript_1.default.factory.createIdentifier("input"),
+            array: MetadataArray_1.MetadataArray.create({
+                type,
+                tags: [],
+            }),
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    const write_tuple_functions = (props) => props.collection
+        .tuples()
+        .filter((t) => t.recursive)
+        .map((tuple, i) => StatementFactory_1.StatementFactory.constant({
+        name: `${props.config.prefix}t${i}`,
+        value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory_1.TypeFactory.keyword("any"),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: typescript_1.default.factory.createIdentifier("input"),
+            tuple,
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
     /* -----------------------------------------------------------
           DECODERS
       ----------------------------------------------------------- */
-    var decode = function (props) {
-        var e_1, _a, e_2, _b;
+    const decode = (props) => {
         if (filter(props.metadata) === false)
             return typescript_1.default.factory.createBlock([]);
-        var unions = [];
-        var _loop_1 = function (tuple) {
+        const unions = [];
+        //----
+        // LIST UP UNION TYPES
+        //----
+        // TUPLES
+        for (const tuple of props.metadata.tuples.filter((tuple) => tuple.type.elements.some((e) => { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); })))
             unions.push({
                 type: "tuple",
-                is: function () {
-                    return IsProgrammer_1.IsProgrammer.decode(__assign(__assign({}, props), { metadata: (function () {
-                            var partial = Metadata_1.Metadata.initialize();
-                            partial.tuples.push(tuple);
-                            return partial;
-                        })() }));
-                },
-                value: function () {
-                    return decode_tuple(__assign(__assign({}, props), { tuple: tuple }));
-                },
+                is: () => IsProgrammer_1.IsProgrammer.decode(Object.assign(Object.assign({}, props), { metadata: (() => {
+                        const partial = Metadata_1.Metadata.initialize();
+                        partial.tuples.push(tuple);
+                        return partial;
+                    })() })),
+                value: () => decode_tuple(Object.assign(Object.assign({}, props), { tuple })),
             });
-        };
-        try {
-            //----
-            // LIST UP UNION TYPES
-            //----
-            // TUPLES
-            for (var _c = __values(props.metadata.tuples.filter(function (tuple) {
-                return tuple.type.elements.some(function (e) { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); });
-            })), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var tuple = _d.value;
-                _loop_1(tuple);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
         // ARRAYS
-        if (props.metadata.arrays.filter(function (a) { return filter(a.type.value); }).length)
+        if (props.metadata.arrays.filter((a) => filter(a.type.value)).length)
             unions.push({
                 type: "array",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(props.input); },
-                value: function () {
-                    return explore_arrays(__assign(__assign({}, props), { arrays: props.metadata.arrays, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
-                },
+                is: () => ExpressionFactory_1.ExpressionFactory.isArray(props.input),
+                value: () => explore_arrays(Object.assign(Object.assign({}, props), { arrays: props.metadata.arrays, explore: Object.assign(Object.assign({}, props.explore), { from: "array" }) })),
             });
         // BUILT-IN CLASSES
-        if (props.metadata.natives.length) {
-            var _loop_2 = function (native) {
+        if (props.metadata.natives.length)
+            for (const native of props.metadata.natives)
                 unions.push({
                     type: "native",
-                    is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf(native.name, props.input); },
-                    value: function () { return typescript_1.default.factory.createReturnStatement(); },
+                    is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf(native.name, props.input),
+                    value: () => typescript_1.default.factory.createReturnStatement(),
                 });
-            };
-            try {
-                for (var _e = __values(props.metadata.natives), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var native = _f.value;
-                    _loop_2(native);
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-        }
         if (props.metadata.sets.length)
             unions.push({
                 type: "set",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set", props.input); },
-                value: function () { return typescript_1.default.factory.createReturnStatement(); },
+                is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set", props.input),
+                value: () => typescript_1.default.factory.createReturnStatement(),
             });
         if (props.metadata.maps.length)
             unions.push({
                 type: "map",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map", props.input); },
-                value: function () { return typescript_1.default.factory.createReturnStatement(); },
+                is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map", props.input),
+                value: () => typescript_1.default.factory.createReturnStatement(),
             });
         // OBJECTS
         if (props.metadata.objects.length)
             unions.push({
                 type: "object",
-                is: function () {
-                    return ExpressionFactory_1.ExpressionFactory.isObject({
-                        checkNull: true,
-                        checkArray: false,
-                        input: props.input,
-                    });
-                },
-                value: function () {
-                    return explore_objects(__assign(__assign({}, props), { explore: __assign(__assign({}, props.explore), { from: "object" }) }));
-                },
+                is: () => ExpressionFactory_1.ExpressionFactory.isObject({
+                    checkNull: true,
+                    checkArray: false,
+                    input: props.input,
+                }),
+                value: () => explore_objects(Object.assign(Object.assign({}, props), { explore: Object.assign(Object.assign({}, props.explore), { from: "object" }) })),
             });
         //----
         // STATEMENTS
         //----
-        var converter = function (v) {
-            return typescript_1.default.isReturnStatement(v) || typescript_1.default.isBlock(v)
-                ? v
-                : typescript_1.default.factory.createExpressionStatement(v);
-        };
-        var statements = unions.map(function (u) {
-            return typescript_1.default.factory.createIfStatement(u.is(), converter(u.value()));
-        });
+        const converter = (v) => typescript_1.default.isReturnStatement(v) || typescript_1.default.isBlock(v)
+            ? v
+            : typescript_1.default.factory.createExpressionStatement(v);
+        const statements = unions.map((u) => typescript_1.default.factory.createIfStatement(u.is(), converter(u.value())));
         return typescript_1.default.factory.createBlock(statements, true);
     };
-    var decode_object = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_object({
-            config: {
-                trace: false,
-                path: false,
-                prefix: PREFIX,
-            },
-            functor: props.functor,
-            object: props.object,
+    const decode_object = (props) => FeatureProgrammer_1.FeatureProgrammer.decode_object({
+        config: {
+            trace: false,
+            path: false,
+            prefix: PREFIX,
+        },
+        functor: props.functor,
+        object: props.object,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_array = (props) => props.array.type.recursive
+        ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}a${props.array.type.index}`)), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: Object.assign(Object.assign({}, props.explore), { source: "function", from: "array" }),
             input: props.input,
-            explore: props.explore,
-        });
-    };
-    var decode_array = function (props) {
-        return props.array.type.recursive
-            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
-                config: props.config,
-                explore: __assign(__assign({}, props.explore), { source: "function", from: "array" }),
-                input: props.input,
-            }))
-            : decode_array_inline(props);
-    };
-    var decode_array_inline = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_array({
+        }))
+        : decode_array_inline(props);
+    const decode_array_inline = (props) => FeatureProgrammer_1.FeatureProgrammer.decode_array({
+        config: props.config,
+        functor: props.functor,
+        combiner: PruneJoiner_1.PruneJoiner.array,
+        array: props.array,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_tuple = (props) => props.tuple.type.recursive
+        ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}t${props.tuple.type.index}`)), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
             config: props.config,
-            functor: props.functor,
-            combiner: PruneJoiner_1.PruneJoiner.array,
-            array: props.array,
+            explore: Object.assign(Object.assign({}, props.explore), { source: "function" }),
             input: props.input,
-            explore: props.explore,
-        });
-    };
-    var decode_tuple = function (props) {
-        return props.tuple.type.recursive
-            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
-                config: props.config,
-                explore: __assign(__assign({}, props.explore), { source: "function" }),
-                input: props.input,
-            }))
-            : decode_tuple_inline(__assign(__assign({}, props), { tuple: props.tuple.type }));
-    };
-    var decode_tuple_inline = function (props) {
-        var elements = props.tuple.elements
-            .map(function (elem, index) { return [elem, index]; })
-            .filter(function (_a) {
-            var _b = __read(_a, 1), elem = _b[0];
-            return filter(elem) && elem.rest === null;
-        })
-            .map(function (_a) {
-            var _b = __read(_a, 2), elem = _b[0], index = _b[1];
-            return decode({
-                context: props.context,
-                config: props.config,
-                functor: props.functor,
-                input: typescript_1.default.factory.createElementAccessExpression(props.input, index),
-                metadata: elem,
-                explore: __assign(__assign({}, props.explore), { from: "array", postfix: props.explore.postfix.length
-                        ? "".concat((0, postfix_of_tuple_1.postfix_of_tuple)(props.explore.postfix), "[").concat(index, "]\"")
-                        : "\"[".concat(index, "]\"") }),
-            });
-        });
-        var rest = (function () {
+        }))
+        : decode_tuple_inline(Object.assign(Object.assign({}, props), { tuple: props.tuple.type }));
+    const decode_tuple_inline = (props) => {
+        const elements = props.tuple.elements
+            .map((elem, index) => [elem, index])
+            .filter(([elem]) => filter(elem) && elem.rest === null)
+            .map(([elem, index]) => decode({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: typescript_1.default.factory.createElementAccessExpression(props.input, index),
+            metadata: elem,
+            explore: Object.assign(Object.assign({}, props.explore), { from: "array", postfix: props.explore.postfix.length
+                    ? `${(0, postfix_of_tuple_1.postfix_of_tuple)(props.explore.postfix)}[${index}]"`
+                    : `"[${index}]"` }),
+        }));
+        const rest = (() => {
             if (props.tuple.elements.length === 0)
                 return null;
-            var last = props.tuple.elements.at(-1);
-            var rest = last.rest;
+            const last = props.tuple.elements.at(-1);
+            const rest = last.rest;
             if (rest === null || filter(rest) === false)
                 return null;
             return decode({
@@ -332,211 +224,171 @@ var MiscPruneProgrammer;
                 functor: props.functor,
                 input: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "slice"), undefined, [ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length - 1)]),
                 metadata: (0, wrap_metadata_rest_tuple_1.wrap_metadata_rest_tuple)(props.tuple.elements.at(-1).rest),
-                explore: __assign(__assign({}, props.explore), { start: props.tuple.elements.length - 1 }),
+                explore: Object.assign(Object.assign({}, props.explore), { start: props.tuple.elements.length - 1 }),
             });
         })();
         return PruneJoiner_1.PruneJoiner.tuple({
-            elements: elements,
-            rest: rest,
+            elements,
+            rest,
         });
     };
     /* -----------------------------------------------------------
           UNION TYPE EXPLORERS
       ----------------------------------------------------------- */
-    var explore_objects = function (props) {
+    const explore_objects = (props) => {
         if (props.metadata.objects.length === 1)
-            return decode_object(__assign(__assign({}, props), { object: props.metadata.objects[0].type }));
-        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal("".concat(PREFIX, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
-    };
-    var explore_arrays = function (props) {
-        return explore_array_like_union_types(__assign(__assign({}, props), { elements: props.arrays, factory: function (next) {
-                return UnionExplorer_1.UnionExplorer.array({
-                    config: {
-                        checker: function (v) {
-                            return IsProgrammer_1.IsProgrammer.decode({
-                                context: props.context,
-                                functor: props.functor,
-                                metadata: v.definition,
-                                input: v.input,
-                                explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return decode_array({
-                                config: props.config,
-                                functor: props.functor,
-                                input: v.input,
-                                array: v.definition,
-                                explore: v.explore,
-                            });
-                        },
-                        empty: typescript_1.default.factory.createStringLiteral("[]"),
-                        success: typescript_1.default.factory.createTrue(),
-                        failure: function (v) {
-                            return create_throw_error({
-                                context: props.context,
-                                functor: props.functor,
-                                expected: v.expected,
-                                input: v.input,
-                            });
-                        },
-                    },
-                    parameters: next.parameters,
-                    input: next.input,
-                    arrays: next.definitions,
-                    explore: next.explore,
-                });
-            } }));
+            return decode_object(Object.assign(Object.assign({}, props), { object: props.metadata.objects[0].type }));
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(`${PREFIX}u${props.metadata.union_index}`)), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
     };
+    const explore_arrays = (props) => explore_array_like_union_types(Object.assign(Object.assign({}, props), { elements: props.arrays, factory: (next) => UnionExplorer_1.UnionExplorer.array({
+            config: {
+                checker: (v) => IsProgrammer_1.IsProgrammer.decode({
+                    context: props.context,
+                    functor: props.functor,
+                    metadata: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_array({
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    array: v.definition,
+                    explore: v.explore,
+                }),
+                empty: typescript_1.default.factory.createStringLiteral("[]"),
+                success: typescript_1.default.factory.createTrue(),
+                failure: (v) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: v.expected,
+                    input: v.input,
+                }),
+            },
+            parameters: next.parameters,
+            input: next.input,
+            arrays: next.definitions,
+            explore: next.explore,
+        }) }));
     //(next.parameters)(next.input, next.elements, next.explore),
-    var explore_array_like_union_types = function (props) {
-        var arrow = function (next) {
-            return props.factory({
-                definitions: props.elements,
-                parameters: next.parameters,
-                input: next.input,
-                explore: next.explore,
-            });
-        };
-        if (props.elements.every(function (e) { return e.type.recursive === false; }))
+    const explore_array_like_union_types = (props) => {
+        const arrow = (next) => props.factory({
+            definitions: props.elements,
+            parameters: next.parameters,
+            input: next.input,
+            explore: next.explore,
+        });
+        if (props.elements.every((e) => e.type.recursive === false))
             typescript_1.default.factory.createCallExpression(arrow({
                 parameters: [],
                 explore: props.explore,
                 input: props.input,
             }), undefined, []);
-        var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
-        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.emplaceUnion(props.config.prefix, props.elements.map(function (e) { return e.type.name; }).join(" | "), function () {
-            return arrow({
-                parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
-                    config: props.config,
-                    type: TypeFactory_1.TypeFactory.keyword("any"),
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                }),
-                explore: __assign(__assign({}, arrayExplore), { postfix: "" }),
+        const arrayExplore = Object.assign(Object.assign({}, props.explore), { source: "function", from: "array" });
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.emplaceUnion(props.config.prefix, props.elements.map((e) => e.type.name).join(" | "), () => arrow({
+            parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory_1.TypeFactory.keyword("any"),
                 input: typescript_1.default.factory.createIdentifier("input"),
-            });
-        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
+            }),
+            explore: Object.assign(Object.assign({}, arrayExplore), { postfix: "" }),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
     };
     // @todo -> must filter out recursive visit
-    var filter = function (metadata) {
-        return metadata.any === false &&
-            (metadata.objects.length !== 0 ||
-                metadata.tuples.some(function (t) {
-                    return !!t.type.elements.length &&
-                        t.type.elements.some(function (e) { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); });
-                }) ||
-                metadata.arrays.some(function (e) { return filter(e.type.value); }));
-    };
+    const filter = (metadata) => metadata.any === false &&
+        (metadata.objects.length !== 0 ||
+            metadata.tuples.some((t) => !!t.type.elements.length &&
+                t.type.elements.some((e) => { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); })) ||
+            metadata.arrays.some((e) => filter(e.type.value)));
     /* -----------------------------------------------------------
           CONFIGURATIONS
       ----------------------------------------------------------- */
-    var PREFIX = "_p";
-    var configure = function (props) {
-        var config = {
+    const PREFIX = "_p";
+    const configure = (props) => {
+        const config = {
             types: {
-                input: function (type, name) {
-                    return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type: type }));
-                },
-                output: function () { return TypeFactory_1.TypeFactory.keyword("void"); },
+                input: (type, name) => typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type })),
+                output: () => TypeFactory_1.TypeFactory.keyword("void"),
             },
             prefix: PREFIX,
             trace: false,
             path: false,
-            initializer: initializer,
-            decoder: function (next) {
-                return decode({
+            initializer,
+            decoder: (next) => decode({
+                context: props.context,
+                functor: props.functor,
+                config,
+                input: next.input,
+                metadata: next.metadata,
+                explore: next.explore,
+            }),
+            objector: {
+                checker: (next) => IsProgrammer_1.IsProgrammer.decode({
                     context: props.context,
                     functor: props.functor,
-                    config: config,
                     input: next.input,
                     metadata: next.metadata,
                     explore: next.explore,
-                });
-            },
-            objector: {
-                checker: function (next) {
-                    return IsProgrammer_1.IsProgrammer.decode({
+                }),
+                decoder: (next) => decode_object({
+                    functor: props.functor,
+                    input: next.input,
+                    object: next.object,
+                    explore: next.explore,
+                }),
+                joiner: PruneJoiner_1.PruneJoiner.object,
+                unionizer: (next) => (0, decode_union_object_1.decode_union_object)({
+                    checker: (v) => IsProgrammer_1.IsProgrammer.decode_object({
                         context: props.context,
                         functor: props.functor,
-                        input: next.input,
-                        metadata: next.metadata,
-                        explore: next.explore,
-                    });
-                },
-                decoder: function (next) {
-                    return decode_object({
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    decoder: (v) => decode_object({
                         functor: props.functor,
-                        input: next.input,
-                        object: next.object,
-                        explore: next.explore,
-                    });
-                },
-                joiner: PruneJoiner_1.PruneJoiner.object,
-                unionizer: function (next) {
-                    return (0, decode_union_object_1.decode_union_object)({
-                        checker: function (v) {
-                            return IsProgrammer_1.IsProgrammer.decode_object({
-                                context: props.context,
-                                functor: props.functor,
-                                input: v.input,
-                                object: v.object,
-                                explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return decode_object({
-                                functor: props.functor,
-                                input: v.input,
-                                object: v.object,
-                                explore: v.explore,
-                            });
-                        },
-                        success: function (exp) { return exp; },
-                        escaper: function (v) {
-                            return create_throw_error({
-                                context: props.context,
-                                functor: props.functor,
-                                expected: v.expected,
-                                input: v.input,
-                            });
-                        },
-                        input: next.input,
-                        objects: next.objects,
-                        explore: next.explore,
-                    });
-                },
-                failure: function (next) {
-                    return create_throw_error({
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    success: (exp) => exp,
+                    escaper: (v) => create_throw_error({
                         context: props.context,
                         functor: props.functor,
-                        expected: next.expected,
-                        input: next.input,
-                    });
-                },
+                        expected: v.expected,
+                        input: v.input,
+                    }),
+                    input: next.input,
+                    objects: next.objects,
+                    explore: next.explore,
+                }),
+                failure: (next) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: next.expected,
+                    input: next.input,
+                }),
             },
             generator: {
-                arrays: function (collection) {
-                    return write_array_functions({
-                        config: config,
-                        functor: props.functor,
-                        collection: collection,
-                    });
-                },
-                tuples: function (collection) {
-                    return write_tuple_functions({
-                        config: config,
-                        context: props.context,
-                        functor: props.functor,
-                        collection: collection,
-                    });
-                },
+                arrays: (collection) => write_array_functions({
+                    config,
+                    functor: props.functor,
+                    collection,
+                }),
+                tuples: (collection) => write_tuple_functions({
+                    config,
+                    context: props.context,
+                    functor: props.functor,
+                    collection,
+                }),
             },
         };
         return config;
     };
-    var initializer = function (props) {
-        var collection = new MetadataCollection_1.MetadataCollection();
-        var result = MetadataFactory_1.MetadataFactory.analyze({
+    const initializer = (props) => {
+        const collection = new MetadataCollection_1.MetadataCollection();
+        const result = MetadataFactory_1.MetadataFactory.analyze({
             checker: props.context.checker,
             transformer: props.context.transformer,
             options: {
@@ -544,7 +396,7 @@ var MiscPruneProgrammer;
                 constant: true,
                 absorb: true,
             },
-            collection: collection,
+            collection,
             type: props.type,
         });
         if (result.success === false)
@@ -553,18 +405,16 @@ var MiscPruneProgrammer;
                 errors: result.errors,
             });
         return {
-            collection: collection,
+            collection,
             metadata: result.data,
         };
     };
-    var create_throw_error = function (props) {
-        return typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(props.context.importer.internal("throwTypeGuardError"), [], [
-            typescript_1.default.factory.createObjectLiteralExpression([
-                typescript_1.default.factory.createPropertyAssignment("method", typescript_1.default.factory.createStringLiteral(props.functor.method)),
-                typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(props.expected)),
-                typescript_1.default.factory.createPropertyAssignment("value", props.input),
-            ], true),
-        ]));
-    };
+    const create_throw_error = (props) => typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(props.context.importer.internal("throwTypeGuardError"), [], [
+        typescript_1.default.factory.createObjectLiteralExpression([
+            typescript_1.default.factory.createPropertyAssignment("method", typescript_1.default.factory.createStringLiteral(props.functor.method)),
+            typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(props.expected)),
+            typescript_1.default.factory.createPropertyAssignment("value", props.input),
+        ], true),
+    ]));
 })(MiscPruneProgrammer || (exports.MiscPruneProgrammer = MiscPruneProgrammer = {}));
 //# sourceMappingURL=MiscPruneProgrammer.js.map