typia 7.0.0-dev.20240920 → 7.0.0-dev.20240922

package/lib/programmers/RandomProgrammer.js

@@ -99,26 +99,30 @@ var RandomProgrammer;
         if (result.success === false)
             throw TransformerError_1.TransformerError.from("typia.".concat(props.importer.method))(result.errors);
         // GENERATE FUNCTION
-        var functions = Object.fromEntries(__spreadArray(__spreadArray(__spreadArray([], __read(write_object_functions(props.importer)(collection).map(function (v, i) { return [
-            Prefix.object(i),
-            v,
-        ]; })), false), __read(write_array_functions(props.importer)(collection).map(function (v, i) { return [
-            Prefix.array(i),
-            v,
-        ]; })), false), __read(write_tuple_functions(props.importer)(collection).map(function (v, i) { return [
-            Prefix.tuple(i),
-            v,
-        ]; })), false));
+        var functions = Object.fromEntries(__spreadArray(__spreadArray(__spreadArray([], __read(write_object_functions({
+            importer: props.importer,
+            collection: collection,
+        }).map(function (v, i) { return [Prefix.object(i), v]; })), false), __read(write_array_functions({
+            importer: props.importer,
+            collection: collection,
+        }).map(function (v, i) { return [Prefix.array(i), v]; })), false), __read(write_tuple_functions({
+            importer: props.importer,
+            collection: collection,
+        }).map(function (v, i) { return [Prefix.tuple(i), v]; })), false));
         var arrow = typescript_1.default.factory.createArrowFunction(undefined, undefined, [
             IdentifierFactory_1.IdentifierFactory.parameter("generator", typescript_1.default.factory.createTypeReferenceNode("Partial<typia.IRandomGenerator>"), (_a = props.init) !== null && _a !== void 0 ? _a : typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionToken)),
         ], 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((_b = props.name) !== null && _b !== void 0 ? _b : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(props.type)),
         ], false), undefined, typescript_1.default.factory.createBlock([
             typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createIdentifier("_generator"), typescript_1.default.SyntaxKind.EqualsToken, typescript_1.default.factory.createIdentifier("generator"))),
-            typescript_1.default.factory.createReturnStatement(decode(props.importer)({
-                function: false,
-                recursive: false,
-            })(result.data)),
+            typescript_1.default.factory.createReturnStatement(decode({
+                importer: props.importer,
+                explore: {
+                    function: false,
+                    recursive: false,
+                },
+                metadata: result.data,
+            })),
         ], true));
         return {
             functions: functions,
@@ -135,225 +139,260 @@ var RandomProgrammer;
             result: result,
         });
     };
-    var write_object_functions = function (importer) {
-        return function (collection) {
-            return collection.objects().map(function (obj, i) {
-                return StatementFactory_1.StatementFactory.constant(Prefix.object(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, [
-                    IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createIdentifier(String(obj.recursive))),
-                    IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
-                ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.object(COALESCE(importer))(decode(importer)({
-                    recursive: obj.recursive,
-                    function: true,
-                }))(obj)));
-            });
-        };
+    var write_object_functions = function (props) {
+        return props.collection.objects().map(function (obj, i) {
+            return StatementFactory_1.StatementFactory.constant(Prefix.object(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createIdentifier(String(obj.recursive))),
+                IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
+            ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.object({
+                coalesce: coalesce(props.importer),
+                decode: function (metadata) {
+                    return decode({
+                        importer: props.importer,
+                        explore: {
+                            recursive: obj.recursive,
+                            function: true,
+                        },
+                        metadata: metadata,
+                    });
+                },
+                object: obj,
+            })));
+        });
     };
-    var write_array_functions = function (importer) {
-        return function (collection) {
-            return collection
-                .arrays()
-                .filter(function (a) { return a.recursive; })
-                .map(function (array, i) {
-                return StatementFactory_1.StatementFactory.constant(Prefix.array(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, [
-                    IdentifierFactory_1.IdentifierFactory.parameter("length", TypeFactory_1.TypeFactory.keyword("number")),
-                    IdentifierFactory_1.IdentifierFactory.parameter("unique", TypeFactory_1.TypeFactory.keyword("boolean")),
-                    IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createTrue()),
-                    IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
-                ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.array(COALESCE(importer))(decode(importer)({
-                    recursive: true,
-                    function: true,
-                }))({
+    var write_array_functions = function (props) {
+        return props.collection
+            .arrays()
+            .filter(function (a) { return a.recursive; })
+            .map(function (array, i) {
+            return StatementFactory_1.StatementFactory.constant(Prefix.array(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory_1.IdentifierFactory.parameter("length", TypeFactory_1.TypeFactory.keyword("number")),
+                IdentifierFactory_1.IdentifierFactory.parameter("unique", TypeFactory_1.TypeFactory.keyword("boolean")),
+                IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createTrue()),
+                IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
+            ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.array({
+                coalesce: coalesce(props.importer),
+                decode: function (metadata) {
+                    return decode({
+                        importer: props.importer,
+                        explore: {
+                            recursive: true,
+                            function: true,
+                        },
+                        metadata: metadata,
+                    });
+                },
+                explore: {
                     recursive: true,
                     function: true,
-                })(typescript_1.default.factory.createIdentifier("length"), typescript_1.default.factory.createIdentifier("unique"))(array.value)));
-            });
-        };
+                },
+                length: typescript_1.default.factory.createIdentifier("length"),
+                unique: typescript_1.default.factory.createIdentifier("unique"),
+                metadata: array.value,
+            })));
+        });
     };
