typia 4.0.0-dev.20230517 → 4.0.0-dev.20230519

package/lib/programmers/CheckerProgrammer.js

@@ -46,12 +46,8 @@ 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 tsclibrary_1 = __importDefault(require("typescript/lib/tsclibrary"));
 var ExpressionFactory_1 = require("../factories/ExpressionFactory");
 var IdentifierFactory_1 = require("../factories/IdentifierFactory");
 var MetadataCollection_1 = require("../factories/MetadataCollection");
@@ -74,6 +70,9 @@ var check_union_tuple_1 = require("./internal/check_union_tuple");
 var decode_union_object_1 = require("./internal/decode_union_object");
 var CheckerProgrammer;
 (function (CheckerProgrammer) {
+    /* -----------------------------------------------------------
+        WRITERS
+    ----------------------------------------------------------- */
     CheckerProgrammer.write = function (project) {
         return function (config) {
             return function (importer) {
@@ -81,78 +80,77 @@ var CheckerProgrammer;
             };
         };
     };
-    CheckerProgrammer.write_functors = function (project) {
-        return function (config) {
-            return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.write_functors(configure(project)(config)(importer))(importer);
-            };
-        };
-    };
-    CheckerProgrammer.write_unioners = function (project, config, importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.write_unioners(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer))(importer);
+    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);
     };
-    var configure = function (project) {
+    var configure = function (p) {
         return function (config) {
             return function (importer) {
                 var _a, _b, _c;
                 var output = {
                     types: {
-                        input: function () { return TypeFactory_1.TypeFactory.keyword("any"); },
+                        input: function () { return TypeFactory_1.TypeFactory.keyword(p.tsc)("any"); },
                         output: function (type, name) {
-                            return tsclibrary_1.default.factory.createTypePredicateNode(undefined, "input", tsclibrary_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(project.checker)(type)));
+                            return p.tsc.factory.createTypePredicateNode(undefined, "input", p.tsc.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(p)(type)));
                         },
                     },
                     trace: config.trace,
                     path: config.path,
                     functors: config.functors,
                     unioners: config.unioners,
-                    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,
-                            })(collection)(type);
-                            return [collection, meta];
-                        };
-                    },
+                    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];
+                    }; },
                     addition: config.addition,
-                    decoder: (_a = config.decoder) !== null && _a !== void 0 ? _a : CheckerProgrammer.decode(project)(config)(importer),
+                    decoder: (_a = config.decoder) !== null && _a !== void 0 ? _a : CheckerProgrammer.decode(p)(config)(importer),
                     objector: {
-                        checker: (_b = config.decoder) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(project)(config)(importer),
-                        decoder: CheckerProgrammer.decode_object(config)(importer),
+                        checker: (_b = config.decoder) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(p)(config)(importer),
+                        decoder: CheckerProgrammer.decode_object(p.tsc)(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 }));
+                            ? (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 tsclibrary_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
+                                return p.tsc.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),
+                                    expression: CheckerProgrammer.decode_object(p.tsc)(config)(importer)(input, obj, explore),
                                     combined: true,
                                 }); }), "(".concat(targets.map(function (t) { return t.name; }).join(" | "), ")"));
                             },
                         failure: function (value, expected) {
-                            return tsclibrary_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
+                            return p.tsc.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"),
+                        type: TypeFactory_1.TypeFactory.keyword(p.tsc)("boolean"),
                     },
                 };
                 if (config.numeric === true)
                     output.generator = {
-                        unioners: FeatureProgrammer_1.FeatureProgrammer.write_unioners(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer))(importer),
+                        unioners: FeatureProgrammer_1.FeatureProgrammer.write_unioners(p.tsc)(configure(p)(__assign(__assign({}, config), { numeric: false }))(importer))(importer),
                     };
                 return output;
             };
         };
     };
