typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/lib/programmers/StringifyProgrammer.js

@@ -46,12 +46,8 @@ 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.StringifyProgrammer = 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");
@@ -73,16 +69,14 @@ var decode_union_object_1 = require("./internal/decode_union_object");
 var feature_object_entries_1 = require("./internal/feature_object_entries");
 var StringifyProgrammer;
 (function (StringifyProgrammer) {
-    StringifyProgrammer.generate = function (project, modulo) {
-        return function (type, name) {
-            return StringifyProgrammer.write(project)(modulo)(type, name);
-        };
-    };
-    StringifyProgrammer.write = function (project) { return function (modulo) {
-        var importer = new FunctionImporeter_1.FunctionImporter();
-        return FeatureProgrammer_1.FeatureProgrammer.analyze(project)(__assign(__assign({}, configure(project)(importer)), { addition: function (collection) {
-                var isFunctors = IsProgrammer_1.IsProgrammer.write_functors(project)(importer)(collection);
-                var isUnioners = IsProgrammer_1.IsProgrammer.write_unioners(project)(importer)(collection);
+    /* -----------------------------------------------------------
+        WRITER
+    ----------------------------------------------------------- */
+    StringifyProgrammer.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) {
@@ -90,298 +84,330 @@ var StringifyProgrammer;
                 })), false);
             } }))(importer);
     }; };