-    var write_tuple_functions = function (importer) {
-        return function (collection) {
-            return collection
-                .tuples()
-                .filter(function (a) { return a.recursive; })
-                .map(function (tuple, i) {
-                return StatementFactory_1.StatementFactory.constant(Prefix.tuple(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, [
-                    IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createTrue()),
-                    IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
-                ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.tuple(decode(importer)({
-                    function: true,
-                    recursive: true,
-                }))(tuple.elements)));
-            });
-        };
+    var write_tuple_functions = function (props) {
+        return props.collection
+            .tuples()
+            .filter(function (a) { return a.recursive; })
+            .map(function (tuple, i) {
+            return StatementFactory_1.StatementFactory.constant(Prefix.tuple(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, [
+                IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createTrue()),
+                IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
+            ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.tuple({
+                decode: function (metadata) {
+                    return decode({
+                        importer: props.importer,
+                        explore: {
+                            function: true,
+                            recursive: true,
+                        },
+                        metadata: metadata,
+                    });
+                },
+                elements: tuple.elements,
+            })));
+        });
     };
     /* -----------------------------------------------------------
       DECODERS
     ----------------------------------------------------------- */
-    var decode = function (importer) {
-        return function (explore) {
-            return function (meta) {
-                var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f, e_7, _g, e_8, _h, e_9, _j, e_10, _k;
-                var expressions = [];
-                if (meta.any)
-                    expressions.push(typescript_1.default.factory.createStringLiteral("any type used..."));
-                // NULL COALESCING
-                if (meta.isRequired() === false || meta.functions.length)
-                    expressions.push(typescript_1.default.factory.createIdentifier("undefined"));
-                if (meta.nullable === true)
-                    expressions.push(typescript_1.default.factory.createNull());
-                try {
-                    // CONSTANT TYPES
-                    for (var _l = __values(meta.constants), _m = _l.next(); !_m.done; _m = _l.next()) {
-                        var constant = _m.value;
-                        try {
-                            for (var _o = (e_2 = void 0, __values(constant.values)), _p = _o.next(); !_p.done; _p = _o.next()) {
-                                var value = _p.value.value;
-                                expressions.push(decode_atomic(value));
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (_p && !_p.done && (_b = _o.return)) _b.call(_o);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_m && !_m.done && (_a = _l.return)) _a.call(_l);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                try {
-                    // ATOMIC VARIABLES
-                    for (var _q = __values(meta.templates), _r = _q.next(); !_r.done; _r = _q.next()) {
-                        var template = _r.value;
-                        expressions.push(decode_template(importer)(explore)(template));
-                    }
-                }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                finally {
-                    try {
-                        if (_r && !_r.done && (_c = _q.return)) _c.call(_q);
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                }
-                try {
-                    for (var _s = __values(meta.atomics), _t = _s.next(); !_t.done; _t = _s.next()) {
-                        var atomic = _t.value;
-                        if (atomic.type === "boolean")
-                            expressions.push(decode_boolean(importer));
-                        else if (atomic.type === "number")
-                            expressions.push.apply(expressions, __spreadArray([], __read(decode_number(importer)(atomic)), false));
-                        else if (atomic.type === "string")
-                            expressions.push.apply(expressions, __spreadArray([], __read(decode_string(importer)(atomic)), false));
-                        else if (atomic.type === "bigint")
-                            expressions.push.apply(expressions, __spreadArray([], __read(decode_bigint(importer)(atomic)), false));
-                    }
-                }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (_t && !_t.done && (_d = _s.return)) _d.call(_s);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                }
-                // INSTANCE TYPES
-                if (meta.escaped)
-                    expressions.push(decode(importer)(explore)(meta.escaped.returns));
-                try {
-                    for (var _u = __values(meta.arrays), _v = _u.next(); !_v.done; _v = _u.next()) {
-                        var array = _v.value;
-                        expressions.push.apply(expressions, __spreadArray([], __read(decode_array(importer)(explore)(array)), false));
-                    }
-                }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (_v && !_v.done && (_e = _u.return)) _e.call(_u);
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                }
-                try {
-                    for (var _w = __values(meta.tuples), _x = _w.next(); !_x.done; _x = _w.next()) {
-                        var tuple = _x.value;
-                        expressions.push(decode_tuple(importer)(explore)(tuple));
-                    }
-                }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                finally {
-                    try {
-                        if (_x && !_x.done && (_f = _w.return)) _f.call(_w);
-                    }
-                    finally { if (e_6) throw e_6.error; }
-                }
-                try {
-                    for (var _y = __values(meta.objects), _z = _y.next(); !_z.done; _z = _y.next()) {
-                        var o = _z.value;
-                        expressions.push(decode_object(importer)(explore)(o));
-                    }
-                }
-                catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                finally {
-                    try {
-                        if (_z && !_z.done && (_g = _y.return)) _g.call(_y);
-                    }
-                    finally { if (e_7) throw e_7.error; }
-                }
-                try {
-                    for (var _0 = __values(meta.natives), _1 = _0.next(); !_1.done; _1 = _0.next()) {
-                        var native = _1.value;
-                        expressions.push(decode_native(importer)(native));
-                    }
-                }
-                catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                finally {
-                    try {
-                        if (_1 && !_1.done && (_h = _0.return)) _h.call(_0);
-                    }
-                    finally { if (e_8) throw e_8.error; }
-                }
-                try {
-                    for (var _2 = __values(meta.sets), _3 = _2.next(); !_3.done; _3 = _2.next()) {
-                        var set = _3.value;
-                        expressions.push(decode_set(importer)(explore)(set));
-                    }
-                }
-                catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                finally {
-                    try {
-                        if (_3 && !_3.done && (_j = _2.return)) _j.call(_2);
-                    }
-                    finally { if (e_9) throw e_9.error; }
-                }
+    var decode = function (props) {
+        var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f, e_7, _g, e_8, _h, e_9, _j, e_10, _k;
+        var expressions = [];
+        if (props.metadata.any === true)
+            expressions.push(typescript_1.default.factory.createStringLiteral("any type used..."));
+        // NULL COALESCING
+        if (props.metadata.isRequired() === false ||
+            props.metadata.functions.length !== 0)
+            expressions.push(typescript_1.default.factory.createIdentifier("undefined"));
+        if (props.metadata.nullable === true)
+            expressions.push(typescript_1.default.factory.createNull());
+        try {
+            // CONSTANT TYPES
+            for (var _l = __values(props.metadata.constants), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var constant = _m.value;
                 try {
-                    for (var _4 = __values(meta.maps), _5 = _4.next(); !_5.done; _5 = _4.next()) {
-                        var map = _5.value;
-                        expressions.push(decode_map(importer)(explore)(map));
+                    for (var _o = (e_2 = void 0, __values(constant.values)), _p = _o.next(); !_p.done; _p = _o.next()) {
+                        var value = _p.value.value;
+                        expressions.push(decode_atomic(value));
                     }
                 }
-                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
                 finally {
                     try {
-                        if (_5 && !_5.done && (_k = _4.return)) _k.call(_4);
+                        if (_p && !_p.done && (_b = _o.return)) _b.call(_o);
                     }
-                    finally { if (e_10) throw e_10.error; }
+                    finally { if (e_2) throw e_2.error; }
                 }
-                // PICK UP A TYPE
-                if (expressions.length === 1)
-                    return expressions[0];
-                return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createCallExpression(importer.use("pick"), undefined, [
-                    typescript_1.default.factory.createArrayLiteralExpression(expressions.map(function (expr) {
-                        return typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, expr);
-                    }), true),
-                ]), undefined, undefined);
-            };
-        };
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_a = _l.return)) _a.call(_l);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            // ATOMIC VARIABLES
+            for (var _q = __values(props.metadata.templates), _r = _q.next(); !_r.done; _r = _q.next()) {
+                var template = _r.value;
+                expressions.push(decode_template(__assign(__assign({}, props), { template: template })));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_r && !_r.done && (_c = _q.return)) _c.call(_q);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            for (var _s = __values(props.metadata.atomics), _t = _s.next(); !_t.done; _t = _s.next()) {
+                var atomic = _t.value;
+                if (atomic.type === "boolean")
+                    expressions.push(decode_boolean(props.importer));
+                else if (atomic.type === "number")
+                    expressions.push.apply(expressions, __spreadArray([], __read(decode_number({
+                        importer: props.importer,
+                        atomic: atomic,
+                    })), false));
+                else if (atomic.type === "string")
+                    expressions.push.apply(expressions, __spreadArray([], __read(decode_string({
+                        importer: props.importer,
+                        atomic: atomic,
+                    })), false));
+                else if (atomic.type === "bigint")
+                    expressions.push.apply(expressions, __spreadArray([], __read(decode_bigint({
+                        importer: props.importer,
+                        atomic: atomic,
+                    })), false));
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_t && !_t.done && (_d = _s.return)) _d.call(_s);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        // INSTANCE TYPES
+        if (props.metadata.escaped)
+            expressions.push(decode(__assign(__assign({}, props), { metadata: props.metadata.escaped.returns })));
+        try {
+            for (var _u = __values(props.metadata.arrays), _v = _u.next(); !_v.done; _v = _u.next()) {
+                var array = _v.value;
+                expressions.push.apply(expressions, __spreadArray([], __read(decode_array(__assign(__assign({}, props), { array: array }))), false));
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_v && !_v.done && (_e = _u.return)) _e.call(_u);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        try {
+            for (var _w = __values(props.metadata.tuples), _x = _w.next(); !_x.done; _x = _w.next()) {
+                var tuple = _x.value;
+                expressions.push(decode_tuple(__assign(__assign({}, props), { tuple: tuple })));
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_x && !_x.done && (_f = _w.return)) _f.call(_w);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        try {
+            for (var _y = __values(props.metadata.objects), _z = _y.next(); !_z.done; _z = _y.next()) {
+                var object = _z.value;
+                expressions.push(decode_object(__assign(__assign({}, props), { object: object })));
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_z && !_z.done && (_g = _y.return)) _g.call(_y);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        try {
+            for (var _0 = __values(props.metadata.natives), _1 = _0.next(); !_1.done; _1 = _0.next()) {
+                var name_1 = _1.value;
+                expressions.push(decode_native({
+                    importer: props.importer,
+                    name: name_1,
+                }));
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_1 && !_1.done && (_h = _0.return)) _h.call(_0);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        try {
+            for (var _2 = __values(props.metadata.sets), _3 = _2.next(); !_3.done; _3 = _2.next()) {
+                var metadata = _3.value;
+                expressions.push(decode_set(__assign(__assign({}, props), { metadata: metadata })));
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_3 && !_3.done && (_j = _2.return)) _j.call(_2);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        try {
+            for (var _4 = __values(props.metadata.maps), _5 = _4.next(); !_5.done; _5 = _4.next()) {
+                var entry = _5.value;
+                expressions.push(decode_map(__assign(__assign({}, props), { entry: entry })));
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_5 && !_5.done && (_k = _4.return)) _k.call(_4);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        // PICK UP A TYPE
+        if (expressions.length === 1)
+            return expressions[0];
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createCallExpression(props.importer.use("pick"), undefined, [
+            typescript_1.default.factory.createArrayLiteralExpression(expressions.map(function (expr) {
+                return typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, expr);
+            }), true),
+        ]), undefined, undefined);
     };
     var decode_boolean = function (importer) {
-        return typescript_1.default.factory.createCallExpression(COALESCE(importer)("boolean"), undefined, undefined);
+        return typescript_1.default.factory.createCallExpression(coalesce(importer)("boolean"), undefined, undefined);
     };
     var decode_atomic = function (value) {
         return typeof value === "boolean"
@@ -364,47 +403,47 @@ var RandomProgrammer;
                     ? typescript_1.default.factory.createStringLiteral(value)
                     : ExpressionFactory_1.ExpressionFactory.bigint(Number(value));
     };
-    var decode_template = function (importer) {
-        return function (explore) {
-            return function (template) {
-                return TemplateFactory_1.TemplateFactory.generate(template.row.map(function (meta) { return decode(importer)(explore)(meta); }));
-            };
-        };
+    var decode_template = function (props) {
+        return TemplateFactory_1.TemplateFactory.generate(props.template.row.map(function (metadata) {
+            return decode(__assign(__assign({}, props), { metadata: metadata }));
+        }));
     };
-    var decode_number = function (importer) {
-        return function (atomic) {
-            return (atomic.tags.length ? atomic.tags : [[]]).map(function (tags) {
-                var type = tags.find(function (t) {
-                    return t.kind === "type" && (t.value === "int32" || t.value === "int64");
+    var decode_number = function (props) {
+        return (props.atomic.tags.length ? props.atomic.tags : [[]]).map(function (tags) {
+            var type = tags.find(function (t) {
+                return t.kind === "type" && (t.value === "int32" || t.value === "int64");
+            })
+                ? "int"
+                : tags.find(function (t) {
+                    return t.kind === "type" &&
+                        (t.value === "uint32" || t.value === "uint64");
                 })
-                    ? "int"
-                    : tags.find(function (t) {
-                        return t.kind === "type" &&
-                            (t.value === "uint32" || t.value === "uint64");
-                    })
-                        ? "uint"
-                        : "double";
-                var multiply = tags.find(function (t) { return t.kind === "multipleOf"; });
-                return (0, random_custom_1.random_custom)(COALESCE(importer))("number")(tags)(RandomRanger_1.RandomRanger.number({
+                    ? "uint"
+                    : "double";
+            var multiply = tags.find(function (t) { return t.kind === "multipleOf"; });
+            return (0, random_custom_1.random_custom)(coalesce(props.importer))("number")(tags)(RandomRanger_1.RandomRanger.number({
+                config: {
                     type: type,
                     transform: function (value) { return ExpressionFactory_1.ExpressionFactory.number(value); },
                     setter: function (args) {
                         return typescript_1.default.factory.createCallExpression(type !== "double" || multiply !== undefined
-                            ? COALESCE(importer)("integer")
-                            : COALESCE(importer)("number"), undefined, args.map(function (val) { return ExpressionFactory_1.ExpressionFactory.number(val); }));
+                            ? coalesce(props.importer)("integer")
+                            : coalesce(props.importer)("number"), undefined, args.map(function (val) { return ExpressionFactory_1.ExpressionFactory.number(val); }));
                     },
-                })({
+                },
+                defaults: {
                     minimum: 0,
                     maximum: 100,
                     gap: 10,
-                })(tags));
-            });
-        };
+                },
+                tags: tags,
+            }));
+        });
     };
-    var decode_bigint = function (importer) {
-        return function (atomic) {
-            return (atomic.tags.length ? atomic.tags : [[]]).map(function (tags) {
-                return (0, random_custom_1.random_custom)(COALESCE(importer))("bigint")(tags)(RandomRanger_1.RandomRanger.number({
+    var decode_bigint = function (props) {
+        return (props.atomic.tags.length ? props.atomic.tags : [[]]).map(function (tags) {
+            return (0, random_custom_1.random_custom)(coalesce(props.importer))("bigint")(tags)(RandomRanger_1.RandomRanger.number({
+                config: {
                     type: tags.find(function (t) {
                         return t.kind === "type" &&
                             (t.value === "uint" || t.value === "uint64");
@@ -413,297 +452,322 @@ var RandomProgrammer;
                         : "int",
                     transform: function (value) { return ExpressionFactory_1.ExpressionFactory.bigint(value); },
                     setter: function (args) {
-                        return typescript_1.default.factory.createCallExpression(COALESCE(importer)("bigint"), undefined, args.map(function (value) { return ExpressionFactory_1.ExpressionFactory.bigint(value); }));
+                        return typescript_1.default.factory.createCallExpression(coalesce(props.importer)("bigint"), undefined, args.map(function (value) { return ExpressionFactory_1.ExpressionFactory.bigint(value); }));
                     },
-                })({
+                },
+                defaults: {
                     minimum: 0,
                     maximum: 100,
                     gap: 10,
-                })(tags));
-            });
-        };
+                },
+                tags: tags,
+            }));
+        });
     };
-    var decode_string = function (importer) {
-        return function (atomic) {
-            return (atomic.tags.length ? atomic.tags : [[]]).map(function (tags) {
-                return (0, random_custom_1.random_custom)(COALESCE(importer))("string")(tags)((function () {
-                    var e_11, _a;
-                    try {
-                        for (var tags_1 = __values(tags), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) {
-                            var t = tags_1_1.value;
-                            if (t.kind === "format")
-                                return typescript_1.default.factory.createCallExpression(COALESCE(importer)(emendFormat(t.value)), undefined, undefined);
-                            else if (t.kind === "pattern")
-                                return typescript_1.default.factory.createCallExpression(COALESCE(importer)("pattern"), undefined, [
-                                    typescript_1.default.factory.createIdentifier("RegExp(".concat(JSON.stringify(t.value), ")")),
-                                ]);
-                        }
+    var decode_string = function (props) {
+        return (props.atomic.tags.length ? props.atomic.tags : [[]]).map(function (tags) {
+            return (0, random_custom_1.random_custom)(coalesce(props.importer))("string")(tags)((function () {
+                var e_11, _a;
+                try {
+                    for (var tags_1 = __values(tags), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) {
+                        var t = tags_1_1.value;
+                        if (t.kind === "format")
+                            return typescript_1.default.factory.createCallExpression(coalesce(props.importer)(emendFormat(t.value)), undefined, undefined);
+                        else if (t.kind === "pattern")
+                            return typescript_1.default.factory.createCallExpression(coalesce(props.importer)("pattern"), undefined, [
+                                typescript_1.default.factory.createIdentifier("RegExp(".concat(JSON.stringify(t.value), ")")),
+                            ]);
                     }
-                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
-                    finally {
-                        try {
-                            if (tags_1_1 && !tags_1_1.done && (_a = tags_1.return)) _a.call(tags_1);
-                        }
-                        finally { if (e_11) throw e_11.error; }
+                }
+                catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                finally {
+                    try {
+                        if (tags_1_1 && !tags_1_1.done && (_a = tags_1.return)) _a.call(tags_1);
                     }
-                    var tail = RandomRanger_1.RandomRanger.length(COALESCE(importer))({
+                    finally { if (e_11) throw e_11.error; }
+                }
+                var tail = RandomRanger_1.RandomRanger.length({
+                    coalesce: coalesce(props.importer),
+                    defaults: {
                         minimum: 5,
                         maximum: 25,
                         gap: 5,
-                    })({
+                    },
+                    accessors: {
                         minimum: "minLength",
                         maximum: "maxLength",
-                    })(tags);
-                    return typescript_1.default.factory.createCallExpression(COALESCE(importer)("string"), undefined, tail ? [tail] : undefined);
-                })());
-            });
-        };
-    };
-    var decode_array = function (importer) {
-        return function (explore) {
-            return function (array) {
-                var fixed = (array.tags.length ? array.tags : [[]]).map(function (tags) { return [
-                    RandomRanger_1.RandomRanger.length(COALESCE(importer))({
-                        minimum: 0,
-                        maximum: 3,
-                        gap: 3,
-                    })({
-                        minimum: "minItems",
-                        maximum: "maxItems",
-                    })(tags),
-                    (function () {
-                        var uniqueItems = tags.find(function (t) { return t.kind === "uniqueItems"; });
-                        return uniqueItems === undefined
-                            ? undefined
-                            : uniqueItems.value === false
-                                ? typescript_1.default.factory.createFalse()
-                                : typescript_1.default.factory.createTrue();
-                    })(),
-                ]; });
-                if (array.type.recursive)
-                    return fixed.map(function (_a) {
-                        var _b = __read(_a, 2), len = _b[0], unique = _b[1];
-                        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal(Prefix.array(array.type.index))), undefined, [
-                            len !== null && len !== void 0 ? len : COALESCE(importer)("length"),
-                            unique !== null && unique !== void 0 ? unique : typescript_1.default.factory.createFalse(),
-                            typescript_1.default.factory.createTrue(),
-                            explore.recursive
-                                ? typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth"))
-                                : ExpressionFactory_1.ExpressionFactory.number(0),
-                        ]);
-                    });
-                return fixed.map(function (_a) {
-                    var _b = __read(_a, 2), len = _b[0], unique = _b[1];
-                    var expr = RandomJoiner_1.RandomJoiner.array(COALESCE(importer))(decode(importer)(explore))(explore)(len, unique)(array.type.value);
-                    return explore.recursive
-                        ? typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createIdentifier("_recursive"), typescript_1.default.factory.createLessThan(ExpressionFactory_1.ExpressionFactory.number(5), typescript_1.default.factory.createIdentifier("_depth"))), undefined, typescript_1.default.factory.createIdentifier("[]"), undefined, expr)
-                        : expr;
+                    },
+                    tags: tags,
                 });
-            };
-        };
+                return typescript_1.default.factory.createCallExpression(coalesce(props.importer)("string"), undefined, tail ? [tail] : undefined);
+            })());
+        });
     };
-    var decode_tuple = function (importer) {
-        return function (explore) {
-            return function (tuple) {
-                return tuple.type.recursive
-                    ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal(Prefix.tuple(tuple.type.index))), undefined, [
-                        typescript_1.default.factory.createTrue(),
-                        explore.recursive
-                            ? typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth"))
-                            : ExpressionFactory_1.ExpressionFactory.number(0),
-                    ])
-                    : RandomJoiner_1.RandomJoiner.tuple(decode(importer)(explore))(tuple.type.elements);
-            };
-        };
+    var decode_array = function (props) {
+        var fixed = (props.array.tags.length ? props.array.tags : [[]]).map(function (tags) { return [
+            RandomRanger_1.RandomRanger.length({
+                coalesce: coalesce(props.importer),
+                defaults: {
+                    minimum: 0,
+                    maximum: 3,
+                    gap: 3,
+                },
+                accessors: {
+                    minimum: "minItems",
+                    maximum: "maxItems",
+                },
+                tags: tags,
+            }),
+            (function () {
+                var uniqueItems = tags.find(function (t) { return t.kind === "uniqueItems"; });
+                return uniqueItems === undefined
+                    ? undefined
+                    : uniqueItems.value === false
+                        ? typescript_1.default.factory.createFalse()
+                        : typescript_1.default.factory.createTrue();
+            })(),
+        ]; });
+        if (props.array.type.recursive)
+            return fixed.map(function (_a) {
+                var _b = __read(_a, 2), len = _b[0], unique = _b[1];
+                return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal(Prefix.array(props.array.type.index))), undefined, [
+                    len !== null && len !== void 0 ? len : coalesce(props.importer)("length"),
+                    unique !== null && unique !== void 0 ? unique : typescript_1.default.factory.createFalse(),
+                    typescript_1.default.factory.createTrue(),
+                    props.explore.recursive
+                        ? typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth"))
+                        : ExpressionFactory_1.ExpressionFactory.number(0),
+                ]);
+            });
+        return fixed.map(function (_a) {
+            var _b = __read(_a, 2), len = _b[0], unique = _b[1];
+            var expr = RandomJoiner_1.RandomJoiner.array({
+                coalesce: coalesce(props.importer),
+                decode: function (metadata) {
+                    return decode(__assign(__assign({}, props), { metadata: metadata }));
+                },
+                explore: props.explore,
+                length: len,
+                unique: unique,
+                metadata: props.array.type.value,
+            });
+            return props.explore.recursive
+                ? typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createIdentifier("_recursive"), typescript_1.default.factory.createLessThan(ExpressionFactory_1.ExpressionFactory.number(5), typescript_1.default.factory.createIdentifier("_depth"))), undefined, typescript_1.default.factory.createIdentifier("[]"), undefined, expr)
+                : expr;
+        });
     };
-    var decode_object = function (importer) {
-        return function (explore) {
-            return function (object) {
-                return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal(Prefix.object(object.index))), undefined, explore.function
-                    ? [
-                        explore.recursive
-                            ? typescript_1.default.factory.createTrue()
-                            : typescript_1.default.factory.createIdentifier("_recursive"),
-                        typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createIdentifier("_recursive"), undefined, typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth")), undefined, typescript_1.default.factory.createIdentifier("_depth")),
-                    ]
-                    : undefined);
-            };
-        };
+    var decode_tuple = function (props) {
+        return props.tuple.type.recursive
+            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal(Prefix.tuple(props.tuple.type.index))), undefined, [
+                typescript_1.default.factory.createTrue(),
+                props.explore.recursive
+                    ? typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth"))
+                    : ExpressionFactory_1.ExpressionFactory.number(0),
+            ])
+            : RandomJoiner_1.RandomJoiner.tuple({
+                decode: function (metadata) {
+                    return decode(__assign(__assign({}, props), { metadata: metadata }));
+                },
+                elements: props.tuple.type.elements,
+            });
+    };
+    var decode_object = function (props) {
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal(Prefix.object(props.object.index))), undefined, props.explore.function
+            ? [
+                props.explore.recursive
+                    ? typescript_1.default.factory.createTrue()
+                    : typescript_1.default.factory.createIdentifier("_recursive"),
+                typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createIdentifier("_recursive"), undefined, typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth")), undefined, typescript_1.default.factory.createIdentifier("_depth")),
+            ]
+            : undefined);
     };
     /* -----------------------------------------------------------
       NATIVE CLASSES
     ----------------------------------------------------------- */
-    var decode_set = function (importer) { return function (explore) { return function (meta) {
+    var decode_set = function (props) {
         return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), undefined, [
-            decode_array(importer)(explore)(MetadataArray_1.MetadataArray.create({
-                tags: [],
-                type: MetadataArrayType_1.MetadataArrayType.create({
-                    value: meta,
-                    recursive: false,
-                    index: null,
-                    nullables: [],
-                    name: "Set<".concat(meta.getName(), ">"),
-                }),
-            }))[0],
+            decode_array(__assign(__assign({}, props), { array: MetadataArray_1.MetadataArray.create({
+                    tags: [],
+                    type: MetadataArrayType_1.MetadataArrayType.create({
+                        value: props.metadata,
+                        recursive: false,
+                        index: null,
+                        nullables: [],
+                        name: "Set<".concat(props.metadata.getName(), ">"),
+                    }),
+                }) }))[0],
         ]);
-    }; }; };
-    var decode_map = function (importer) {
-        return function (explore) {
-            return function (map) {
-                return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), undefined, [
-                    decode_array(importer)(explore)(MetadataArray_1.MetadataArray.create({
-                        tags: [],
-                        type: MetadataArrayType_1.MetadataArrayType.create({
-                            name: "Map<".concat(map.key.getName(), ", ").concat(map.value.getName(), ">"),
-                            index: null,
-                            recursive: false,
-                            nullables: [],
-                            value: Metadata_1.Metadata.create(__assign(__assign({}, Metadata_1.Metadata.initialize()), { tuples: [
-                                    (function () {
-                                        var type = MetadataTupleType_1.MetadataTupleType.create({
-                                            name: "[".concat(map.key.getName(), ", ").concat(map.value.getName(), "]"),
-                                            index: null,
-                                            recursive: false,
-                                            nullables: [],
-                                            elements: [map.key, map.value],
-                                        });
-                                        type.of_map = true;
-                                        return MetadataTuple_1.MetadataTuple.create({
-                                            type: type,
-                                            tags: [],
-                                        });
-                                    })(),
-                                ] })),
-                        }),
-                    }))[0],
-                ]);
-            };
-        };
     };
-    var decode_native = function (importer) {
-        return function (type) {
-            if (type === "Boolean")
-                return decode_boolean(importer);
-            else if (type === "Number")
-                return decode_number(importer)(MetadataAtomic_1.MetadataAtomic.create({
+    var decode_map = function (props) {
+        return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), undefined, [
+            decode_array(__assign(__assign({}, props), { array: MetadataArray_1.MetadataArray.create({
+                    tags: [],
+                    type: MetadataArrayType_1.MetadataArrayType.create({
+                        name: "Map<".concat(props.entry.key.getName(), ", ").concat(props.entry.value.getName(), ">"),
+                        index: null,
+                        recursive: false,
+                        nullables: [],
+                        value: Metadata_1.Metadata.create(__assign(__assign({}, Metadata_1.Metadata.initialize()), { tuples: [
+                                (function () {
+                                    var type = MetadataTupleType_1.MetadataTupleType.create({
+                                        name: "[".concat(props.entry.key.getName(), ", ").concat(props.entry.value.getName(), "]"),
+                                        index: null,
+                                        recursive: false,
+                                        nullables: [],
+                                        elements: [props.entry.key, props.entry.value],
+                                    });
+                                    type.of_map = true;
+                                    return MetadataTuple_1.MetadataTuple.create({
+                                        type: type,
+                                        tags: [],
+                                    });
+                                })(),
+                            ] })),
+                    }),
+                }) }))[0],
+        ]);
+    };
+    var decode_native = function (props) {
+        if (props.name === "Boolean")
+            return decode_boolean(props.importer);
+        else if (props.name === "Number")
+            return decode_number({
+                importer: props.importer,
+                atomic: MetadataAtomic_1.MetadataAtomic.create({
                     type: "number",
                     tags: [],
-                }))[0];
-            else if (type === "String")
-                return decode_string(importer)(MetadataAtomic_1.MetadataAtomic.create({
+                }),
+            })[0];
+        else if (props.name === "String")
+            return decode_string({
+                importer: props.importer,
+                atomic: MetadataAtomic_1.MetadataAtomic.create({
                     type: "string",
                     tags: [],
-                }))[0];
-            else if (type === "Date")
-                return decode_native_date(importer);
-            else if (type === "Uint8Array" ||
-                type === "Uint8ClampedArray" ||
-                type === "Uint16Array" ||
-                type === "Uint32Array" ||
-                type === "BigUint64Array" ||
-                type === "Int8Array" ||
-                type === "Int16Array" ||
-                type === "Int32Array" ||
-                type === "BigInt64Array" ||
-                type === "Float32Array" ||
-                type === "Float64Array")
-                return decode_native_byte_array(importer)(type);
-            else if (type === "ArrayBuffer" || type === "SharedArrayBuffer")
-                return decode_native_array_buffer(importer)(type);
-            else if (type === "DataView")
-                return decode_native_data_view(importer);
-            else if (type === "Blob")
-                return decode_native_blob(importer);
-            else if (type === "File")
-                return decode_native_file(importer);
-            else if (type === "RegExp")
-                return decode_regexp();
-            else
-                return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(type), undefined, []);
-        };
+                }),
+            })[0];
+        else if (props.name === "Date")
+            return decode_native_date(props.importer);
+        else if (props.name === "Uint8Array" ||
+            props.name === "Uint8ClampedArray" ||
+            props.name === "Uint16Array" ||
+            props.name === "Uint32Array" ||
+            props.name === "BigUint64Array" ||
+            props.name === "Int8Array" ||
+            props.name === "Int16Array" ||
+            props.name === "Int32Array" ||
+            props.name === "BigInt64Array" ||
+            props.name === "Float32Array" ||
+            props.name === "Float64Array")
+            return decode_native_byte_array(__assign(__assign({}, props), { name: props.name }));
+        else if (props.name === "ArrayBuffer" || props.name === "SharedArrayBuffer")
+            return decode_native_array_buffer(__assign(__assign({}, props), { name: props.name }));
+        else if (props.name === "DataView")
+            return decode_native_data_view(props.importer);
+        else if (props.name === "Blob")
+            return decode_native_blob(props.importer);
+        else if (props.name === "File")
+            return decode_native_file(props.importer);
+        else if (props.name === "RegExp")
+            return decode_regexp();
+        else
+            return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.name), undefined, []);
     };
     var decode_native_date = function (importer) {
         return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Date"), undefined, [
-            typescript_1.default.factory.createCallExpression(COALESCE(importer)("datetime"), undefined, []),
+            typescript_1.default.factory.createCallExpression(coalesce(importer)("datetime"), undefined, []),
         ]);
     };
