typia 7.0.0-dev.20241111-2 → 7.0.0-dev.20241114

package/lib/programmers/CheckerProgrammer.js

@@ -1,178 +1,113 @@
 "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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CheckerProgrammer = 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 ValueFactory_1 = require("../factories/ValueFactory");
-var MetadataArray_1 = require("../schemas/metadata/MetadataArray");
-var MetadataTuple_1 = require("../schemas/metadata/MetadataTuple");
-var TransformerError_1 = require("../transformers/TransformerError");
-var FeatureProgrammer_1 = require("./FeatureProgrammer");
-var IsProgrammer_1 = require("./IsProgrammer");
-var AtomicPredicator_1 = require("./helpers/AtomicPredicator");
-var OptionPredicator_1 = require("./helpers/OptionPredicator");
-var UnionExplorer_1 = require("./helpers/UnionExplorer");
-var check_array_length_1 = require("./internal/check_array_length");
-var check_bigint_1 = require("./internal/check_bigint");
-var check_native_1 = require("./internal/check_native");
-var check_number_1 = require("./internal/check_number");
-var check_string_1 = require("./internal/check_string");
-var check_template_1 = require("./internal/check_template");
-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 ValueFactory_1 = require("../factories/ValueFactory");
+const MetadataArray_1 = require("../schemas/metadata/MetadataArray");
+const MetadataTuple_1 = require("../schemas/metadata/MetadataTuple");
+const TransformerError_1 = require("../transformers/TransformerError");
+const FeatureProgrammer_1 = require("./FeatureProgrammer");
+const IsProgrammer_1 = require("./IsProgrammer");
+const AtomicPredicator_1 = require("./helpers/AtomicPredicator");
+const OptionPredicator_1 = require("./helpers/OptionPredicator");
+const UnionExplorer_1 = require("./helpers/UnionExplorer");
+const check_array_length_1 = require("./internal/check_array_length");
+const check_bigint_1 = require("./internal/check_bigint");
+const check_native_1 = require("./internal/check_native");
+const check_number_1 = require("./internal/check_number");
+const check_string_1 = require("./internal/check_string");
+const check_template_1 = require("./internal/check_template");
+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 CheckerProgrammer;
 (function (CheckerProgrammer) {
     /* -----------------------------------------------------------
           WRITERS
       ----------------------------------------------------------- */
-    CheckerProgrammer.compose = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.compose(__assign(__assign({}, props), { config: configure(props) }));
-    };
-    CheckerProgrammer.write = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.write({
-            config: configure(props),
+    CheckerProgrammer.compose = (props) => FeatureProgrammer_1.FeatureProgrammer.compose(Object.assign(Object.assign({}, props), { config: configure(props) }));
+    CheckerProgrammer.write = (props) => FeatureProgrammer_1.FeatureProgrammer.write({
+        config: configure(props),
+        context: props.context,
+        functor: props.functor,
+        type: props.type,
+        name: props.name,
+    });
+    CheckerProgrammer.write_object_functions = (props) => FeatureProgrammer_1.FeatureProgrammer.write_object_functions({
+        config: configure(props),
+        context: props.context,
+        collection: props.collection,
+    });
+    CheckerProgrammer.write_union_functions = (props) => FeatureProgrammer_1.FeatureProgrammer.write_union_functions({
+        config: configure({
             context: props.context,
+            config: Object.assign(Object.assign({}, props.config), { numeric: false }),
             functor: props.functor,
-            type: props.type,
-            name: props.name,
-        });
-    };
-    CheckerProgrammer.write_object_functions = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.write_object_functions({
-            config: configure(props),
+        }),
+        collection: props.collection,
+    });
+    CheckerProgrammer.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: "",
+            } }))),
+    }));
+    CheckerProgrammer.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({
+            config: props.config,
             context: props.context,
-            collection: props.collection,
-        });
-    };
-    CheckerProgrammer.write_union_functions = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.write_union_functions({
-            config: configure({
-                context: props.context,
-                config: __assign(__assign({}, props.config), { numeric: false }),
-                functor: props.functor,
-            }),
-            collection: props.collection,
-        });
-    };
-    CheckerProgrammer.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: "",
-                    } }))),
-            });
-        });
-    };
-    CheckerProgrammer.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({
-                    config: props.config,
-                    context: props.context,
-                    functor: props.functor,
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                    tuple: tuple,
-                    explore: {
-                        tracable: props.config.trace,
-                        source: "function",
-                        from: "array",
-                        postfix: "",
-                    },
-                })),
-            });
-        });
-    };
-    var configure = function (props) { return ({
-        types: {
-            input: function () { return TypeFactory_1.TypeFactory.keyword("any"); },
-            output: function (type, name) {
-                return typescript_1.default.factory.createTypePredicateNode(undefined, "input", typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type: type })));
+            functor: props.functor,
+            input: typescript_1.default.factory.createIdentifier("input"),
+            tuple,
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
             },
+        })),
+    }));
+    const configure = (props) => ({
+        types: {
+            input: () => TypeFactory_1.TypeFactory.keyword("any"),
+            output: (type, name) => typescript_1.default.factory.createTypePredicateNode(undefined, "input", typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type }))),
         },
         trace: props.config.trace,
         path: props.config.path,
         prefix: props.config.prefix,
