typia 7.0.0-dev.20240923 → 7.0.0-dev.20240928

package/lib/programmers/misc/MiscCloneProgrammer.js

@@ -47,10 +47,14 @@ var wrap_metadata_rest_tuple_1 = require("../internal/wrap_metadata_rest_tuple")
 var MiscCloneProgrammer;
 (function (MiscCloneProgrammer) {
     MiscCloneProgrammer.decompose = function (props) {
-        var config = configure(props.context)(props.importer);
+        var config = configure(props);
         if (props.validated === false)
             config.addition = function (collection) {
-                return IsProgrammer_1.IsProgrammer.write_function_statements(props.context)(props.importer)(collection);
+                return IsProgrammer_1.IsProgrammer.write_function_statements({
+                    context: props.context,
+                    importer: props.importer,
+                    collection: collection,
+                });
             };
         var composed = FeatureProgrammer_1.FeatureProgrammer.compose(__assign(__assign({}, props), { config: config }));
         return {
@@ -68,445 +72,543 @@ var MiscCloneProgrammer;
             result: result,
         });
     };
-    var write_array_functions = function (config) {
-        return function (importer) {
-            return function (collection) {
-                return collection
-                    .arrays()
-                    .filter(function (a) { return a.recursive; })
-                    .map(function (type, 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"), MetadataArray_1.MetadataArray.create({
-                        type: type,
-                        tags: [],
-                    }), {
-                        tracable: config.trace,
-                        source: "function",
-                        from: "array",
-                        postfix: "",
-                    })));
-                });
-            };
-        };
+    var write_array_functions = function (props) {
+        return props.collection
+            .arrays()
+            .filter(function (a) { return a.recursive; })
+            .map(function (type, i) {
+            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "a").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline({
+                config: props.config,
+                importer: props.importer,
+                input: typescript_1.default.factory.createIdentifier("input"),
+                array: MetadataArray_1.MetadataArray.create({
+                    type: type,
+                    tags: [],
+                }),
+                explore: {
+                    tracable: props.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 write_tuple_functions = function (props) {
+        return props.collection
+            .tuples()
+            .filter(function (t) { return t.recursive; })
+            .map(function (tuple, i) {
+            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "t").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
+                config: props.config,
+                context: props.context,
+                importer: props.importer,
+                input: typescript_1.default.factory.createIdentifier("input"),
+                tuple: tuple,
+                explore: {
+                    tracable: props.config.trace,
+                    source: "function",
+                    from: "array",
+                    postfix: "",
+                },
+            })));
+        });
     };
     /* -----------------------------------------------------------
           DECODERS
       ----------------------------------------------------------- */
