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

package/lib/programmers/PruneProgrammer.js

@@ -46,12 +46,17 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PruneProgrammer = void 0;
+var typescript_1 = __importDefault(require("typescript"));
 var ExpressionFactory_1 = require("../factories/ExpressionFactory");
 var IdentifierFactory_1 = require("../factories/IdentifierFactory");
 var MetadataCollection_1 = require("../factories/MetadataCollection");
 var MetadataFactory_1 = require("../factories/MetadataFactory");
+var StatementFactory_1 = require("../factories/StatementFactory");
 var TypeFactory_1 = require("../factories/TypeFactory");
 var Metadata_1 = require("../metadata/Metadata");
 var FeatureProgrammer_1 = require("./FeatureProgrammer");
@@ -60,270 +65,340 @@ var FunctionImporeter_1 = require("./helpers/FunctionImporeter");
 var PruneJoiner_1 = require("./helpers/PruneJoiner");
 var UnionExplorer_1 = require("./helpers/UnionExplorer");
 var decode_union_object_1 = require("./internal/decode_union_object");
+var wrap_metadata_rest_tuple_1 = require("./internal/wrap_metadata_rest_tuple");
 var PruneProgrammer;
 (function (PruneProgrammer) {
-    /**
-     * @deprecated Use `write()` function instead
-     */
     PruneProgrammer.generate = function (project, modulo) {
         return function (type, name) {
             return PruneProgrammer.write(project)(modulo)(type, name);
         };
     };
-    PruneProgrammer.write = function (p) { return function (modulo) {
-        var importer = new FunctionImporeter_1.FunctionImporter(p.tsc);
-        return FeatureProgrammer_1.FeatureProgrammer.analyze(p)(__assign(__assign({}, configure(p)(importer)), { addition: function (collection) {
-                var isFunctors = IsProgrammer_1.IsProgrammer.write_functors(p)(importer)(collection);
-                var isUnioners = IsProgrammer_1.IsProgrammer.write_unioners(p)(importer)(collection);
-                return __spreadArray(__spreadArray(__spreadArray([], __read(importer.declare(modulo)), false), __read(isFunctors.filter(function (_, i) {
-                    return importer.hasLocal("$io".concat(i));
-                })), false), __read(isUnioners.filter(function (_, i) {
-                    return importer.hasLocal("$iu".concat(i));
-                })), false);
-            } }))(importer);
+    PruneProgrammer.write = function (project) { return function (modulo) {
+        var importer = new FunctionImporeter_1.FunctionImporter();
+        return FeatureProgrammer_1.FeatureProgrammer.write(project)(__assign(__assign({}, configure(project)(importer)), { addition: function (collection) { return __spreadArray(__spreadArray([], __read(IsProgrammer_1.IsProgrammer.write_function_statements(project)(importer)(collection)), false), __read(importer.declare(modulo)), false); } }))(importer);
     }; };
-    /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-    var decode = function (p) {
+    var write_array_functions = function (config) {
         return function (importer) {
-            return function (input, meta, explore) {
-                var e_1, _a, e_2, _b;
-                var tsc = p.tsc;
-                if (filter(meta) === false)
-                    return tsc.factory.createBlock([]);
-                var unions = [];
-                var _loop_1 = function (tuple) {
-                    unions.push({
-                        type: "tuple",
-                        is: function () {
-                            return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, (function () {
-                                var partial = Metadata_1.Metadata.initialize();
-                                partial.tuples.push(tuple);
-                                return partial;
-                            })(), explore, [], []);
-                        },
-                        value: function () {
-                            return decode_tuple(p)(importer)(input, tuple, explore);
-                        },
+            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(config)(importer)(typescript_1.default.factory.createIdentifier("input"), array, {
+                        tracable: config.trace,
+                        source: "function",
+                        from: "array",
+                        postfix: "",
+                    })));
+                });
+            };
+        };
+    };
+    var 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: "",
+                        })));
                     });
                 };