-        initializer: function (next) {
-            var collection = new MetadataCollection_1.MetadataCollection();
-            var result = MetadataFactory_1.MetadataFactory.analyze({
+        initializer: (next) => {
+            const collection = new MetadataCollection_1.MetadataCollection();
+            const result = MetadataFactory_1.MetadataFactory.analyze({
                 checker: next.context.checker,
                 transformer: next.context.transformer,
                 options: {
@@ -180,150 +115,125 @@ var CheckerProgrammer;
                     constant: true,
                     absorb: true,
                 },
-                collection: collection,
+                collection,
                 type: next.type,
             });
             if (result.success === false)
                 throw TransformerError_1.TransformerError.from({
-                    code: "typia.".concat(next.functor.method),
+                    code: `typia.${next.functor.method}`,
                     errors: result.errors,
                 });
             return {
-                collection: collection,
+                collection,
                 metadata: result.data,
             };
         },
         addition: props.config.addition,
         decoder: props.config.decoder
-            ? function (next) { return props.config.decoder(next); }
-            : function (next) {
-                return CheckerProgrammer.decode({
-                    context: props.context,
-                    config: props.config,
-                    functor: props.functor,
-                    input: next.input,
-                    metadata: next.metadata,
-                    explore: next.explore,
-                });
-            },
+            ? (next) => props.config.decoder(next)
+            : (next) => CheckerProgrammer.decode({
+                context: props.context,
+                config: props.config,
+                functor: props.functor,
+                input: next.input,
+                metadata: next.metadata,
+                explore: next.explore,
+            }),
         objector: {
             checker: props.config.decoder
-                ? function (next) { return props.config.decoder(next); }
-                : function (next) {
-                    return CheckerProgrammer.decode({
-                        context: props.context,
-                        config: props.config,
-                        functor: props.functor,
-                        input: next.input,
-                        metadata: next.metadata,
-                        explore: next.explore,
-                    });
-                },
-            decoder: function (next) {
-                return CheckerProgrammer.decode_object({
+                ? (next) => props.config.decoder(next)
+                : (next) => CheckerProgrammer.decode({
+                    context: props.context,
                     config: props.config,
                     functor: props.functor,
                     input: next.input,
-                    object: next.object,
+                    metadata: next.metadata,
                     explore: next.explore,
-                });
-            },
+                }),
+            decoder: (next) => CheckerProgrammer.decode_object({
+                config: props.config,
+                functor: props.functor,
+                input: next.input,
+                object: next.object,
+                explore: next.explore,
+            }),
             joiner: props.config.joiner.object,
             unionizer: props.config.equals
-                ? function (next) {
+                ? (next) => {
                     var _a;
                     return (0, decode_union_object_1.decode_union_object)({
-                        checker: function (v) {
-                            return CheckerProgrammer.decode_object({
-                                config: props.config,
-                                functor: props.functor,
-                                object: v.object,
-                                input: v.input,
-                                explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return CheckerProgrammer.decode_object({
-                                config: props.config,
-                                functor: props.functor,
-                                input: v.input,
-                                object: v.object,
-                                explore: __assign(__assign({}, v.explore), { tracable: true }),
-                            });
-                        },
-                        success: (_a = props.config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }),
-                        escaper: function (v) {
-                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
-                        },
+                        checker: (v) => CheckerProgrammer.decode_object({
+                            config: props.config,
+                            functor: props.functor,
+                            object: v.object,
+                            input: v.input,
+                            explore: v.explore,
+                        }),
+                        decoder: (v) => CheckerProgrammer.decode_object({
+                            config: props.config,
+                            functor: props.functor,
+                            input: v.input,
+                            object: v.object,
+                            explore: Object.assign(Object.assign({}, v.explore), { tracable: true }),
+                        }),
+                        success: (_a = props.config.joiner.is) !== null && _a !== void 0 ? _a : ((expr) => expr),
+                        escaper: (v) => typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v)),
                         input: next.input,
                         objects: next.objects,
                         explore: next.explore,
                     });
                 }
-                : function (next) {
-                    return props.config.combiner({
-                        logic: "or",
-                        explore: next.explore,
-                        input: next.input,
-                        binaries: next.objects.map(function (object) { return ({
-                            expression: CheckerProgrammer.decode_object({
-                                config: props.config,
-                                functor: props.functor,
-                                object: object,
-                                input: next.input,
-                                explore: next.explore,
-                            }),
-                            combined: true,
-                        }); }),
-                        expected: "(".concat(next.objects.map(function (t) { return t.name; }).join(" | "), ")"),
-                    });
-                },
-            failure: function (next) {
-                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(next));
-            },
+                : (next) => props.config.combiner({
+                    logic: "or",
+                    explore: next.explore,
+                    input: next.input,
+                    binaries: next.objects.map((object) => ({
+                        expression: CheckerProgrammer.decode_object({
+                            config: props.config,
+                            functor: props.functor,
+                            object,
+                            input: next.input,
+                            explore: next.explore,
+                        }),
+                        combined: true,
+                    })),
+                    expected: `(${next.objects.map((t) => t.name).join(" | ")})`,
+                }),
+            failure: (next) => typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(next)),
             is: props.config.joiner.is,
             required: props.config.joiner.required,
             full: props.config.joiner.full
-                ? function (next) { return props.config.joiner.full(next); }
+                ? (next) => props.config.joiner.full(next)
                 : undefined,
             type: TypeFactory_1.TypeFactory.keyword("boolean"),
         },
         generator: {
             unions: props.config.numeric
-                ? function (collection) {
-                    return FeatureProgrammer_1.FeatureProgrammer.write_union_functions({
-                        config: configure(__assign(__assign({}, props), { config: __assign(__assign({}, props.config), { numeric: false }) })),
-                        collection: collection,
-                    });
-                }
+                ? (collection) => FeatureProgrammer_1.FeatureProgrammer.write_union_functions({
+                    config: configure(Object.assign(Object.assign({}, props), { config: Object.assign(Object.assign({}, props.config), { numeric: false }) })),
+                    collection,
+                })
                 : undefined,
-            arrays: function (collection) {
-                return CheckerProgrammer.write_array_functions(__assign(__assign({}, props), { collection: collection }));
-            },
-            tuples: function (collection) {
-                return CheckerProgrammer.write_tuple_functions(__assign(__assign({}, props), { collection: collection }));
-            },
+            arrays: (collection) => CheckerProgrammer.write_array_functions(Object.assign(Object.assign({}, props), { collection })),
+            tuples: (collection) => CheckerProgrammer.write_tuple_functions(Object.assign(Object.assign({}, props), { collection })),
         },
-    }); };
+    });
     /* -----------------------------------------------------------
           DECODERS
       ----------------------------------------------------------- */
