typia 7.0.0-dev.20240923 → 7.0.0-dev.20240928

package/lib/programmers/CheckerProgrammer.js

@@ -82,685 +82,1045 @@ var CheckerProgrammer;
           WRITERS
       ----------------------------------------------------------- */
     CheckerProgrammer.compose = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.compose(__assign(__assign({}, props), { config: configure(props.context)(props.config)(props.importer) }));
+        return FeatureProgrammer_1.FeatureProgrammer.compose(__assign(__assign({}, props), { config: configure(props) }));
     };
-    CheckerProgrammer.write = function (project) {
-        return function (config) {
-            return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.write(project)(configure(project)(config)(importer))(importer);
-            };
-        };
+    CheckerProgrammer.write = function (props) {
+        return FeatureProgrammer_1.FeatureProgrammer.write(props.context)(configure(props))(props.importer)(props.type, props.name);
     };
-    CheckerProgrammer.write_object_functions = function (project) {
-        return function (config) {
-            return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.write_object_functions(configure(project)(config)(importer))(importer);
-            };
-        };
+    CheckerProgrammer.write_object_functions = function (props) {
+        return FeatureProgrammer_1.FeatureProgrammer.write_object_functions({
+            config: configure(props),
+            importer: props.importer,
+            collection: props.collection,
+        });
     };
-    CheckerProgrammer.write_union_functions = function (project) {
-        return function (config) {
-            return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer));
-            };
-        };
+    CheckerProgrammer.write_union_functions = function (props) {
+        return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure({
+            context: props.context,
+            config: __assign(__assign({}, props.config), { numeric: false }),
+            importer: props.importer,
+        }))(props.collection);
     };
-    CheckerProgrammer.write_array_functions = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (collection) {
-                    return collection
-                        .arrays()
-                        .filter(function (a) { return a.recursive; })
-                        .map(function (type, i) {
-                        return StatementFactory_1.StatementFactory.constant("".concat(config.prefix, "a").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline(project)(config)(importer)(typescript_1.default.factory.createIdentifier("input"), MetadataArray_1.MetadataArray.create({
-                            type: type,
-                            tags: [],
-                        }), {
-                            tracable: config.trace,
-                            source: "function",
-                            from: "array",
-                            postfix: "",
-                        })));
-                    });
-                };
-            };
-        };
+    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("".concat(props.config.prefix, "a").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(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 (project) {
-        return function (config) {
-            return function (importer) {
-                return function (collection) {
-                    return collection
-                        .tuples()
-                        .filter(function (t) { return t.recursive; })
-                        .map(function (tuple, i) {
-                        return StatementFactory_1.StatementFactory.constant("".concat(config.prefix, "t").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline(project)(config)(importer)(typescript_1.default.factory.createIdentifier("input"), tuple, {
-                            tracable: 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("".concat(props.config.prefix, "t").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
+                config: props.config,
+                context: props.context,
+                importer: props.importer,
+                input: typescript_1.default.factory.createIdentifier("input"),
+                tuple: tuple,
+                explore: {
+                    tracable: props.config.trace,
+                    source: "function",
+                    from: "array",
+                    postfix: "",
+                },
+            })));
+        });
     };
-    var configure = function (project) {
-        return function (config) {
-            return function (importer) {
-                var _a;
-                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(project.checker)(type)));
-                        },
+    var configure = function (props) {
+        var _a;
+        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(props.context.checker)(type)));
+                },
+            },
+            trace: props.config.trace,
+            path: props.config.path,
+            prefix: props.config.prefix,
+            initializer: function (context) { return function (importer) { return function (type) {
+                var collection = new MetadataCollection_1.MetadataCollection();
+                var result = MetadataFactory_1.MetadataFactory.analyze({
+                    checker: context.checker,
+                    transformer: context.transformer,
+                    options: {
+                        escape: false,
+                        constant: true,
+                        absorb: true,
                     },
-                    trace: config.trace,
-                    path: config.path,
-                    prefix: config.prefix,
-                    initializer: function (project) { return function (importer) { return function (type) {
-                        var collection = new MetadataCollection_1.MetadataCollection();
-                        var result = MetadataFactory_1.MetadataFactory.analyze({
-                            checker: project.checker,
-                            transformer: project.transformer,
-                            options: {
-                                escape: false,
-                                constant: true,
-                                absorb: true,
-                            },
-                            collection: collection,
-                            type: type,
+                    collection: collection,
+                    type: type,
+                });
+                if (result.success === false)
+                    throw TransformerError_1.TransformerError.from("typia.".concat(importer.method))(result.errors);
+                return [collection, result.data];
+            }; }; },
+            addition: props.config.addition,
+            decoder: function () {
+                return props.config.decoder
+                    ? function (input, metadata, explore) {
+                        return props.config.decoder()(input, metadata, explore);
+                    }
+                    : function (input, metadata, explore) {
+                        return CheckerProgrammer.decode({
+                            context: props.context,
+                            config: props.config,
+                            importer: props.importer,
+                            input: input,
+                            metadata: metadata,
+                            explore: explore,
+                        });
+                    };
+            },
+            objector: {
+                checker: function () { return function (input, metadata, explore) {
+                    var _a, _b, _c;
+                    return (_c = (_b = (_a = props.config).decoder) === null || _b === void 0 ? void 0 : _b.call(_a)(input, metadata, explore)) !== null && _c !== void 0 ? _c : CheckerProgrammer.decode({
+                        context: props.context,
+                        config: props.config,
+                        importer: props.importer,
+                        input: input,
+                        metadata: metadata,
+                        explore: explore,
+                    });
+                }; },
+                decoder: function () { return function (input, object, explore) {
+                    return CheckerProgrammer.decode_object({
+                        config: props.config,
+                        importer: props.importer,
+                        input: input,
+                        object: object,
+                        explore: explore,
+                    });
+                }; },
+                joiner: props.config.joiner.object,
+                unionizer: props.config.equals
+                    ? (0, decode_union_object_1.decode_union_object)(function (input, object, explore) {
+                        return CheckerProgrammer.decode_object({
+                            config: props.config,
+                            importer: props.importer,
+                            object: object,
+                            input: input,
+                            explore: explore,
+                        });
+                    })(function (input, object, explore) {
+                        return CheckerProgrammer.decode_object({
+                            config: props.config,
+                            importer: props.importer,
+                            input: input,
+                            object: object,
+                            explore: __assign(__assign({}, explore), { tracable: true }),
+                        });
+                    })((_a = props.config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }))(function (input, expected) {
+                        return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
+                            input: input,
+                            expected: expected,
+                        }));
+                    })
+                    : function (input, targets, explore) {
+                        return props.config.combiner({
+                            explore: explore,
+                            logic: "or",
+                            input: input,
+                            binaries: targets.map(function (object) { return ({
+                                expression: CheckerProgrammer.decode_object({
+                                    config: props.config,
+                                    importer: props.importer,
+                                    input: input,
+                                    object: object,
+                                    explore: explore,
+                                }),
+                                combined: true,
+                            }); }),
+                            expected: "(".concat(targets.map(function (t) { return t.name; }).join(" | "), ")"),
                         });
-                        if (result.success === false)
-                            throw TransformerError_1.TransformerError.from("typia.".concat(importer.method))(result.errors);
-                        return [collection, result.data];
-                    }; }; },
-                    addition: config.addition,
-                    decoder: function () { var _a, _b; return (_b = (_a = config.decoder) === null || _a === void 0 ? void 0 : _a.call(config)) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(project)(config)(importer); },
-                    objector: {
-                        checker: function () { var _a, _b; return (_b = (_a = config.decoder) === null || _a === void 0 ? void 0 : _a.call(config)) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(project)(config)(importer); },
-                        decoder: function () { return CheckerProgrammer.decode_object(config)(importer); },
-                        joiner: config.joiner.object,
-                        unionizer: config.equals
-                            ? (0, decode_union_object_1.decode_union_object)(CheckerProgrammer.decode_object(config)(importer))(function (input, obj, explore) {
-                                return CheckerProgrammer.decode_object(config)(importer)(input, obj, __assign(__assign({}, explore), { tracable: true }));
-                            })((_a = config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }))(function (value, expected) {
-                                return typescript_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
-                            })
-                            : function (input, targets, explore) {
-                                return config.combiner(explore)("or")(input, targets.map(function (obj) { return ({
-                                    expression: CheckerProgrammer.decode_object(config)(importer)(input, obj, explore),
-                                    combined: true,
-                                }); }), "(".concat(targets.map(function (t) { return t.name; }).join(" | "), ")"));
-                            },
-                        failure: function (value, expected) {
-                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
-                        },
-                        is: config.joiner.is,
-                        required: config.joiner.required,
-                        full: config.joiner.full,
-                        type: TypeFactory_1.TypeFactory.keyword("boolean"),
-                    },
-                    generator: {
-                        unions: config.numeric
-                            ? function () {
-                                return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer));
-                            }
-                            : undefined,
-                        arrays: function () { return CheckerProgrammer.write_array_functions(project)(config)(importer); },
-                        tuples: function () { return CheckerProgrammer.write_tuple_functions(project)(config)(importer); },
                     },