-    var decode_native_byte_array = function (importer) {
-        return function (type) {
-            new BigInt64Array();
-            var _a = __read((function () {
-                if (type === "Uint8Array" || type === "Uint8ClampedArray")
-                    return [0, 255];
-                else if (type === "Uint16Array")
-                    return [0, 65535];
-                else if (type === "Uint32Array")
-                    return [0, 4294967295];
-                else if (type === "BigUint64Array")
-                    return [0, 18446744073709551615];
-                else if (type === "Int8Array")
-                    return [-128, 127];
-                else if (type === "Int16Array")
-                    return [-32768, 32767];
-                else if (type === "Int32Array")
-                    return [-2147483648, 2147483647];
-                else if (type === "BigInt64Array")
-                    return [-9223372036854775808, 9223372036854775807];
-                else if (type === "Float32Array")
-                    return [-1.175494351e38, 3.4028235e38];
-                return [Number.MIN_VALUE, Number.MAX_VALUE];
-            })(), 2), minimum = _a[0], maximum = _a[1];
-            var literal = type === "BigInt64Array" || type === "BigUint64Array"
-                ? ExpressionFactory_1.ExpressionFactory.bigint
-                : ExpressionFactory_1.ExpressionFactory.number;
-            return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(type), [], [
-                typescript_1.default.factory.createCallExpression(COALESCE(importer)("array"), undefined, [
-                    typescript_1.default.factory.createArrowFunction(undefined, undefined, [], TypeFactory_1.TypeFactory.keyword("any"), undefined, typescript_1.default.factory.createCallExpression(COALESCE(importer)(type === "Float32Array" || type === "Float64Array"
-                        ? "number"
-                        : type === "BigInt64Array" || type === "BigUint64Array"
-                            ? "bigint"
-                            : "integer"), undefined, [literal(minimum), literal(maximum)])),
-                ]),
-            ]);
-        };
+    var decode_native_byte_array = function (props) {
+        new BigInt64Array();
+        var _a = __read((function () {
+            if (props.name === "Uint8Array" || props.name === "Uint8ClampedArray")
+                return [0, 255];
+            else if (props.name === "Uint16Array")
+                return [0, 65535];
+            else if (props.name === "Uint32Array")
+                return [0, 4294967295];
+            else if (props.name === "BigUint64Array")
+                return [0, 18446744073709551615];
+            else if (props.name === "Int8Array")
+                return [-128, 127];
+            else if (props.name === "Int16Array")
+                return [-32768, 32767];
+            else if (props.name === "Int32Array")
+                return [-2147483648, 2147483647];
+            else if (props.name === "BigInt64Array")
+                return [-9223372036854775808, 9223372036854775807];
+            else if (props.name === "Float32Array")
+                return [-1.175494351e38, 3.4028235e38];
+            return [Number.MIN_VALUE, Number.MAX_VALUE];
+        })(), 2), minimum = _a[0], maximum = _a[1];
+        var literal = props.name === "BigInt64Array" || props.name === "BigUint64Array"
+            ? ExpressionFactory_1.ExpressionFactory.bigint
+            : ExpressionFactory_1.ExpressionFactory.number;
+        return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.name), [], [
+            typescript_1.default.factory.createCallExpression(coalesce(props.importer)("array"), undefined, [
+                typescript_1.default.factory.createArrowFunction(undefined, undefined, [], TypeFactory_1.TypeFactory.keyword("any"), undefined, typescript_1.default.factory.createCallExpression(coalesce(props.importer)(props.name === "Float32Array" || props.name === "Float64Array"
+                    ? "number"
+                    : props.name === "BigInt64Array" ||
+                        props.name === "BigUint64Array"
+                        ? "bigint"
+                        : "integer"), undefined, [literal(minimum), literal(maximum)])),
+            ]),
+        ]);
     };
     var decode_native_blob = function (importer) {
         return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Blob"), undefined, [
-            typescript_1.default.factory.createArrayLiteralExpression([decode_native_byte_array(importer)("Uint8Array")], true),
+            typescript_1.default.factory.createArrayLiteralExpression([
+                decode_native_byte_array({
+                    importer: importer,
+                    name: "Uint8Array",
+                }),
+            ], true),
         ]);
     };
     var decode_native_file = function (importer) {
         return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("File"), undefined, [
-            typescript_1.default.factory.createArrayLiteralExpression([decode_native_byte_array(importer)("Uint8Array")], true),
+            typescript_1.default.factory.createArrayLiteralExpression([
+                decode_native_byte_array({
+                    importer: importer,
+                    name: "Uint8Array",
+                }),
+            ], true),
             typescript_1.default.factory.createTemplateExpression(typescript_1.default.factory.createTemplateHead(""), [
-                typescript_1.default.factory.createTemplateSpan(typescript_1.default.factory.createCallExpression(COALESCE(importer)("string"), undefined, [typescript_1.default.factory.createNumericLiteral(8)]), typescript_1.default.factory.createTemplateMiddle(".")),
-                typescript_1.default.factory.createTemplateSpan(typescript_1.default.factory.createCallExpression(COALESCE(importer)("string"), undefined, [typescript_1.default.factory.createNumericLiteral(3)]), typescript_1.default.factory.createTemplateTail("")),
+                typescript_1.default.factory.createTemplateSpan(typescript_1.default.factory.createCallExpression(coalesce(importer)("string"), undefined, [typescript_1.default.factory.createNumericLiteral(8)]), typescript_1.default.factory.createTemplateMiddle(".")),
+                typescript_1.default.factory.createTemplateSpan(typescript_1.default.factory.createCallExpression(coalesce(importer)("string"), undefined, [typescript_1.default.factory.createNumericLiteral(3)]), typescript_1.default.factory.createTemplateTail("")),
             ]),
         ]);
     };