-                try {
-                    //----
-                    // LIST UP UNION TYPES
-                    //----
-                    // TUPLES
-                    for (var _c = __values(meta.tuples.filter(function (t) {
-                        return t.some(function (e) { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); });
-                    })), _d = _c.next(); !_d.done; _d = _c.next()) {
-                        var tuple = _d.value;
-                        _loop_1(tuple);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                // ARRAYS
-                if (meta.arrays.filter(filter).length)
-                    unions.push({
-                        type: "array",
-                        is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(tsc)(input); },
-                        value: function () {
-                            return explore_arrays(p)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), [], []);
-                        },
-                    });
-                // BUILT-IN CLASSES
-                if (meta.natives.length) {
-                    var _loop_2 = function (native) {
+            };
+        };
+    };
+    var decode = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, meta, explore) {
+                    var e_1, _a, e_2, _b;
+                    if (filter(meta) === false)
+                        return typescript_1.default.factory.createBlock([]);
+                    var unions = [];
+                    var _loop_1 = function (tuple) {
                         unions.push({
-                            type: "native",
+                            type: "tuple",
                             is: function () {
-                                return ExpressionFactory_1.ExpressionFactory.isInstanceOf(tsc)(native)(input);
+                                return IsProgrammer_1.IsProgrammer.decode(project)(importer)(input, (function () {
+                                    var partial = Metadata_1.Metadata.initialize();
+                                    partial.tuples.push(tuple);
+                                    return partial;
+                                })(), explore, [], []);
+                            },
+                            value: function () {
+                                return decode_tuple(project)(config)(importer)(input, tuple, explore);
                             },
-                            value: function () { return tsc.factory.createReturnStatement(); },
                         });
                     };
                     try {
-                        for (var _e = __values(meta.natives), _f = _e.next(); !_f.done; _f = _e.next()) {
-                            var native = _f.value;
-                            _loop_2(native);
+                        for (var _c = __values(meta.tuples.filter(function (t) {
+                            return t.elements.some(function (e) { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); });
+                        })), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var tuple = _d.value;
+                            _loop_1(tuple);
                         }
                     }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
                     finally {
                         try {
-                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                         }
-                        finally { if (e_2) throw e_2.error; }
+                        finally { if (e_1) throw e_1.error; }
                     }
-                }
-                if (meta.sets.length)
-                    unions.push({
-                        type: "set",
-                        is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf(tsc)("Set")(input); },
-                        value: function () { return tsc.factory.createReturnStatement(); },
-                    });
-                if (meta.maps.length)
-                    unions.push({
-                        type: "map",
-                        is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf(tsc)("Map")(input); },
-                        value: function () { return tsc.factory.createReturnStatement(); },
-                    });
-                // OBJECTS
-                if (meta.objects.length)
-                    unions.push({
-                        type: "object",
-                        is: function () {
-                            return ExpressionFactory_1.ExpressionFactory.isObject(tsc)({
-                                checkNull: true,
-                                checkArray: false,
-                            })(input);
-                        },
-                        value: function () {
-                            return explore_objects(tsc)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" }));
-                        },
+                    if (meta.arrays.filter(function (a) { return filter(a.value); }).length)
+                        unions.push({
+                            type: "array",
+                            is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(input); },
+                            value: function () {
+                                return explore_arrays(project)(config)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }));
+                            },
+                        });
+                    if (meta.natives.length) {
+                        var _loop_2 = function (native) {
+                            unions.push({
+                                type: "native",
+                                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf(native)(input); },
+                                value: function () { return typescript_1.default.factory.createReturnStatement(); },
+                            });
+                        };
+                        try {
+                            for (var _e = __values(meta.natives), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                var native = _f.value;
+                                _loop_2(native);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                    if (meta.sets.length)
+                        unions.push({
+                            type: "set",
+                            is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set")(input); },
+                            value: function () { return typescript_1.default.factory.createReturnStatement(); },
+                        });
+                    if (meta.maps.length)
+                        unions.push({
+                            type: "map",
+                            is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map")(input); },
+                            value: function () { return typescript_1.default.factory.createReturnStatement(); },
+                        });
+                    if (meta.objects.length)
+                        unions.push({
+                            type: "object",
+                            is: function () {
+                                return ExpressionFactory_1.ExpressionFactory.isObject({
+                                    checkNull: true,
+                                    checkArray: false,
+                                })(input);
+                            },
+                            value: function () {
+                                return explore_objects(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" }));
+                            },
+                        });
+                    var converter = function (v) {
+                        return typescript_1.default.isReturnStatement(v) || typescript_1.default.isBlock(v)
+                            ? v
+                            : typescript_1.default.factory.createExpressionStatement(v);
+                    };
+                    var statements = unions.map(function (u) {
+                        return typescript_1.default.factory.createIfStatement(u.is(), converter(u.value()));
                     });
-                //----
-                // STATEMENTS
-                //----
-                var converter = function (v) {
-                    return tsc.isReturnStatement(v) || tsc.isBlock(v)
-                        ? v
-                        : tsc.factory.createExpressionStatement(v);
+                    return typescript_1.default.factory.createBlock(statements, true);
                 };
-                var statements = unions.map(function (u) {
-                    return tsc.factory.createIfStatement(u.is(), converter(u.value()));
-                });
-                return tsc.factory.createBlock(statements, true);
             };
         };
     };