-                });
-            };
-        };
+                failure: function (input, expected) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
+                        input: input,
+                        expected: expected,
+                    }));
+                },
+                is: props.config.joiner.is,
+                required: props.config.joiner.required,
+                full: props.config.joiner.full
+                    ? function (condition) { return function (input, expected, explore) {
+                        return props.config.joiner.full({
+                            condition: condition,
+                            input: input,
+                            expected: expected,
+                            explore: explore,
+                        });
+                    }; }
+                    : undefined,
+                type: TypeFactory_1.TypeFactory.keyword("boolean"),
+            },
+            generator: {
+                unions: props.config.numeric
+                    ? function () {
+                        return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure(__assign(__assign({}, props), { config: __assign(__assign({}, props.config), { numeric: false }) })));
+                    }
+                    : undefined,
+                arrays: function () { return function (collection) {
+                    return CheckerProgrammer.write_array_functions(__assign(__assign({}, props), { collection: collection }));
+                }; },
+                tuples: function () { return function (collection) {
+                    return CheckerProgrammer.write_tuple_functions(__assign(__assign({}, props), { collection: collection }));
+                }; },
+            },
+        });
     };
     /* -----------------------------------------------------------
           DECODERS
       ----------------------------------------------------------- */
-    /**
-     * @internal
-     */
-    CheckerProgrammer.decode = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, metadata, explore) {
-                    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
-                    if (metadata.any)
-                        return config.success;
-                    var top = [];
-                    var binaries = [];
-                    var add = create_add(binaries)(input);
-                    var getConstantValue = function (value) {
-                        if (typeof value === "string")
-                            return typescript_1.default.factory.createStringLiteral(value);
-                        else if (typeof value === "bigint")
-                            return ExpressionFactory_1.ExpressionFactory.bigint(value);
-                        return typescript_1.default.factory.createIdentifier(value.toString());
-                    };
-                    //----
-                    // CHECK OPTIONAL
-                    //----
-                    // @todo -> should be elaborated
-                    var checkOptional = metadata.empty() || metadata.isUnionBucket();
-                    // NULLABLE
-                    if (checkOptional || metadata.nullable)
-                        (metadata.nullable ? add : create_add(top)(input))(metadata.nullable, ValueFactory_1.ValueFactory.NULL());
-                    // UNDEFINDABLE
-                    if (checkOptional || !metadata.isRequired())
-                        (metadata.isRequired() ? create_add(top)(input) : add)(!metadata.isRequired(), ValueFactory_1.ValueFactory.UNDEFINED());
-                    // FUNCTIONAL
-                    if (metadata.functions.length)
-                        if (OptionPredicator_1.OptionPredicator.functional(project.options) ||
-                            metadata.size() !== 1)
-                            add(true, typescript_1.default.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(input));
-                        else
-                            binaries.push({
-                                combined: false,
-                                expression: config.success,
-                            });
-                    //----
-                    // VALUES
-                    //----
-                    // CONSTANT VALUES
-                    var constants = metadata.constants.filter(function (c) {
-                        return AtomicPredicator_1.AtomicPredicator.constant({
-                            metadata: metadata,
-                            name: c.type,
-                        });
-                    });
-                    var constantLength = constants
-                        .map(function (c) { return c.values.length; })
-                        .reduce(function (a, b) { return a + b; }, 0);
-                    if (constantLength >= 10) {
-                        var values = constants
-                            .map(function (c) { return c.values.map(function (v) { return v.value; }); })
-                            .flat();
-                        add(true, typescript_1.default.factory.createTrue(), typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(importer.emplaceVariable("".concat(config.prefix, "v").concat(importer.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());
-                            })),
-                        ])))("has"), undefined, [input]));
-                    }
-                    else
+    CheckerProgrammer.decode = function (props) {
+        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+        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) {
+            if (typeof value === "string")
+                return typescript_1.default.factory.createStringLiteral(value);
+            else if (typeof value === "bigint")
+                return ExpressionFactory_1.ExpressionFactory.bigint(value);
+            return typescript_1.default.factory.createIdentifier(value.toString());
+        };
+        //----
+        // CHECK OPTIONAL
+        //----
+        // @todo -> should be elaborated
+        var checkOptional = props.metadata.empty() || props.metadata.isUnionBucket();
+        // NULLABLE
+        if (checkOptional || props.metadata.nullable)
+            if (props.metadata.nullable)
+                add({
+                    exact: props.metadata.nullable,
+                    left: ValueFactory_1.ValueFactory.NULL(),
+                });
+            else
+                create_add({
+                    binaries: top,
+                    default: props.input,
+                    exact: props.metadata.nullable,
+                    left: ValueFactory_1.ValueFactory.NULL(),
+                });
+        // UNDEFINDABLE
+        if (checkOptional || !props.metadata.isRequired())
+            if (props.metadata.isRequired())
+                create_add({
+                    binaries: top,
+                    default: props.input,
+                    exact: false,
+                    left: ValueFactory_1.ValueFactory.UNDEFINED(),
+                });
+            else
+                add({
+                    exact: true,
+                    left: ValueFactory_1.ValueFactory.UNDEFINED(),
+                });
+        // FUNCTIONAL
+        if (props.metadata.functions.length)
+            if (OptionPredicator_1.OptionPredicator.functional(props.context.options) ||
+                props.metadata.size() !== 1)
+                add({
+                    exact: true,
+                    left: typescript_1.default.factory.createStringLiteral("function"),
+                    right: ValueFactory_1.ValueFactory.TYPEOF(props.input),
+                });
+            else
+                binaries.push({
+                    combined: false,
+                    expression: props.config.success,
+                });
+        //----
+        // 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);
+        if (constantLength >= 10) {
+            var values = constants
+                .map(function (c) { return c.values.map(function (v) { return v.value; }); })
+                .flat();
+            add({
+                exact: true,
+                left: typescript_1.default.factory.createTrue(),
+                right: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.importer.emplaceVariable("".concat(props.config.prefix, "v").concat(props.importer.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());
+                    })),
+                ])))("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 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: 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(true, 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; }
-                                    }
+                            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_1_1) { e_1 = { error: e_1_1 }; }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
                         finally {
                             try {
-                                if (constants_1_1 && !constants_1_1.done && (_a = constants_1.return)) _a.call(constants_1);
+                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                             }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                    try {
-                        // ATOMIC VALUES
-                        for (var _g = __values(metadata.atomics), _h = _g.next(); !_h.done; _h = _g.next()) {
-                            var atom = _h.value;
-                            if (AtomicPredicator_1.AtomicPredicator.atomic({
-                                metadata: metadata,
-                                name: atom.type,
-                            }) === false)
-                                continue;
-                            else if (atom.type === "number")
-                                binaries.push({
-                                    expression: config.atomist(explore)((0, check_number_1.check_number)(project, config.numeric)(atom)(input))(input),
-                                    combined: false,
-                                });
-                            else if (atom.type === "bigint")
-                                binaries.push({
-                                    expression: config.atomist(explore)((0, check_bigint_1.check_bigint)(project)(atom)(input))(input),
-                                    combined: false,
-                                });
-                            else if (atom.type === "string")
-                                binaries.push({
-                                    expression: config.atomist(explore)((0, check_string_1.check_string)(project)(atom)(input))(input),
-                                    combined: false,
-                                });
-                            else
-                                add(true, typescript_1.default.factory.createStringLiteral(atom.type), ValueFactory_1.ValueFactory.TYPEOF(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_2) throw e_2.error; }
                         }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                    // TEMPLATE LITERAL VALUES
-                    if (metadata.templates.length)
-                        if (AtomicPredicator_1.AtomicPredicator.template(metadata))
-                            binaries.push({
-                                expression: config.atomist(explore)((0, check_template_1.check_template)(metadata.templates)(input))(input),
-                                combined: false,
-                            });
-                    try {
-                        // NATIVE CLASSES
-                        for (var _j = __values(metadata.natives), _k = _j.next(); !_k.done; _k = _j.next()) {
-                            var native = _k.value;
-                            binaries.push({
-                                expression: (0, check_native_1.check_native)(native)(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 (pre, expected) {
-                        return function (body) {
-                            return instances.push({
-                                pre: pre,
-                                expected: expected,
-                                body: body,
-                            });
-                        };
-                    };
-                    // SETS
-                    if (metadata.sets.length) {
-                        var install = prepare((0, check_native_1.check_native)("Set")(input), metadata.sets.map(function (elem) { return "Set<".concat(elem.getName(), ">"); }).join(" | "));
-                        if (metadata.sets.some(function (elem) { return elem.any; }))
-                            install(null);
-                        else
-                            install(explore_sets(project)(config)(importer)(input, metadata.sets, __assign(__assign({}, explore), { from: "array" })));
-                    }
-                    // MAPS
-                    if (metadata.maps.length) {
-                        var install = prepare((0, check_native_1.check_native)("Map")(input), metadata.maps
-                            .map(function (_a) {
-                            var key = _a.key, value = _a.value;
-                            return "Map<".concat(key, ", ").concat(value, ">");
-                        })
-                            .join(" | "));
-                        if (metadata.maps.some(function (elem) { return elem.key.any && elem.value.any; }))
-                            install(null);
-                        else
-                            install(explore_maps(project)(config)(importer)(input, metadata.maps, __assign(__assign({}, explore), { from: "array" })));
-                    }
-                    // ARRAYS AND TUPLES
-                    if (metadata.tuples.length + metadata.arrays.length > 0) {
-                        var install = prepare(config.atomist(explore)({
-                            expected: __spreadArray(__spreadArray([], __read(metadata.tuples.map(function (t) { return t.type.name; })), false), __read(metadata.arrays.map(function (a) { return a.getName(); })), false).join(" | "),
-                            expression: ExpressionFactory_1.ExpressionFactory.isArray(input),
+                }
+            }
+            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({
+                    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)(props.context, props.config.numeric)(atom)(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)(props.context)(atom)(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)(props.context)(atom)(props.input),
+                            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; }
+        }
+        // TEMPLATE LITERAL VALUES
+        if (props.metadata.templates.length)
+            if (AtomicPredicator_1.AtomicPredicator.template(props.metadata))
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: (0, check_template_1.check_template)(props.metadata.templates)(props.input),
+                        input: props.input,
+                    }),
+                    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)(native)(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); };
+        // SETS
+        if (props.metadata.sets.length) {
+            var install = function (body) {
+                return prepare({
+                    knock: (0, check_native_1.check_native)("Set")(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.any; }))
+                install(null);
+            else
+                install(explore_sets({
+                    config: props.config,
+                    context: props.context,
+                    importer: props.importer,
+                    sets: props.metadata.sets,
+                    input: props.input,
+                    explore: __assign(__assign({}, props.explore), { from: "array" }),
+                }));
+        }
+        // MAPS
+        if (props.metadata.maps.length) {
+            var install = function (body) {
+                return prepare({
+                    knock: (0, check_native_1.check_native)("Map")(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; }))
+                install(null);
+            else
+                install(explore_maps({
+                    config: props.config,
+                    context: props.context,
+                    importer: props.importer,
+                    maps: props.metadata.maps,
+                    input: props.input,
+                    explore: __assign(__assign({}, props.explore), { from: "array" }),
+                }));
+        }
+        // ARRAYS AND TUPLES
+        if (props.metadata.tuples.length + props.metadata.arrays.length > 0) {
+            var install = function (body) {
+                return prepare({
+                    knock: 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), __spreadArray(__spreadArray([], __read(metadata.tuples), false), __read(metadata.arrays), false).map(function (elem) { return elem.type.name; })
-                            .join(" | "));
-                        if (metadata.arrays.length === 0)
-                            if (metadata.tuples.length === 1)
-                                install(decode_tuple(project)(config)(importer)(input, metadata.tuples[0], __assign(__assign({}, explore), { from: "array" })));
-                            // TUPLE ONLY
-                            else
-                                install(explore_tuples(project)(config)(importer)(input, metadata.tuples, __assign(__assign({}, explore), { from: "array" })));
-                        else if (metadata.arrays.some(function (elem) { return elem.type.value.any; }))
-                            install(null);
-                        else if (metadata.tuples.length === 0)
-                            if (metadata.arrays.length === 1)
-                                // ARRAY ONLY
-                                install(decode_array(project)(config)(importer)(input, metadata.arrays[0], __assign(__assign({}, explore), { from: "array" })));
-                            else
-                                install(explore_arrays(project)(config)(importer)(input, metadata.arrays, __assign(__assign({}, explore), { from: "array" })));
-                        else
-                            install(explore_arrays_and_tuples(project)(config)(importer)(input, __spreadArray(__spreadArray([], __read(metadata.tuples), false), __read(metadata.arrays), false), explore));
-                    }
-                    // OBJECT
-                    if (metadata.objects.length > 0)
-                        prepare(ExpressionFactory_1.ExpressionFactory.isObject({
-                            checkNull: true,
-                            checkArray: metadata.objects.some(function (obj) {
-                                return obj.properties.every(function (prop) { return !prop.key.isSoleLiteral() || !prop.value.isRequired(); });
-                            }),
-                        })(input), metadata.objects.map(function (obj) { return obj.name; }).join(" | "))(explore_objects(config)(importer)(input, metadata, __assign(__assign({}, explore), { from: "object" })));
-                    if (instances.length) {
-                        var transformer = function (merger) {
-                            return function (ins) {
-                                return ins.body
-                                    ? {
-                                        expression: merger(ins.pre, ins.body),
-                                        combined: true,
-                                    }
-                                    : {
-                                        expression: ins.pre,
-                                        combined: false,
-                                    };
-                            };
-                        };
-                        if (instances.length === 1)
-                            binaries.push(transformer(function (pre, body) {
-                                return config.combiner(explore)("and")(input, [pre, body].map(function (expression) { return ({
-                                    expression: expression,
-                                    combined: expression !== pre,
-                                }); }), metadata.getName());
-                            })(instances[0]));
-                        else
-                            binaries.push({
-                                expression: config.combiner(explore)("or")(input, instances.map(transformer(typescript_1.default.factory.createLogicalAnd)), metadata.getName()),
-                                combined: true,
-                            });
-                    }
-                    // ESCAPED CASE
-                    if (metadata.escaped !== null)
-                        binaries.push({
+                        },
+                        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,
+                });
+            };
+            if (props.metadata.arrays.length === 0)
+                if (props.metadata.tuples.length === 1)
+                    install(decode_tuple({
+                        config: props.config,
+                        context: props.context,
+                        importer: props.importer,
+                        tuple: props.metadata.tuples[0],
+                        input: props.input,
+                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                    }));
+                // TUPLE ONLY
+                else
+                    install(explore_tuples({
+                        config: props.config,
+                        context: props.context,
+                        importer: props.importer,
+                        tuples: props.metadata.tuples,
+                        input: props.input,
+                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                    }));
+            else if (props.metadata.arrays.some(function (elem) { return elem.type.value.any; }))
+                install(null);
+            else if (props.metadata.tuples.length === 0)
+                if (props.metadata.arrays.length === 1)
+                    // ARRAY ONLY
+                    install(decode_array({
+                        config: props.config,
+                        context: props.context,
+                        importer: props.importer,
+                        array: props.metadata.arrays[0],
+                        input: props.input,
+                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                    }));
+                else
+                    install(explore_arrays({
+                        config: props.config,
+                        context: props.context,
+                        importer: props.importer,
+                        arrays: props.metadata.arrays,
+                        input: props.input,
+                        explore: __assign(__assign({}, props.explore), { from: "array" }),
+                    }));
+            else
+                install(explore_arrays_and_tuples({
+                    config: props.config,
+                    context: props.context,
+                    importer: props.importer,
+                    definitions: __spreadArray(__spreadArray([], __read(props.metadata.tuples), false), __read(props.metadata.arrays), false),
+                    input: props.input,
+                    explore: props.explore,
+                }));
+        }
+        // OBJECT
+        if (props.metadata.objects.length > 0)
+            prepare({
+                knock: ExpressionFactory_1.ExpressionFactory.isObject({
+                    checkNull: true,
+                    checkArray: props.metadata.objects.some(function (obj) {
+                        return obj.properties.every(function (prop) { return !prop.key.isSoleLiteral() || !prop.value.isRequired(); });
+                    }),
+                })(props.input),
+                expected: props.metadata.objects.map(function (obj) { return obj.name; }).join(" | "),
+                body: explore_objects({
+                    config: props.config,
+                    importer: props.importer,
+                    metadata: props.metadata,
+                    input: props.input,
+                    explore: __assign(__assign({}, props.explore), { from: "object" }),
+                }),
+            });
+        if (instances.length) {
+            var transformer = function (merger) {
+                return function (ins) {
+                    return ins.body
+                        ? {
+                            expression: merger(ins.knock, ins.body),
+                            combined: true,
+                        }
+                        : {
+                            expression: ins.knock,
                             combined: false,
-                            expression: metadata.escaped.original.size() === 1 &&
-                                metadata.escaped.original.natives.length === 1
-                                ? (0, check_native_1.check_native)(metadata.escaped.original.natives[0])(input)
-                                : typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode(project)(config)(importer)(input, metadata.escaped.original, explore), typescript_1.default.factory.createLogicalAnd(IsProgrammer_1.IsProgrammer.decode_to_json(false)(input), decode_escaped(project)(config)(importer)(input, metadata.escaped.returns, explore))),
-                        });
-                    //----
-                    // COMBINE CONDITIONS
-                    //----
-                    return top.length && binaries.length
-                        ? config.combiner(explore)("and")(input, __spreadArray(__spreadArray([], __read(top), false), [
-                            {
-                                expression: config.combiner(explore)("or")(input, binaries, metadata.getName()),
-                                combined: true,
-                            },
-                        ], false), metadata.getName())
-                        : binaries.length
-                            ? config.combiner(explore)("or")(input, binaries, metadata.getName())
-                            : config.success;
+                        };
                 };
             };
-        };
+            if (instances.length === 1)
+                binaries.push(transformer(function (pre, body) {
+                    return props.config.combiner({
+                        explore: props.explore,
+                        logic: "and",
+                        input: props.input,
+                        binaries: [pre, body].map(function (expression) { return ({
+                            expression: expression,
+                            combined: expression !== pre,
+                        }); }),
+                        expected: props.metadata.getName(),
+                    });
+                })(instances[0]));
+            else
+                binaries.push({
+                    expression: props.config.combiner({
+                        explore: props.explore,
+                        logic: "or",
+                        input: props.input,
+                        binaries: instances.map(transformer(typescript_1.default.factory.createLogicalAnd)),
+                        expected: props.metadata.getName(),
+                    }),
+                    combined: true,
+                });
+        }
+        // ESCAPED CASE
+        if (props.metadata.escaped !== null)
+            binaries.push({
+                combined: false,
+                expression: props.metadata.escaped.original.size() === 1 &&
+                    props.metadata.escaped.original.natives.length === 1
+                    ? (0, check_native_1.check_native)(props.metadata.escaped.original.natives[0])(props.input)
+                    : typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
+                        context: props.context,
+                        config: props.config,
+                        importer: props.importer,
+                        metadata: props.metadata.escaped.original,
+                        input: props.input,
+                        explore: props.explore,
+                    }), typescript_1.default.factory.createLogicalAnd(IsProgrammer_1.IsProgrammer.decode_to_json({
+                        checkNull: false,
+                        input: props.input,
+                    }), decode_escaped({
+                        config: props.config,
+                        context: props.context,
+                        importer: props.importer,
+                        metadata: props.metadata.escaped.returns,
+                        input: props.input,
+                        explore: props.explore,
+                    }))),
+            });
+        //----
+        // COMBINE CONDITIONS
+        //----
+        return top.length && binaries.length
+            ? props.config.combiner({
+                explore: props.explore,
+                logic: "and",
+                input: props.input,
+                binaries: __spreadArray(__spreadArray([], __read(top), false), [
+                    {
+                        expression: props.config.combiner({
+                            explore: props.explore,
+                            logic: "or",
+                            input: props.input,
+                            binaries: binaries,
+                            expected: props.metadata.getName(),
+                        }),
+                        combined: true,
+                    },
+                ], false),
+                expected: props.metadata.getName(),
+            })
+            : binaries.length
+                ? props.config.combiner({
+                    explore: props.explore,
+                    logic: "or",
+                    input: props.input,
+                    binaries: binaries,
+                    expected: props.metadata.getName(),
+                })
+                : props.config.success;
     };