-    CheckerProgrammer.decode = function (props) {
-        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    CheckerProgrammer.decode = (props) => {
         if (props.metadata.any)
             return props.config.success;
-        var top = [];
-        var binaries = [];
-        var add = function (next) {
-            return create_add({
-                binaries: binaries,
-                left: next.left,
-                right: next.right,
-                exact: next.exact,
-                default: props.input,
-            });
-        };
-        var getConstantValue = function (value) {
+        const top = [];
+        const binaries = [];
+        const add = (next) => create_add({
+            binaries,
+            left: next.left,
+            right: next.right,
+            exact: next.exact,
+            default: props.input,
+        });
+        const getConstantValue = (value) => {
             if (typeof value === "string")
                 return typescript_1.default.factory.createStringLiteral(value);
             else if (typeof value === "bigint")
@@ -334,7 +244,7 @@ var CheckerProgrammer;
         // CHECK OPTIONAL
         //----
         // @todo -> should be elaborated
-        var checkOptional = props.metadata.empty() || props.metadata.isUnionBucket();
+        const checkOptional = props.metadata.empty() || props.metadata.isUnionBucket();
         // NULLABLE
         if (checkOptional || props.metadata.nullable)
             if (props.metadata.nullable)
@@ -381,134 +291,97 @@ var CheckerProgrammer;
         // VALUES
         //----
         // CONSTANT VALUES
-        var constants = props.metadata.constants.filter(function (c) {
-            return AtomicPredicator_1.AtomicPredicator.constant({
-                metadata: props.metadata,
-                name: c.type,
-            });
-        });
-        var constantLength = constants
-            .map(function (c) { return c.values.length; })
-            .reduce(function (a, b) { return a + b; }, 0);
+        const constants = props.metadata.constants.filter((c) => AtomicPredicator_1.AtomicPredicator.constant({
+            metadata: props.metadata,
+            name: c.type,
+        }));
+        const constantLength = constants
+            .map((c) => c.values.length)
+            .reduce((a, b) => a + b, 0);
         if (constantLength >= 10) {
-            var values = constants
-                .map(function (c) { return c.values.map(function (v) { return v.value; }); })
+            const values = constants
+                .map((c) => c.values.map((v) => v.value))
                 .flat();
             add({
                 exact: true,
                 left: typescript_1.default.factory.createTrue(),
-                right: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.functor.emplaceVariable("".concat(props.config.prefix, "v").concat(props.functor.increment()), typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), undefined, [
-                    typescript_1.default.factory.createArrayLiteralExpression(values.map(function (v) {
-                        return typeof v === "boolean"
-                            ? v === true
-                                ? typescript_1.default.factory.createTrue()
-                                : typescript_1.default.factory.createFalse()
-                            : typeof v === "bigint"
-                                ? ExpressionFactory_1.ExpressionFactory.bigint(v)
-                                : typeof v === "number"
-                                    ? ExpressionFactory_1.ExpressionFactory.number(v)
-                                    : typescript_1.default.factory.createStringLiteral(v.toString());
-                    })),
+                right: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.functor.emplaceVariable(`${props.config.prefix}v${props.functor.increment()}`, typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), undefined, [
+                    typescript_1.default.factory.createArrayLiteralExpression(values.map((v) => typeof v === "boolean"
+                        ? v === true
+                            ? typescript_1.default.factory.createTrue()
+                            : typescript_1.default.factory.createFalse()
+                        : typeof v === "bigint"
+                            ? ExpressionFactory_1.ExpressionFactory.bigint(v)
+                            : typeof v === "number"
+                                ? ExpressionFactory_1.ExpressionFactory.number(v)
+                                : typescript_1.default.factory.createStringLiteral(v.toString()))),
                 ])), "has"), undefined, [props.input]),
             });
         }
         else
-            try {
-                for (var constants_1 = __values(constants), constants_1_1 = constants_1.next(); !constants_1_1.done; constants_1_1 = constants_1.next()) {
-                    var c = constants_1_1.value;
-                    if (AtomicPredicator_1.AtomicPredicator.constant({
-                        metadata: props.metadata,
-                        name: c.type,
-                    }))
-                        try {
-                            for (var _e = (e_2 = void 0, __values(c.values)), _f = _e.next(); !_f.done; _f = _e.next()) {
-                                var v = _f.value;
-                                add({
-                                    exact: true,
-                                    left: getConstantValue(v.value),
-                                });
-                            }
-                        }
-                        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; }
-                        }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (constants_1_1 && !constants_1_1.done && (_a = constants_1.return)) _a.call(constants_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        try {
-            // ATOMIC VALUES
-            for (var _g = __values(props.metadata.atomics), _h = _g.next(); !_h.done; _h = _g.next()) {
-                var atom = _h.value;
-                if (AtomicPredicator_1.AtomicPredicator.atomic({
+            for (const c of constants)
+                if (AtomicPredicator_1.AtomicPredicator.constant({
                     metadata: props.metadata,
-                    name: atom.type,
-                }) === false)
-                    continue;
-                else if (atom.type === "number")
-                    binaries.push({
-                        expression: props.config.atomist({
-                            explore: props.explore,
-                            entry: (0, check_number_1.check_number)({
-                                context: props.context,
-                                numeric: props.config.numeric,
-                                atomic: atom,
-                                input: props.input,
-                            }),
+                    name: c.type,
+                }))
+                    for (const v of c.values)
+                        add({
+                            exact: true,
+                            left: getConstantValue(v.value),
+                        });
+        // ATOMIC VALUES
+        for (const atom of props.metadata.atomics)
+            if (AtomicPredicator_1.AtomicPredicator.atomic({
+                metadata: props.metadata,
+                name: atom.type,
+            }) === false)
+                continue;
+            else if (atom.type === "number")
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: (0, check_number_1.check_number)({
+                            context: props.context,
+                            numeric: props.config.numeric,
+                            atomic: atom,
                             input: props.input,
                         }),
-                        combined: false,
-                    });
-                else if (atom.type === "bigint")
-                    binaries.push({
-                        expression: props.config.atomist({
-                            explore: props.explore,
-                            entry: (0, check_bigint_1.check_bigint)({
-                                context: props.context,
-                                atomic: atom,
-                                input: props.input,
-                            }),
+                        input: props.input,
+                    }),
+                    combined: false,
+                });
+            else if (atom.type === "bigint")
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: (0, check_bigint_1.check_bigint)({
+                            context: props.context,
+                            atomic: atom,
                             input: props.input,
                         }),
-                        combined: false,
-                    });
-                else if (atom.type === "string")
-                    binaries.push({
-                        expression: props.config.atomist({
-                            explore: props.explore,
-                            entry: (0, check_string_1.check_string)({
-                                context: props.context,
-                                atomic: atom,
-                                input: props.input,
-                            }),
+                        input: props.input,
+                    }),
+                    combined: false,
+                });
+            else if (atom.type === "string")
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: (0, check_string_1.check_string)({
+                            context: props.context,
+                            atomic: atom,
                             input: props.input,
                         }),
-                        combined: false,
-                    });
-                else
-                    add({
-                        exact: true,
-                        left: typescript_1.default.factory.createStringLiteral(atom.type),
-                        right: ValueFactory_1.ValueFactory.TYPEOF(props.input),
-                    });
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
+                        input: props.input,
+                    }),
+                    combined: false,
+                });
+            else
+                add({
+                    exact: true,
+                    left: typescript_1.default.factory.createStringLiteral(atom.type),
+                    right: ValueFactory_1.ValueFactory.TYPEOF(props.input),
+                });
         // TEMPLATE LITERAL VALUES
         if (props.metadata.templates.length)
             if (AtomicPredicator_1.AtomicPredicator.template(props.metadata))