-    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;
-                    // ANY TYPE
-                    if (meta.any ||
-                        meta.arrays.some(function (a) { return a.type.value.any; }) ||
-                        meta.tuples.some(function (t) {
-                            return !!t.type.elements.length && t.type.elements.every(function (e) { return e.any; });
-                        }))
-                        return typescript_1.default.factory.createCallExpression(importer.use("any"), undefined, [
-                            input,
-                        ]);
-                    var unions = [];
-                    //----
-                    // LIST UP UNION TYPES
-                    //----
-                    // FUNCTIONAL
-                    if (meta.functions.length)
-                        unions.push({
-                            type: "functional",
-                            is: function () {
-                                return typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createStringLiteral("function"), typescript_1.default.factory.createTypeOfExpression(input));
-                            },
-                            value: function () { return typescript_1.default.factory.createIdentifier("undefined"); },
-                        });
-                    var _loop_1 = function (tuple) {
-                        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)(config)(importer)(input, tuple, explore);
-                            },
-                        });
-                    };
-                    try {
-                        // TUPLES
-                        for (var _d = __values(meta.tuples), _e = _d.next(); !_e.done; _e = _d.next()) {
-                            var tuple = _e.value;
-                            _loop_1(tuple);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    // ARRAYS
-                    if (meta.arrays.length)
-                        unions.push({
-                            type: "array",
-                            is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(input); },
-                            value: function () {
-                                return explore_arrays(project)(config)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }));
-                            },
-                        });
-                    // NATIVE TYPES
-                    if (meta.sets.length)
-                        unions.push({
-                            type: "set",
-                            is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set")(input); },
-                            value: function () {
-                                return explore_sets(project)(config)(importer)(input, meta.sets, __assign(__assign({}, explore), { from: "array" }));
-                            },
-                        });
-                    if (meta.maps.length)
-                        unions.push({
-                            type: "map",
-                            is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map")(input); },
-                            value: function () {
-                                return explore_maps(project)(config)(importer)(input, meta.maps, __assign(__assign({}, explore), { from: "array" }));
-                            },
-                        });
-                    var _loop_2 = function (native) {
-                        unions.push({
-                            type: "native",
-                            is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf(native)(input); },
-                            value: function () {
-                                return native === "Boolean" || native === "Number" || native === "String"
-                                    ? typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("valueOf"), undefined, undefined)
-                                    : decode_native(native)(input);
-                            },
-                        });
-                    };
-                    try {
-                        for (var _f = __values(meta.natives), _g = _f.next(); !_g.done; _g = _f.next()) {
-                            var native = _g.value;
-                            _loop_2(native);
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                    // OBJECTS
-                    if (meta.objects.length)
-                        unions.push({
-                            type: "object",
-                            is: function () {
-                                return ExpressionFactory_1.ExpressionFactory.isObject({
-                                    checkNull: true,
-                                    checkArray: false,
-                                })(input);
-                            },
-                            value: function () {
-                                return explore_objects(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" }));
-                            },
+    var decode = function (props) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        // ANY TYPE
+        if (props.metadata.any ||
+            props.metadata.arrays.some(function (a) { return a.type.value.any; }) ||
+            props.metadata.tuples.some(function (t) { return !!t.type.elements.length && t.type.elements.every(function (e) { return e.any; }); }))
+            return typescript_1.default.factory.createCallExpression(props.importer.use("any"), undefined, [props.input]);
+        var unions = [];
+        //----
+        // LIST UP UNION TYPES
+        //----
+        // FUNCTIONAL
+        if (props.metadata.functions.length)
+            unions.push({
+                type: "functional",
+                is: function () {
+                    return typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createStringLiteral("function"), typescript_1.default.factory.createTypeOfExpression(props.input));
+                },
+                value: function () { return typescript_1.default.factory.createIdentifier("undefined"); },
+            });
+        var _loop_1 = function (tuple) {
+            unions.push({
+                type: "tuple",
+                is: function () {
+                    return IsProgrammer_1.IsProgrammer.decode(__assign(__assign({}, props), { metadata: (function () {
+                            var partial = Metadata_1.Metadata.initialize();
+                            partial.tuples.push(tuple);
+                            return partial;
+                        })() }));
+                },
+                value: function () {
+                    return decode_tuple(__assign(__assign({}, props), { tuple: tuple }));
+                },
+            });
+        };
+        try {
+            // TUPLES
+            for (var _d = __values(props.metadata.tuples), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var tuple = _e.value;
+                _loop_1(tuple);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // ARRAYS
+        if (props.metadata.arrays.length)
+            unions.push({
+                type: "array",
+                is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(props.input); },
+                value: function () {
+                    return explore_arrays(__assign(__assign({}, props), { arrays: props.metadata.arrays, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
+                },
+            });
+        // NATIVE TYPES
+        if (props.metadata.sets.length)
+            unions.push({
+                type: "set",
+                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set")(props.input); },
+                value: function () {
+                    return explore_sets(__assign(__assign({}, props), { sets: props.metadata.sets, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
+                },
+            });
+        if (props.metadata.maps.length)
+            unions.push({
+                type: "map",
+                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map")(props.input); },
+                value: function () {
+                    return explore_maps(__assign(__assign({}, props), { maps: props.metadata.maps, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
+                },
+            });
+        var _loop_2 = function (native) {
+            unions.push({
+                type: "native",
+                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf(native)(props.input); },
+                value: function () {
+                    return native === "Boolean" || native === "Number" || native === "String"
+                        ? typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input)("valueOf"), undefined, undefined)
+                        : decode_native({
+                            type: native,
+                            input: props.input,
                         });
-                    // COMPOSITION
-                    if (unions.length === 0)
-                        return input;
-                    else if (unions.length === 1 && meta.size() === 1) {
-                        var value = (meta.nullable || meta.isRequired() === false) && is_instance(meta)
-                            ? typescript_1.default.factory.createConditionalExpression(input, undefined, unions[0].value(), undefined, input)
-                            : unions[0].value();
-                        return typescript_1.default.factory.createAsExpression(value, TypeFactory_1.TypeFactory.keyword("any"));
-                    }
-                    else {
-                        var last = input;
-                        try {
-                            for (var _h = __values(unions.reverse()), _j = _h.next(); !_j.done; _j = _h.next()) {
-                                var u = _j.value;
-                                last = typescript_1.default.factory.createConditionalExpression(u.is(), undefined, u.value(), undefined, last);
-                            }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
-                            }
-                            finally { if (e_3) throw e_3.error; }
-                        }
-                        return typescript_1.default.factory.createAsExpression(last, TypeFactory_1.TypeFactory.keyword("any"));
-                    }
-                };
-            };
+                },
+            });
         };
+        try {
+            for (var _f = __values(props.metadata.natives), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var native = _g.value;
+                _loop_2(native);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        // OBJECTS
+        if (props.metadata.objects.length)
+            unions.push({
+                type: "object",
+                is: function () {
+                    return ExpressionFactory_1.ExpressionFactory.isObject({
+                        checkNull: true,
+                        checkArray: false,
+                    })(props.input);
+                },
+                value: function () {
+                    return explore_objects(__assign(__assign({}, props), { explore: __assign(__assign({}, props.explore), { from: "object" }) }));
+                },
+            });
+        // COMPOSITION
+        if (unions.length === 0)
+            return props.input;
+        else if (unions.length === 1 && props.metadata.size() === 1) {
+            var value = (props.metadata.nullable || props.metadata.isRequired() === false) &&
+                is_instance(props.metadata)
+                ? typescript_1.default.factory.createConditionalExpression(props.input, undefined, unions[0].value(), undefined, props.input)
+                : unions[0].value();
+            return typescript_1.default.factory.createAsExpression(value, TypeFactory_1.TypeFactory.keyword("any"));
+        }
+        else {
+            var last = props.input;
+            try {
+                for (var _h = __values(unions.reverse()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var u = _j.value;
+                    last = typescript_1.default.factory.createConditionalExpression(u.is(), undefined, u.value(), undefined, last);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            return typescript_1.default.factory.createAsExpression(last, TypeFactory_1.TypeFactory.keyword("any"));
+        }
     };
-    var decode_object = function (importer) {
+    var decode_object = function (props) {
         return FeatureProgrammer_1.FeatureProgrammer.decode_object({
             trace: false,
             path: false,
             prefix: PREFIX,
-        })(importer);
+        })(props.importer)(props.input, props.object, props.explore);
     };
-    var decode_array = function (config) {
-        return function (importer) {
-            return function (input, array, explore) {
-                return array.type.recursive
-                    ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "a").concat(array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function", from: "array" }))(input))
-                    : decode_array_inline(config)(importer)(input, array, explore);
-            };
-        };
+    var decode_array = function (props) {
+        return props.array.type.recursive
+            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, props.explore), { source: "function", from: "array" }))(props.input))
+            : decode_array_inline(props);
     };
-    var decode_array_inline = function (config) {
-        return function (importer) {
-            return function (input, array, explore) {
-                return FeatureProgrammer_1.FeatureProgrammer.decode_array(config)(importer)(CloneJoiner_1.CloneJoiner.array)(input, array, explore);
-            };
-        };
+    var decode_array_inline = function (props) {
+        return FeatureProgrammer_1.FeatureProgrammer.decode_array(props.config)(props.importer)(CloneJoiner_1.CloneJoiner.array)(props.input, props.array, props.explore);
     };
-    var decode_tuple = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, tuple, explore) {
-                    return tuple.type.recursive
-                        ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "t").concat(tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function" }))(input))
-                        : decode_tuple_inline(project)(config)(importer)(input, tuple.type, explore);
-                };
-            };
-        };
+    var decode_tuple = function (props) {
+        return props.tuple.type.recursive
+            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, props.explore), { source: "function" }))(props.input))
+            : decode_tuple_inline(__assign(__assign({}, props), { tuple: props.tuple.type }));
     };
-    var decode_tuple_inline = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, tuple, explore) {
-                    var elements = tuple.elements
-                        .filter(function (m) { return m.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((0, postfix_of_tuple_1.postfix_of_tuple)(explore.postfix), "[").concat(index, "]\"")
-                                : "\"[".concat(index, "]\"") }));
-                    });
-                    var rest = (function () {
-                        if (tuple.elements.length === 0)
-                            return null;
-                        var last = tuple.elements.at(-1);
-                        var rest = last.rest;
-                        if (rest === null)
-                            return null;
-                        return decode(project)(config)(importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("slice"), undefined, [ExpressionFactory_1.ExpressionFactory.number(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 CloneJoiner_1.CloneJoiner.tuple({
-                        elements: elements,
-                        rest: rest,
-                    });
-                };
-            };
-        };
+    var decode_tuple_inline = function (props) {
+        var elements = props.tuple.elements
+            .filter(function (m) { return m.rest === null; })
+            .map(function (elem, index) {
+            return decode({
+                context: props.context,
+                config: props.config,
+                importer: props.importer,
+                input: typescript_1.default.factory.createElementAccessExpression(props.input, index),
+                metadata: elem,
+                explore: __assign(__assign({}, props.explore), { from: "array", postfix: props.explore.postfix.length
+                        ? "".concat((0, postfix_of_tuple_1.postfix_of_tuple)(props.explore.postfix), "[").concat(index, "]\"")
+                        : "\"[".concat(index, "]\"") }),
+            });
+        });
+        var rest = (function () {
+            if (props.tuple.elements.length === 0)
+                return null;
+            var last = props.tuple.elements.at(-1);
+            var rest = last.rest;
+            if (rest === null)
+                return null;
+            return decode({
+                context: props.context,
+                config: props.config,
+                importer: props.importer,
+                input: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input)("slice"), undefined, [ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length - 1)]),
+                metadata: (0, wrap_metadata_rest_tuple_1.wrap_metadata_rest_tuple)(props.tuple.elements.at(-1).rest),
+                explore: __assign(__assign({}, props.explore), { start: props.tuple.elements.length - 1 }),
+            });
+        })();
+        return CloneJoiner_1.CloneJoiner.tuple({
+            elements: elements,
+            rest: rest,
+        });
     };
     /* -----------------------------------------------------------
           NATIVE CLASSES
       ----------------------------------------------------------- */