-    CheckerProgrammer.decode_object = function (config) { return function (importer) {
-        var func = FeatureProgrammer_1.FeatureProgrammer.decode_object(config)(importer);
-        return function (input, obj, explore) {
-            obj.validated = true;
-            return func(input, obj, explore);
-        };
-    }; };
-    var decode_array = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, array, explore) {
-                    if (array.type.recursive === false)
-                        return decode_array_inline(project)(config)(importer)(input, array, explore);
-                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
-                    return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "a").concat(array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function", from: "array" }))(input)), config.joiner.failure(input, array.type.name, explore));
-                };
-            };
-        };
+    CheckerProgrammer.decode_object = function (props) {
+        var _a;
+        (_a = props.object).validated || (_a.validated = true);
+        return FeatureProgrammer_1.FeatureProgrammer.decode_object(props.config)(props.importer)(props.input, props.object, props.explore);
     };
-    var decode_array_inline = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, array, explore) {
-                    var length = (0, check_array_length_1.check_array_length)(project)(array)(input);
-                    var main = FeatureProgrammer_1.FeatureProgrammer.decode_array({
-                        prefix: config.prefix,
-                        trace: config.trace,
-                        path: config.path,
-                        decoder: function () { return CheckerProgrammer.decode(project)(config)(importer); },
-                    })(importer)(config.joiner.array)(input, array, explore);
-                    return length.expression === null && length.conditions.length === 0
-                        ? main
-                        : typescript_1.default.factory.createLogicalAnd(config.atomist(explore)(length)(input), main);
-                };
-            };
-        };
+    var decode_array = function (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.importer.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, arrayExplore), { source: "function", from: "array" }))(props.input)), props.config.joiner.failure({
+            input: props.input,
+            expected: props.array.type.name,
+            explore: arrayExplore,
+        }));
     };