@@ -523,43 +396,30 @@ var CheckerProgrammer;
                     }),
                     combined: false,
                 });
-        try {
-            // NATIVE CLASSES
-            for (var _j = __values(props.metadata.natives), _k = _j.next(); !_k.done; _k = _j.next()) {
-                var native = _k.value;
-                binaries.push({
-                    expression: (0, check_native_1.check_native)({
-                        name: native.name,
-                        input: props.input,
-                    }),
-                    combined: false,
-                });
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_k && !_k.done && (_d = _j.return)) _d.call(_j);
-            }
-            finally { if (e_4) throw e_4.error; }
-        }
-        var instances = [];
-        var prepare = function (next) { return instances.push(next); };
+        // NATIVE CLASSES
+        for (const native of props.metadata.natives)
+            binaries.push({
+                expression: (0, check_native_1.check_native)({
+                    name: native.name,
+                    input: props.input,
+                }),
+                combined: false,
+            });
+        const instances = [];
+        const prepare = (next) => instances.push(next);
         // SETS
         if (props.metadata.sets.length) {
-            var install = function (body) {
-                return prepare({
-                    head: (0, check_native_1.check_native)({
-                        name: "Set",
-                        input: props.input,
-                    }),
-                    expected: props.metadata.sets
-                        .map(function (elem) { return "Set<".concat(elem.getName(), ">"); })
-                        .join(" | "),
-                    body: body,
-                });
-            };
-            if (props.metadata.sets.some(function (elem) { return elem.value.any; }))
+            const install = (body) => prepare({
+                head: (0, check_native_1.check_native)({
+                    name: "Set",
+                    input: props.input,
+                }),
+                expected: props.metadata.sets
+                    .map((elem) => `Set<${elem.getName()}>`)
+                    .join(" | "),
+                body,
+            });
+            if (props.metadata.sets.some((elem) => elem.value.any))
                 install(null);
             else
                 install(explore_sets({
@@ -568,27 +428,22 @@ var CheckerProgrammer;
                     functor: props.functor,
                     sets: props.metadata.sets,
                     input: props.input,
-                    explore: __assign(__assign({}, props.explore), { from: "array" }),
+                    explore: Object.assign(Object.assign({}, props.explore), { from: "array" }),
                 }));
         }
         // MAPS
         if (props.metadata.maps.length) {
-            var install = function (body) {
-                return prepare({
-                    head: (0, check_native_1.check_native)({
-                        name: "Map",
-                        input: props.input,
-                    }),
-                    expected: props.metadata.maps
-                        .map(function (_a) {
-                        var key = _a.key, value = _a.value;
-                        return "Map<".concat(key, ", ").concat(value, ">");
-                    })
-                        .join(" | "),
-                    body: body,
-                });
-            };
-            if (props.metadata.maps.some(function (elem) { return elem.key.any && elem.value.any; }))
+            const install = (body) => prepare({
+                head: (0, check_native_1.check_native)({
+                    name: "Map",
+                    input: props.input,
+                }),
+                expected: props.metadata.maps
+                    .map(({ key, value }) => `Map<${key}, ${value}>`)
+                    .join(" | "),
+                body,
+            });
+            if (props.metadata.maps.some((elem) => elem.key.any && elem.value.any))
                 install(null);
             else
                 install(explore_maps({
@@ -597,27 +452,29 @@ var CheckerProgrammer;
                     functor: props.functor,
                     maps: props.metadata.maps,
                     input: props.input,
-                    explore: __assign(__assign({}, props.explore), { from: "array" }),
+                    explore: Object.assign(Object.assign({}, props.explore), { from: "array" }),
                 }));
         }
         // ARRAYS AND TUPLES
         if (props.metadata.tuples.length + props.metadata.arrays.length > 0) {
-            var install = function (body) {
-                return prepare({
-                    head: props.config.atomist({
-                        explore: props.explore,
-                        entry: {
-                            expected: __spreadArray(__spreadArray([], __read(props.metadata.tuples.map(function (t) { return t.type.name; })), false), __read(props.metadata.arrays.map(function (a) { return a.getName(); })), false).join(" | "),
-                            expression: ExpressionFactory_1.ExpressionFactory.isArray(props.input),
-                            conditions: [],
-                        },
-                        input: props.input,
-                    }),
-                    expected: __spreadArray(__spreadArray([], __read(props.metadata.tuples), false), __read(props.metadata.arrays), false).map(function (elem) { return elem.type.name; })
-                        .join(" | "),
-                    body: body,
-                });
-            };
+            const install = (body) => prepare({
+                head: props.config.atomist({
+                    explore: props.explore,
+                    entry: {
+                        expected: [
+                            ...props.metadata.tuples.map((t) => t.type.name),
+                            ...props.metadata.arrays.map((a) => a.getName()),
+                        ].join(" | "),
+                        expression: ExpressionFactory_1.ExpressionFactory.isArray(props.input),
+                        conditions: [],
+                    },
+                    input: props.input,
+                }),
+                expected: [...props.metadata.tuples, ...props.metadata.arrays]
+                    .map((elem) => elem.type.name)
+                    .join(" | "),
+                body,
+            });
             if (props.metadata.arrays.length === 0)
                 if (props.metadata.tuples.length === 1)
                     install(decode_tuple({
@@ -626,7 +483,7 @@ var CheckerProgrammer;
                         functor: props.functor,
                         tuple: props.metadata.tuples[0],
                         input: props.input,
-                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                        explore: Object.assign(Object.assign({}, props.explore), { from: "array" }),
                     }));
                 // TUPLE ONLY
                 else
@@ -636,9 +493,9 @@ var CheckerProgrammer;
                         functor: props.functor,
                         tuples: props.metadata.tuples,
                         input: props.input,
-                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                        explore: Object.assign(Object.assign({}, props.explore), { from: "array" }),
                     }));
