typia 4.0.0-dev.20230527 → 4.0.0-dev.20230604

package/lib/programmers/CheckerProgrammer.js

@@ -46,15 +46,20 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CheckerProgrammer = void 0;
+var typescript_1 = __importDefault(require("typescript"));
 var ExpressionFactory_1 = require("../factories/ExpressionFactory");
 var IdentifierFactory_1 = require("../factories/IdentifierFactory");
 var MetadataCollection_1 = require("../factories/MetadataCollection");
 var MetadataFactory_1 = require("../factories/MetadataFactory");
+var StatementFactory_1 = require("../factories/StatementFactory");
 var TypeFactory_1 = require("../factories/TypeFactory");
 var ValueFactory_1 = require("../factories/ValueFactory");
-var Metadata_1 = require("../metadata/Metadata");
+var MetadataTuple_1 = require("../metadata/MetadataTuple");
 var FeatureProgrammer_1 = require("./FeatureProgrammer");
 var AtomicPredicator_1 = require("./helpers/AtomicPredicator");
 var OptionPredicator_1 = require("./helpers/OptionPredicator");
@@ -66,91 +71,140 @@ var check_native_1 = require("./internal/check_native");
 var check_number_1 = require("./internal/check_number");
 var check_string_1 = require("./internal/check_string");
 var check_template_1 = require("./internal/check_template");
-var check_union_tuple_1 = require("./internal/check_union_tuple");
 var decode_union_object_1 = require("./internal/decode_union_object");
+var wrap_metadata_rest_tuple_1 = require("./internal/wrap_metadata_rest_tuple");
 var CheckerProgrammer;
 (function (CheckerProgrammer) {
-    /* -----------------------------------------------------------
-        WRITERS
-    ----------------------------------------------------------- */
     CheckerProgrammer.write = function (project) {
         return function (config) {
             return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.analyze(project)(configure(project)(config)(importer))(importer);
+                return FeatureProgrammer_1.FeatureProgrammer.write(project)(configure(project)(config)(importer))(importer);
+            };
+        };
+    };
+    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_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_array_functions = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (collection) {
+                    return collection
+                        .arrays()
+                        .filter(function (a) { return a.recursive; })
+                        .map(function (array, 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"), array, {
+                            tracable: config.trace,
+                            source: "function",
+                            from: "array",
+                            postfix: "",
+                        }, [], [])));
+                    });
+                };
             };
         };
     };
-    CheckerProgrammer.write_functors = function (p) { return function (config) { return function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.write_functors(p.tsc)(configure(p)(config)(importer))(importer);
-    }; }; };
-    CheckerProgrammer.write_unioners = function (p, config, importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.write_unioners(p.tsc)(configure(p)(__assign(__assign({}, config), { numeric: false }))(importer))(importer);
+    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: "",
+                        }, [], [])));
+                    });
+                };
+            };
+        };
     };