-    var decode_tuple = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, tuple, explore) {
-                    if (tuple.type.recursive === false)
-                        return decode_tuple_inline(project)(config)(importer)(input, tuple.type, explore);
-                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
-                    return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "t").concat(tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function" }))(input)), config.joiner.failure(input, tuple.type.name, explore));
-                };
-            };
-        };
+    var decode_array_inline = function (props) {
+        var length = (0, check_array_length_1.check_array_length)(props.context)(props.array)(props.input);
+        var main = FeatureProgrammer_1.FeatureProgrammer.decode_array({
+            prefix: props.config.prefix,
+            trace: props.config.trace,
+            path: props.config.path,
+            decoder: function () { return function (input, metadata, explore) {
+                return CheckerProgrammer.decode(__assign(__assign({}, props), { input: input, metadata: metadata, explore: explore }));
+            }; },
+        })(props.importer)(props.config.joiner.array)(props.input, props.array, props.explore);
+        return length.expression === null && length.conditions.length === 0
+            ? main
+            : typescript_1.default.factory.createLogicalAnd(props.config.atomist({
+                explore: props.explore,
+                input: props.input,
+                entry: length,
+            }), main);
     };
-    var decode_tuple_inline = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, tuple, explore) {
-                    var binaries = tuple.elements
-                        .filter(function (meta) { return meta.rest === null; })
-                        .map(function (meta, index) {
-                        return CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createElementAccessExpression(input, index), meta, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
-                                ? "".concat((0, postfix_of_tuple_1.postfix_of_tuple)(explore.postfix), "[").concat(index, "]\"")
-                                : "\"[".concat(index, "]\"") }));
-                    });
-                    var rest = tuple.elements.length && tuple.elements.at(-1).rest !== null
-                        ? CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("slice"), undefined, [ExpressionFactory_1.ExpressionFactory.number(tuple.elements.length - 1)]), (0, wrap_metadata_rest_tuple_1.wrap_metadata_rest_tuple)(tuple.elements.at(-1).rest), __assign(__assign({}, explore), { start: tuple.elements.length - 1 }))
-                        : null;
-                    var arrayLength = typescript_1.default.factory.createPropertyAccessExpression(input, "length");
-                    return config.combiner(explore)("and")(input, __spreadArray(__spreadArray(__spreadArray([], __read((rest === null
-                        ? tuple.elements.every(function (t) { return t.optional === false; })
-                            ? [
-                                {
-                                    combined: false,
-                                    expression: typescript_1.default.factory.createStrictEquality(arrayLength, ExpressionFactory_1.ExpressionFactory.number(tuple.elements.length)),
-                                },
-                            ]
-                            : [
-                                {
-                                    combined: false,
-                                    expression: typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createLessThanEquals(ExpressionFactory_1.ExpressionFactory.number(tuple.elements.filter(function (t) { return t.optional === false; })
-                                        .length), arrayLength), typescript_1.default.factory.createGreaterThanEquals(ExpressionFactory_1.ExpressionFactory.number(tuple.elements.length), arrayLength)),
-                                },
-                            ]
-                        : [])), false), __read((config.joiner.tuple
-                        ? [
-                            {
-                                expression: config.joiner.tuple(binaries),
-                                combined: true,
-                            },
-                        ]
-                        : binaries.map(function (expression) { return ({
-                            expression: expression,
-                            combined: true,
-                        }); }))), false), __read((rest !== null
-                        ? [
-                            {
-                                expression: rest,
-                                combined: true,
-                            },
-                        ]
-                        : [])), false), "[".concat(tuple.elements.map(function (t) { return t.getName(); }).join(", "), "]"));
-                };
-            };
-        };
+    var decode_tuple = function (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.importer.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, arrayExplore), { source: "function" }))(props.input)), props.config.joiner.failure({
+            input: props.input,
+            expected: props.tuple.type.name,
+            explore: arrayExplore,
+        }));
     };