-    var decode_tuple = function (p) {
+    var decode_object = function (importer) {
+        return FeatureProgrammer_1.FeatureProgrammer.decode_object({
+            trace: false,
+            path: false,
+            prefix: PREFIX,
+        })(importer);
+    };
+    var decode_array = function (config) {
         return function (importer) {
-            return function (input, tuple, explore) {
-                var children = tuple
-                    .map(function (elem, index) { return [elem, index]; })
-                    .filter(function (_a) {
-                    var _b = __read(_a, 1), elem = _b[0];
-                    return filter(elem) && elem.rest === null;
-                })
-                    .map(function (_a) {
-                    var _b = __read(_a, 2), elem = _b[0], index = _b[1];
-                    return decode(p)(importer)(p.tsc.factory.createElementAccessExpression(input, index), elem, __assign(__assign({}, explore), { from: "array" }));
-                });
-                var rest = (function () {
-                    if (tuple.length === 0)
-                        return null;
-                    var last = tuple[tuple.length - 1];
-                    var rest = last.rest;
-                    if (rest === null || filter(rest) === false)
-                        return null;
-                    return decode(p)(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(rest);
-                        return wrapper;
-                    })(), __assign(__assign({}, explore), { start: tuple.length - 1 }));
-                })();
-                return PruneJoiner_1.PruneJoiner.tuple(p.tsc)(children, rest);
+            return function (input, array, explore) {
+                return array.recursive
+                    ? 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))
+                    : decode_array_inline(config)(importer)(input, array, explore);
             };
         };
     };
