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

package/lib/programmers/StringifyProgrammer.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.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");
 var MetadataFactory_1 = require("../factories/MetadataFactory");
+var StatementFactory_1 = require("../factories/StatementFactory");
 var TypeFactory_1 = require("../factories/TypeFactory");
 var ValueFactory_1 = require("../factories/ValueFactory");
 var Metadata_1 = require("../metadata/Metadata");
@@ -67,527 +72,586 @@ var UnionExplorer_1 = require("./helpers/UnionExplorer");
 var check_native_1 = require("./internal/check_native");
 var decode_union_object_1 = require("./internal/decode_union_object");
 var feature_object_entries_1 = require("./internal/feature_object_entries");
+var wrap_metadata_rest_tuple_1 = require("./internal/wrap_metadata_rest_tuple");
 var StringifyProgrammer;
 (function (StringifyProgrammer) {
-    /* -----------------------------------------------------------
-        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) {
-                    return importer.hasLocal("$iu".concat(i));
-                })), false);
-            } }))(importer);
+    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();
+        var config = configure(project)(importer);
+        return FeatureProgrammer_1.FeatureProgrammer.write(project)(__assign(__assign({}, config), { 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, 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
+            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: "",
+                        })));
+                    });
+                };
+            };
+        };
+    };
+    var decode = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, meta, explore) {
+                    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)(config)(importer)(input, meta.resolved, explore);
+                        else
+                            unions.push({
+                                type: "resolved",
+                                is: function () { return IsProgrammer_1.IsProgrammer.decode_to_json(false)(input); },
+                                value: function () {
+                                    return decode_to_json(project)(config)(importer)(input, meta.resolved, explore);
+                                },
+                            });
+                    else if (meta.functional === true)
                         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);
-                            },
+                            type: "functional",
+                            is: function () { return IsProgrammer_1.IsProgrammer.decode_functional(input); },
+                            value: function () { return decode_functional(explore); },
                         });
-                else if (meta.functional === true)
-                    unions.push({
-                        type: "functional",
-                        is: function () { return IsProgrammer_1.IsProgrammer.decode_functional(p.tsc)(input); },
-                        value: function () { return decode_functional(p.tsc)(explore); },
-                    });
-                // 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"),
+                    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(project)(importer)(input, partial_1, explore, [], []);
+                                    },
+                                    value: function () {
+                                        return decode_atomic(project)(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: "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);
+                                },
+                            });
+                        else if (meta.templates.length === 0)
                             unions.push({
-                                type: "template literal",
+                                type: "const string",
                                 is: function () {
-                                    return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, partial_1, explore, [], []);
+                                    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_atomic(p)(importer)(input, "string", explore);
+                                    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);
+                        }
                     }
-                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(p)(importer)(input, (function () {
-                                    var partial = Metadata_1.Metadata.initialize();
-                                    partial.atomics.push(constant.type);
-                                    return partial;
-                                })(), explore, [], []);
-                            },
-                            value: function () {
-                                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);
+                    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(project)(importer)(input, (function () {
+                                        var partial = Metadata_1.Metadata.initialize();
+                                        partial.atomics.push(type);
+                                        return partial;
+                                    })(), explore, [], []);
+                                },
+                                value: function () {
+                                    return decode_atomic(project)(importer)(input, type, explore);
+                                },
+                            });
+                    };
                     try {
-                        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                        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 _s = (e_6 = void 0, __values(tuple.elements)), _t = _s.next(); !_t.done; _t = _s.next()) {
+                                var child = _t.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 (_t && !_t.done && (_r = _s.return)) _r.call(_s);
+                            }
+                            finally { if (e_6) throw e_6.error; }
+                        }
                         unions.push({
-                            type: "atomic",
+                            type: "tuple",
                             is: function () {
-                                return IsProgrammer_1.IsProgrammer.decode(p)(importer)(input, (function () {
+                                return IsProgrammer_1.IsProgrammer.decode(project)(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(p)(importer)(input, type, explore);
+                                return decode_tuple(project)(config)(importer)(input, tuple, explore);
                             },
                         });
-                };
-                try {
-                    /// 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; }
-                }
-                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(), ")."));
+                        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; }
-                    }
-                    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, tags);
-                        },
-                    });
-                };
-                try {
-                    // TUPLES
-                    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; }
                     }
-                    finally { if (e_3) throw e_3.error; }
-                }
-                // 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(), ")."));
+                    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.value))
+                                    throw new Error("Error on typia.stringify(): array cannot contain undefined value (".concat(child.value.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.length === 1
+                            ? function () {
+                                return decode_array(config)(importer)(input, meta.arrays[0], __assign(__assign({}, explore), { from: "array" }));
+                            }
+                            : meta.arrays.some(function (elem) { return elem.value.any; })
+                                ? function () {
+                                    return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("JSON.stringify"), undefined, [input]);
+                                }
+                                : function () {
+                                    return explore_arrays(project)(config)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }));
+                                };
+                        unions.push({
+                            type: "array",
+                            is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(input); },
+                            value: value,
+                        });
                     }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                    finally {
+                    if (meta.natives.length) {
+                        var _loop_4 = function (native) {
+                            unions.push({
+                                type: "object",
+                                is: function () { return (0, check_native_1.check_native)(native)(input); },
+                                value: function () {
+                                    return AtomicPredicator_1.AtomicPredicator.native(native)
+                                        ? decode_atomic(project)(importer)(input, native.toLowerCase(), explore)
+                                        : typescript_1.default.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 p.tsc.factory.createCallExpression(p.tsc.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(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,
-                    });
-                }
-                // BUILT-IN CLASSES
-                if (meta.natives.length) {
-                    var _loop_4 = function (native) {
+                    }
+                    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 (0, check_native_1.check_native)(p.tsc)(native)(input); },
+                            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 AtomicPredicator_1.AtomicPredicator.native(native)
-                                    ? decode_atomic(p)(importer)(input, native.toLowerCase(), explore)
-                                    : p.tsc.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)({
+                                            decoder: function () {
+                                                return decode(project)(config)(importer);
+                                            },
+                                            trace: false,
+                                            path: false,
+                                        })(importer)(obj)(typescript_1.default.factory.createAsExpression(input, TypeFactory_1.TypeFactory.keyword("any")));
+                                        return StringifyJoinder_1.StringifyJoiner.object(importer)(typescript_1.default.factory.createAsExpression(input, TypeFactory_1.TypeFactory.keyword("any")), entries);
+                                    })()
+                                    : explore_objects(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" }));
                             },
                         });
+                    var wrapper = function (output) {
+                        return wrap_required(input, meta, explore)(wrap_nullable(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; }
-                    }
-                }
-                // SETS
-                if (meta.sets.length)
-                    unions.push({
-                        type: "object",
-                        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 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));
+                    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));
                 };
-                // 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));
             };
         };
     };
-    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 (tsc) { return function (importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_object(tsc)({
+    var decode_object = function (importer) {
+        return FeatureProgrammer_1.FeatureProgrammer.decode_object({
             trace: false,
             path: false,
-            functors: FUNCTORS,
+            prefix: PREFIX,
         })(importer);
-    }; };
-    var decode_tuple = function (p) {
+    };
+    var decode_array = function (config) {
         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(p)(importer)(p.tsc.factory.createElementAccessExpression(input, index), elem, __assign(__assign({}, explore), { from: "array" }), tags);
-                });
-                var rest = (function () {
-                    if (tuple.length === 0)
-                        return null;
-                    var last = tuple[tuple.length - 1];
-                    if (last.rest === null)
-                        return null;
-                    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 p.tsc.factory.createCallExpression(importer.use("rest"), undefined, [code]);
-                })();
-                return StringifyJoinder_1.StringifyJoiner.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_inline = function (config) {
+        return function (importer) {
+            return function (input, array, explore) {
+                return FeatureProgrammer_1.FeatureProgrammer.decode_array(config)(importer)(StringifyJoinder_1.StringifyJoiner.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
+                        .filter(function (elem) { return elem.rest === null; })
+                        .map(function (elem, index) {
+                        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);
+                        if (last.rest === null)
+                            return null;
+                        var code = 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 typescript_1.default.factory.createCallExpression(importer.use("rest"), undefined, [code]);
+                    })();
+                    return StringifyJoinder_1.StringifyJoiner.tuple(children, rest);
+                };
             };
         };
     };
-    var decode_atomic = function (p) {
+    var decode_atomic = function (project) {
         return function (importer) {
             return function (input, type, explore) {
                 if (type === "string")
-                    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 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 explore.from !== "top"
                     ? input
-                    : p.tsc.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(p.tsc)(input)("toString"), undefined, undefined);
+                    : typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("toString"), undefined, undefined);
             };
         };
     };
-    var decode_constant_string = function (p) {
+    var decode_constant_string = function (project) {
         return function (importer) {
             return function (input, values, explore) {
                 if (values.every(function (v) { return !StringifyPredicator_1.StringifyPredicator.require_escape(v); }))
                     return [
-                        p.tsc.factory.createStringLiteral('"'),
+                        typescript_1.default.factory.createStringLiteral('"'),
                         input,
-                        p.tsc.factory.createStringLiteral('"'),
-                    ].reduce(function (x, y) { return p.tsc.factory.createAdd(x, y); });
+                        typescript_1.default.factory.createStringLiteral('"'),
+                    ].reduce(function (x, y) { return typescript_1.default.factory.createAdd(x, y); });
                 else
-                    return decode_atomic(p)(importer)(input, "string", explore);
+                    return decode_atomic(project)(importer)(input, "string", explore);
             };
         };
     };
-    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_to_json = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, resolved, explore) {
+                    return decode(project)(config)(importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("toJSON"), undefined, []), resolved, explore);
+                };
             };
         };
     };
-    var decode_functional = function (tsc) { return function (explore) {
+    var decode_functional = function (explore) {
         return explore.from === "array"
-            ? 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(p.tsc)(importer, input, expected);
-            },
-        });
-    }; };
-    var explore_objects = function (tsc) {
+            ? typescript_1.default.factory.createStringLiteral("null")
+            : typescript_1.default.factory.createIdentifier("undefined");
+    };
+    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 meta.objects.length === 1
+                    ? decode_object(importer)(input, meta.objects[0], explore)
+                    : 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));
             };
         };
     };
-    /* -----------------------------------------------------------
-        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 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 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 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 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 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"));
+        };
+    };
+    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_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 iterate = function (tsc) {
+    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)(expected)(input),
+        ], false), true);
+    };
+    var PREFIX = "$s";
+    var configure = function (project) {
         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);
+            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("string"); },
+                },
+                prefix: PREFIX,
+                trace: false,
+                path: false,
+                initializer: initializer,
+                decoder: function () { return decode(project)(config)(importer); },
+                objector: {
+                    checker: function () { return function (input, meta, explore) {
+                        return IsProgrammer_1.IsProgrammer.decode(project)(importer)(input, meta, explore, [], []);
+                    }; },
+                    decoder: function () { return 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)(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;
         };
     };
-    /* -----------------------------------------------------------
-        CONFIGURATIONS
-    ----------------------------------------------------------- */
-    var FUNCTORS = "$so";
-    var UNIONERS = "$su";
-    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 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,
+                absorb: true,
+                validate: function (meta) {
+                    if (meta.atomics.find(function (str) { return str === "bigint"; }))
+                        throw new Error(NO_BIGINT);
                 },
-                output: function () { return TypeFactory_1.TypeFactory.keyword(p.tsc)("string"); },
-            },
-            functors: FUNCTORS,
-            unioners: UNIONERS,
-            trace: false,
-            path: false,
-            initializer: initializer,
-            decoder: decode(p)(importer),
-            objector: OBJECTOR(p)(importer),
-        }); };
-    };
-    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);
-            },
-        }); };
+            })(collection)(type);
+            return [collection, meta];
+        };
     };
-    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),
-            ]));
+    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),
+                ]));
+            };
         };
     };
-})(StringifyProgrammer || (exports.StringifyProgrammer = StringifyProgrammer = {}));
+})(StringifyProgrammer = exports.StringifyProgrammer || (exports.StringifyProgrammer = {}));
 var NO_BIGINT = "Error on typia.stringify(): does not allow bigint type.";
 //# sourceMappingURL=StringifyProgrammer.js.map