-    var decode_escaped = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, meta, explore) {
-                    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(project)(config)(importer)(typescript_1.default.factory.createIdentifier("input"), meta, explore))), undefined, [
-                        typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("toJSON"), undefined, []),
-                    ]);
-                };
-            };
-        };
+    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,
+                importer: props.importer,
+                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
+            ? CheckerProgrammer.decode({
+                config: props.config,
+                context: props.context,
+                importer: props.importer,
+                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 }),
+            })
+            : null;
+        var 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; })
+                    ? [
+                        {
+                            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(function (t) { return t.optional === false; })
+                                .length), arrayLength), typescript_1.default.factory.createGreaterThanEquals(ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length), arrayLength)),
+                        },
+                    ]
+                : [])), 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(", "), "]"),
+        });
+    };
+    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, []),
+        ]);
     };
     /* -----------------------------------------------------------
           UNION TYPE EXPLORERS
       ----------------------------------------------------------- */
-    var explore_sets = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, sets, explore) {
-                    return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
-                        checker: CheckerProgrammer.decode(project)(config)(importer),
-                        decoder: decode_array(project)(config)(importer),
-                        empty: config.success,
-                        success: config.success,
-                        failure: function (input, expected, explore) {
-                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                        },
-                    })([])(input, sets, explore), undefined, undefined);
-                };
-            };
-        };
+    var explore_sets = function (props) {
+        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
+            checker: function (input, metadata, explore, _container) {
+                return CheckerProgrammer.decode({
+                    context: props.context,
+                    config: props.config,
+                    importer: props.importer,
+                    input: input,
+                    metadata: metadata,
+                    explore: explore,
+                });
+            },
+            decoder: function (input, array, explore) {
+                return decode_array({
+                    config: props.config,
+                    context: props.context,
+                    importer: props.importer,
+                    array: array,
+                    input: input,
+                    explore: explore,
+                });
+            },
+            empty: props.config.success,
+            success: props.config.success,
+            failure: function (input, expected, explore) {
+                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
+                    input: input,
+                    expected: expected,
+                    explore: explore,
+                }));
+            },
+        })([])(props.input, props.sets, props.explore), undefined, undefined);
     };