-    CheckerProgrammer.decode = function (project) {
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    /**
+     * @internal
+     */
+    CheckerProgrammer.decode = function (p) {
         return function (config) {
             return function (importer) {
                 return function (input, meta, explore, metaTags, jsDocTags) {
@@ -161,28 +159,40 @@ var CheckerProgrammer;
                         return config.success;
                     var top = [];
                     var binaries = [];
-                    var add = create_add(binaries)(input);
+                    var add = create_add(p.tsc)(binaries)(input);
                     var getConstantValue = function (value) {
                         return typeof value === "string"
-                            ? tsclibrary_1.default.factory.createStringLiteral(value)
-                            : tsclibrary_1.default.factory.createIdentifier(value.toString());
+                            ? p.tsc.factory.createStringLiteral(value)
+                            : p.tsc.factory.createIdentifier(value.toString());
                     };
+                    //----
+                    // CHECK OPTIONAL
+                    //----
+                    // @todo -> should be elaborated
                     var checkOptional = meta.empty() || meta.isUnionBucket();
+                    // NULLABLE
                     if (checkOptional ||
-                        meta.nullable)
-                        (meta.nullable ? add : create_add(top)(input))(meta.nullable, ValueFactory_1.ValueFactory.NULL());
+                        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.required)
-                        (meta.required ? create_add(top)(input) : add)(!meta.required, ValueFactory_1.ValueFactory.UNDEFINED());
+                        (meta.required ? create_add(p.tsc)(top)(input) : add)(!meta.required, ValueFactory_1.ValueFactory.UNDEFINED(p.tsc));
+                    // FUNCTIONAL
                     if (meta.functional === true)
-                        if (OptionPredicator_1.OptionPredicator.functional(project.options) ||
-                            meta.size() !== 1)
-                            add(true, tsclibrary_1.default.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(input));
+                        if (OptionPredicator_1.OptionPredicator.functional(p.options) || meta.size() !== 1)
+                            add(true, p.tsc.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(p.tsc)(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))
@@ -209,27 +219,28 @@ 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)(project, config.numeric)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    expression: config.atomist(explore)((0, check_number_1.check_number)(p, 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)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    expression: config.atomist(explore)((0, check_bigint_1.check_bigint)(p.tsc)(importer)(metaTags)(jsDocTags)(input))(input),
                                     combined: false,
                                 });
                             else if (type === "string")
                                 binaries.push({
-                                    expression: config.atomist(explore)((0, check_string_1.check_string)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    expression: config.atomist(explore)((0, check_string_1.check_string)(p.tsc)(importer)(metaTags)(jsDocTags)(input))(input),
                                     combined: false,
                                 });
                             else
-                                add(true, tsclibrary_1.default.factory.createStringLiteral(type), ValueFactory_1.ValueFactory.TYPEOF(input));
+                                add(true, p.tsc.factory.createStringLiteral(type), ValueFactory_1.ValueFactory.TYPEOF(p.tsc)(input));
                         }
                     }
                     catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -239,17 +250,19 @@ 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)(importer)(metaTags)(jsDocTags)(meta.templates)(input))(input),
+                                expression: config.atomist(explore)((0, check_template_1.check_template)(p.tsc)(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)(native)(input),
+                                expression: (0, check_native_1.check_native)(p.tsc)(native)(input),
                                 combined: false,
                             });
                         }
@@ -271,17 +284,19 @@ var CheckerProgrammer;
                             });
                         };
                     };