-    var decode_array = function (p) { return function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_array(p.tsc)(configure(p)(importer))(importer)(PruneJoiner_1.PruneJoiner.array(p.tsc));
-    }; };
-    var decode_object = function (tsc) { return function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_object(tsc)({
-            trace: false,
-            path: false,
-            functors: FUNCTORS,
-        })(importer);
-    }; };
-    var explore_arrays = function (p) { return function (importer) {
-        return UnionExplorer_1.UnionExplorer.array(p.tsc)({
-            checker: IsProgrammer_1.IsProgrammer.decode(p)(importer),
-            decoder: decode_array(p)(importer),
-            empty: p.tsc.factory.createReturnStatement(),
-            success: p.tsc.factory.createTrue(),
-            failure: function (input, expected) {
-                return create_throw_error(p.tsc)(importer)(expected)(input);
-            },
-        });
-    }; };
-    var explore_objects = function (tsc) {
+    var decode_array_inline = function (config) {
+        return function (importer) {
+            return function (input, array, explore) {
+                return FeatureProgrammer_1.FeatureProgrammer.decode_array(config)(importer)(PruneJoiner_1.PruneJoiner.array)(input, array, explore, [], []);
+            };
+        };
+    };
+    var decode_tuple = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, tuple, explore) {
+                    return tuple.recursive
+                        ? 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))
+                        : decode_tuple_inline(project)(config)(importer)(input, tuple, explore);
+                };
+            };
+        };
+    };
+    var decode_tuple_inline = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, tuple, explore) {
+                    var children = tuple.elements
+                        .map(function (elem, index) { return [elem, index]; })
+                        .filter(function (_a) {
+                        var _b = __read(_a, 1), elem = _b[0];
+                        return filter(elem) && elem.rest === null;
+                    })
+                        .map(function (_a) {
+                        var _b = __read(_a, 2), elem = _b[0], index = _b[1];
+                        return decode(project)(config)(importer)(typescript_1.default.factory.createElementAccessExpression(input, index), elem, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
+                                ? "".concat(explore.postfix.slice(0, -1), "[").concat(index, "]\"")
+                                : "\"[".concat(index, "]\"") }));
+                    });
+                    var rest = (function () {
+                        if (tuple.elements.length === 0)
+                            return null;
+                        var last = tuple.elements.at(-1);
+                        var rest = last.rest;
+                        if (rest === null || filter(rest) === false)
+                            return null;
+                        return 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 }));
+                    })();
+                    return PruneJoiner_1.PruneJoiner.tuple(children, rest);
+                };
+            };
+        };
+    };
+    var explore_objects = function (config) {
         return function (importer) {
             return function (input, meta, explore) {
                 if (meta.objects.length === 1)
-                    return decode_object(tsc)(importer)(input, meta.objects[0], explore);
-                return tsc.factory.createCallExpression(tsc.factory.createIdentifier("".concat(UNIONERS).concat(meta.union_index)), undefined, [input]);
+                    return decode_object(importer)(input, meta.objects[0], explore);
+                return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(PREFIX, "u").concat(meta.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input));
+            };
+        };
+    };
+    var explore_arrays = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, elements, explore) {
+                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array({
+                        checker: IsProgrammer_1.IsProgrammer.decode(project)(importer),
+                        decoder: decode_array(config)(importer),
+                        empty: typescript_1.default.factory.createStringLiteral("[]"),
+                        success: typescript_1.default.factory.createTrue(),
+                        failure: function (input, expected) {
+                            return create_throw_error(importer)(expected)(input);
+                        },
+                    }))(input, elements, explore);
+                };
+            };
+        };
+    };
+    var explore_array_like_union_types = function (config) {
+        return function (importer) {
+            return function (factory) {
+                return function (input, elements, explore) {
+                    var arrow = function (parameters) {
+                        return function (explore) {
+                            return function (input) {
+                                return factory(parameters)(input, elements, explore, [], []);
+                            };
+                        };
+                    };
+                    if (elements.every(function (e) { return e.recursive === false; }))
+                        typescript_1.default.factory.createCallExpression(arrow([])(explore)(input), undefined, []);
+                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
+                    return 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));
+                };
             };
         };
     };
     var filter = function (meta) {
         return meta.any === false &&
             (meta.objects.length !== 0 ||
-                meta.tuples.some(function (t) { return t.some(function (e) { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); }); }) ||
-                meta.arrays.some(function (e) { return filter(e); }));
+                meta.tuples.some(function (t) {
+                    return t.elements.some(function (e) { var _a; return filter((_a = e.rest) !== null && _a !== void 0 ? _a : e); });
+                }) ||
+                meta.arrays.some(function (e) { return filter(e.value); }));
     };