-    var explore_maps = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, maps, explore) {
-                    return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
-                        checker: function (input, entry, explore) {
-                            var func = CheckerProgrammer.decode(project)(config)(importer);
-                            return typescript_1.default.factory.createLogicalAnd(func(typescript_1.default.factory.createElementAccessExpression(input, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") })), func(typescript_1.default.factory.createElementAccessExpression(input, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") })));
-                        },
-                        decoder: decode_array(project)(config)(importer),
-                        empty: config.success,
-                        success: config.success,
-                        failure: function (input, expected, explore) {
-                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                        },
-                    })([])(input, maps, explore), undefined, undefined);
-                };
-            };
-        };
+    var explore_maps = function (props) {
+        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
+            checker: function (input, entry, explore) {
+                return typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
+                    config: props.config,
+                    context: props.context,
+                    importer: props.importer,
+                    input: typescript_1.default.factory.createElementAccessExpression(input, 0),
+                    metadata: entry[0],
+                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }),
+                }), CheckerProgrammer.decode({
+                    config: props.config,
+                    context: props.context,
+                    importer: props.importer,
+                    input: typescript_1.default.factory.createElementAccessExpression(input, 1),
+                    metadata: entry[1],
+                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }),
+                }));
+            },
+            decoder: function (input, array, explore) {
+                return decode_array({
+                    context: props.context,
+                    config: props.config,
+                    importer: props.importer,
+                    array: array,
+                    input: input,
+                    explore: explore,
+                });
+            },
+            empty: props.config.success,
+            success: props.config.success,
+            failure: function (input, expected, explore) {
+                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
+                    input: input,
+                    expected: expected,
+                    explore: explore,
+                }));
+            },
+        })([])(props.input, props.maps, props.explore), undefined, undefined);
     };