-    var decode_native_array_buffer = function (importer) {
-        return function (type) {
-            return type === "ArrayBuffer"
-                ? IdentifierFactory_1.IdentifierFactory.access(decode_native_byte_array(importer)("Uint8Array"))("buffer")
-                : ExpressionFactory_1.ExpressionFactory.selfCall(typescript_1.default.factory.createBlock([
-                    StatementFactory_1.StatementFactory.constant("length", typescript_1.default.factory.createCallExpression(COALESCE(importer)("integer"), undefined, [])),
-                    StatementFactory_1.StatementFactory.constant("buffer", typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("SharedArrayBuffer"), [], [typescript_1.default.factory.createIdentifier("length")])),
-                    StatementFactory_1.StatementFactory.constant("bytes", typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Uint8Array"), [], [typescript_1.default.factory.createIdentifier("buffer")])),
-                    typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(typescript_1.default.factory.createIdentifier("bytes"))("set"), undefined, [
-                        typescript_1.default.factory.createCallExpression(COALESCE(importer)("array"), undefined, [
-                            typescript_1.default.factory.createArrowFunction(undefined, undefined, [], TypeFactory_1.TypeFactory.keyword("any"), undefined, typescript_1.default.factory.createCallExpression(COALESCE(importer)("integer"), undefined, [
-                                ExpressionFactory_1.ExpressionFactory.number(0),
-                                ExpressionFactory_1.ExpressionFactory.number(255),
-                            ])),
-                            typescript_1.default.factory.createIdentifier("length"),
-                        ]),
-                        ExpressionFactory_1.ExpressionFactory.number(0),
-                    ])),
-                    typescript_1.default.factory.createReturnStatement(typescript_1.default.factory.createIdentifier("buffer")),
-                ], true));
-        };
+    var decode_native_array_buffer = function (props) {
+        return props.name === "ArrayBuffer"
+            ? IdentifierFactory_1.IdentifierFactory.access(decode_native_byte_array({
+                importer: props.importer,
+                name: "Uint8Array",
+            }))("buffer")
+            : ExpressionFactory_1.ExpressionFactory.selfCall(typescript_1.default.factory.createBlock([
+                StatementFactory_1.StatementFactory.constant("length", typescript_1.default.factory.createCallExpression(coalesce(props.importer)("integer"), undefined, [])),
+                StatementFactory_1.StatementFactory.constant("buffer", typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("SharedArrayBuffer"), [], [typescript_1.default.factory.createIdentifier("length")])),
+                StatementFactory_1.StatementFactory.constant("bytes", typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Uint8Array"), [], [typescript_1.default.factory.createIdentifier("buffer")])),
+                typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(typescript_1.default.factory.createIdentifier("bytes"))("set"), undefined, [
+                    typescript_1.default.factory.createCallExpression(coalesce(props.importer)("array"), undefined, [
+                        typescript_1.default.factory.createArrowFunction(undefined, undefined, [], TypeFactory_1.TypeFactory.keyword("any"), undefined, typescript_1.default.factory.createCallExpression(coalesce(props.importer)("integer"), undefined, [
+                            ExpressionFactory_1.ExpressionFactory.number(0),
+                            ExpressionFactory_1.ExpressionFactory.number(255),
+                        ])),
+                        typescript_1.default.factory.createIdentifier("length"),
+                    ]),
+                    ExpressionFactory_1.ExpressionFactory.number(0),
+                ])),
+                typescript_1.default.factory.createReturnStatement(typescript_1.default.factory.createIdentifier("buffer")),
+            ], true));
     };
     var decode_native_data_view = function (importer) {
         return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("DataView"), [], [
-            IdentifierFactory_1.IdentifierFactory.access(decode_native_byte_array(importer)("Uint8Array"))("buffer"),
+            IdentifierFactory_1.IdentifierFactory.access(decode_native_byte_array({
+                importer: importer,
+                name: "Uint8Array",
+            }))("buffer"),
         ]);
     };
     var decode_regexp = function () {
@@ -715,7 +779,7 @@ var Prefix = {
     array: function (i) { return "$ra".concat(i); },
     tuple: function (i) { return "$rt".concat(i); },
 };
-var COALESCE = function (importer) { return function (name) {
+var coalesce = function (importer) { return function (name) {
     return ExpressionFactory_1.ExpressionFactory.coalesce(Escaper_1.Escaper.variable(name)
         ? typescript_1.default.factory.createPropertyAccessChain(typescript_1.default.factory.createIdentifier("_generator"), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), typescript_1.default.factory.createIdentifier(name))
         : typescript_1.default.factory.createElementAccessChain(typescript_1.default.factory.createIdentifier("_generator"), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), typescript_1.default.factory.createStringLiteral(name)))(IdentifierFactory_1.IdentifierFactory.access(importer.use("generator"))(name));