-    var configure = function (p) {
+    var configure = function (project) {
         return function (config) {
             return function (importer) {
-                var _a, _b, _c;
-                var output = {
+                var _a;
+                return ({
                     types: {
-                        input: function () { return TypeFactory_1.TypeFactory.keyword(p.tsc)("any"); },
+                        input: function () { return TypeFactory_1.TypeFactory.keyword("any"); },
                         output: function (type, name) {
-                            return p.tsc.factory.createTypePredicateNode(undefined, "input", p.tsc.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(p)(type)));
+                            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)));
                         },
                     },
                     trace: config.trace,
                     path: config.path,
-                    functors: config.functors,
-                    unioners: config.unioners,
-                    initializer: function (p) { return function (type) {
-                        var collection = new MetadataCollection_1.MetadataCollection();
-                        var meta = MetadataFactory_1.MetadataFactory.analyze(p)({
-                            resolve: false,
-                            constant: true,
-                        })(collection)(type);
-                        return [collection, meta];
-                    }; },
+                    prefix: config.prefix,
+                    initializer: function (_a) {
+                        var checker = _a.checker;
+                        return function (type) {
+                            var collection = new MetadataCollection_1.MetadataCollection();
+                            var meta = MetadataFactory_1.MetadataFactory.analyze(checker)({
+                                resolve: false,
+                                constant: true,
+                                absorb: true,
+                                validate: function (meta) {
+                                    if (meta.arrays.length > 1 &&
+                                        meta.arrays.some(function (a) { return a.recursive; }))
+                                        throw new Error("Repeated union array types are not supported yet.");
+                                },
+                            })(collection)(type);
+                            return [collection, meta];
+                        };
+                    },
                     addition: config.addition,
-                    decoder: (_a = config.decoder) !== null && _a !== void 0 ? _a : CheckerProgrammer.decode(p)(config)(importer),
+                    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: (_b = config.decoder) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(p)(config)(importer),
-                        decoder: CheckerProgrammer.decode_object(p.tsc)(config)(importer),
+                        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)(p.tsc)(CheckerProgrammer.decode_object(p.tsc)(config)(importer))(function (input, obj, explore) {
-                                return CheckerProgrammer.decode_object(p.tsc)(config)(importer)(input, obj, __assign(__assign({}, explore), { tracable: true }));
-                            })((_c = config.joiner.is) !== null && _c !== void 0 ? _c : (function (expr) { return expr; }))(function (value, expected) {
-                                return p.tsc.factory.createReturnStatement(config.joiner.failure(value, expected));
+                            ? (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(p.tsc)(config)(importer)(input, obj, explore),
+                                    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 p.tsc.factory.createReturnStatement(config.joiner.failure(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(p.tsc)("boolean"),
+                        type: TypeFactory_1.TypeFactory.keyword("boolean"),
                     },
-                };
-                if (config.numeric === true)
-                    output.generator = {
-                        unioners: FeatureProgrammer_1.FeatureProgrammer.write_unioners(p.tsc)(configure(p)(__assign(__assign({}, config), { numeric: false }))(importer))(importer),
-                    };
-                return output;
+                    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); },
+                    },
+                });
             };
         };
     };
