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

package/lib/programmers/notations/NotationGeneralProgrammer.js

@@ -1,71 +1,45 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotationGeneralProgrammer = 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 StringUtil_1 = require("../../utils/StringUtil");
-var FeatureProgrammer_1 = require("../FeatureProgrammer");
-var IsProgrammer_1 = require("../IsProgrammer");
-var FunctionProgrammer_1 = require("../helpers/FunctionProgrammer");
-var NotationJoiner_1 = require("../helpers/NotationJoiner");
-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 StringUtil_1 = require("../../utils/StringUtil");
+const FeatureProgrammer_1 = require("../FeatureProgrammer");
+const IsProgrammer_1 = require("../IsProgrammer");
+const FunctionProgrammer_1 = require("../helpers/FunctionProgrammer");
+const NotationJoiner_1 = require("../helpers/NotationJoiner");
+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 NotationGeneralProgrammer;
 (function (NotationGeneralProgrammer) {
-    NotationGeneralProgrammer.returnType = function (props) {
-        return props.context.importer.type({
-            file: "typia",
-            name: "".concat(StringUtil_1.StringUtil.capitalize(props.rename.name), "Case"),
-            arguments: [typescript_1.default.factory.createTypeReferenceNode(props.type)],
-        });
-    };
-    NotationGeneralProgrammer.decompose = function (props) {
+    NotationGeneralProgrammer.returnType = (props) => props.context.importer.type({
+        file: "typia",
+        name: `${StringUtil_1.StringUtil.capitalize(props.rename.name)}Case`,
+        arguments: [typescript_1.default.factory.createTypeReferenceNode(props.type)],
+    });
+    NotationGeneralProgrammer.decompose = (props) => {
         var _a;
-        var config = configure(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,
@@ -79,75 +53,66 @@ var NotationGeneralProgrammer;
             }), undefined, composed.body),
         };
     };