-    var decode = function (project, importer) {
-        return function (input, meta, explore, tags) {
-            var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e;
-            if (meta.any === true)
-                return wrap_required(input, meta, explore)(wrap_functional(input, meta, explore)(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("JSON.stringify"), undefined, [input])));
-            var size = meta.size();
-            if (size === 0 &&
-                (meta.required === false || meta.nullable === true)) {
-                if (meta.required === false && meta.nullable === true)
-                    return explore.from === "array"
-                        ? typescript_1.default.factory.createStringLiteral("null")
-                        : typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createNull(), input), undefined, typescript_1.default.factory.createStringLiteral("null"), undefined, typescript_1.default.factory.createIdentifier("undefined"));
-                else if (meta.required === false)
-                    return explore.from === "array"
-                        ? typescript_1.default.factory.createStringLiteral("null")
-                        : typescript_1.default.factory.createIdentifier("undefined");
-                else
-                    return typescript_1.default.factory.createStringLiteral("null");
-            }
-            var unions = [];
-            if (meta.resolved !== null)
-                if (size === 1)
-                    return decode_to_json(project, importer)(input, meta.resolved, explore, tags);
-                else
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    var decode = function (p) {
+        return function (importer) {
+            return function (input, meta, explore, tags) {
+                var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e;
+                // ANY TYPE
+                if (meta.any === true)
+                    return wrap_required(p.tsc)(input, meta, explore)(wrap_functional(p.tsc)(input, meta, explore)(p.tsc.factory.createCallExpression(p.tsc.factory.createIdentifier("JSON.stringify"), undefined, [input])));
+                // ONLY NULL OR UNDEFINED
+                var size = meta.size();
+                if (size === 0 &&
+                    (meta.required === false || meta.nullable === true)) {
+                    if (meta.required === false && meta.nullable === true)
+                        return explore.from === "array"
+                            ? p.tsc.factory.createStringLiteral("null")
+                            : p.tsc.factory.createConditionalExpression(p.tsc.factory.createStrictEquality(p.tsc.factory.createNull(), input), undefined, p.tsc.factory.createStringLiteral("null"), undefined, p.tsc.factory.createIdentifier("undefined"));
+                    else if (meta.required === false)
+                        return explore.from === "array"
+                            ? p.tsc.factory.createStringLiteral("null")
+                            : p.tsc.factory.createIdentifier("undefined");
+                    else
+                        return p.tsc.factory.createStringLiteral("null");
+                }
+                //----
+                // LIST UP UNION TYPES
+                //----
+                var unions = [];
+                // toJSON() METHOD
+                if (meta.resolved !== null)
+                    if (size === 1)
+                        return decode_to_json(p)(importer)(input, meta.resolved, explore, tags);
+                    else
+                        unions.push({
+                            type: "resolved",
+                            is: function () {
+                                return IsProgrammer_1.IsProgrammer.decode_to_json(p.tsc)(false)(input);
+                            },
+                            value: function () {
+                                return decode_to_json(p)(importer)(input, meta.resolved, explore, tags);
+                            },
+                        });
+                else if (meta.functional === true)
                     unions.push({
-                        type: "resolved",
-                        is: function () { return IsProgrammer_1.IsProgrammer.decode_to_json(false)(input); },
-                        value: function () {
-                            return decode_to_json(project, importer)(input, meta.resolved, explore, tags);
-                        },
+                        type: "functional",
+                        is: function () { return IsProgrammer_1.IsProgrammer.decode_functional(p.tsc)(input); },
+                        value: function () { return decode_functional(p.tsc)(explore); },
                     });
-            else if (meta.functional === true)
-                unions.push({
-                    type: "functional",
-                    is: function () { return IsProgrammer_1.IsProgrammer.decode_functional(input); },
-                    value: function () { return decode_functional(explore); },
-                });
-            if (meta.templates.length ||
-                ArrayUtil_1.ArrayUtil.has(meta.constants, function (c) { return c.type === "string"; }))
-                if (AtomicPredicator_1.AtomicPredicator.template(meta)) {
-                    var partial_1 = Metadata_1.Metadata.initialize();
-                    partial_1.atomics.push("string"),
+                // TEMPLATES
+                if (meta.templates.length ||
+                    ArrayUtil_1.ArrayUtil.has(meta.constants, function (c) { return c.type === "string"; }))
+                    if (AtomicPredicator_1.AtomicPredicator.template(meta)) {
+                        var partial_1 = Metadata_1.Metadata.initialize();
+                        partial_1.atomics.push("string"),
+                            unions.push({
+                                type: "template literal",
+                                is: function () {
+                                    return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, partial_1, explore, [], []);
+                                },
+                                value: function () {
+                                    return decode_atomic(p)(importer)(input, "string", explore);
+                                },
+                            });
+                    }
+                var _loop_1 = function (constant) {
+                    if (AtomicPredicator_1.AtomicPredicator.constant(meta)(constant.type) === false)
+                        return "continue";
+                    else if (constant.type !== "string")
                         unions.push({
-                            type: "template literal",
+                            type: "atomic",
                             is: function () {
-                                return IsProgrammer_1.IsProgrammer.decode(project, importer)(input, partial_1, explore, [], []);
+                                return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, (function () {
+                                    var partial = Metadata_1.Metadata.initialize();
+                                    partial.atomics.push(constant.type);
+                                    return partial;
+                                })(), explore, [], []);
                             },
                             value: function () {
-                                return decode_atomic(project)(importer)(input, "string", explore, tags);
+                                return decode_atomic(p)(importer)(input, constant.type, explore);
                             },
                         });
+                    else if (meta.templates.length === 0)
+                        unions.push({
+                            type: "const string",
+                            is: function () {
+                                return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, (function () {
+                                    var partial = Metadata_1.Metadata.initialize();
+                                    partial.atomics.push("string");
+                                    return partial;
+                                })(), explore, [], []);
+                            },
+                            value: function () {
+                                return decode_constant_string(p)(importer)(input, __spreadArray([], __read(constant.values), false), explore);
+                            },
+                        });
+                };
+                try {
+                    // CONSTANTS
+                    for (var _f = __values(meta.constants), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var constant = _g.value;
+                        _loop_1(constant);
+                    }
                 }
-            var _loop_1 = function (constant) {
-                if (AtomicPredicator_1.AtomicPredicator.constant(meta)(constant.type) === false)
-                    return "continue";
-                else if (constant.type !== "string")
-                    unions.push({
-                        type: "atomic",
-                        is: function () {
-                            return IsProgrammer_1.IsProgrammer.decode(project, importer)(input, (function () {
-                                var partial = Metadata_1.Metadata.initialize();
-                                partial.atomics.push(constant.type);
-                                return partial;
-                            })(), explore, [], []);
-                        },
-                        value: function () {
-                            return decode_atomic(project)(importer)(input, constant.type, explore, tags);
-                        },
-                    });
-                else if (meta.templates.length === 0)
-                    unions.push({
-                        type: "const string",
-                        is: function () {
-                            return IsProgrammer_1.IsProgrammer.decode(project, importer)(input, (function () {
-                                var partial = Metadata_1.Metadata.initialize();
-                                partial.atomics.push("string");
-                                return partial;
-                            })(), explore, [], []);
-                        },
-                        value: function () {
-                            return decode_constant_string(project)(importer)(input, __spreadArray([], __read(constant.values), false), explore);
-                        },
-                    });
-            };
-            try {
-                for (var _f = __values(meta.constants), _g = _f.next(); !_g.done; _g = _f.next()) {
-                    var constant = _g.value;
-                    _loop_1(constant);
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
+                var _loop_2 = function (type) {
+                    if (AtomicPredicator_1.AtomicPredicator.atomic(meta)(type))
+                        unions.push({
+                            type: "atomic",
+                            is: function () {
+                                return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, (function () {
+                                    var partial = Metadata_1.Metadata.initialize();
+                                    partial.atomics.push(type);
+                                    return partial;
+                                })(), explore, [], []);
+                            },
+                            value: function () {
+                                return decode_atomic(p)(importer)(input, type, explore);
+                            },
+                        });
+                };
                 try {
-                    if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                    /// ATOMICS
+                    for (var _h = __values(meta.atomics), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        var type = _j.value;
+                        _loop_2(type);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                    }
+                    finally { if (e_2) throw e_2.error; }
                 }
-                finally { if (e_1) throw e_1.error; }
-            }
-            var _loop_2 = function (type) {
-                if (AtomicPredicator_1.AtomicPredicator.atomic(meta)(type))
+                var _loop_3 = function (tuple) {
+                    var e_6, _r;
+                    try {
+                        for (var tuple_1 = (e_6 = void 0, __values(tuple)), tuple_1_1 = tuple_1.next(); !tuple_1_1.done; tuple_1_1 = tuple_1.next()) {
+                            var child = tuple_1_1.value;
+                            if (StringifyPredicator_1.StringifyPredicator.undefindable(meta))
+                                throw new Error("Error on typia.stringify(): tuple cannot contain undefined value - (".concat(child.getName(), ")."));
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (tuple_1_1 && !tuple_1_1.done && (_r = tuple_1.return)) _r.call(tuple_1);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
                     unions.push({
-                        type: "atomic",
+                        type: "tuple",
                         is: function () {
-                            return IsProgrammer_1.IsProgrammer.decode(project, importer)(input, (function () {
+                            return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, (function () {
                                 var partial = Metadata_1.Metadata.initialize();
-                                partial.atomics.push(type);
+                                partial.tuples.push(tuple);
                                 return partial;
                             })(), explore, [], []);
                         },
                         value: function () {
-                            return decode_atomic(project)(importer)(input, type, explore, tags);
+                            return decode_tuple(p)(importer)(input, tuple, explore, tags);
                         },
                     });
-            };
-            try {
-                for (var _h = __values(meta.atomics), _j = _h.next(); !_j.done; _j = _h.next()) {
-                    var type = _j.value;
-                    _loop_2(type);
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            var _loop_3 = function (tuple) {
-                var e_6, _r;
+                };
                 try {
-                    for (var tuple_1 = (e_6 = void 0, __values(tuple)), tuple_1_1 = tuple_1.next(); !tuple_1_1.done; tuple_1_1 = tuple_1.next()) {
-                        var child = tuple_1_1.value;
-                        if (StringifyPredicator_1.StringifyPredicator.undefindable(meta))
-                            throw new Error("Error on typia.stringify(): tuple cannot contain undefined value - (".concat(child.getName(), ")."));
+                    // TUPLES
+                    for (var _k = __values(meta.tuples), _l = _k.next(); !_l.done; _l = _k.next()) {
+                        var tuple = _l.value;
+                        _loop_3(tuple);
                     }
                 }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
                 finally {
                     try {
-                        if (tuple_1_1 && !tuple_1_1.done && (_r = tuple_1.return)) _r.call(tuple_1);
+                        if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
                     }
-                    finally { if (e_6) throw e_6.error; }
+                    finally { if (e_3) throw e_3.error; }
                 }
-                unions.push({
-                    type: "tuple",
-                    is: function () {
-                        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)(importer)(input, tuple, explore, tags);
-                    },
-                });
-            };
-            try {
-                for (var _k = __values(meta.tuples), _l = _k.next(); !_l.done; _l = _k.next()) {
-                    var tuple = _l.value;
-                    _loop_3(tuple);
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            if (meta.arrays.length) {
-                try {
-                    for (var _m = __values(meta.arrays), _o = _m.next(); !_o.done; _o = _m.next()) {
-                        var child = _o.value;
-                        if (StringifyPredicator_1.StringifyPredicator.undefindable(child))
-                            throw new Error("Error on typia.stringify(): array cannot contain undefined value (".concat(child.getName(), ")."));
+                // ARRAYS
+                if (meta.arrays.length) {
+                    try {
+                        for (var _m = __values(meta.arrays), _o = _m.next(); !_o.done; _o = _m.next()) {
+                            var child = _o.value;
+                            if (StringifyPredicator_1.StringifyPredicator.undefindable(child))
+                                throw new Error("Error on typia.stringify(): array cannot contain undefined value (".concat(child.getName(), ")."));
+                        }
                     }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    var value = meta.arrays.some(function (elem) { return elem.any; })
+                        ? function () {
+                            return p.tsc.factory.createCallExpression(p.tsc.factory.createIdentifier("JSON.stringify"), undefined, [input]);
+                        }
+                        : function () {
+                            return explore_arrays(p)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), [], []);
+                        };
+                    unions.push({
+                        type: "array",
+                        is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(p.tsc)(input); },
+                        value: value,
+                    });
                 }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
+                // BUILT-IN CLASSES
+                if (meta.natives.length) {
+                    var _loop_4 = function (native) {
+                        unions.push({
+                            type: "object",
+                            is: function () { return (0, check_native_1.check_native)(p.tsc)(native)(input); },
+                            value: function () {
+                                return AtomicPredicator_1.AtomicPredicator.native(native)
+                                    ? decode_atomic(p)(importer)(input, native.toLowerCase(), explore)
+                                    : p.tsc.factory.createStringLiteral("{}");
+                            },
+                        });
+                    };
                     try {
-                        if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+                        for (var _p = __values(meta.natives), _q = _p.next(); !_q.done; _q = _p.next()) {
+                            var native = _q.value;
+                            _loop_4(native);
+                        }
                     }
-                    finally { if (e_4) throw e_4.error; }
-                }
-                var value = meta.arrays.some(function (elem) { return elem.any; })
-                    ? function () {
-                        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("JSON.stringify"), undefined, [input]);
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
+                        }
+                        finally { if (e_5) throw e_5.error; }
                     }
-                    : function () {
-                        return explore_arrays(project)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), [], []);
-                    };
-                unions.push({
-                    type: "array",
-                    is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(input); },
-                    value: value,
-                });
-            }
-            if (meta.natives.length) {
-                var _loop_4 = function (native) {
+                }
+                // SETS
+                if (meta.sets.length)
                     unions.push({
                         type: "object",
-                        is: function () { return (0, check_native_1.check_native)(native)(input); },
+                        is: function () {
+                            return ExpressionFactory_1.ExpressionFactory.isInstanceOf(p.tsc)("Set")(input);
+                        },
+                        value: function () { return p.tsc.factory.createStringLiteral("{}"); },
+                    });
+                // MAPS
+                if (meta.maps.length)
+                    unions.push({
+                        type: "object",
+                        is: function () {
+                            return ExpressionFactory_1.ExpressionFactory.isInstanceOf(p.tsc)("Map")(input);
+                        },
+                        value: function () { return p.tsc.factory.createStringLiteral("{}"); },
+                    });
+                // OBJECTS
+                if (meta.objects.length)
+                    unions.push({
+                        type: "object",
+                        is: function () {
+                            return ExpressionFactory_1.ExpressionFactory.isObject(p.tsc)({
+                                checkNull: true,
+                                checkArray: meta.objects.some(function (obj) {
+                                    return obj.properties.every(function (prop) {
+                                        return !prop.key.isSoleLiteral() ||
+                                            !prop.value.required;
+                                    });
+                                }),
+                            })(input);
+                        },
                         value: function () {
-                            return AtomicPredicator_1.AtomicPredicator.native(native)
-                                ? decode_atomic(project)(importer)(input, native.toLowerCase(), explore, tags)
-                                : typescript_1.default.factory.createStringLiteral("{}");
+                            return meta.isParentResolved() === false &&
+                                meta.objects.length === 1 &&
+                                meta.objects[0]._Is_simple()
+                                ? (function () {
+                                    var obj = meta.objects[0];
+                                    var entries = (0, feature_object_entries_1.feature_object_entries)(p.tsc)({
+                                        decoder: decode(p)(importer),
+                                        trace: false,
+                                        path: false,
+                                    })(importer)(obj)(input);
+                                    return StringifyJoinder_1.StringifyJoiner.object(p.tsc)(importer)(input, entries);
+                                })()
+                                : explore_objects(p.tsc)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" }));
                         },
                     });
+                //----
+                // RETURNS
+                //----
+                // CHECK NULL AND UNDEFINED
+                var wrapper = function (output) {
+                    return wrap_required(p.tsc)(input, meta, explore)(wrap_nullable(p.tsc)(input, meta)(output));
                 };
-                try {
-                    for (var _p = __values(meta.natives), _q = _p.next(); !_q.done; _q = _p.next()) {
-                        var native = _q.value;
-                        _loop_4(native);
-                    }
-                }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                }
-            }
-            if (meta.sets.length)
-                unions.push({
-                    type: "object",
-                    is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set")(input); },
-                    value: function () { return typescript_1.default.factory.createStringLiteral("{}"); },
-                });
-            if (meta.maps.length)
-                unions.push({
-                    type: "object",
-                    is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map")(input); },
-                    value: function () { return typescript_1.default.factory.createStringLiteral("{}"); },
-                });
-            if (meta.objects.length)
-                unions.push({
-                    type: "object",
-                    is: function () {
-                        return ExpressionFactory_1.ExpressionFactory.isObject({
-                            checkNull: true,
-                            checkArray: meta.objects.some(function (obj) {
-                                return obj.properties.every(function (prop) {
-                                    return !prop.key.isSoleLiteral() ||
-                                        !prop.value.required;
-                                });
-                            }),
-                        })(input);
-                    },
-                    value: function () {
-                        return meta.isParentResolved() === false &&
-                            meta.objects.length === 1 &&
-                            meta.objects[0]._Is_simple()
-                            ? (function () {
-                                var obj = meta.objects[0];
-                                var entries = (0, feature_object_entries_1.feature_object_entries)({
-                                    decoder: decode(project, importer),
-                                    trace: false,
-                                    path: false,
-                                })(importer)(obj)(input);
-                                return StringifyJoinder_1.StringifyJoiner.object(importer)(input, entries);
-                            })()
-                            : explore_objects(importer)(input, meta, __assign(__assign({}, explore), { from: "object" }));
-                    },
-                });
-            var wrapper = function (output) {
-                return wrap_required(input, meta, explore)(wrap_nullable(input, meta)(output));
+                // DIRECT RETURN
+                if (unions.length === 0)
+                    return p.tsc.factory.createCallExpression(p.tsc.factory.createIdentifier("JSON.stringify"), undefined, [input]);
+                else if (unions.length === 1)
+                    return wrapper(unions[0].value());
+                // RETURN WITH TYPE CHECKING
+                return wrapper(p.tsc.factory.createCallExpression(p.tsc.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, iterate(p.tsc)(importer)(input, unions, meta.getName())), undefined, undefined));
             };
-            if (unions.length === 0)
-                return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("JSON.stringify"), undefined, [input]);
-            else if (unions.length === 1)
-                return wrapper(unions[0].value());
-            return wrapper(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, iterate(importer, input, unions, meta.getName())), undefined, undefined));
         };
     };