-    /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-    /**
-     * @internal
-     */
-    CheckerProgrammer.decode = function (p) {
+    CheckerProgrammer.decode = function (project) {
         return function (config) {
             return function (importer) {
                 return function (input, meta, explore, metaTags, jsDocTags) {
@@ -159,40 +213,27 @@ var CheckerProgrammer;
                         return config.success;
                     var top = [];
                     var binaries = [];
-                    var add = create_add(p.tsc)(binaries)(input);
+                    var add = create_add(binaries)(input);
                     var getConstantValue = function (value) {
                         return typeof value === "string"
-                            ? p.tsc.factory.createStringLiteral(value)
-                            : p.tsc.factory.createIdentifier(value.toString());
+                            ? typescript_1.default.factory.createStringLiteral(value)
+                            : typescript_1.default.factory.createIdentifier(value.toString());
                     };
-                    //----
-                    // CHECK OPTIONAL
-                    //----
-                    // @todo -> should be elaborated
                     var checkOptional = meta.empty() || meta.isUnionBucket();
-                    // NULLABLE
-                    if (checkOptional ||
-                        meta.nullable
-                    // || (meta.objects.length && meta.size() !== meta.objects.length)
-                    )
-                        (meta.nullable ? add : create_add(p.tsc)(top)(input))(meta.nullable, ValueFactory_1.ValueFactory.NULL(p.tsc));
-                    // UNDEFINDABLE
+                    if (checkOptional || meta.nullable)
+                        (meta.nullable ? add : create_add(top)(input))(meta.nullable, ValueFactory_1.ValueFactory.NULL());
                     if (checkOptional || !meta.required)
-                        (meta.required ? create_add(p.tsc)(top)(input) : add)(!meta.required, ValueFactory_1.ValueFactory.UNDEFINED(p.tsc));
-                    // FUNCTIONAL
+                        (meta.required ? create_add(top)(input) : add)(!meta.required, ValueFactory_1.ValueFactory.UNDEFINED());
                     if (meta.functional === true)
-                        if (OptionPredicator_1.OptionPredicator.functional(p.options) || meta.size() !== 1)
-                            add(true, p.tsc.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(p.tsc)(input));
+                        if (OptionPredicator_1.OptionPredicator.functional(project.options) ||
+                            meta.size() !== 1)
+                            add(true, typescript_1.default.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(input));
                         else
                             binaries.push({
                                 combined: false,
                                 expression: config.success,
                             });
                     try {
-                        //----
-                        // VALUES
-                        //----
-                        // CONSTANT VALUES
                         for (var _e = __values(meta.constants), _f = _e.next(); !_f.done; _f = _e.next()) {
                             var constant = _f.value;
                             if (AtomicPredicator_1.AtomicPredicator.constant(meta)(constant.type))
@@ -219,28 +260,27 @@ var CheckerProgrammer;
                         finally { if (e_1) throw e_1.error; }
                     }
                     try {
-                        // ATOMIC VALUES
                         for (var _j = __values(meta.atomics), _k = _j.next(); !_k.done; _k = _j.next()) {
                             var type = _k.value;
                             if (AtomicPredicator_1.AtomicPredicator.atomic(meta)(type) === false)
                                 continue;
                             else if (type === "number")
                                 binaries.push({
-                                    expression: config.atomist(explore)((0, check_number_1.check_number)(p, config.numeric)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    expression: config.atomist(explore)((0, check_number_1.check_number)(project, config.numeric)(importer)(metaTags)(jsDocTags)(input))(input),
                                     combined: false,
                                 });
                             else if (type === "bigint")
                                 binaries.push({
-                                    expression: config.atomist(explore)((0, check_bigint_1.check_bigint)(p.tsc)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    expression: config.atomist(explore)((0, check_bigint_1.check_bigint)(importer)(metaTags)(jsDocTags)(input))(input),
                                     combined: false,
                                 });
                             else if (type === "string")
                                 binaries.push({
-                                    expression: config.atomist(explore)((0, check_string_1.check_string)(p.tsc)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    expression: config.atomist(explore)((0, check_string_1.check_string)(importer)(metaTags)(jsDocTags)(input))(input),
                                     combined: false,
                                 });
                             else
-                                add(true, p.tsc.factory.createStringLiteral(type), ValueFactory_1.ValueFactory.TYPEOF(p.tsc)(input));
+                                add(true, typescript_1.default.factory.createStringLiteral(type), ValueFactory_1.ValueFactory.TYPEOF(input));
                         }
                     }
                     catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -250,19 +290,17 @@ var CheckerProgrammer;
                         }
                         finally { if (e_3) throw e_3.error; }
                     }
-                    // TEMPLATE LITERAL VALUES
                     if (meta.templates.length)
                         if (AtomicPredicator_1.AtomicPredicator.template(meta))
                             binaries.push({
-                                expression: config.atomist(explore)((0, check_template_1.check_template)(p.tsc)(importer)(metaTags)(jsDocTags)(meta.templates)(input))(input),
+                                expression: config.atomist(explore)((0, check_template_1.check_template)(importer)(metaTags)(jsDocTags)(meta.templates)(input))(input),
                                 combined: false,
                             });
                     try {
-                        // NATIVE CLASSES
                         for (var _l = __values(meta.natives), _m = _l.next(); !_m.done; _m = _l.next()) {
                             var native = _m.value;
                             binaries.push({
-                                expression: (0, check_native_1.check_native)(p.tsc)(native)(input),
+                                expression: (0, check_native_1.check_native)(native)(input),
                                 combined: false,
                             });
                         }
@@ -284,19 +322,17 @@ var CheckerProgrammer;
                             });
                         };
                     };
-                    // SETS
                     if (meta.sets.length) {
-                        var install = prepare((0, check_native_1.check_native)(p.tsc)("Set")(input), meta.sets
+                        var install = prepare((0, check_native_1.check_native)("Set")(input), meta.sets
                             .map(function (elem) { return "Set<".concat(elem.getName(), ">"); })
                             .join(" | "));
                         if (meta.sets.some(function (elem) { return elem.any; }))
                             install(null);
                         else
-                            install(explore_sets(p)(config)(importer)(input, meta.sets, __assign(__assign({}, explore), { from: "array" }), [], []));
+                            install(explore_sets(project)(config)(importer)(input, meta.sets, __assign(__assign({}, explore), { from: "array" }), [], []));
                     }
-                    // MAPS
                     if (meta.maps.length) {
-                        var install = prepare((0, check_native_1.check_native)(p.tsc)("Map")(input), meta.maps
+                        var install = prepare((0, check_native_1.check_native)("Map")(input), meta.maps
                             .map(function (_a) {
                             var key = _a.key, value = _a.value;
                             return "Map<".concat(key, ", ").concat(value, ">");
@@ -305,31 +341,28 @@ var CheckerProgrammer;
                         if (meta.maps.some(function (elem) { return elem.key.any && elem.value.any; }))
                             install(null);
                         else
-                            install(explore_maps(p)(config)(importer)(input, meta.maps.map(function (m) { return [m.key, m.value]; }), __assign(__assign({}, explore), { from: "array" }), [], []));
+                            install(explore_maps(project)(config)(importer)(input, meta.maps, __assign(__assign({}, explore), { from: "array" }), [], []));
                     }
-                    // ARRAYS AND TUPLES
                     if (meta.tuples.length + meta.arrays.length > 0) {
-                        var install = prepare(config.atomist(explore)((0, check_array_1.check_array)(p.tsc)(importer)(meta.tuples.length === 0 ? metaTags : [])(jsDocTags)(input))(input), __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false).map(function (elem) {
-                            return Array.isArray(elem)
-                                ? "[".concat(elem
-                                    .map(function (elem) { return elem.getName(); })
-                                    .join(", "), "]")
-                                : "Array<".concat(elem.getName(), ">");
-                        })
+                        var install = prepare(config.atomist(explore)((0, check_array_1.check_array)(importer)(meta.tuples.length === 0 ? metaTags : [])(jsDocTags)(input))(input), __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false).map(function (elem) { return elem.name; })
                             .join(" | "));
                         if (meta.arrays.length === 0)
-                            install(explore_tuples(p)(config)(importer)(input, meta.tuples, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
-                        else if (meta.arrays.some(function (elem) { return elem.any; }))
+                            if (meta.tuples.length === 1)
+                                install(decode_tuple(project)(config)(importer)(input, meta.tuples[0], __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            else
+                                install(explore_tuples(project)(config)(importer)(input, meta.tuples, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                        else if (meta.arrays.some(function (elem) { return elem.value.any; }))
                             install(null);
                         else if (meta.tuples.length === 0)
-                            // ARRAY ONLY
-                            install(explore_arrays(p)(config)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            if (meta.arrays.length === 1)
+                                install(decode_array(project)(config)(importer)(input, meta.arrays[0], __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            else
+                                install(explore_arrays(project)(config)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
                         else
-                            install(explore_arrays_and_tuples(p)(config)(importer)(input, __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false), explore, metaTags, jsDocTags));
+                            install(explore_arrays_and_tuples(project)(config)(importer)(input, __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false), explore, metaTags, jsDocTags));
                     }
-                    // OBJECT
                     if (meta.objects.length > 0)
-                        prepare(ExpressionFactory_1.ExpressionFactory.isObject(p.tsc)({
+                        prepare(ExpressionFactory_1.ExpressionFactory.isObject({
                             checkNull: true,
                             checkArray: meta.objects.some(function (obj) {
                                 return obj.properties.every(function (prop) {
@@ -337,7 +370,7 @@ var CheckerProgrammer;
                                         !prop.value.required;
                                 });
                             }),
-                        })(input), meta.objects.map(function (obj) { return obj.name; }).join(" | "))(explore_objects(p.tsc)(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" })));
+                        })(input), meta.objects.map(function (obj) { return obj.name; }).join(" | "))(explore_objects(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" })));
                     if (instances.length) {
                         var transformer = function (merger) {
                             return function (ins) {
@@ -361,13 +394,10 @@ var CheckerProgrammer;
                             })(instances[0]));
                         else
                             binaries.push({
-                                expression: config.combiner(explore)("or")(input, instances.map(transformer(p.tsc.factory.createLogicalAnd)), meta.getName()),
+                                expression: config.combiner(explore)("or")(input, instances.map(transformer(typescript_1.default.factory.createLogicalAnd)), meta.getName()),
                                 combined: true,
                             });
                     }
-                    //----
-                    // COMBINE CONDITIONS
-                    //----
                     return top.length && binaries.length
                         ? config.combiner(explore)("and")(input, __spreadArray(__spreadArray([], __read(top), false), [
                             {
@@ -382,201 +412,246 @@ var CheckerProgrammer;
             };
         };
     };
-    CheckerProgrammer.decode_tuple = function (p) {
+    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 (checkLength) {
-                    return function (input, tuple, explore, tagList, jsDocTags) {
-                        var binaries = tuple
-                            .filter(function (meta) { return meta.rest === null; })
-                            .map(function (meta, index) {
-                            return CheckerProgrammer.decode(p)(config)(importer)(p.tsc.factory.createElementAccessExpression(input, index), meta, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
-                                    ? "".concat(explore.postfix.slice(0, -1), "[").concat(index, "]\"")
-                                    : "[".concat(index, "]") }), tagList, jsDocTags);
-                        });
-                        var rest = tuple.length && tuple[tuple.length - 1].rest !== null
-                            ? CheckerProgrammer.decode(p)(config)(importer)(p.tsc.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(p.tsc)(input)("slice"), undefined, [
-                                p.tsc.factory.createNumericLiteral(tuple.length - 1),
-                            ]), (function () {
-                                var wrapper = Metadata_1.Metadata.initialize();
-                                wrapper.arrays.push(tuple[tuple.length - 1].rest);
-                                return wrapper;
-                            })(), __assign(__assign({}, explore), { start: tuple.length - 1 }), tagList, jsDocTags)
-                            : null;
-                        var arrayLength = p.tsc.factory.createPropertyAccessExpression(input, "length");
-                        return config.combiner(explore)("and")(input, __spreadArray(__spreadArray(__spreadArray([], __read((checkLength && rest === null
-                            ? tuple.every(function (t) { return t.optional === false; })
-                                ? [
-                                    {
-                                        combined: false,
-                                        expression: p.tsc.factory.createStrictEquality(arrayLength, p.tsc.factory.createNumericLiteral(tuple.length)),
-                                    },
-                                ]
-                                : [
-                                    {
-                                        combined: false,
-                                        expression: p.tsc.factory.createLogicalAnd(p.tsc.factory.createLessThanEquals(p.tsc.factory.createNumericLiteral(tuple.filter(function (t) {
-                                            return t.optional ===
-                                                false;
-                                        }).length), arrayLength), p.tsc.factory.createGreaterThanEquals(p.tsc.factory.createNumericLiteral(tuple.length), arrayLength)),
-                                    },
-                                ]
-                            : [])), false), __read((config.joiner.tuple
+                return function (input, array, explore, metaTags, jsDocTags) {
+                    if (array.recursive === false)
+                        return decode_array_inline(project)(config)(importer)(input, array, explore, metaTags, jsDocTags);
+                    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.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function", from: "array" }))(input)), config.joiner.failure(input, array.name, explore));
+                };
+            };
+        };
+    };
+    var decode_array_inline = function (project) {
+        return function (config) {
+            return function (importer) {
+                return 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);
+            };
+        };
+    };
+    var decode_tuple = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, tuple, explore, tagList, jsDocTags) {
+                    if (tuple.recursive === false)
+                        return decode_tuple_inline(project)(config)(importer)(input, tuple, explore, tagList, jsDocTags);
+                    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.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function" }))(input)), config.joiner.failure(input, tuple.name, explore));
+                };
+            };
+        };
+    };
+    var decode_tuple_inline = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, tuple, explore, tagList, jsDocTags) {
+                    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(explore.postfix.slice(0, -1), "[").concat(index, "]\"")
+                                : "\"[".concat(index, "]\"") }), tagList, jsDocTags);
+                    });
+                    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, [
+                            typescript_1.default.factory.createNumericLiteral(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 }), tagList, jsDocTags)
+                        : 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; })
                             ? [
                                 {
-                                    expression: config.joiner.tuple(binaries),
-                                    combined: true,
+                                    combined: false,
+                                    expression: typescript_1.default.factory.createStrictEquality(arrayLength, typescript_1.default.factory.createNumericLiteral(tuple.elements.length)),
                                 },
                             ]
-                            : binaries.map(function (expression) { return ({
-                                expression: expression,
-                                combined: true,
-                            }); }))), false), __read((rest !== null
-                            ? [
+                            : [
                                 {
-                                    expression: rest,
-                                    combined: true,
+                                    combined: false,
+                                    expression: typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createLessThanEquals(typescript_1.default.factory.createNumericLiteral(tuple.elements.filter(function (t) {
+                                        return t.optional === false;
+                                    }).length), arrayLength), typescript_1.default.factory.createGreaterThanEquals(typescript_1.default.factory.createNumericLiteral(tuple.elements.length), arrayLength)),
                                 },
                             ]
-                            : [])), false), "[".concat(tuple.map(function (t) { return t.getName(); }).join(", "), "]"));
-                    };
+                        : [])), 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_array = function (p) { return function (config) { return function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_array(p.tsc)({
-            trace: config.trace,
-            path: config.path,
-            decoder: CheckerProgrammer.decode(p)(config)(importer),
-        })(importer)(config.joiner.array);
-    }; }; };
-    CheckerProgrammer.decode_object = function (tsc) {
+    var explore_sets = function (project) {
         return function (config) {
             return function (importer) {
-                var func = FeatureProgrammer_1.FeatureProgrammer.decode_object(tsc)(config)(importer);
-                return function (input, obj, explore) {
-                    obj.validated = true;
-                    return func(input, obj, explore);
+                return function (input, sets, explore, tags, jsDocTags) {
+                    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, tags, jsDocTags), undefined, undefined);
                 };
             };
         };
     };