-    var decode_native = function (type) { return function (input) {
-        return type === "Date" ||
-            type === "Uint8Array" ||
-            type === "Uint8ClampedArray" ||
-            type === "Uint16Array" ||
-            type === "Uint32Array" ||
-            type === "BigUint64Array" ||
-            type === "Int8Array" ||
-            type === "Int16Array" ||
-            type === "Int32Array" ||
-            type === "BigInt64Array" ||
-            type === "Float32Array" ||
-            type === "Float64Array" ||
-            type === "RegExp"
-            ? decode_native_copyable(type)(input)
-            : type === "ArrayBuffer" || type === "SharedArrayBuffer"
-                ? decode_native_buffer(type)(input)
-                : type === "DataView"
-                    ? decode_native_data_view(input)
-                    : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(type), undefined, []);
-    }; };
-    var decode_native_copyable = function (type) { return function (input) {
-        return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(type), undefined, [input]);
-    }; };
-    var decode_native_buffer = function (type) { return function (input) {
+    var decode_native = function (props) {
+        return props.type === "Date" ||
+            props.type === "Uint8Array" ||
+            props.type === "Uint8ClampedArray" ||
+            props.type === "Uint16Array" ||
+            props.type === "Uint32Array" ||
+            props.type === "BigUint64Array" ||
+            props.type === "Int8Array" ||
+            props.type === "Int16Array" ||
+            props.type === "Int32Array" ||
+            props.type === "BigInt64Array" ||
+            props.type === "Float32Array" ||
+            props.type === "Float64Array" ||
+            props.type === "RegExp"
+            ? decode_native_copyable(props)
+            : props.type === "ArrayBuffer" || props.type === "SharedArrayBuffer"
+                ? decode_native_buffer({
+                    type: props.type,
+                    input: props.input,
+                })
+                : props.type === "DataView"
+                    ? decode_native_data_view(props.input)
+                    : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.type), undefined, []);
+    };
+    var decode_native_copyable = function (props) {
+        return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.type), undefined, [props.input]);
+    };
+    var decode_native_buffer = function (props) {
         return ExpressionFactory_1.ExpressionFactory.selfCall(typescript_1.default.factory.createBlock([
-            StatementFactory_1.StatementFactory.constant("buffer", typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(type), undefined, [IdentifierFactory_1.IdentifierFactory.access(input)("byteLength")])),
+            StatementFactory_1.StatementFactory.constant("buffer", typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.type), undefined, [IdentifierFactory_1.IdentifierFactory.access(props.input)("byteLength")])),
             typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Uint8Array"), undefined, [typescript_1.default.factory.createIdentifier("buffer")]))("set"), undefined, [
-                typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Uint8Array"), undefined, [input]),
+                typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Uint8Array"), undefined, [props.input]),
             ])),
             typescript_1.default.factory.createReturnStatement(typescript_1.default.factory.createIdentifier("buffer")),
         ], true));