-    var decode_array = function (project) { return function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_array(configure(project)(importer))(importer)(StringifyJoinder_1.StringifyJoiner.array);
+    var decode_array = function (p) { return function (importer) {
+        return FeatureProgrammer_1.FeatureProgrammer.decode_array(p.tsc)(configure(p)(importer))(importer)(StringifyJoinder_1.StringifyJoiner.array(p.tsc));
     }; };
-    var decode_object = function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_object({
+    var decode_object = function (tsc) { return function (importer) {
+        return FeatureProgrammer_1.FeatureProgrammer.decode_object(tsc)({
             trace: false,
             path: false,
             functors: FUNCTORS,
         })(importer);
-    };
-    var decode_tuple = function (project) {
+    }; };
+    var decode_tuple = function (p) {
         return function (importer) {
             return function (input, tuple, explore, tags) {
                 var children = tuple
                     .filter(function (elem) { return elem.rest === null; })
                     .map(function (elem, index) {
-                    return decode(project, importer)(typescript_1.default.factory.createElementAccessExpression(input, index), elem, __assign(__assign({}, explore), { from: "array" }), tags);
+                    return decode(p)(importer)(p.tsc.factory.createElementAccessExpression(input, index), elem, __assign(__assign({}, explore), { from: "array" }), tags);
                 });
                 var rest = (function () {
                     if (tuple.length === 0)
@@ -389,163 +415,179 @@ var StringifyProgrammer;
                     var last = tuple[tuple.length - 1];
                     if (last.rest === null)
                         return null;
-                    var code = decode(project, importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("slice"), undefined, [typescript_1.default.factory.createNumericLiteral(tuple.length - 1)]), (function () {
+                    var code = 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(tuple[tuple.length - 1].rest);
                         return wrapper;
                     })(), __assign(__assign({}, explore), { start: tuple.length - 1 }), tags);
-                    return typescript_1.default.factory.createCallExpression(importer.use("rest"), undefined, [code]);
+                    return p.tsc.factory.createCallExpression(importer.use("rest"), undefined, [code]);
                 })();
-                return StringifyJoinder_1.StringifyJoiner.tuple(children, rest);
+                return StringifyJoinder_1.StringifyJoiner.tuple(p.tsc)(children, rest);
             };
         };
     };
-    var decode_atomic = function (project) {
+    var decode_atomic = function (p) {
         return function (importer) {
-            return function (input, type, explore, tagList) {
+            return function (input, type, explore) {
                 if (type === "string")
-                    if (tagList.find(function (tag) { return tag.kind === "format"; }) !== undefined)
-                        return [
-                            typescript_1.default.factory.createStringLiteral('"'),
-                            input,
-                            typescript_1.default.factory.createStringLiteral('"'),
-                        ].reduce(function (x, y) { return typescript_1.default.factory.createAdd(x, y); });
-                    else
-                        return typescript_1.default.factory.createCallExpression(importer.use("string"), undefined, [input]);
-                else if (type === "number" &&
-                    OptionPredicator_1.OptionPredicator.numeric(project.options))
-                    input = typescript_1.default.factory.createCallExpression(importer.use("number"), undefined, [input]);
+                    return p.tsc.factory.createCallExpression(importer.use("string"), undefined, [input]);
+                else if (type === "number" && OptionPredicator_1.OptionPredicator.numeric(p.options))
+                    input = p.tsc.factory.createCallExpression(importer.use("number"), undefined, [input]);
                 return explore.from !== "top"
                     ? input
-                    : typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("toString"), undefined, undefined);
+                    : p.tsc.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(p.tsc)(input)("toString"), undefined, undefined);
             };
         };
     };
-    var decode_constant_string = function (project) {
+    var decode_constant_string = function (p) {
         return function (importer) {
             return function (input, values, explore) {
                 if (values.every(function (v) { return !StringifyPredicator_1.StringifyPredicator.require_escape(v); }))
                     return [
-                        typescript_1.default.factory.createStringLiteral('"'),
+                        p.tsc.factory.createStringLiteral('"'),
                         input,
-                        typescript_1.default.factory.createStringLiteral('"'),
-                    ].reduce(function (x, y) { return typescript_1.default.factory.createAdd(x, y); });
+                        p.tsc.factory.createStringLiteral('"'),
+                    ].reduce(function (x, y) { return p.tsc.factory.createAdd(x, y); });
                 else
-                    return decode_atomic(project)(importer)(input, "string", explore, []);
+                    return decode_atomic(p)(importer)(input, "string", explore);
             };
         };
     };
-    var decode_to_json = function (project, importer) {
-        return function (input, resolved, explore, tags) {
-            return decode(project, importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("toJSON"), undefined, []), resolved, explore, tags);
+    var decode_to_json = function (p) {
+        return function (importer) {
+            return function (input, resolved, explore, tags) {
+                return decode(p)(importer)(p.tsc.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(p.tsc)(input)("toJSON"), undefined, []), resolved, explore, tags);
+            };
         };
     };
-    var decode_functional = function (explore) {
+    var decode_functional = function (tsc) { return function (explore) {
         return explore.from === "array"
-            ? typescript_1.default.factory.createStringLiteral("null")
-            : typescript_1.default.factory.createIdentifier("undefined");
-    };
-    var explore_arrays = function (project) { return function (importer) {
-        return UnionExplorer_1.UnionExplorer.array({
-            checker: IsProgrammer_1.IsProgrammer.decode(project, importer),
-            decoder: decode_array(project)(importer),
-            empty: typescript_1.default.factory.createStringLiteral("[]"),
-            success: typescript_1.default.factory.createTrue(),
+            ? tsc.factory.createStringLiteral("null")
+            : tsc.factory.createIdentifier("undefined");
+    }; };
+    /* -----------------------------------------------------------
+        EXPLORERS
+    ----------------------------------------------------------- */
+    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.createStringLiteral("[]"),
+            success: p.tsc.factory.createTrue(),
             failure: function (input, expected) {
-                return create_throw_error(importer, input, expected);
+                return create_throw_error(p.tsc)(importer, input, expected);
             },
         });
     }; };
-    var explore_objects = function (importer) {
-        return function (input, meta, explore) {
-            if (meta.objects.length === 1)
-                return decode_object(importer)(input, meta.objects[0], explore);
-            return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("".concat(UNIONERS).concat(meta.union_index)), undefined, [input]);
+    var explore_objects = function (tsc) {
+        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]);
+            };
         };
     };