-    /* -----------------------------------------------------------
-        CONFIGURATIONS
-    ----------------------------------------------------------- */
-    var FUNCTORS = "$po";
-    var UNIONERS = "$pu";
-    var configure = function (p) {
-        return function (importer) { return ({
-            types: {
-                input: function (type, name) {
-                    return p.tsc.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(p)(type));
+    var PREFIX = "$p";
+    var configure = function (project) {
+        return function (importer) {
+            var config = {
+                types: {
+                    input: function (type, name) {
+                        return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(project.checker)(type));
+                    },
+                    output: function () { return TypeFactory_1.TypeFactory.keyword("void"); },
                 },
-                output: function () { return TypeFactory_1.TypeFactory.keyword(p.tsc)("void"); },
-            },
-            functors: FUNCTORS,
-            unioners: UNIONERS,
-            trace: false,
-            path: false,
-            initializer: initializer,
-            decoder: decode(p)(importer),
-            objector: objector(p)(importer),
-        }); };
+                prefix: PREFIX,
+                trace: false,
+                path: false,
+                initializer: initializer,
+                decoder: function () { return decode(project)(config)(importer); },
+                objector: {
+                    checker: function () { return IsProgrammer_1.IsProgrammer.decode(project)(importer); },
+                    decoder: function () { return decode_object(importer); },
+                    joiner: PruneJoiner_1.PruneJoiner.object,
+                    unionizer: (0, decode_union_object_1.decode_union_object)(IsProgrammer_1.IsProgrammer.decode_object(importer))(decode_object(importer))(function (exp) { return exp; })(function (value, expected) {
+                        return create_throw_error(importer)(expected)(value);
+                    }),
+                    failure: function (input, expected) {
+                        return create_throw_error(importer)(expected)(input);
+                    },
+                },
+                generator: {
+                    arrays: function () { return write_array_functions(config)(importer); },
+                    tuples: function () {
+                        return write_tuple_functions(project)(config)(importer);
+                    },
+                },
+            };
+            return config;
+        };
     };
-    var objector = function (p) {
-        return function (importer) { return ({
-            checker: IsProgrammer_1.IsProgrammer.decode(p)(importer),
-            decoder: decode_object(p.tsc)(importer),
-            joiner: PruneJoiner_1.PruneJoiner.object(p.tsc),
-            unionizer: (0, decode_union_object_1.decode_union_object)(p.tsc)(IsProgrammer_1.IsProgrammer.decode_object(p.tsc)(importer))(decode_object(p.tsc)(importer))(function (exp) { return exp; })(function (value, expected) {
-                return create_throw_error(p.tsc)(importer)(expected)(value);
-            }),
-            failure: function (input, expected) {
-                return create_throw_error(p.tsc)(importer)(expected)(input);
-            },
-        }); };
+    var 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,
+            })(collection)(type);
+            return [collection, meta];
+        };
     };
-    var 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];
-    }; };
-    var create_throw_error = function (tsc) {
-        return function (importer) {
-            return function (expected) {
-                return function (value) {
-                    return tsc.factory.createExpressionStatement(tsc.factory.createCallExpression(importer.use("throws"), [], [
-                        tsc.factory.createObjectLiteralExpression([
-                            tsc.factory.createPropertyAssignment("expected", tsc.factory.createStringLiteral(expected)),
-                            tsc.factory.createPropertyAssignment("value", value),
-                        ], true),
-                    ]));
-                };
+    var create_throw_error = function (importer) {
+        return function (expected) {
+            return function (value) {
+                return typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(importer.use("throws"), [], [
+                    typescript_1.default.factory.createObjectLiteralExpression([
+                        typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(expected)),
+                        typescript_1.default.factory.createPropertyAssignment("value", value),
+                    ], true),
+                ]));
             };
         };
     };
-})(PruneProgrammer || (exports.PruneProgrammer = PruneProgrammer = {}));
+})(PruneProgrammer = exports.PruneProgrammer || (exports.PruneProgrammer = {}));
 //# sourceMappingURL=PruneProgrammer.js.map