-    }; };
+    };
     var decode_native_data_view = function (input) {
         return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("DataView"), undefined, [IdentifierFactory_1.IdentifierFactory.access(input)("buffer")]);
     };
     /* -----------------------------------------------------------
           EXPLORERS FOR UNION TYPES
       ----------------------------------------------------------- */
-    var explore_sets = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, sets, explore) {
-                    return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
-                        checker: IsProgrammer_1.IsProgrammer.decode(project)(importer),
-                        decoder: function (input, array, explore) {
-                            return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], [decode_array(config)(importer)(input, array, explore)]);
-                        },
-                        empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], []),
-                        success: typescript_1.default.factory.createTrue(),
-                        failure: function (input, expected) {
-                            return create_throw_error(importer)(expected)(input);
-                        },
-                    })([])(input, sets, explore), undefined, undefined);
-                };
-            };
-        };
+    var explore_sets = function (props) {
+        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
+            checker: function (input, metadata, explore) {
+                return IsProgrammer_1.IsProgrammer.decode({
+                    context: props.context,
+                    importer: props.importer,
+                    input: input,
+                    metadata: metadata,
+                    explore: explore,
+                });
+            },
+            decoder: function (input, array, explore) {
+                return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], [
+                    decode_array({
+                        config: props.config,
+                        importer: props.importer,
+                        input: input,
+                        array: array,
+                        explore: explore,
+                    }),
+                ]);
+            },
+            empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], []),
+            success: typescript_1.default.factory.createTrue(),
+            failure: function (input, expected) {
+                return create_throw_error({
+                    importer: props.importer,
+                    expected: expected,
+                    input: input,
+                });
+            },
+        })([])(props.input, props.sets, props.explore), undefined, undefined);
     };