-    var explore_tuples = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, tuples, explore) {
-                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.tuple({
-                        checker: decode_tuple(project)(config)(importer),
-                        decoder: decode_tuple(project)(config)(importer),
-                        empty: config.success,
-                        success: config.success,
-                        failure: function (input, expected, explore) {
-                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                        },
-                    }))(input, tuples, explore);
-                };
-            };
-        };
+    var explore_tuples = function (props) {
+        return explore_array_like_union_types({
+            config: props.config,
+            importer: props.importer,
+            factory: UnionExplorer_1.UnionExplorer.tuple({
+                checker: function (input, tuple, explore) {
+                    return decode_tuple({
+                        context: props.context,
+                        config: props.config,
+                        importer: props.importer,
+                        input: input,
+                        tuple: tuple,
+                        explore: explore,
+                    });
+                },
+                decoder: function (input, tuple, explore) {
+                    return decode_tuple({
+                        context: props.context,
+                        config: props.config,
+                        importer: props.importer,
+                        tuple: tuple,
+                        input: input,
+                        explore: explore,
+                    });
+                },
+                empty: props.config.success,
+                success: props.config.success,
+                failure: function (input, expected, explore) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
+                        input: input,
+                        expected: expected,
+                        explore: explore,
+                    }));
+                },
+            }),
+            definitions: props.tuples,
+            input: props.input,
+            explore: props.explore,
+        });
     };
-    var explore_arrays = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, arrays, explore) {
-                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array({
-                        checker: CheckerProgrammer.decode(project)(config)(importer),
-                        decoder: decode_array(project)(config)(importer),
-                        empty: config.success,
-                        success: config.success,
-                        failure: function (input, expected, explore) {
-                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                        },
-                    }))(input, arrays, explore);
-                };
-            };
-        };
+    var explore_arrays = function (props) {
+        return explore_array_like_union_types({
+            config: props.config,
+            importer: props.importer,
+            factory: UnionExplorer_1.UnionExplorer.array({
+                checker: function (input, metadata, explore) {
+                    return CheckerProgrammer.decode({
+                        context: props.context,
+                        config: props.config,
+                        importer: props.importer,
+                        metadata: metadata,
+                        input: input,
+                        explore: explore,
+                    });
+                },
+                decoder: function (input, array, explore) {
+                    return decode_array({
+                        context: props.context,
+                        config: props.config,
+                        importer: props.importer,
+                        array: array,
+                        input: input,
+                        explore: explore,
+                    });
+                },
+                empty: props.config.success,
+                success: props.config.success,
+                failure: function (input, expected, explore) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
+                        input: input,
+                        expected: expected,
+                        explore: explore,
+                    }));
+                },
+            }),
+            definitions: props.arrays,
+            input: props.input,
+            explore: props.explore,
+        });
     };