-    var wrap_required = function (input, meta, explore) {
-        if (meta.required === true && meta.any === false)
-            return function (expression) { return expression; };
-        return function (expression) {
-            return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createIdentifier("undefined"), input), undefined, expression, undefined, explore.from === "array"
-                ? typescript_1.default.factory.createStringLiteral("null")
-                : typescript_1.default.factory.createIdentifier("undefined"));
+    /* -----------------------------------------------------------
+        RETURN SCRIPTS
+    ----------------------------------------------------------- */
+    var wrap_required = function (tsc) {
+        return function (input, meta, explore) {
+            if (meta.required === true && meta.any === false)
+                return function (expression) { return expression; };
+            return function (expression) {
+                return tsc.factory.createConditionalExpression(tsc.factory.createStrictInequality(tsc.factory.createIdentifier("undefined"), input), undefined, expression, undefined, explore.from === "array"
+                    ? tsc.factory.createStringLiteral("null")
+                    : tsc.factory.createIdentifier("undefined"));
+            };
         };
     };
-    var wrap_nullable = function (input, meta) {
-        if (meta.nullable === false)
-            return function (expression) { return expression; };
-        return function (expression) {
-            return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createNull(), input), undefined, expression, undefined, typescript_1.default.factory.createStringLiteral("null"));
+    var wrap_nullable = function (tsc) {
+        return function (input, meta) {
+            if (meta.nullable === false)
+                return function (expression) { return expression; };
+            return function (expression) {
+                return tsc.factory.createConditionalExpression(tsc.factory.createStrictInequality(tsc.factory.createNull(), input), undefined, expression, undefined, tsc.factory.createStringLiteral("null"));
+            };
         };
     };