-    var explore_maps = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, maps, explore) {
-                    return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
-                        checker: function (top, entry, explore) {
-                            var func = IsProgrammer_1.IsProgrammer.decode(project)(importer);
-                            return typescript_1.default.factory.createLogicalAnd(func(typescript_1.default.factory.createElementAccessExpression(top, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") })), func(typescript_1.default.factory.createElementAccessExpression(top, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") })));
-                        },
-                        decoder: function (input, array, explore) {
-                            return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], [decode_array(config)(importer)(input, array, explore)]);
-                        },
-                        empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], []),
-                        success: typescript_1.default.factory.createTrue(),
-                        failure: function (input, expected) {
-                            return create_throw_error(importer)(expected)(input);
-                        },
-                    })([])(input, maps, explore), undefined, undefined);
-                };
-            };
-        };
+    var explore_maps = function (props) {
+        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
+            checker: function (top, entry, explore) {
+                return typescript_1.default.factory.createLogicalAnd(IsProgrammer_1.IsProgrammer.decode({
+                    context: props.context,
+                    importer: props.importer,
+                    input: typescript_1.default.factory.createElementAccessExpression(top, 0),
+                    metadata: entry[0],
+                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }),
+                }), IsProgrammer_1.IsProgrammer.decode({
+                    context: props.context,
+                    importer: props.importer,
+                    input: typescript_1.default.factory.createElementAccessExpression(top, 1),
+                    metadata: entry[1],
+                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }),
+                }));
+            },
+            decoder: function (input, array, explore) {
+                return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], [
+                    decode_array({
+                        config: props.config,
+                        importer: props.importer,
+                        input: input,
+                        array: array,
+                        explore: explore,
+                    }),
+                ]);
+            },
+            empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], []),
+            success: typescript_1.default.factory.createTrue(),
+            failure: function (input, expected) {
+                return create_throw_error({
+                    importer: props.importer,
+                    expected: expected,
+                    input: input,
+                });
+            },
+        })([])(props.input, props.maps, props.explore), undefined, undefined);
     };