-    NotationGeneralProgrammer.write = function (props) {
-        var functor = new FunctionProgrammer_1.FunctionProgrammer(props.modulo.getText());
-        var result = NotationGeneralProgrammer.decompose(__assign(__assign({}, props), { functor: functor, validated: true }));
+    NotationGeneralProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer_1.FunctionProgrammer(props.modulo.getText());
+        const result = NotationGeneralProgrammer.decompose(Object.assign(Object.assign({}, props), { functor, validated: true }));
         return FeatureProgrammer_1.FeatureProgrammer.writeDecomposed({
-            functor: functor,
+            functor,
             modulo: props.modulo,
-            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(__assign(__assign({}, props), { 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(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input"), tuple: tuple, explore: {
-                        tracable: props.config.trace,
-                        source: "function",
-                        from: "array",
-                        postfix: "",
-                    } }))),
-            });
+            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(Object.assign(Object.assign({}, props), { 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(Object.assign(Object.assign({}, props), { 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, e_3, _c;
+    const decode = (props) => {
         // ANY TYPE
         if (props.metadata.any ||
-            props.metadata.arrays.some(function (a) { return a.type.value.any; }) ||
-            props.metadata.tuples.some(function (t) { return !!t.type.elements.length && t.type.elements.every(function (e) { return e.any; }); }))
+            props.metadata.arrays.some((a) => a.type.value.any) ||
+            props.metadata.tuples.some((t) => !!t.type.elements.length && t.type.elements.every((e) => e.any)))
             return ExpressionFactory_1.ExpressionFactory.currying({
                 function: props.context.importer.internal("notationAny"),
                 arguments: [
-                    props.context.importer.internal("notation".concat(StringUtil_1.StringUtil.capitalize(props.rename.name))),
+                    props.context.importer.internal(`notation${StringUtil_1.StringUtil.capitalize(props.rename.name)}`),
                     props.input,
                 ],
             });
-        var unions = [];
+        const unions = [];
         //----
         // LIST UP UNION TYPES
         //----
@@ -155,301 +120,217 @@ var NotationGeneralProgrammer;
         if (props.metadata.functions.length)
             unions.push({
                 type: "functional",
-                is: function () {
-                    return typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createStringLiteral("function"), typescript_1.default.factory.createTypeOfExpression(props.input));
-                },
-                value: function () { return typescript_1.default.factory.createIdentifier("undefined"); },
+                is: () => typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createStringLiteral("function"), typescript_1.default.factory.createTypeOfExpression(props.input)),
+                value: () => typescript_1.default.factory.createIdentifier("undefined"),
             });
-        var _loop_1 = function (tuple) {
+        // TUPLES
+        for (const tuple of props.metadata.tuples)
             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 {
-            // TUPLES
-            for (var _d = __values(props.metadata.tuples), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var tuple = _e.value;
-                _loop_1(tuple);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
         // ARRAYS
         if (props.metadata.arrays.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" }) })),
             });
         // NATIVE TYPES
         if (props.metadata.sets.length)
             unions.push({
                 type: "set",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set", props.input); },
-                value: function () {
-                    return explore_sets(__assign(__assign({}, props), { sets: props.metadata.sets, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
-                },
+                is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set", props.input),
+                value: () => explore_sets(Object.assign(Object.assign({}, props), { sets: props.metadata.sets, explore: Object.assign(Object.assign({}, props.explore), { from: "array" }) })),
             });
         if (props.metadata.maps.length)
             unions.push({
                 type: "map",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map", props.input); },
-                value: function () {
-                    return explore_maps(__assign(__assign({}, props), { maps: props.metadata.maps, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
-                },
+                is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map", props.input),
+                value: () => explore_maps(Object.assign(Object.assign({}, props), { maps: props.metadata.maps, explore: Object.assign(Object.assign({}, props.explore), { from: "array" }) })),
             });
-        var _loop_2 = function (native) {
+        for (const native of props.metadata.natives) {
             if (native.name === "WeakSet" || native.name === "WeakMap")
-                return "continue";
+                continue;
             unions.push({
                 type: "native",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf(native.name, props.input); },
-                value: function () {
-                    return native.name === "Boolean" ||
-                        native.name === "Number" ||
-                        native.name === "String"
-                        ? typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "valueOf"), undefined, undefined)
-                        : decode_native({
-                            name: native.name,
-                            input: props.input,
-                        });
-                },
+                is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf(native.name, props.input),
+                value: () => native.name === "Boolean" ||
+                    native.name === "Number" ||
+                    native.name === "String"
+                    ? typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "valueOf"), undefined, undefined)
+                    : decode_native({
+                        name: native.name,
+                        input: props.input,
+                    }),
             });
-        };
-        try {
-            for (var _f = __values(props.metadata.natives), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var native = _g.value;
-                _loop_2(native);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-            }
-            finally { if (e_2) throw e_2.error; }
         }
         // 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" }) })),
             });
         // COMPOSITION
         if (unions.length === 0)
             return props.input;
         else if (unions.length === 1 && props.metadata.size() === 1) {
-            var value = (props.metadata.nullable || props.metadata.isRequired() === false) &&
+            const value = (props.metadata.nullable || props.metadata.isRequired() === false) &&
                 is_instance(props.metadata)
                 ? typescript_1.default.factory.createConditionalExpression(props.input, undefined, unions[0].value(), undefined, props.input)
                 : unions[0].value();
             return typescript_1.default.factory.createAsExpression(value, TypeFactory_1.TypeFactory.keyword("any"));
         }
         else {
-            var last = props.input;
-            try {
-                for (var _h = __values(unions.reverse()), _j = _h.next(); !_j.done; _j = _h.next()) {
-                    var u = _j.value;
-                    last = typescript_1.default.factory.createConditionalExpression(u.is(), undefined, u.value(), undefined, last);
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
+            let last = props.input;
+            for (const u of unions.reverse())
+                last = typescript_1.default.factory.createConditionalExpression(u.is(), undefined, u.value(), undefined, last);
             return typescript_1.default.factory.createAsExpression(last, TypeFactory_1.TypeFactory.keyword("any"));
         }
     };
-    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: NotationJoiner_1.NotationJoiner.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: NotationJoiner_1.NotationJoiner.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
-            .filter(function (m) { return m.rest === null; })
-            .map(function (elem, index) {
-            return decode(__assign(__assign({}, props), { 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
+            .filter((m) => m.rest === null)
+            .map((elem, index) => decode(Object.assign(Object.assign({}, props), { 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)
                 return null;
-            return decode(__assign(__assign({}, props), { 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 }) }));
+            return decode(Object.assign(Object.assign({}, props), { 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: Object.assign(Object.assign({}, props.explore), { start: props.tuple.elements.length - 1 }) }));
         })();
         return NotationJoiner_1.NotationJoiner.tuple({
-            elements: elements,
-            rest: rest,
+            elements,
+            rest,
         });
     };
     /* -----------------------------------------------------------
           NATIVE CLASSES
       ----------------------------------------------------------- */
-    var decode_native = function (props) {
-        return props.name === "Date"
-            ? typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.name), undefined, [props.input])
-            : props.input;
-    };
+    const decode_native = (props) => props.name === "Date"
+        ? typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.name), undefined, [props.input])
+        : props.input;
     /* -----------------------------------------------------------
           EXPLORERS FOR UNION TYPES
       ----------------------------------------------------------- */
-    var explore_sets = function (props) {
-        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
-            config: {
-                checker: function (v) {
-                    return IsProgrammer_1.IsProgrammer.decode({
-                        context: props.context,
-                        functor: props.functor,
-                        input: v.input,
-                        metadata: v.definition,
-                        explore: v.explore,
-                    });
-                },
-                decoder: function (v) {
-                    return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], [
-                        decode_array({
-                            config: props.config,
-                            functor: props.functor,
-                            input: v.input,
-                            array: v.definition,
-                            explore: v.explore,
-                        }),
-                    ]);
-                },
-                empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], []),
-                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: [],
-            input: props.input,
-            sets: props.sets,
-            explore: props.explore,
-        }), undefined, undefined);
-    };
-    var explore_maps = function (props) {
-        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
-            config: {
-                checker: function (v) {
-                    return typescript_1.default.factory.createLogicalAnd(IsProgrammer_1.IsProgrammer.decode({
-                        context: props.context,
-                        functor: props.functor,
-                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 0),
-                        metadata: v.definition[0],
-                        explore: __assign(__assign({}, props.explore), { postfix: "".concat(v.explore.postfix, "[0]") }),
-                    }), IsProgrammer_1.IsProgrammer.decode({
-                        context: props.context,
-                        functor: props.functor,
-                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 1),
-                        metadata: v.definition[1],
-                        explore: __assign(__assign({}, props.explore), { postfix: "".concat(props.explore.postfix, "[1]") }),
-                    }));
-                },
-                decoder: function (v) {
-                    return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], [
-                        decode_array({
-                            config: props.config,
-                            functor: props.functor,
-                            input: v.input,
-                            array: v.definition,
-                            explore: v.explore,
-                        }),
-                    ]);
-                },
-                empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], []),
-                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: [],
-            input: props.input,
-            maps: props.maps,
-            explore: props.explore,
-        }), undefined, undefined);
-    };
-    var explore_objects = function (props) {
+    const explore_sets = (props) => typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
+        config: {
+            checker: (v) => IsProgrammer_1.IsProgrammer.decode({
+                context: props.context,
+                functor: props.functor,
+                input: v.input,
+                metadata: v.definition,
+                explore: v.explore,
+            }),
+            decoder: (v) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], [
+                decode_array({
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    array: v.definition,
+                    explore: v.explore,
+                }),
+            ]),
+            empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], []),
+            success: typescript_1.default.factory.createTrue(),
+            failure: (v) => create_throw_error({
+                context: props.context,
+                functor: props.functor,
+                expected: v.expected,
+                input: v.input,
+            }),
+        },
+        parameters: [],
+        input: props.input,
+        sets: props.sets,
+        explore: props.explore,
+    }), undefined, undefined);
+    const explore_maps = (props) => typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
+        config: {
+            checker: (v) => typescript_1.default.factory.createLogicalAnd(IsProgrammer_1.IsProgrammer.decode({
+                context: props.context,
+                functor: props.functor,
+                input: typescript_1.default.factory.createElementAccessExpression(v.input, 0),
+                metadata: v.definition[0],
+                explore: Object.assign(Object.assign({}, props.explore), { postfix: `${v.explore.postfix}[0]` }),
+            }), IsProgrammer_1.IsProgrammer.decode({
+                context: props.context,
+                functor: props.functor,
+                input: typescript_1.default.factory.createElementAccessExpression(v.input, 1),
+                metadata: v.definition[1],
+                explore: Object.assign(Object.assign({}, props.explore), { postfix: `${props.explore.postfix}[1]` }),
+            })),
+            decoder: (v) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], [
+                decode_array({
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    array: v.definition,
+                    explore: v.explore,
+                }),
+            ]),
+            empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], []),
+            success: typescript_1.default.factory.createTrue(),
+            failure: (v) => create_throw_error({
+                context: props.context,
+                functor: props.functor,
+                expected: v.expected,
+                input: v.input,
+            }),
+        },
+        parameters: [],
+        input: props.input,
+        maps: props.maps,
+        explore: props.explore,
+    }), undefined, undefined);
+    const explore_objects = (props) => {
         if (props.metadata.objects.length === 1)
             return decode_object({
                 functor: props.functor,
@@ -457,75 +338,61 @@ var NotationGeneralProgrammer;
                 input: props.input,
                 explore: props.explore,
             });
-        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));
+        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));
     };