-            else if (props.metadata.arrays.some(function (elem) { return elem.type.value.any; }))
+            else if (props.metadata.arrays.some((elem) => elem.type.value.any))
                 install(null);
             else if (props.metadata.tuples.length === 0)
                 if (props.metadata.arrays.length === 1)
@@ -649,7 +506,7 @@ var CheckerProgrammer;
                         functor: props.functor,
                         array: props.metadata.arrays[0],
                         input: props.input,
-                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                        explore: Object.assign(Object.assign({}, props.explore), { from: "array" }),
                     }));
                 else
                     install(explore_arrays({
@@ -658,14 +515,14 @@ var CheckerProgrammer;
                         functor: props.functor,
                         arrays: props.metadata.arrays,
                         input: props.input,
-                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                        explore: Object.assign(Object.assign({}, props.explore), { from: "array" }),
                     }));
             else
                 install(explore_arrays_and_tuples({
                     config: props.config,
                     context: props.context,
                     functor: props.functor,
-                    definitions: __spreadArray(__spreadArray([], __read(props.metadata.tuples), false), __read(props.metadata.arrays), false),
+                    definitions: [...props.metadata.tuples, ...props.metadata.arrays],
                     input: props.input,
                     explore: props.explore,
                 }));
@@ -675,49 +532,41 @@ var CheckerProgrammer;
             prepare({
                 head: ExpressionFactory_1.ExpressionFactory.isObject({
                     checkNull: true,
-                    checkArray: props.metadata.objects.some(function (obj) {
-                        return obj.type.properties.every(function (prop) { return !prop.key.isSoleLiteral() || !prop.value.isRequired(); });
-                    }),
+                    checkArray: props.metadata.objects.some((obj) => obj.type.properties.every((prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired())),
                     input: props.input,
                 }),
                 expected: props.metadata.objects
-                    .map(function (obj) { return obj.type.name; })
+                    .map((obj) => obj.type.name)
                     .join(" | "),
                 body: explore_objects({
                     config: props.config,
                     functor: props.functor,
                     metadata: props.metadata,
                     input: props.input,
-                    explore: __assign(__assign({}, props.explore), { from: "object" }),
+                    explore: Object.assign(Object.assign({}, props.explore), { from: "object" }),
                 }),
             });
         if (instances.length) {
-            var transformer = function (merge) {
-                return function (instance) {
-                    return instance.body
-                        ? {
-                            expression: merge(instance.head, instance.body),
-                            combined: true,
-                        }
-                        : {
-                            expression: instance.head,
-                            combined: false,
-                        };
+            const transformer = (merge) => (instance) => instance.body
+                ? {
+                    expression: merge(instance.head, instance.body),
+                    combined: true,
+                }
+                : {
+                    expression: instance.head,
+                    combined: false,
                 };
-            };
             if (instances.length === 1)
-                binaries.push(transformer(function (head, body) {
-                    return props.config.combiner({
-                        explore: props.explore,
-                        logic: "and",
-                        input: props.input,
-                        binaries: [head, body].map(function (expression) { return ({
-                            expression: expression,
-                            combined: expression !== head,
-                        }); }),
-                        expected: props.metadata.getName(),
-                    });
-                })(instances[0]));
+                binaries.push(transformer((head, body) => props.config.combiner({
+                    explore: props.explore,
+                    logic: "and",
+                    input: props.input,
+                    binaries: [head, body].map((expression) => ({
+                        expression,
+                        combined: expression !== head,
+                    })),
+                    expected: props.metadata.getName(),
+                }))(instances[0]));
             else
                 binaries.push({
                     expression: props.config.combiner({
@@ -767,18 +616,19 @@ var CheckerProgrammer;
                 explore: props.explore,
                 logic: "and",
                 input: props.input,
-                binaries: __spreadArray(__spreadArray([], __read(top), false), [
+                binaries: [
+                    ...top,
                     {
                         expression: props.config.combiner({
                             explore: props.explore,
                             logic: "or",
                             input: props.input,
-                            binaries: binaries,
+                            binaries,
                             expected: props.metadata.getName(),
                         }),
                         combined: true,
                     },
-                ], false),
+                ],
                 expected: props.metadata.getName(),
             })
             : binaries.length
@@ -786,23 +636,23 @@ var CheckerProgrammer;
                     explore: props.explore,
                     logic: "or",
                     input: props.input,
-                    binaries: binaries,
+                    binaries,
                     expected: props.metadata.getName(),
                 })
                 : props.config.success;
     };
-    CheckerProgrammer.decode_object = function (props) {
+    CheckerProgrammer.decode_object = (props) => {
         var _a;
         (_a = props.object).validated || (_a.validated = true);
         return FeatureProgrammer_1.FeatureProgrammer.decode_object(props);
     };
-    var decode_array = function (props) {
+    const decode_array = (props) => {
         if (props.array.type.recursive === false)
             return decode_array_inline(props);
-        var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
-        return typescript_1.default.factory.createLogicalOr(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({
+        const arrayExplore = Object.assign(Object.assign({}, props.explore), { source: "function", from: "array" });
+        return typescript_1.default.factory.createLogicalOr(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: __assign(__assign({}, arrayExplore), { source: "function", from: "array" }),
+            explore: Object.assign(Object.assign({}, arrayExplore), { source: "function", from: "array" }),
             input: props.input,
         })), props.config.joiner.failure({
             input: props.input,
@@ -810,20 +660,18 @@ var CheckerProgrammer;
             explore: arrayExplore,
         }));
     };
-    var decode_array_inline = function (props) {
-        var length = (0, check_array_length_1.check_array_length)({
+    const decode_array_inline = (props) => {
+        const length = (0, check_array_length_1.check_array_length)({
             context: props.context,
             array: props.array,
             input: props.input,
         });
-        var main = FeatureProgrammer_1.FeatureProgrammer.decode_array({
+        const main = FeatureProgrammer_1.FeatureProgrammer.decode_array({
             config: {
                 prefix: props.config.prefix,
                 trace: props.config.trace,
                 path: props.config.path,
-                decoder: function (next) {
-                    return CheckerProgrammer.decode(__assign(__assign({}, props), next));
-                },
+                decoder: (next) => CheckerProgrammer.decode(Object.assign(Object.assign({}, props), next)),
             },
             functor: props.functor,
             combiner: props.config.joiner.array,
@@ -839,13 +687,13 @@ var CheckerProgrammer;
                 entry: length,
             }), main);
     };
-    var decode_tuple = function (props) {
+    const decode_tuple = (props) => {
         if (props.tuple.type.recursive === false)
-            return decode_tuple_inline(__assign(__assign({}, props), { tuple: props.tuple.type }));
-        var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
-        return typescript_1.default.factory.createLogicalOr(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({
+            return decode_tuple_inline(Object.assign(Object.assign({}, props), { tuple: props.tuple.type }));
+        const arrayExplore = Object.assign(Object.assign({}, props.explore), { source: "function", from: "array" });
+        return typescript_1.default.factory.createLogicalOr(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,
-            explore: __assign(__assign({}, arrayExplore), { source: "function" }),
+            explore: Object.assign(Object.assign({}, arrayExplore), { source: "function" }),
             input: props.input,
         })), props.config.joiner.failure({
             input: props.input,
@@ -853,368 +701,314 @@ var CheckerProgrammer;
             explore: arrayExplore,
         }));
     };
-    var decode_tuple_inline = function (props) {
-        var binaries = props.tuple.elements
-            .filter(function (metadata) { return metadata.rest === null; })
-            .map(function (metadata, index) {
-            return CheckerProgrammer.decode({
-                context: props.context,
-                config: props.config,
-                functor: props.functor,
-                input: typescript_1.default.factory.createElementAccessExpression(props.input, index),
-                metadata: metadata,
-                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 = props.tuple.elements.length && props.tuple.elements.at(-1).rest !== null
+    const decode_tuple_inline = (props) => {
+        const binaries = props.tuple.elements
+            .filter((metadata) => metadata.rest === null)
+            .map((metadata, index) => CheckerProgrammer.decode({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: typescript_1.default.factory.createElementAccessExpression(props.input, index),
+            metadata,
+            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 = props.tuple.elements.length && props.tuple.elements.at(-1).rest !== null
             ? CheckerProgrammer.decode({
                 config: props.config,
                 context: props.context,
                 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 }),
             })
             : null;
-        var arrayLength = typescript_1.default.factory.createPropertyAccessExpression(props.input, "length");
+        const arrayLength = typescript_1.default.factory.createPropertyAccessExpression(props.input, "length");
         return props.config.combiner({
             explore: props.explore,
             logic: "and",
             input: props.input,
-            binaries: __spreadArray(__spreadArray(__spreadArray([], __read((rest === null
-                ? props.tuple.elements.every(function (t) { return t.optional === false; })
+            binaries: [
+                ...(rest === null
+                    ? props.tuple.elements.every((t) => t.optional === false)
+                        ? [
+                            {
+                                combined: false,
+                                expression: typescript_1.default.factory.createStrictEquality(arrayLength, ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length)),
+                            },
+                        ]
+                        : [
+                            {
+                                combined: false,
+                                expression: typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createLessThanEquals(ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.filter((t) => t.optional === false)
+                                    .length), arrayLength), typescript_1.default.factory.createGreaterThanEquals(ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length), arrayLength)),
+                            },
+                        ]
+                    : []),
+                ...(props.config.joiner.tuple
                     ? [
                         {
-                            combined: false,
-                            expression: typescript_1.default.factory.createStrictEquality(arrayLength, ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length)),
+                            expression: props.config.joiner.tuple(binaries),
+                            combined: true,
                         },
                     ]
-                    : [
+                    : binaries.map((expression) => ({
+                        expression,
+                        combined: true,
+                    }))),
+                ...(rest !== null
+                    ? [
                         {
-                            combined: false,
-                            expression: typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createLessThanEquals(ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.filter(function (t) { return t.optional === false; })
-                                .length), arrayLength), typescript_1.default.factory.createGreaterThanEquals(ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length), arrayLength)),
+                            expression: rest,
+                            combined: true,
                         },
                     ]
-                : [])), false), __read((props.config.joiner.tuple
-                ? [
-                    {
-                        expression: props.config.joiner.tuple(binaries),
-                        combined: true,
-                    },
-                ]
-                : binaries.map(function (expression) { return ({
-                    expression: expression,
-                    combined: true,
-                }); }))), false), __read((rest !== null
-                ? [
-                    {
-                        expression: rest,
-                        combined: true,
-                    },
-                ]
-                : [])), false),
-            expected: "[".concat(props.tuple.elements.map(function (t) { return t.getName(); }).join(", "), "]"),
+                    : []),
+            ],
+            expected: `[${props.tuple.elements.map((t) => t.getName()).join(", ")}]`,
         });
     };
-    var decode_escaped = function (props) {
-        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createParenthesizedExpression(typescript_1.default.factory.createArrowFunction(undefined, undefined, [IdentifierFactory_1.IdentifierFactory.parameter("input", TypeFactory_1.TypeFactory.keyword("any"))], undefined, undefined, CheckerProgrammer.decode(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input") })))), undefined, [
-            typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "toJSON"), undefined, []),
-        ]);
-    };
+    const decode_escaped = (props) => typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createParenthesizedExpression(typescript_1.default.factory.createArrowFunction(undefined, undefined, [IdentifierFactory_1.IdentifierFactory.parameter("input", TypeFactory_1.TypeFactory.keyword("any"))], undefined, undefined, CheckerProgrammer.decode(Object.assign(Object.assign({}, props), { input: typescript_1.default.factory.createIdentifier("input") })))), undefined, [
+        typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "toJSON"), undefined, []),
+    ]);
     /* -----------------------------------------------------------
           UNION TYPE EXPLORERS
       ----------------------------------------------------------- */
-    var explore_sets = function (props) {
-        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
+    const explore_sets = (props) => typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
+        config: {
+            checker: (v) => CheckerProgrammer.decode({
+                context: props.context,
+                config: props.config,
+                functor: props.functor,
+                input: v.input,
+                metadata: v.definition,
+                explore: v.explore,
+            }),
+            decoder: (v) => decode_array({
+                config: props.config,
+                context: props.context,
+                functor: props.functor,
+                array: v.definition,
+                input: v.input,
+                explore: v.explore,
+            }),
+            empty: props.config.success,
+            success: props.config.success,
+            failure: (v) => typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v)),
+        },
+        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(CheckerProgrammer.decode({
+                config: props.config,
+                context: props.context,
+                functor: props.functor,
+                input: typescript_1.default.factory.createElementAccessExpression(v.input, 0),
+                metadata: v.definition[0],
+                explore: Object.assign(Object.assign({}, v.explore), { postfix: `${v.explore.postfix}[0]` }),
+            }), CheckerProgrammer.decode({
+                config: props.config,
+                context: props.context,
+                functor: props.functor,
+                input: typescript_1.default.factory.createElementAccessExpression(v.input, 1),
+                metadata: v.definition[1],
+                explore: Object.assign(Object.assign({}, v.explore), { postfix: `${v.explore.postfix}[1]` }),
+            })),
+            decoder: (v) => decode_array({
+                context: props.context,
+                config: props.config,
+                functor: props.functor,
+                array: v.definition,
+                input: v.input,
+                explore: v.explore,
+            }),
+            empty: props.config.success,
+            success: props.config.success,
+            failure: (v) => typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v)),
+        },
+        parameters: [],
+        input: props.input,
+        maps: props.maps,
+        explore: props.explore,
+    }), undefined, undefined);
+    const explore_tuples = (props) => explore_array_like_union_types({
+        config: props.config,
+        functor: props.functor,
+        factory: (next) => UnionExplorer_1.UnionExplorer.tuple({
             config: {
-                checker: function (v) {
-                    return CheckerProgrammer.decode({
-                        context: props.context,
-                        config: props.config,
-                        functor: props.functor,
-                        input: v.input,
-                        metadata: v.definition,
-                        explore: v.explore,
-                    });
-                },
-                decoder: function (v) {
-                    return decode_array({
-                        config: props.config,
-                        context: props.context,
-                        functor: props.functor,
-                        array: v.definition,
-                        input: v.input,
-                        explore: v.explore,
-                    });
-                },
+                checker: (v) => decode_tuple({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    tuple: v.definition,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_tuple({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    tuple: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
                 empty: props.config.success,
                 success: props.config.success,
-                failure: function (v) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
-                },
+                failure: (v) => typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v)),
             },
-            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({
+            parameters: next.parameters,
+            tuples: next.definitions,
+            input: next.input,
+            explore: next.explore,
+        }),
+        definitions: props.tuples,
+        input: props.input,
+        explore: props.explore,
+    });
+    const explore_arrays = (props) => explore_array_like_union_types({
+        config: props.config,
+        functor: props.functor,
+        factory: (next) => UnionExplorer_1.UnionExplorer.array({
             config: {
-                checker: function (v) {
-                    return typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
-                        config: props.config,
-                        context: props.context,
-                        functor: props.functor,
-                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 0),
-                        metadata: v.definition[0],
-                        explore: __assign(__assign({}, v.explore), { postfix: "".concat(v.explore.postfix, "[0]") }),
-                    }), CheckerProgrammer.decode({
+                checker: (v) => CheckerProgrammer.decode({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    metadata: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_array({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    array: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                empty: props.config.success,
+                success: props.config.success,
+                failure: (v) => typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v)),
+            },
+            parameters: next.parameters,
+            arrays: next.definitions,
+            input: next.input,
+            explore: next.explore,
+        }),
+        definitions: props.arrays,
+        input: props.input,
+        explore: props.explore,
+    });
+    const explore_arrays_and_tuples = (props) => explore_array_like_union_types({
+        config: props.config,
+        functor: props.functor,
+        factory: (next) => UnionExplorer_1.UnionExplorer.array_or_tuple({
+            config: {
+                checker: (v) => v.definition instanceof MetadataTuple_1.MetadataTuple
+                    ? decode_tuple({
                         config: props.config,
                         context: props.context,
                         functor: props.functor,
-                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 1),
-                        metadata: v.definition[1],
-                        explore: __assign(__assign({}, v.explore), { postfix: "".concat(v.explore.postfix, "[1]") }),
-                    }));
-                },
-                decoder: function (v) {
-                    return decode_array({
-                        context: props.context,
-                        config: props.config,
-                        functor: props.functor,
-                        array: v.definition,
                         input: v.input,
+                        tuple: v.definition,
                         explore: v.explore,
-                    });
-                },
-                empty: props.config.success,
-                success: props.config.success,
-                failure: function (v) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
-                },
-            },
-            parameters: [],
-            input: props.input,
-            maps: props.maps,
-            explore: props.explore,
-        }), undefined, undefined);
-    };
-    var explore_tuples = function (props) {
-        return explore_array_like_union_types({
-            config: props.config,
-            functor: props.functor,
-            factory: function (next) {
-                return UnionExplorer_1.UnionExplorer.tuple({
-                    config: {
-                        checker: function (v) {
-                            return decode_tuple({
-                                context: props.context,
-                                config: props.config,
-                                functor: props.functor,
-                                input: v.input,
-                                tuple: v.definition,
-                                explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return decode_tuple({
-                                context: props.context,
-                                config: props.config,
+                    })
+                    : props.config.atomist({
+                        explore: v.explore,
+                        entry: {
+                            expected: props.definitions
+                                .map((elem) => elem instanceof MetadataArray_1.MetadataArray
+                                ? elem.getName()
+                                : elem.type.name)
+                                .join(" | "),
+                            expression: CheckerProgrammer.decode({
                                 functor: props.functor,
-                                tuple: v.definition,
-                                input: v.input,
-                                explore: v.explore,
-                            });
-                        },
-                        empty: props.config.success,
-                        success: props.config.success,
-                        failure: function (v) {
-                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
-                        },
-                    },
-                    parameters: next.parameters,
-                    tuples: next.definitions,
-                    input: next.input,
-                    explore: next.explore,
-                });
-            },
-            definitions: props.tuples,
-            input: props.input,
-            explore: props.explore,
-        });
-    };
-    var explore_arrays = function (props) {
-        return explore_array_like_union_types({
-            config: props.config,
-            functor: props.functor,
-            factory: function (next) {
-                return UnionExplorer_1.UnionExplorer.array({
-                    config: {
-                        checker: function (v) {
-                            return CheckerProgrammer.decode({
                                 context: props.context,
                                 config: props.config,
-                                functor: props.functor,
                                 metadata: v.definition,
                                 input: v.input,
                                 explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return decode_array({
-                                context: props.context,
-                                config: props.config,
-                                functor: props.functor,
-                                array: v.definition,
-                                input: v.input,
-                                explore: v.explore,
-                            });
-                        },
-                        empty: props.config.success,
-                        success: props.config.success,
-                        failure: function (v) {
-                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
-                        },
-                    },
-                    parameters: next.parameters,
-                    arrays: next.definitions,
-                    input: next.input,
-                    explore: next.explore,
-                });
-            },
-            definitions: props.arrays,
-            input: props.input,
-            explore: props.explore,
-        });
-    };
-    var explore_arrays_and_tuples = function (props) {
-        return explore_array_like_union_types({
-            config: props.config,
-            functor: props.functor,
-            factory: function (next) {
-                return UnionExplorer_1.UnionExplorer.array_or_tuple({
-                    config: {
-                        checker: function (v) {
-                            return v.definition instanceof MetadataTuple_1.MetadataTuple
-                                ? decode_tuple({
-                                    config: props.config,
-                                    context: props.context,
-                                    functor: props.functor,
-                                    input: v.input,
-                                    tuple: v.definition,
-                                    explore: v.explore,
-                                })
-                                : props.config.atomist({
-                                    explore: v.explore,
-                                    entry: {
-                                        expected: props.definitions
-                                            .map(function (elem) {
-                                            return elem instanceof MetadataArray_1.MetadataArray
-                                                ? elem.getName()
-                                                : elem.type.name;
-                                        })
-                                            .join(" | "),
-                                        expression: CheckerProgrammer.decode({
-                                            functor: props.functor,
-                                            context: props.context,
-                                            config: props.config,
-                                            metadata: v.definition,
-                                            input: v.input,
-                                            explore: v.explore,
-                                        }),
-                                        conditions: [],
-                                    },
-                                    input: v.container,
-                                });
-                        },
-                        decoder: function (v) {
-                            return v.definition instanceof MetadataTuple_1.MetadataTuple
-                                ? decode_tuple({
-                                    context: props.context,
-                                    config: props.config,
-                                    functor: props.functor,
-                                    input: v.input,
-                                    tuple: v.definition,
-                                    explore: v.explore,
-                                })
-                                : decode_array({
-                                    context: props.context,
-                                    config: props.config,
-                                    functor: props.functor,
-                                    input: v.input,
-                                    array: v.definition,
-                                    explore: v.explore,
-                                });
-                        },
-                        empty: props.config.success,
-                        success: props.config.success,
-                        failure: function (v) {
-                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                            }),
+                            conditions: [],
                         },
-                    },
-                    parameters: next.parameters,
-                    definitions: next.definitions,
-                    input: next.input,
-                    explore: next.explore,
-                });
+                        input: v.container,
+                    }),
+                decoder: (v) => v.definition instanceof MetadataTuple_1.MetadataTuple
+                    ? decode_tuple({
+                        context: props.context,
+                        config: props.config,
+                        functor: props.functor,
+                        input: v.input,
+                        tuple: v.definition,
+                        explore: v.explore,
+                    })
+                    : decode_array({
+                        context: props.context,
+                        config: props.config,
+                        functor: props.functor,
+                        input: v.input,
+                        array: v.definition,
+                        explore: v.explore,
+                    }),
+                empty: props.config.success,
+                success: props.config.success,
+                failure: (v) => typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v)),
             },
-            input: props.input,
+            parameters: next.parameters,
+            definitions: next.definitions,
+            input: next.input,
+            explore: next.explore,
+        }),
+        input: props.input,
+        definitions: props.definitions,
+        explore: props.explore,
+    });
+    const explore_array_like_union_types = (props) => {
+        const arrow = (next) => props.factory({
+            parameters: next.parameters,
             definitions: props.definitions,
-            explore: props.explore,
+            input: next.input,
+            explore: next.explore,
         });
-    };
-    var explore_array_like_union_types = function (props) {
-        var arrow = function (next) {
-            return props.factory({
-                parameters: next.parameters,
-                definitions: props.definitions,
-                input: next.input,
-                explore: next.explore,
-            });
-        };
-        if (props.definitions.every(function (e) { return e.type.recursive === false; }))
+        if (props.definitions.every((e) => e.type.recursive === false))
             typescript_1.default.factory.createCallExpression(arrow({
                 explore: props.explore,
                 input: props.input,
                 parameters: [],
             }), undefined, []);
-        var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
-        return typescript_1.default.factory.createLogicalOr(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.createLogicalOr(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(props)), props.config.joiner.failure({
+            }),
+            explore: Object.assign(Object.assign({}, arrayExplore), { postfix: "" }),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props)), props.config.joiner.failure({
             input: props.input,
-            expected: props.definitions.map(function (e) { return e.type.name; }).join(" | "),
+            expected: props.definitions.map((e) => e.type.name).join(" | "),
             explore: arrayExplore,
         }));
     };
-    var explore_objects = function (props) {
-        return props.metadata.objects.length === 1
-            ? CheckerProgrammer.decode_object({
-                config: props.config,
-                functor: props.functor,
-                object: props.metadata.objects[0].type,
-                input: props.input,
-                explore: props.explore,
-            })
-            : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal("".concat(props.config.prefix, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
-    };
+    const explore_objects = (props) => props.metadata.objects.length === 1
+        ? CheckerProgrammer.decode_object({
+            config: props.config,
+            functor: props.functor,
+            object: props.metadata.objects[0].type,
+            input: props.input,
+            explore: props.explore,
+        })
+        : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}u${props.metadata.union_index}`)), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
 })(CheckerProgrammer || (exports.CheckerProgrammer = CheckerProgrammer = {}));
-var create_add = function (props) {
+const create_add = (props) => {
     var _a;
-    var factory = props.exact
+    const factory = props.exact
         ? typescript_1.default.factory.createStrictEquality
         : typescript_1.default.factory.createStrictInequality;
     props.binaries.push({