-    var explore_objects = function (config) {
-        return function (importer) {
-            return function (input, meta, explore) {
-                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));
-            };
-        };
+    var explore_objects = function (props) {
+        return props.metadata.objects.length === 1
+            ? decode_object(__assign(__assign({}, props), { object: props.metadata.objects[0] }))
+            : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(PREFIX, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(props.explore)(props.input));
     };
-    var explore_arrays = function (project) {
-        return function (config) {
-            return function (importer) {
-                return function (input, elements, explore) {
-                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array({
-                        checker: IsProgrammer_1.IsProgrammer.decode(project)(importer),
-                        decoder: decode_array(config)(importer),
-                        empty: typescript_1.default.factory.createIdentifier("[]"),
-                        success: typescript_1.default.factory.createTrue(),
-                        failure: function (input, expected) {
-                            return create_throw_error(importer)(expected)(input);
-                        },
-                    }))(input, elements, explore);
-                };
-            };
-        };
+    var explore_arrays = function (props) {
+        return explore_array_like_union_types(__assign(__assign({}, props), { elements: props.arrays, factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.array({
+                    checker: function (input, metadata, explore) {
+                        return IsProgrammer_1.IsProgrammer.decode({
+                            context: props.context,
+                            importer: props.importer,
+                            input: input,
+                            metadata: metadata,
+                            explore: explore,
+                        });
+                    },
+                    decoder: function (input, array, explore) {
+                        return decode_array({
+                            config: props.config,
+                            importer: props.importer,
+                            input: input,
+                            array: array,
+                            explore: explore,
+                        });
+                    },
+                    empty: typescript_1.default.factory.createIdentifier("[]"),
+                    success: typescript_1.default.factory.createTrue(),
+                    failure: function (input, expected) {
+                        return create_throw_error({
+                            importer: props.importer,
+                            expected: expected,
+                            input: input,
+                        });
+                    },
+                })(next.parameters)(next.input, next.elements, next.explore);
+            } }));
     };