-    var explore_arrays = function (props) {
-        return explore_array_like_union_types(__assign(__assign({}, props), { factory: function (next) {
-                return UnionExplorer_1.UnionExplorer.array({
-                    config: {
-                        checker: function (v) {
-                            return IsProgrammer_1.IsProgrammer.decode({
-                                context: props.context,
-                                functor: props.functor,
-                                input: v.input,
-                                metadata: v.definition,
-                                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.createIdentifier("[]"),
-                        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,
-                });
-            }, definitions: props.arrays, input: props.input, explore: props.explore }));
-    };
-    var explore_array_like_union_types = function (props) {
-        var arrow = function (next) {
-            return props.factory({
-                parameters: next.parameters,
-                definitions: props.definitions,
-                explore: next.explore,
-                input: next.input,
-            });
-        };
-        if (props.definitions.every(function (e) { return e.type.recursive === false; }))
+    const explore_arrays = (props) => explore_array_like_union_types(Object.assign(Object.assign({}, props), { factory: (next) => UnionExplorer_1.UnionExplorer.array({
+            config: {
+                checker: (v) => IsProgrammer_1.IsProgrammer.decode({
+                    context: props.context,
+                    functor: props.functor,
+                    input: v.input,
+                    metadata: v.definition,
+                    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.createIdentifier("[]"),
+                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,
+        }), definitions: props.arrays, input: props.input, explore: props.explore }));
+    const explore_array_like_union_types = (props) => {
+        const arrow = (next) => props.factory({
+            parameters: next.parameters,
+            definitions: props.definitions,
+            explore: next.explore,
+            input: next.input,
+        });
+        if (props.definitions.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.definitions.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.definitions.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({
+            }),
+            explore: Object.assign(Object.assign({}, arrayExplore), { postfix: "" }),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
             config: props.config,
             explore: arrayExplore,
             input: props.input,
@@ -534,130 +401,104 @@ var NotationGeneralProgrammer;
     /* -----------------------------------------------------------
           CONFIGURATIONS
       ----------------------------------------------------------- */
-    var PREFIX = "_c";
-    var configure = function (props) {
-        var config = {
+    const PREFIX = "_c";
+    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 (type, name) {
-                    return NotationGeneralProgrammer.returnType({
-                        rename: props.rename,
-                        context: props.context,
-                        type: name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({
-                            checker: props.context.checker,
-                            type: type,
-                        }),
-                    });
-                },
+                input: (type, name) => typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type })),
+                output: (type, name) => NotationGeneralProgrammer.returnType({
+                    rename: props.rename,
+                    context: props.context,
+                    type: name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({
+                        checker: props.context.checker,
+                        type,
+                    }),
+                }),
             },
             prefix: PREFIX,
             trace: false,
             path: false,
-            initializer: initializer,
-            decoder: function (next) {
-                return decode({
-                    config: config,
-                    rename: props.rename,
+            initializer,
+            decoder: (next) => decode({
+                config,
+                rename: props.rename,
+                context: props.context,
+                functor: props.functor,
+                metadata: next.metadata,
+                explore: next.explore,
+                input: next.input,
+            }),
+            objector: {
+                checker: (next) => IsProgrammer_1.IsProgrammer.decode({
                     context: props.context,
                     functor: props.functor,
+                    input: next.input,
                     metadata: next.metadata,
                     explore: next.explore,
+                }),
+                decoder: (next) => decode_object({
+                    functor: props.functor,
+                    object: next.object,
                     input: next.input,
-                });
-            },
-            objector: {
-                checker: function (next) {
-                    return IsProgrammer_1.IsProgrammer.decode({
+                    explore: next.explore,
+                }),
+                joiner: (next) => NotationJoiner_1.NotationJoiner.object({
+                    rename: props.rename,
+                    input: next.input,
+                    entries: next.entries,
+                }),
+                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({
+                        object: v.object,
+                        input: v.input,
+                        explore: v.explore,
+                    }),
+                    decoder: (v) => decode_object({
                         functor: props.functor,
-                        object: next.object,
-                        input: next.input,
-                        explore: next.explore,
-                    });
-                },
-                joiner: function (next) {
-                    return NotationJoiner_1.NotationJoiner.object({
-                        rename: props.rename,
-                        input: next.input,
-                        entries: next.entries,
-                    });
-                },
-                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,
-                                object: v.object,
-                                input: v.input,
-                                explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return decode_object({
-                                functor: props.functor,
-                                object: v.object,
-                                input: v.input,
-                                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({
+                        object: v.object,
+                        input: v.input,
+                        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({
-                        functor: props.functor,
-                        config: config,
-                        collection: collection,
-                    });
-                },
-                tuples: function (collection) {
-                    return write_tuple_functions({
-                        rename: props.rename,
-                        context: props.context,
-                        functor: props.functor,
-                        config: config,
-                        collection: collection,
-                    });
-                },
+                arrays: (collection) => write_array_functions({
+                    functor: props.functor,
+                    config,
+                    collection,
+                }),
+                tuples: (collection) => write_tuple_functions({
+                    rename: props.rename,
+                    context: props.context,
+                    functor: props.functor,
+                    config,
+                    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: {
@@ -665,7 +506,7 @@ var NotationGeneralProgrammer;
                 constant: true,
                 absorb: true,
             },
-            collection: collection,
+            collection,
             type: props.type,
         });
         if (result.success === false)
@@ -674,27 +515,23 @@ var NotationGeneralProgrammer;
                 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"), undefined, [
-            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),
-        ]));
-    };
-    var is_instance = function (metadata) {
-        return !!metadata.objects.length ||
-            !!metadata.arrays.length ||
-            !!metadata.tuples.length ||
-            !!metadata.sets.length ||
-            !!metadata.maps.length ||
-            !!metadata.natives.length ||
-            (metadata.rest !== null && is_instance(metadata.rest));
-    };
+    const create_throw_error = (props) => typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(props.context.importer.internal("throwTypeGuardError"), undefined, [
+        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 is_instance = (metadata) => !!metadata.objects.length ||
+        !!metadata.arrays.length ||
+        !!metadata.tuples.length ||
+        !!metadata.sets.length ||
+        !!metadata.maps.length ||
+        !!metadata.natives.length ||
+        (metadata.rest !== null && is_instance(metadata.rest));
 })(NotationGeneralProgrammer || (exports.NotationGeneralProgrammer = NotationGeneralProgrammer = {}));
 //# sourceMappingURL=NotationGeneralProgrammer.js.map