-    var wrap_functional = function (input, meta, explore) {
-        if (meta.functional === false)
-            return function (expression) { return expression; };
-        return function (expression) {
-            return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(input)), undefined, expression, undefined, decode_functional(explore));
+    var wrap_functional = function (tsc) {
+        return function (input, meta, explore) {
+            if (meta.functional === false)
+                return function (expression) { return expression; };
+            return function (expression) {
+                return tsc.factory.createConditionalExpression(tsc.factory.createStrictInequality(tsc.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(tsc)(input)), undefined, expression, undefined, decode_functional(tsc)(explore));
+            };
         };
     };
-    var iterate = function (importer, input, unions, expected) {
-        return typescript_1.default.factory.createBlock(__spreadArray(__spreadArray([], __read(unions.map(function (u) {
-            return typescript_1.default.factory.createIfStatement(u.is(), typescript_1.default.factory.createReturnStatement(u.value()));
-        })), false), [
-            create_throw_error(importer, input, expected),
-        ], false), true);
+    var iterate = function (tsc) {
+        return function (importer) {
+            return function (input, unions, expected) {
+                return tsc.factory.createBlock(__spreadArray(__spreadArray([], __read(unions.map(function (u) {
+                    return tsc.factory.createIfStatement(u.is(), tsc.factory.createReturnStatement(u.value()));
+                })), false), [
+                    create_throw_error(tsc)(importer, input, expected),
+                ], false), true);
+            };
+        };
     };
+    /* -----------------------------------------------------------
+        CONFIGURATIONS
+    ----------------------------------------------------------- */
     var FUNCTORS = "$so";
     var UNIONERS = "$su";
-    var configure = function (project) {
+    var configure = function (p) {
         return function (importer) { return ({
             types: {
                 input: function (type, name) {
-                    return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(project.checker)(type));
+                    return p.tsc.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(p)(type));
                 },
-                output: function () { return TypeFactory_1.TypeFactory.keyword("string"); },
+                output: function () { return TypeFactory_1.TypeFactory.keyword(p.tsc)("string"); },
             },
             functors: FUNCTORS,
             unioners: UNIONERS,
             trace: false,
             path: false,
             initializer: initializer,
-            decoder: decode(project, importer),
-            objector: OBJECTOR(project, importer),
+            decoder: decode(p)(importer),
+            objector: OBJECTOR(p)(importer),
         }); };
     };