-    var explore_array_like_union_types = function (config) {
-        return function (importer) {
-            return function (factory) {
-                return function (input, elements, explore) {
-                    var arrow = function (parameters) {
-                        return function (explore) {
-                            return function (input) {
-                                return factory(parameters)(input, elements, explore);
-                            };
-                        };
-                    };
-                    if (elements.every(function (e) { return e.type.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.type.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 explore_array_like_union_types = function (props) {
+        var arrow = function (next) {
+            return props.factory({
+                elements: props.elements,
+                parameters: next.parameters,
+                input: next.input,
+                explore: next.explore,
+            });
         };
+        if (props.elements.every(function (e) { return e.type.recursive === false; }))
+            typescript_1.default.factory.createCallExpression(arrow({
+                parameters: [],
+                explore: props.explore,
+                input: props.input,
+            }), undefined, []);
+        var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.emplaceUnion(props.config.prefix, props.elements.map(function (e) { return e.type.name; }).join(" | "), function () {
+            return arrow({
+                parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")),
+                explore: __assign(__assign({}, arrayExplore), { postfix: "" }),
+                input: typescript_1.default.factory.createIdentifier("input"),
+            });
+        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input));
     };
     /* -----------------------------------------------------------
           CONFIGURATIONS
       ----------------------------------------------------------- */
     var PREFIX = "$c";
-    var configure = function (project) {
-        return function (importer) {
-            var config = {
-                types: {
-                    input: function (type, name) {
-                        return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(project.checker)(type));
-                    },
-                    output: function (type, name) {
-                        return typescript_1.default.factory.createImportTypeNode(typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createStringLiteral("typia")), undefined, typescript_1.default.factory.createIdentifier("Resolved"), [
-                            typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(project.checker)(type)),
-                        ], false);
-                    },
+    var configure = function (props) {
+        var config = {
+            types: {
+                input: function (type, name) {
+                    return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(type));
                 },
-                prefix: PREFIX,
-                trace: false,
-                path: false,
-                initializer: initializer,
-                decoder: function () { return decode(project)(config)(importer); },
-                objector: {
-                    checker: function () { return IsProgrammer_1.IsProgrammer.decode(project)(importer); },
-                    decoder: function () { return decode_object(importer); },
-                    joiner: CloneJoiner_1.CloneJoiner.object,
-                    unionizer: (0, decode_union_object_1.decode_union_object)(IsProgrammer_1.IsProgrammer.decode_object(project)(importer))(decode_object(importer))(function (exp) { return exp; })(function (input, expected) {
-                        return create_throw_error(importer)(expected)(input);
-                    }),
-                    failure: function (input, expected) {
-                        return create_throw_error(importer)(expected)(input);
-                    },
+                output: function (type, name) {
+                    return typescript_1.default.factory.createImportTypeNode(typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createStringLiteral("typia")), undefined, typescript_1.default.factory.createIdentifier("Resolved"), [
+                        typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(type)),
+                    ], false);
                 },
-                generator: {
-                    arrays: function () { return write_array_functions(config)(importer); },
-                    tuples: function () { return write_tuple_functions(project)(config)(importer); },
+            },
+            prefix: PREFIX,
+            trace: false,
+            path: false,
+            initializer: initializer,
+            decoder: function () { return function (input, metadata, explore) {
+                return decode({
+                    context: props.context,
+                    importer: props.importer,
+                    config: config,
+                    input: input,
+                    metadata: metadata,
+                    explore: explore,
+                });
+            }; },
+            objector: {
+                checker: function () { return function (input, metadata, explore) {
+                    return IsProgrammer_1.IsProgrammer.decode({
+                        context: props.context,
+                        importer: props.importer,
+                        input: input,
+                        metadata: metadata,
+                        explore: explore,
+                    });
+                }; },
+                decoder: function () { return function (input, object, explore) {
+                    return decode_object({
+                        importer: props.importer,
+                        input: input,
+                        object: object,
+                        explore: explore,
+                    });
+                }; },
+                joiner: CloneJoiner_1.CloneJoiner.object,
+                unionizer: (0, decode_union_object_1.decode_union_object)(function (input, object, explore) {
+                    return IsProgrammer_1.IsProgrammer.decode_object({
+                        context: props.context,
+                        importer: props.importer,
+                        input: input,
+                        object: object,
+                        explore: explore,
+                    });
+                })(function (input, object, explore) {
+                    return decode_object({
+                        importer: props.importer,
+                        input: input,
+                        object: object,
+                        explore: explore,
+                    });
+                })(function (exp) { return exp; })(function (input, expected) {
+                    return create_throw_error({
+                        importer: props.importer,
+                        expected: expected,
+                        input: input,
+                    });
+                }),
+                failure: function (input, expected) {
+                    return create_throw_error({
+                        importer: props.importer,
+                        expected: expected,
+                        input: input,
+                    });
                 },
-            };
-            return config;
+            },
+            generator: {
+                arrays: function () { return function (collection) {
+                    return write_array_functions({
+                        importer: props.importer,
+                        config: config,
+                        collection: collection,
+                    });
+                }; },
+                tuples: function () { return function (collection) {
+                    return write_tuple_functions({
+                        context: props.context,
+                        importer: props.importer,
+                        config: config,
+                        collection: collection,
+                    });
+                }; },
+            },
         };
+        return config;
     };
-    var initializer = function (project) { return function (importer) { return function (type) {
+    var initializer = function (context) { return function (importer) { return function (type) {
         var collection = new MetadataCollection_1.MetadataCollection();
         var result = MetadataFactory_1.MetadataFactory.analyze({
-            checker: project.checker,
-            transformer: project.transformer,
+            checker: context.checker,
+            transformer: context.transformer,
             options: {
                 escape: false,
                 constant: true,
                 absorb: true,
-                validate: function (meta) {
+                validate: function (metadata) {
                     var output = [];
-                    if (meta.natives.some(function (n) { return n === "WeakSet"; }))
+                    if (metadata.natives.some(function (n) { return n === "WeakSet"; }))
                         output.push("unable to clone WeakSet");
-                    else if (meta.natives.some(function (n) { return n === "WeakMap"; }))
+                    else if (metadata.natives.some(function (n) { return n === "WeakMap"; }))
                         output.push("unable to clone WeakMap");
                     return output;
                 },
@@ -518,26 +620,22 @@ var MiscCloneProgrammer;
             throw TransformerError_1.TransformerError.from("typia.misc.".concat(importer.method))(result.errors);
         return [collection, result.data];
     }; }; };
-    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),
-                ]));
-            };
-        };
+    var create_throw_error = function (props) {
+        return typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(props.importer.use("throws"), [], [
+            typescript_1.default.factory.createObjectLiteralExpression([
+                typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(props.expected)),
+                typescript_1.default.factory.createPropertyAssignment("value", props.input),
+            ], true),
+        ]));
     };
-    var is_instance = function (meta) {
-        return !!meta.objects.length ||
-            !!meta.arrays.length ||
-            !!meta.tuples.length ||
-            !!meta.sets.length ||
-            !!meta.maps.length ||
-            !!meta.natives.length ||
-            (meta.rest !== null && is_instance(meta.rest));
+    var is_instance = function (metadata) {
+        return !!metadata.objects.length ||
+            !!metadata.arrays.length ||
+            !!metadata.tuples.length ||
+            !!metadata.sets.length ||
+            !!metadata.maps.length ||
+            !!metadata.natives.length ||
+            (metadata.rest !== null && is_instance(metadata.rest));
     };
 })(MiscCloneProgrammer || (exports.MiscCloneProgrammer = MiscCloneProgrammer = {}));
 //# sourceMappingURL=MiscCloneProgrammer.js.map