-    var explore_arrays_and_tuples = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, elements, explore) {
-                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array_or_tuple({
-                        checker: function (front, target, explore, array) {
-                            return target instanceof MetadataTuple_1.MetadataTuple
-                                ? decode_tuple(project)(config)(importer)(front, target, explore)
-                                : config.atomist(explore)({
-                                    expected: elements
-                                        .map(function (elem) {
-                                        return elem instanceof MetadataArray_1.MetadataArray
-                                            ? elem.getName()
-                                            : elem.type.name;
-                                    })
-                                        .join(" | "),
-                                    expression: CheckerProgrammer.decode(project)(config)(importer)(front, target, explore),
-                                    conditions: [],
-                                })(array);
-                        },
-                        decoder: function (input, target, explore) {
-                            return target instanceof MetadataTuple_1.MetadataTuple
-                                ? decode_tuple(project)(config)(importer)(input, target, explore)
-                                : decode_array(project)(config)(importer)(input, target, explore);
-                        },
-                        empty: config.success,
-                        success: config.success,
-                        failure: function (input, expected, explore) {
-                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                        },
-                    }))(input, elements, explore);
-                };
-            };
-        };
+    var explore_arrays_and_tuples = function (props) {
+        return explore_array_like_union_types({
+            config: props.config,
+            importer: props.importer,
+            factory: UnionExplorer_1.UnionExplorer.array_or_tuple({
+                checker: function (input, definition, explore, array) {
+                    return definition instanceof MetadataTuple_1.MetadataTuple
+                        ? decode_tuple({
+                            config: props.config,
+                            context: props.context,
+                            importer: props.importer,
+                            input: input,
+                            tuple: definition,
+                            explore: explore,
+                        })
+                        : props.config.atomist({
+                            explore: explore,
+                            entry: {
+                                expected: props.definitions
+                                    .map(function (elem) {
+                                    return elem instanceof MetadataArray_1.MetadataArray
+                                        ? elem.getName()
+                                        : elem.type.name;
+                                })
+                                    .join(" | "),
+                                expression: CheckerProgrammer.decode({
+                                    importer: props.importer,
+                                    context: props.context,
+                                    config: props.config,
+                                    input: input,
+                                    metadata: definition,
+                                    explore: explore,
+                                }),
+                                conditions: [],
+                            },
+                            input: array,
+                        });
+                },
+                decoder: function (input, definition, explore) {
+                    return definition instanceof MetadataTuple_1.MetadataTuple
+                        ? decode_tuple({
+                            context: props.context,
+                            config: props.config,
+                            importer: props.importer,
+                            input: input,
+                            tuple: definition,
+                            explore: explore,
+                        })
+                        : decode_array({
+                            context: props.context,
+                            config: props.config,
+                            importer: props.importer,
+                            input: input,
+                            array: definition,
+                            explore: explore,
+                        });
+                },
+                empty: props.config.success,
+                success: props.config.success,
+                failure: function (input, expected, explore) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
+                        input: input,
+                        expected: expected,
+                        explore: explore,
+                    }));
+                },
+            }),
+            input: props.input,
+            definitions: props.definitions,
+            explore: props.explore,
+        });
     };
-    var explore_array_like_union_types = function (config) {
-        return function (importer) {
-            return function (factory) {
-                return function (input, elements, explore) {
-                    var arrow = function (parameters) {
-                        return function (explore) {
-                            return function (input) {
-                                return factory(parameters)(input, elements, explore);
-                            };
-                        };
-                    };
-                    if (elements.every(function (e) { return e.type.recursive === false; }))
-                        typescript_1.default.factory.createCallExpression(arrow([])(explore)(input), undefined, []);
-                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
-                    return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.emplaceUnion(config.prefix, elements.map(function (e) { return e.type.name; }).join(" | "), function () {
-                        return arrow(FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")))(__assign(__assign({}, explore), { postfix: "" }))(typescript_1.default.factory.createIdentifier("input"));
-                    })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input)), config.joiner.failure(input, elements.map(function (e) { return e.type.name; }).join(" | "), explore));
-                };
-            };
+    var explore_array_like_union_types = function (props) {
+        var arrow = function (next) {
+            return props.factory(next.parameters)(next.input, props.definitions, next.explore);
         };
+        if (props.definitions.every(function (e) { return 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.importer.emplaceUnion(props.config.prefix, props.definitions.map(function (e) { return e.type.name; }).join(" | "), function () {
+            return arrow({
+                parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")),
+                explore: __assign(__assign({}, arrayExplore), { postfix: "" }),
+                input: typescript_1.default.factory.createIdentifier("input"),
+            });
+        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input)), props.config.joiner.failure({
+            input: props.input,
+            expected: props.definitions.map(function (e) { return e.type.name; }).join(" | "),
+            explore: arrayExplore,
+        }));
     };
-    var explore_objects = function (config) {
-        return function (importer) {
-            return function (input, meta, explore) {
-                return meta.objects.length === 1
-                    ? CheckerProgrammer.decode_object(config)(importer)(input, meta.objects[0], explore)
-                    : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "u").concat(meta.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input));
-            };
-        };
+    var explore_objects = function (props) {
+        return props.metadata.objects.length === 1
+            ? CheckerProgrammer.decode_object({
+                config: props.config,
+                importer: props.importer,
+                object: props.metadata.objects[0],
+                input: props.input,
+                explore: props.explore,
+            })
+            : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(props.explore)(props.input));
     };
 })(CheckerProgrammer || (exports.CheckerProgrammer = CheckerProgrammer = {}));
-var create_add = function (binaries) {
-    return function (defaultInput) {
-        return function (exact, left, right) {
-            if (right === void 0) { right = defaultInput; }
-            var factory = exact
-                ? typescript_1.default.factory.createStrictEquality
-                : typescript_1.default.factory.createStrictInequality;
-            binaries.push({
-                expression: factory(left, right),
-                combined: false,
-            });
-        };
-    };
+var create_add = function (props) {
+    var _a;
+    var factory = props.exact
+        ? typescript_1.default.factory.createStrictEquality
+        : typescript_1.default.factory.createStrictInequality;
+    props.binaries.push({
+        expression: factory(props.left, (_a = props.right) !== null && _a !== void 0 ? _a : props.default),
+        combined: false,
+    });
 };
 //# sourceMappingURL=CheckerProgrammer.js.map