-    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: true,
-                constant: true,
-                validate: function (meta) {
-                    if (meta.atomics.find(function (str) { return str === "bigint"; }))
-                        throw new Error(NO_BIGINT);
-                },
-            })(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: true,
+            constant: true,
+            validate: function (meta) {
+                if (meta.atomics.find(function (str) { return str === "bigint"; }))
+                    throw new Error(NO_BIGINT);
+            },
+        })(collection)(type);
+        return [collection, meta];
+    }; };
+    var OBJECTOR = function (p) {
+        return function (importer) { return ({
+            checker: IsProgrammer_1.IsProgrammer.decode(p)(importer),
+            decoder: decode_object(p.tsc)(importer),
+            joiner: StringifyJoinder_1.StringifyJoiner.object(p.tsc)(importer),
+            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, value, expected);
+            }),
+            failure: function (input, expected) {
+                return create_throw_error(p.tsc)(importer, input, expected);
+            },
+        }); };
     };
-    var OBJECTOR = function (project, importer) { return ({
-        checker: IsProgrammer_1.IsProgrammer.decode(project, importer),
-        decoder: decode_object(importer),
-        joiner: StringifyJoinder_1.StringifyJoiner.object(importer),
-        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, value, expected);
-        }),
-        failure: function (input, expected) {
-            return create_throw_error(importer, input, expected);
-        },
-    }); };
-    var create_throw_error = function (importer, value, expected) {
-        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),
-        ]));
+    var create_throw_error = function (tsc) {
+        return function (importer, value, expected) {
+            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),
+            ]));
+        };
     };
-})(StringifyProgrammer = exports.StringifyProgrammer || (exports.StringifyProgrammer = {}));
+})(StringifyProgrammer || (exports.StringifyProgrammer = StringifyProgrammer = {}));
 var NO_BIGINT = "Error on typia.stringify(): does not allow bigint type.";
 //# sourceMappingURL=StringifyProgrammer.js.map