+                    // SETS
                     if (meta.sets.length) {
-                        var install = prepare((0, check_native_1.check_native)("Set")(input), meta.sets
+                        var install = prepare((0, check_native_1.check_native)(p.tsc)("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(project)(config)(importer)(input, meta.sets, __assign(__assign({}, explore), { from: "array" }), [], []));
+                            install(explore_sets(p)(config)(importer)(input, meta.sets, __assign(__assign({}, explore), { from: "array" }), [], []));
                     }
+                    // MAPS
                     if (meta.maps.length) {
-                        var install = prepare((0, check_native_1.check_native)("Map")(input), meta.maps
+                        var install = prepare((0, check_native_1.check_native)(p.tsc)("Map")(input), meta.maps
                             .map(function (_a) {
                             var key = _a.key, value = _a.value;
                             return "Map<".concat(key, ", ").concat(value, ">");
@@ -290,10 +305,11 @@ var CheckerProgrammer;
                         if (meta.maps.some(function (elem) { return elem.key.any && elem.value.any; }))
                             install(null);
                         else
-                            install(explore_maps(project)(config)(importer)(input, meta.maps.map(function (m) { return [m.key, m.value]; }), __assign(__assign({}, explore), { from: "array" }), [], []));
+                            install(explore_maps(p)(config)(importer)(input, meta.maps.map(function (m) { return [m.key, m.value]; }), __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)(importer)(meta.tuples.length === 0 ? metaTags : [])(jsDocTags)(input))(input), __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false).map(function (elem) {
+                        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(); })
@@ -302,16 +318,18 @@ var CheckerProgrammer;
                         })
                             .join(" | "));
                         if (meta.arrays.length === 0)
-                            install(explore_tuples(project)(config)(importer)(input, meta.tuples, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            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; }))
                             install(null);
                         else if (meta.tuples.length === 0)
-                            install(explore_arrays(project, config, importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            // ARRAY ONLY
+                            install(explore_arrays(p)(config)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
                         else
-                            install(explore_arrays_and_tuples(project, config, importer)(input, __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false), explore, metaTags, jsDocTags));
+                            install(explore_arrays_and_tuples(p)(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({
+                        prepare(ExpressionFactory_1.ExpressionFactory.isObject(p.tsc)({
                             checkNull: true,
                             checkArray: meta.objects.some(function (obj) {
                                 return obj.properties.every(function (prop) {
@@ -319,7 +337,7 @@ var CheckerProgrammer;
                                         !prop.value.required;
                                 });
                             }),
-                        })(input), meta.objects.map(function (obj) { return obj.name; }).join(" | "))(explore_objects(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" })));
+                        })(input), meta.objects.map(function (obj) { return obj.name; }).join(" | "))(explore_objects(p.tsc)(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" })));
                     if (instances.length) {
                         var transformer = function (merger) {
                             return function (ins) {
@@ -343,10 +361,13 @@ var CheckerProgrammer;
                             })(instances[0]));
                         else
                             binaries.push({
-                                expression: config.combiner(explore)("or")(input, instances.map(transformer(tsclibrary_1.default.factory.createLogicalAnd)), meta.getName()),
+                                expression: config.combiner(explore)("or")(input, instances.map(transformer(p.tsc.factory.createLogicalAnd)), meta.getName()),
                                 combined: true,
                             });
                     }
+                    //----
+                    // COMBINE CONDITIONS
+                    //----
                     return top.length && binaries.length
                         ? config.combiner(explore)("and")(input, __spreadArray(__spreadArray([], __read(top), false), [
                             {
@@ -361,7 +382,7 @@ var CheckerProgrammer;
             };
         };
     };
-    CheckerProgrammer.decode_tuple = function (project) {
+    CheckerProgrammer.decode_tuple = function (p) {
         return function (config) {
             return function (importer) {
                 return function (checkLength) {
@@ -369,34 +390,35 @@ var CheckerProgrammer;
                         var binaries = tuple
                             .filter(function (meta) { return meta.rest === null; })
                             .map(function (meta, index) {
-                            return CheckerProgrammer.decode(project)(config)(importer)(tsclibrary_1.default.factory.createElementAccessExpression(input, index), meta, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
+                            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(project)(config)(importer)(tsclibrary_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("slice"), undefined, [
-                                tsclibrary_1.default.factory.createNumericLiteral(tuple.length - 1),
+                            ? 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 = tsclibrary_1.default.factory.createPropertyAccessExpression(input, "length");
+                        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: tsclibrary_1.default.factory.createStrictEquality(arrayLength, tsclibrary_1.default.factory.createNumericLiteral(tuple.length)),
+                                        expression: p.tsc.factory.createStrictEquality(arrayLength, p.tsc.factory.createNumericLiteral(tuple.length)),
                                     },
                                 ]
                                 : [
                                     {
                                         combined: false,
-                                        expression: tsclibrary_1.default.factory.createLogicalAnd(tsclibrary_1.default.factory.createLessThanEquals(tsclibrary_1.default.factory.createNumericLiteral(tuple.filter(function (t) {
-                                            return t.optional === false;
-                                        }).length), arrayLength), tsclibrary_1.default.factory.createGreaterThanEquals(tsclibrary_1.default.factory.createNumericLiteral(tuple.length), arrayLength)),
+                                        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
@@ -422,144 +444,138 @@ var CheckerProgrammer;
             };
         };
     };
-    var decode_array = function (project) {
-        return function (config) {
-            return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.decode_array({
-                    trace: config.trace,
-                    path: config.path,
-                    decoder: CheckerProgrammer.decode(project)(config)(importer),
-                })(importer)(config.joiner.array);
-            };
-        };
-    };
-    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 explore_sets = function (project) {
+    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) {
         return function (config) {
             return function (importer) {
-                return 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 tsclibrary_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                    },
-                });
-            };
-        };
-    };
-    var explore_maps = function (project) {
-        return function (config) {
-            return function (importer) {
-                return UnionExplorer_1.UnionExplorer.map({
-                    checker: function (input, entry, explore) {
-                        var func = CheckerProgrammer.decode(project)(config)(importer);
-                        return tsclibrary_1.default.factory.createLogicalAnd(func(tsclibrary_1.default.factory.createElementAccessExpression(input, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }), [], []), func(tsclibrary_1.default.factory.createElementAccessExpression(input, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }), [], []));
-                    },
-                    decoder: function (input, target, explore) {
-                        return decode_array(project)(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 tsclibrary_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                    },
-                });
-            };
-        };
-    };
-    var explore_tuples = function (project) {
-        return function (config) {
-            return function (importer) {
-                return UnionExplorer_1.UnionExplorer.tuple({
-                    checker: (0, check_union_tuple_1.check_union_tuple)(project)(config)(importer),
-                    decoder: CheckerProgrammer.decode_tuple(project)(config)(importer)(true),
-                    empty: config.success,
-                    success: config.success,
-                    failure: function (input, expected, explore) {
-                        return tsclibrary_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                    },
-                });
+                var func = FeatureProgrammer_1.FeatureProgrammer.decode_object(tsc)(config)(importer);
+                return function (input, obj, explore) {
+                    obj.validated = true;
+                    return func(input, obj, explore);
+                };
             };
         };
     };
-    var explore_arrays = function (project, config, importer) {
-        return UnionExplorer_1.UnionExplorer.array({
-            checker: CheckerProgrammer.decode(project)(config)(importer),
-            decoder: decode_array(project)(config)(importer),
+    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 tsclibrary_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                return p.tsc.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
             },
         });
-    };
-    var explore_arrays_and_tuples = function (project, config, importer) {
-        return UnionExplorer_1.UnionExplorer.array_or_tuple({
+    }; }; };
+    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)(project)(config)(importer)(front, target, explore, tags, jsDocTags, array)
+                    ? (0, check_union_tuple_1.check_union_tuple)(p)(config)(importer)(front, target, explore, tags, jsDocTags, array)
                     : 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),
+                        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(project)(config)(importer)(true)(input, target, explore, tags, jsDocTags)
-                    : decode_array(project)(config)(importer)(input, target, explore, tags, jsDocTags);
+                    ? 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 tsclibrary_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                return p.tsc.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
             },
         });
-    };
-    var explore_objects = function (config) { return function (importer) {
-        var objector = CheckerProgrammer.decode_object(config)(importer);
-        return function (input, meta, explore) {
-            if (meta.objects.length === 1)
-                return objector(input, meta.objects[0], explore);
-            return tsclibrary_1.default.factory.createCallExpression(tsclibrary_1.default.factory.createIdentifier(importer.useLocal("".concat(config.unioners).concat(meta.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.get_object_arguments(config)(explore)(input));
+    }; }; };
+    var explore_objects = function (tsc) {
+        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));
+                };
+            };
         };
-    }; };
+    };
 })(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
-                ? tsclibrary_1.default.factory.createStrictEquality
-                : tsclibrary_1.default.factory.createStrictInequality;
-            binaries.push({
-                expression: factory(left, right),
-                combined: false,
-            });
+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,
+                });
+            };
         };
     };
 };