-    var explore_sets = function (p) { return function (config) { return function (importer) {
-        return UnionExplorer_1.UnionExplorer.set(p.tsc)({
-            checker: CheckerProgrammer.decode(p)(config)(importer),
-            decoder: decode_array(p)(config)(importer),
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return p.tsc.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
-    }; }; };
-    var explore_maps = function (p) { return function (config) { return function (importer) {
-        return UnionExplorer_1.UnionExplorer.map(p.tsc)({
-            checker: function (input, entry, explore) {
-                var func = CheckerProgrammer.decode(p)(config)(importer);
-                return p.tsc.factory.createLogicalAnd(func(p.tsc.factory.createElementAccessExpression(input, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }), [], []), func(p.tsc.factory.createElementAccessExpression(input, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }), [], []));
-            },
-            decoder: function (input, target, explore) {
-                return decode_array(p)(config)(importer)(input, Metadata_1.Metadata.create({
-                    any: false,
-                    nullable: false,
-                    required: true,
-                    optional: false,
-                    functional: false,
-                    resolved: null,
-                    constants: [],
-                    atomics: [],
-                    templates: [],
-                    rest: null,
-                    arrays: [],
-                    tuples: [target],
-                    objects: [],
-                    natives: [],
-                    sets: [],
-                    maps: [],
-                }), explore, [], []);
-            },
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return p.tsc.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
-    }; }; };
-    var explore_tuples = function (p) { return function (config) { return function (importer) {
-        return UnionExplorer_1.UnionExplorer.tuple(p.tsc)({
-            checker: (0, check_union_tuple_1.check_union_tuple)(p)(config)(importer),
-            decoder: CheckerProgrammer.decode_tuple(p)(config)(importer)(true),
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return p.tsc.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
-    }; }; };
-    var explore_arrays = function (p) { return function (config) { return function (importer) {
-        return UnionExplorer_1.UnionExplorer.array(p.tsc)({
-            checker: CheckerProgrammer.decode(p)(config)(importer),
-            decoder: decode_array(p)(config)(importer),
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return p.tsc.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
-    }; }; };
-    var explore_arrays_and_tuples = function (p) { return function (config) { return function (importer) {
-        return UnionExplorer_1.UnionExplorer.array_or_tuple(p.tsc)({
-            checker: function (front, target, explore, tags, jsDocTags, array) {
-                return Array.isArray(target)
-                    ? (0, check_union_tuple_1.check_union_tuple)(p)(config)(importer)(front, target, explore, tags, jsDocTags, array)
-                    : config.atomist(explore)({
-                        expression: CheckerProgrammer.decode(p)(config)(importer)(front, target, explore, tags, jsDocTags),
-                        tags: (0, check_array_length_1.check_array_length)(p.tsc)(tags)(array),
-                    })(array);
-            },
-            decoder: function (input, target, explore, tags, jsDocTags) {
-                return Array.isArray(target)
-                    ? CheckerProgrammer.decode_tuple(p)(config)(importer)(true)(input, target, explore, tags, jsDocTags)
-                    : decode_array(p)(config)(importer)(input, target, explore, tags, jsDocTags);
-            },
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return p.tsc.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
-    }; }; };
-    var explore_objects = function (tsc) {
+    var explore_maps = function (project) {
         return function (config) {
             return function (importer) {
-                var objector = CheckerProgrammer.decode_object(tsc)(config)(importer);
-                return function (input, meta, explore) {
-                    if (meta.objects.length === 1)
-                        return objector(input, meta.objects[0], explore);
-                    return tsc.factory.createCallExpression(tsc.factory.createIdentifier(importer.useLocal("".concat(config.unioners).concat(meta.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.get_object_arguments(tsc)(config)(explore)(input));
+                return function (input, maps, explore, tags, jsDocTags) {
+                    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, tags, jsDocTags), undefined, undefined);
                 };
             };
         };
     };
-})(CheckerProgrammer || (exports.CheckerProgrammer = CheckerProgrammer = {}));
-var create_add = function (tsc) {
-    return function (binaries) {
-        return function (defaultInput) {
-            return function (exact, left, right) {
-                if (right === void 0) { right = defaultInput; }
-                var factory = exact
-                    ? tsc.factory.createStrictEquality
-                    : tsc.factory.createStrictInequality;
-                binaries.push({
-                    expression: factory(left, right),
-                    combined: false,
-                });
+    var explore_tuples = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, tuples, explore, tags, jsDocTags) {
+                    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, tags, jsDocTags);
+                };
             };
         };
     };
+    var explore_arrays = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, arrays, explore, tags, jsDocTags) {
+                    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, tags, jsDocTags);
+                };
+            };
+        };
+    };
+    var explore_arrays_and_tuples = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, elements, explore, tags, jsDocTags) {
+                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array_or_tuple({
+                        checker: function (front, target, explore, tags, jsDocTags, array) {
+                            return target instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple(project)(config)(importer)(front, target, explore, tags, jsDocTags)
+                                : config.atomist(explore)({
+                                    expression: CheckerProgrammer.decode(project)(config)(importer)(front, target, explore, tags, jsDocTags),
+                                    tags: (0, check_array_length_1.check_array_length)(tags)(array),
+                                })(array);
+                        },
+                        decoder: function (input, target, explore, tags, jsDocTags) {
+                            return target instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple(project)(config)(importer)(input, target, explore, tags, jsDocTags)
+                                : decode_array(project)(config)(importer)(input, target, explore, tags, jsDocTags);
+                        },
+                        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, tags, jsDocTags);
+                };
+            };
+        };
+    };
+    var explore_array_like_union_types = function (config) {
+        return function (importer) {
+            return function (factory) {
+                return function (input, elements, explore, tags, jsDocTags) {
+                    var arrow = function (parameters) {
+                        return function (explore) {
+                            return function (input) {
+                                return factory(parameters)(input, elements, explore, tags, jsDocTags);
+                            };
+                        };
+                    };
+                    if (elements.every(function (e) { return e.recursive === false; }))
+                        typescript_1.default.factory.createCallExpression(arrow([])(explore)(input), undefined, []);
+                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
+                    return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.emplaceUnion(config.prefix, elements.map(function (e) { return e.name; }).join(" | "), function () {
+                        return arrow(FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")))(__assign(__assign({}, explore), { postfix: "" }))(typescript_1.default.factory.createIdentifier("input"));
+                    })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input)), config.joiner.failure(input, elements.map(function (e) { return e.name; }).join(" | "), explore));
+                };
+            };
+        };
+    };
+    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));
+            };
+        };
+    };
+})(CheckerProgrammer = exports.CheckerProgrammer || (exports.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,
+            });
+        };
+    };
 };
 //# sourceMappingURL=CheckerProgrammer.js.map