typia 7.0.0-dev.20241112 → 7.0.0-dev.20241114

package/lib/programmers/json/JsonStringifyProgrammer.js

@@ -1,171 +1,113 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonStringifyProgrammer = void 0;
-var typescript_1 = __importDefault(require("typescript"));
-var ExpressionFactory_1 = require("../../factories/ExpressionFactory");
-var IdentifierFactory_1 = require("../../factories/IdentifierFactory");
-var JsonMetadataFactory_1 = require("../../factories/JsonMetadataFactory");
-var StatementFactory_1 = require("../../factories/StatementFactory");
-var TypeFactory_1 = require("../../factories/TypeFactory");
-var ValueFactory_1 = require("../../factories/ValueFactory");
-var Metadata_1 = require("../../schemas/metadata/Metadata");
-var MetadataArray_1 = require("../../schemas/metadata/MetadataArray");
-var MetadataAtomic_1 = require("../../schemas/metadata/MetadataAtomic");
-var FeatureProgrammer_1 = require("../FeatureProgrammer");
-var IsProgrammer_1 = require("../IsProgrammer");
-var AtomicPredicator_1 = require("../helpers/AtomicPredicator");
-var FunctionProgrammer_1 = require("../helpers/FunctionProgrammer");
-var OptionPredicator_1 = require("../helpers/OptionPredicator");
-var StringifyJoinder_1 = require("../helpers/StringifyJoinder");
-var StringifyPredicator_1 = require("../helpers/StringifyPredicator");
-var UnionExplorer_1 = require("../helpers/UnionExplorer");
-var check_native_1 = require("../internal/check_native");
-var decode_union_object_1 = require("../internal/decode_union_object");
-var postfix_of_tuple_1 = require("../internal/postfix_of_tuple");
-var wrap_metadata_rest_tuple_1 = require("../internal/wrap_metadata_rest_tuple");
+const typescript_1 = __importDefault(require("typescript"));
+const ExpressionFactory_1 = require("../../factories/ExpressionFactory");
+const IdentifierFactory_1 = require("../../factories/IdentifierFactory");
+const JsonMetadataFactory_1 = require("../../factories/JsonMetadataFactory");
+const StatementFactory_1 = require("../../factories/StatementFactory");
+const TypeFactory_1 = require("../../factories/TypeFactory");
+const ValueFactory_1 = require("../../factories/ValueFactory");
+const Metadata_1 = require("../../schemas/metadata/Metadata");
+const MetadataArray_1 = require("../../schemas/metadata/MetadataArray");
+const MetadataAtomic_1 = require("../../schemas/metadata/MetadataAtomic");
+const FeatureProgrammer_1 = require("../FeatureProgrammer");
+const IsProgrammer_1 = require("../IsProgrammer");
+const AtomicPredicator_1 = require("../helpers/AtomicPredicator");
+const FunctionProgrammer_1 = require("../helpers/FunctionProgrammer");
+const OptionPredicator_1 = require("../helpers/OptionPredicator");
+const StringifyJoinder_1 = require("../helpers/StringifyJoinder");
+const StringifyPredicator_1 = require("../helpers/StringifyPredicator");
+const UnionExplorer_1 = require("../helpers/UnionExplorer");
+const check_native_1 = require("../internal/check_native");
+const decode_union_object_1 = require("../internal/decode_union_object");
+const postfix_of_tuple_1 = require("../internal/postfix_of_tuple");
+const wrap_metadata_rest_tuple_1 = require("../internal/wrap_metadata_rest_tuple");
 var JsonStringifyProgrammer;
 (function (JsonStringifyProgrammer) {
     /* -----------------------------------------------------------
       WRITER
     ----------------------------------------------------------- */
-    JsonStringifyProgrammer.decompose = function (props) {
-        var config = configure(props);
+    JsonStringifyProgrammer.decompose = (props) => {
+        const config = configure(props);
         if (props.validated === false)
-            config.addition = function (collection) {
-                return IsProgrammer_1.IsProgrammer.write_function_statements({
-                    context: props.context,
-                    functor: props.functor,
-                    collection: collection,
-                });
-            };
-        var composed = FeatureProgrammer_1.FeatureProgrammer.compose(__assign(__assign({}, props), { config: config }));
+            config.addition = (collection) => IsProgrammer_1.IsProgrammer.write_function_statements({
+                context: props.context,
+                functor: props.functor,
+                collection,
+            });
+        const composed = FeatureProgrammer_1.FeatureProgrammer.compose(Object.assign(Object.assign({}, props), { config }));
         return {
             functions: composed.functions,
             statements: composed.statements,
             arrow: typescript_1.default.factory.createArrowFunction(undefined, undefined, composed.parameters, composed.response, undefined, composed.body),
         };
     };
-    JsonStringifyProgrammer.write = function (props) {
-        var functor = new FunctionProgrammer_1.FunctionProgrammer(props.modulo.getText());
-        var result = JsonStringifyProgrammer.decompose(__assign(__assign({}, props), { validated: false, functor: functor }));
+    JsonStringifyProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer_1.FunctionProgrammer(props.modulo.getText());
+        const result = JsonStringifyProgrammer.decompose(Object.assign(Object.assign({}, props), { validated: false, functor }));
         return FeatureProgrammer_1.FeatureProgrammer.writeDecomposed({
             modulo: props.modulo,
-            functor: functor,
-            result: result,
-        });
-    };
-    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({
-                name: "".concat(props.config.prefix, "a").concat(i),
-                value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
-                    config: props.config,
-                    type: TypeFactory_1.TypeFactory.keyword("any"),
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline({
-                    config: props.config,
-                    functor: props.functor,
-                    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 (props) {
-        return props.collection
-            .tuples()
-            .filter(function (t) { return t.recursive; })
-            .map(function (tuple, i) {
-            return StatementFactory_1.StatementFactory.constant({
-                name: "".concat(props.config.prefix, "t").concat(i),
-                value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
-                    config: props.config,
-                    type: TypeFactory_1.TypeFactory.keyword("any"),
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
-                    context: props.context,
-                    config: props.config,
-                    functor: props.functor,
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                    tuple: tuple,
-                    explore: {
-                        tracable: props.config.trace,
-                        source: "function",
-                        from: "array",
-                        postfix: "",
-                    },
-                })),
-            });
+            functor,
+            result,
         });
     };
+    const write_array_functions = (props) => props.collection
+        .arrays()
+        .filter((a) => a.recursive)
+        .map((type, i) => StatementFactory_1.StatementFactory.constant({
+        name: `${props.config.prefix}a${i}`,
+        value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory_1.TypeFactory.keyword("any"),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline({
+            config: props.config,
+            functor: props.functor,
+            input: typescript_1.default.factory.createIdentifier("input"),
+            array: MetadataArray_1.MetadataArray.create({
+                type,
+                tags: [],
+            }),
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    const write_tuple_functions = (props) => props.collection
+        .tuples()
+        .filter((t) => t.recursive)
+        .map((tuple, i) => StatementFactory_1.StatementFactory.constant({
+        name: `${props.config.prefix}t${i}`,
+        value: typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory_1.TypeFactory.keyword("any"),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: typescript_1.default.factory.createIdentifier("input"),
+            tuple,
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
     /* -----------------------------------------------------------
       DECODERS
     ----------------------------------------------------------- */
-    var decode = function (props) {
-        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
-        var _e;
+    const decode = (props) => {
+        var _a;
         // ANY TYPE
         if (props.metadata.any === true)
             return wrap_required({
@@ -180,7 +122,7 @@ var JsonStringifyProgrammer;
                 }),
             });
         // ONLY NULL OR UNDEFINED
-        var size = props.metadata.size();
+        const size = props.metadata.size();
         if (size === 0 &&
             (props.metadata.isRequired() === false ||
                 props.metadata.nullable === true)) {
@@ -199,265 +141,164 @@ var JsonStringifyProgrammer;
         //----
         // LIST UP UNION TYPES
         //----
-        var unions = [];
+        const unions = [];
         // toJSON() METHOD
         if (props.metadata.escaped !== null)
             unions.push({
                 type: "resolved",
                 is: props.metadata.escaped.original.size() === 1 &&
-                    ((_e = props.metadata.escaped.original.natives[0]) === null || _e === void 0 ? void 0 : _e.name) === "Date"
-                    ? function () {
-                        return (0, check_native_1.check_native)({
-                            name: "Date",
-                            input: props.input,
-                        });
-                    }
-                    : function () {
-                        return IsProgrammer_1.IsProgrammer.decode_to_json({
-                            checkNull: false,
-                            input: props.input,
-                        });
-                    },
-                value: function () {
-                    return decode_to_json(__assign(__assign({}, props), { metadata: props.metadata.escaped.returns }));
-                },
+                    ((_a = props.metadata.escaped.original.natives[0]) === null || _a === void 0 ? void 0 : _a.name) === "Date"
+                    ? () => (0, check_native_1.check_native)({
+                        name: "Date",
+                        input: props.input,
+                    })
+                    : () => IsProgrammer_1.IsProgrammer.decode_to_json({
+                        checkNull: false,
+                        input: props.input,
+                    }),
+                value: () => decode_to_json(Object.assign(Object.assign({}, props), { metadata: props.metadata.escaped.returns })),
             });
         else if (props.metadata.functions.length)
             unions.push({
                 type: "functional",
-                is: function () { return IsProgrammer_1.IsProgrammer.decode_functional(props.input); },
-                value: function () { return decode_functional(props.explore); },
+                is: () => IsProgrammer_1.IsProgrammer.decode_functional(props.input),
+                value: () => decode_functional(props.explore),
             });
         // TEMPLATES
         if (props.metadata.templates.length)
             if (AtomicPredicator_1.AtomicPredicator.template(props.metadata)) {
-                var partial_1 = Metadata_1.Metadata.initialize();
-                partial_1.atomics.push(MetadataAtomic_1.MetadataAtomic.create({ type: "string", tags: [] })),
+                const partial = Metadata_1.Metadata.initialize();
+                partial.atomics.push(MetadataAtomic_1.MetadataAtomic.create({ type: "string", tags: [] })),
                     unions.push({
                         type: "template literal",
-                        is: function () {
-                            return IsProgrammer_1.IsProgrammer.decode(__assign(__assign({}, props), { metadata: partial_1 }));
-                        },
-                        value: function () {
-                            return decode_atomic(__assign(__assign({}, props), { type: "string" }));
-                        },
+                        is: () => IsProgrammer_1.IsProgrammer.decode(Object.assign(Object.assign({}, props), { metadata: partial })),
+                        value: () => decode_atomic(Object.assign(Object.assign({}, props), { type: "string" })),
                     });
             }
-        var _loop_1 = function (constant) {
+        // CONSTANTS
+        for (const constant of props.metadata.constants)
             if (AtomicPredicator_1.AtomicPredicator.constant({
                 metadata: props.metadata,
                 name: constant.type,
             }) === false)
-                return "continue";
+                continue;
             else if (constant.type !== "string")
                 unions.push({
                     type: "atomic",
-                    is: function () {
-                        return IsProgrammer_1.IsProgrammer.decode(__assign(__assign({}, props), { metadata: (function () {
-                                var partial = Metadata_1.Metadata.initialize();
-                                partial.atomics.push(MetadataAtomic_1.MetadataAtomic.create({
-                                    type: constant.type,
-                                    tags: [],
-                                }));
-                                return partial;
-                            })() }));
-                    },
-                    value: function () {
-                        return decode_atomic(__assign(__assign({}, props), { type: constant.type }));
-                    },
+                    is: () => IsProgrammer_1.IsProgrammer.decode(Object.assign(Object.assign({}, props), { metadata: (() => {
+                            const partial = Metadata_1.Metadata.initialize();
+                            partial.atomics.push(MetadataAtomic_1.MetadataAtomic.create({
+                                type: constant.type,
+                                tags: [],
+                            }));
+                            return partial;
+                        })() })),
+                    value: () => decode_atomic(Object.assign(Object.assign({}, props), { type: constant.type })),
                 });
             else if (props.metadata.templates.length === 0)
                 unions.push({
                     type: "const string",
-                    is: function () {
-                        return IsProgrammer_1.IsProgrammer.decode(__assign(__assign({}, props), { metadata: (function () {
-                                var partial = Metadata_1.Metadata.initialize();
-                                partial.atomics.push(MetadataAtomic_1.MetadataAtomic.create({
-                                    type: "string",
-                                    tags: [],
-                                }));
-                                return partial;
-                            })() }));
-                    },
-                    value: function () {
-                        return decode_constant_string(__assign(__assign({}, props), { values: __spreadArray([], __read(constant.values.map(function (v) { return v.value; })), false) }));
-                    },
+                    is: () => IsProgrammer_1.IsProgrammer.decode(Object.assign(Object.assign({}, props), { metadata: (() => {
+                            const partial = Metadata_1.Metadata.initialize();
+                            partial.atomics.push(MetadataAtomic_1.MetadataAtomic.create({
+                                type: "string",
+                                tags: [],
+                            }));
+                            return partial;
+                        })() })),
+                    value: () => decode_constant_string(Object.assign(Object.assign({}, props), { values: [...constant.values.map((v) => v.value)] })),
                 });
-        };
-        try {
-            // CONSTANTS
-            for (var _f = __values(props.metadata.constants), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var constant = _g.value;
-                _loop_1(constant);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        var _loop_2 = function (a) {
+        /// ATOMICS
+        for (const a of props.metadata.atomics)
             if (AtomicPredicator_1.AtomicPredicator.atomic({
                 metadata: props.metadata,
                 name: a.type,
             }))
                 unions.push({
                     type: "atomic",
-                    is: function () {
-                        return IsProgrammer_1.IsProgrammer.decode(__assign(__assign({}, props), { metadata: (function () {
-                                var partial = Metadata_1.Metadata.initialize();
-                                partial.atomics.push(a);
-                                return partial;
-                            })() }));
-                    },
-                    value: function () {
-                        return decode_atomic(__assign(__assign({}, props), { type: a.type }));
-                    },
+                    is: () => IsProgrammer_1.IsProgrammer.decode(Object.assign(Object.assign({}, props), { metadata: (() => {
+                            const partial = Metadata_1.Metadata.initialize();
+                            partial.atomics.push(a);
+                            return partial;
+                        })() })),
+                    value: () => decode_atomic(Object.assign(Object.assign({}, props), { type: a.type })),
                 });
-        };
-        try {
-            /// ATOMICS
-            for (var _h = __values(props.metadata.atomics), _j = _h.next(); !_j.done; _j = _h.next()) {
-                var a = _j.value;
-                _loop_2(a);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        var _loop_3 = function (tuple) {
+        // TUPLES
+        for (const tuple of props.metadata.tuples)
             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 }));
-                },
+                is: () => IsProgrammer_1.IsProgrammer.decode(Object.assign(Object.assign({}, props), { metadata: (() => {
+                        const partial = Metadata_1.Metadata.initialize();
+                        partial.tuples.push(tuple);
+                        return partial;
+                    })() })),
+                value: () => decode_tuple(Object.assign(Object.assign({}, props), { tuple })),
             });
-        };
-        try {
-            // TUPLES
-            for (var _k = __values(props.metadata.tuples), _l = _k.next(); !_l.done; _l = _k.next()) {
-                var tuple = _l.value;
-                _loop_3(tuple);
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
         // ARRAYS
         if (props.metadata.arrays.length) {
-            var value = props.metadata.arrays.length === 1
-                ? function () {
-                    return decode_array(__assign(__assign({}, props), { array: props.metadata.arrays[0], explore: __assign(__assign({}, props.explore), { from: "array" }) }));
-                }
-                : props.metadata.arrays.some(function (elem) { return elem.type.value.any; })
-                    ? function () {
-                        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("JSON.stringify"), undefined, [props.input]);
-                    }
-                    : function () {
-                        return explore_arrays(__assign(__assign({}, props), { arrays: props.metadata.arrays, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
-                    };
+            const value = props.metadata.arrays.length === 1
+                ? () => decode_array(Object.assign(Object.assign({}, props), { array: props.metadata.arrays[0], explore: Object.assign(Object.assign({}, props.explore), { from: "array" }) }))
+                : props.metadata.arrays.some((elem) => elem.type.value.any)
+                    ? () => typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("JSON.stringify"), undefined, [props.input])
+                    : () => explore_arrays(Object.assign(Object.assign({}, props), { arrays: props.metadata.arrays, explore: Object.assign(Object.assign({}, props.explore), { from: "array" }) }));
             unions.push({
                 type: "array",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(props.input); },
-                value: value,
+                is: () => ExpressionFactory_1.ExpressionFactory.isArray(props.input),
+                value,
             });
         }
         // BUILT-IN CLASSES
-        if (props.metadata.natives.length) {
-            var _loop_4 = function (native) {
+        if (props.metadata.natives.length)
+            for (const native of props.metadata.natives)
                 unions.push({
                     type: "object",
-                    is: function () {
-                        return (0, check_native_1.check_native)({
-                            name: native.name,
-                            input: props.input,
-                        });
-                    },
-                    value: function () {
-                        return AtomicPredicator_1.AtomicPredicator.native(native.name)
-                            ? decode_atomic(__assign(__assign({}, props), { type: native.name.toLowerCase() }))
-                            : typescript_1.default.factory.createStringLiteral("{}");
-                    },
+                    is: () => (0, check_native_1.check_native)({
+                        name: native.name,
+                        input: props.input,
+                    }),
+                    value: () => AtomicPredicator_1.AtomicPredicator.native(native.name)
+                        ? decode_atomic(Object.assign(Object.assign({}, props), { type: native.name.toLowerCase() }))
+                        : typescript_1.default.factory.createStringLiteral("{}"),
                 });
-            };
-            try {
-                for (var _m = __values(props.metadata.natives), _o = _m.next(); !_o.done; _o = _m.next()) {
-                    var native = _o.value;
-                    _loop_4(native);
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
-        }
         // SETS
         if (props.metadata.sets.length)
             unions.push({
                 type: "object",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set", props.input); },
-                value: function () { return typescript_1.default.factory.createStringLiteral("{}"); },
+                is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf("Set", props.input),
+                value: () => typescript_1.default.factory.createStringLiteral("{}"),
             });
         // MAPS
         if (props.metadata.maps.length)
             unions.push({
                 type: "object",
-                is: function () { return ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map", props.input); },
-                value: function () { return typescript_1.default.factory.createStringLiteral("{}"); },
+                is: () => ExpressionFactory_1.ExpressionFactory.isInstanceOf("Map", props.input),
+                value: () => typescript_1.default.factory.createStringLiteral("{}"),
             });
         // OBJECTS
         if (props.metadata.objects.length)
             unions.push({
                 type: "object",
-                is: function () {
-                    return ExpressionFactory_1.ExpressionFactory.isObject({
-                        checkNull: true,
-                        checkArray: props.metadata.objects.some(function (object) {
-                            return object.type.properties.every(function (prop) { return !prop.key.isSoleLiteral() || !prop.value.isRequired(); });
-                        }),
-                        input: props.input,
-                    });
-                },
-                value: function () {
-                    return explore_objects(__assign(__assign({}, props), { explore: __assign(__assign({}, props.explore), { from: "object" }) }));
-                },
+                is: () => ExpressionFactory_1.ExpressionFactory.isObject({
+                    checkNull: true,
+                    checkArray: props.metadata.objects.some((object) => object.type.properties.every((prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired())),
+                    input: props.input,
+                }),
+                value: () => explore_objects(Object.assign(Object.assign({}, props), { explore: Object.assign(Object.assign({}, props.explore), { from: "object" }) })),
             });
         //----
         // RETURNS
         //----
         // CHECK NULL AND UNDEFINED
-        var wrapper = function (output) {
-            return wrap_required({
+        const wrapper = (output) => wrap_required({
+            input: props.input,
+            metadata: props.metadata,
+            explore: props.explore,
+            expression: wrap_nullable({
                 input: props.input,
                 metadata: props.metadata,
-                explore: props.explore,
-                expression: wrap_nullable({
-                    input: props.input,
-                    metadata: props.metadata,
-                    expression: output,
-                }),
-            });
-        };
+                expression: output,
+            }),
+        });
         // DIRECT RETURN
         if (unions.length === 0)
             return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("JSON.stringify"), undefined, [props.input]);
@@ -469,179 +310,151 @@ var JsonStringifyProgrammer;
             functor: props.functor,
             input: props.input,
             expected: props.metadata.getName(),
-            unions: unions,
+            unions,
         })), undefined, undefined));
     };
-    var decode_object = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_object({
-            config: {
-                trace: false,
-                path: false,
-                prefix: PREFIX,
-            },
-            functor: props.functor,
-            object: props.object,
+    const decode_object = (props) => FeatureProgrammer_1.FeatureProgrammer.decode_object({
+        config: {
+            trace: false,
+            path: false,
+            prefix: PREFIX,
+        },
+        functor: props.functor,
+        object: props.object,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_array = (props) => props.array.type.recursive
+        ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}a${props.array.type.index}`)), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+            config: props.config,
             input: props.input,
-            explore: props.explore,
-        });
-    };
-    var decode_array = function (props) {
-        return props.array.type.recursive
-            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
-                config: props.config,
-                input: props.input,
-                explore: __assign(__assign({}, props.explore), { source: "function", from: "array" }),
-            }))
-            : decode_array_inline(props);
-    };
-    var decode_array_inline = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_array({
+            explore: Object.assign(Object.assign({}, props.explore), { source: "function", from: "array" }),
+        }))
+        : decode_array_inline(props);
+    const decode_array_inline = (props) => FeatureProgrammer_1.FeatureProgrammer.decode_array({
+        config: props.config,
+        functor: props.functor,
+        combiner: StringifyJoinder_1.StringifyJoiner.array,
+        array: props.array,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_tuple = (props) => props.tuple.type.recursive
+        ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}t${props.tuple.type.index}`)), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
             config: props.config,
-            functor: props.functor,
-            combiner: StringifyJoinder_1.StringifyJoiner.array,
-            array: props.array,
+            explore: Object.assign(Object.assign({}, props.explore), { source: "function" }),
             input: props.input,
-            explore: props.explore,
-        });
-    };
-    var decode_tuple = function (props) {
-        return props.tuple.type.recursive
-            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
-                config: props.config,
-                explore: __assign(__assign({}, props.explore), { source: "function" }),
-                input: props.input,
-            }))
-            : decode_tuple_inline(__assign(__assign({}, props), { tuple: props.tuple.type }));
-    };
-    var decode_tuple_inline = function (props) {
-        var elements = props.tuple.elements
-            .filter(function (elem) { return elem.rest === null; })
-            .map(function (elem, index) {
-            return decode(__assign(__assign({}, props), { 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 () {
+        }))
+        : decode_tuple_inline(Object.assign(Object.assign({}, props), { tuple: props.tuple.type }));
+    const decode_tuple_inline = (props) => {
+        const elements = props.tuple.elements
+            .filter((elem) => elem.rest === null)
+            .map((elem, index) => decode(Object.assign(Object.assign({}, props), { input: typescript_1.default.factory.createElementAccessExpression(props.input, index), metadata: elem, explore: Object.assign(Object.assign({}, props.explore), { from: "array", postfix: props.explore.postfix.length
+                    ? `${(0, postfix_of_tuple_1.postfix_of_tuple)(props.explore.postfix)}[${index}]"`
+                    : `"[${index}]"` }) })));
+        const rest = (() => {
             if (props.tuple.elements.length === 0)
                 return null;
-            var last = props.tuple.elements.at(-1);
+            const last = props.tuple.elements.at(-1);
             if (last.rest === null)
                 return null;
-            var code = decode(__assign(__assign({}, props), { 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 }) }));
+            const code = decode(Object.assign(Object.assign({}, props), { 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: Object.assign(Object.assign({}, props.explore), { start: props.tuple.elements.length - 1 }) }));
             return typescript_1.default.factory.createCallExpression(props.context.importer.internal("jsonStringifyRest"), undefined, [code]);
         })();
         return StringifyJoinder_1.StringifyJoiner.tuple({
-            elements: elements,
-            rest: rest,
+            elements,
+            rest,
         });
     };
-    var decode_atomic = function (props) {
+    const decode_atomic = (props) => {
         if (props.type === "string")
             return typescript_1.default.factory.createCallExpression(props.context.importer.internal("jsonStringifyString"), undefined, [props.input]);
         else if (props.type === "number" &&
             OptionPredicator_1.OptionPredicator.numeric(props.context.options))
-            props = __assign(__assign({}, props), { input: typescript_1.default.factory.createCallExpression(props.context.importer.internal("jsonStringifyNumber"), undefined, [props.input]) });
+            props = Object.assign(Object.assign({}, props), { input: typescript_1.default.factory.createCallExpression(props.context.importer.internal("jsonStringifyNumber"), undefined, [props.input]) });
         return props.explore.from !== "top"
             ? props.input
             : typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "toString"), undefined, undefined);
     };
-    var decode_constant_string = function (props) {
-        if (props.values.every(function (v) { return !StringifyPredicator_1.StringifyPredicator.require_escape(v); }))
+    const decode_constant_string = (props) => {
+        if (props.values.every((v) => !StringifyPredicator_1.StringifyPredicator.require_escape(v)))
             return [
                 typescript_1.default.factory.createStringLiteral('"'),
                 props.input,
                 typescript_1.default.factory.createStringLiteral('"'),
-            ].reduce(function (x, y) { return typescript_1.default.factory.createAdd(x, y); });
-        return decode_atomic(__assign(__assign({}, props), { type: "string" }));
+            ].reduce((x, y) => typescript_1.default.factory.createAdd(x, y));
+        return decode_atomic(Object.assign(Object.assign({}, props), { type: "string" }));
     };
-    var decode_to_json = function (props) {
-        return decode(__assign(__assign({}, props), { input: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "toJSON"), undefined, []) }));
-    };
-    var decode_functional = function (explore) {
-        return explore.from === "array"
-            ? typescript_1.default.factory.createStringLiteral("null")
-            : typescript_1.default.factory.createIdentifier("undefined");
+    const decode_to_json = (props) => {
+        return decode(Object.assign(Object.assign({}, props), { input: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "toJSON"), undefined, []) }));
     };
+    const decode_functional = (explore) => explore.from === "array"
+        ? typescript_1.default.factory.createStringLiteral("null")
+        : typescript_1.default.factory.createIdentifier("undefined");
     /* -----------------------------------------------------------
       EXPLORERS
     ----------------------------------------------------------- */
-    var explore_objects = function (props) {
-        return props.metadata.objects.length === 1
-            ? decode_object({
-                functor: props.functor,
-                input: props.input,
-                object: props.metadata.objects[0].type,
-                explore: props.explore,
-            })
-            : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal("".concat(PREFIX, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
-    };
-    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({
-                    config: {
-                        checker: function (v) {
-                            return IsProgrammer_1.IsProgrammer.decode({
-                                context: props.context,
-                                functor: props.functor,
-                                metadata: v.definition,
-                                input: v.input,
-                                explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return decode_array({
-                                config: props.config,
-                                functor: props.functor,
-                                input: v.input,
-                                array: v.definition,
-                                explore: v.explore,
-                            });
-                        },
-                        empty: typescript_1.default.factory.createStringLiteral("[]"),
-                        success: typescript_1.default.factory.createTrue(),
-                        failure: function (v) {
-                            return create_throw_error({
-                                context: props.context,
-                                functor: props.functor,
-                                expected: v.expected,
-                                input: v.input,
-                            });
-                        },
-                    },
-                    parameters: next.parameters,
-                    input: next.input,
-                    arrays: next.definitions,
-                    explore: next.explore,
-                });
-            } }));
-    };
-    var explore_array_like_union_types = function (props) {
-        var arrow = function (next) {
-            return props.factory({
-                definitions: props.elements,
-                parameters: next.parameters,
-                input: next.input,
-                explore: next.explore,
-            });
-        };
-        if (props.elements.every(function (e) { return e.type.recursive === false; }))
+    const explore_objects = (props) => props.metadata.objects.length === 1
+        ? decode_object({
+            functor: props.functor,
+            input: props.input,
+            object: props.metadata.objects[0].type,
+            explore: props.explore,
+        })
+        : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(`${PREFIX}u${props.metadata.union_index}`)), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
+    const explore_arrays = (props) => explore_array_like_union_types(Object.assign(Object.assign({}, props), { elements: props.arrays, factory: (next) => UnionExplorer_1.UnionExplorer.array({
+            config: {
+                checker: (v) => IsProgrammer_1.IsProgrammer.decode({
+                    context: props.context,
+                    functor: props.functor,
+                    metadata: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_array({
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    array: v.definition,
+                    explore: v.explore,
+                }),
+                empty: typescript_1.default.factory.createStringLiteral("[]"),
+                success: typescript_1.default.factory.createTrue(),
+                failure: (v) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: v.expected,
+                    input: v.input,
+                }),
+            },
+            parameters: next.parameters,
+            input: next.input,
+            arrays: next.definitions,
+            explore: next.explore,
+        }) }));
+    const explore_array_like_union_types = (props) => {
+        const arrow = (next) => props.factory({
+            definitions: props.elements,
+            parameters: next.parameters,
+            input: next.input,
+            explore: next.explore,
+        });
+        if (props.elements.every((e) => 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.functor.emplaceUnion(props.config.prefix, props.elements.map(function (e) { return e.type.name; }).join(" | "), function () {
-            return arrow({
-                parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
-                    config: props.config,
-                    type: TypeFactory_1.TypeFactory.keyword("any"),
-                    input: typescript_1.default.factory.createIdentifier("input"),
-                }),
-                explore: __assign(__assign({}, arrayExplore), { postfix: "" }),
+        const arrayExplore = Object.assign(Object.assign({}, props.explore), { source: "function", from: "array" });
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.emplaceUnion(props.config.prefix, props.elements.map((e) => e.type.name).join(" | "), () => arrow({
+            parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory_1.TypeFactory.keyword("any"),
                 input: typescript_1.default.factory.createIdentifier("input"),
-            });
-        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+            }),
+            explore: Object.assign(Object.assign({}, arrayExplore), { postfix: "" }),
+            input: typescript_1.default.factory.createIdentifier("input"),
+        }))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
             config: props.config,
             explore: arrayExplore,
             input: props.input,
@@ -650,155 +463,124 @@ var JsonStringifyProgrammer;
     /* -----------------------------------------------------------
       RETURN SCRIPTS
     ----------------------------------------------------------- */
-    var wrap_required = function (props) {
+    const wrap_required = (props) => {
         if (props.metadata.isRequired() === true && props.metadata.any === false)
             return props.expression;
         return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createIdentifier("undefined"), props.input), undefined, props.expression, undefined, props.explore.from === "array"
             ? typescript_1.default.factory.createStringLiteral("null")
             : typescript_1.default.factory.createIdentifier("undefined"));
     };
-    var wrap_nullable = function (props) {
+    const wrap_nullable = (props) => {
         if (props.metadata.nullable === false)
             return props.expression;
         return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createNull(), props.input), undefined, props.expression, undefined, typescript_1.default.factory.createStringLiteral("null"));
     };
-    var wrap_functional = function (props) {
+    const wrap_functional = (props) => {
         if (props.metadata.functions.length === 0)
             return props.expression;
         return typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createStrictInequality(typescript_1.default.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(props.input)), undefined, props.expression, undefined, decode_functional(props.explore));
     };
-    var iterate = function (props) {
-        return typescript_1.default.factory.createBlock(__spreadArray(__spreadArray([], __read(props.unions.map(function (u) {
-            return typescript_1.default.factory.createIfStatement(u.is(), typescript_1.default.factory.createReturnStatement(u.value()));
-        })), false), [
-            create_throw_error(props),
-        ], false), true);
-    };
+    const iterate = (props) => typescript_1.default.factory.createBlock([
+        ...props.unions.map((u) => typescript_1.default.factory.createIfStatement(u.is(), typescript_1.default.factory.createReturnStatement(u.value()))),
+        create_throw_error(props),
+    ], true);
     /* -----------------------------------------------------------
       CONFIGURATIONS
     ----------------------------------------------------------- */
-    var PREFIX = "_s";
-    var configure = function (props) {
-        var config = {
+    const PREFIX = "_s";
+    const configure = (props) => {
+        const config = {
             types: {
-                input: function (type, name) {
-                    return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type: type }));
-                },
-                output: function () { return TypeFactory_1.TypeFactory.keyword("string"); },
+                input: (type, name) => typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type })),
+                output: () => TypeFactory_1.TypeFactory.keyword("string"),
             },
             prefix: PREFIX,
             trace: false,
             path: false,
-            initializer: initializer,
-            decoder: function (next) {
-                return decode({
+            initializer,
+            decoder: (next) => decode({
+                context: props.context,
+                functor: props.functor,
+                config,
+                metadata: next.metadata,
+                input: next.input,
+                explore: next.explore,
+            }),
+            objector: {
+                checker: (next) => IsProgrammer_1.IsProgrammer.decode({
                     context: props.context,
                     functor: props.functor,
-                    config: config,
                     metadata: next.metadata,
                     input: next.input,
                     explore: next.explore,
-                });
-            },
-            objector: {
-                checker: function (next) {
-                    return IsProgrammer_1.IsProgrammer.decode({
+                }),
+                decoder: (next) => decode_object({
+                    functor: props.functor,
+                    input: next.input,
+                    object: next.object,
+                    explore: next.explore,
+                }),
+                joiner: (next) => StringifyJoinder_1.StringifyJoiner.object(Object.assign(Object.assign({}, next), { context: props.context })),
+                unionizer: (next) => (0, decode_union_object_1.decode_union_object)({
+                    checker: (v) => IsProgrammer_1.IsProgrammer.decode_object({
                         context: props.context,
                         functor: props.functor,
-                        metadata: next.metadata,
-                        input: next.input,
-                        explore: next.explore,
-                    });
-                },
-                decoder: function (next) {
-                    return decode_object({
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    decoder: (v) => decode_object({
                         functor: props.functor,
-                        input: next.input,
-                        object: next.object,
-                        explore: next.explore,
-                    });
-                },
-                joiner: function (next) {
-                    return StringifyJoinder_1.StringifyJoiner.object(__assign(__assign({}, next), { context: props.context }));
-                },
-                unionizer: function (next) {
-                    return (0, decode_union_object_1.decode_union_object)({
-                        checker: function (v) {
-                            return IsProgrammer_1.IsProgrammer.decode_object({
-                                context: props.context,
-                                functor: props.functor,
-                                input: v.input,
-                                object: v.object,
-                                explore: v.explore,
-                            });
-                        },
-                        decoder: function (v) {
-                            return decode_object({
-                                functor: props.functor,
-                                input: v.input,
-                                object: v.object,
-                                explore: v.explore,
-                            });
-                        },
-                        success: function (exp) { return exp; },
-                        escaper: function (v) {
-                            return create_throw_error({
-                                context: props.context,
-                                functor: props.functor,
-                                expected: v.expected,
-                                input: v.input,
-                            });
-                        },
-                        objects: next.objects,
-                        explore: next.explore,
-                        input: next.input,
-                    });
-                },
-                failure: function (next) {
-                    return create_throw_error({
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    success: (exp) => exp,
+                    escaper: (v) => create_throw_error({
                         context: props.context,
                         functor: props.functor,
-                        expected: next.expected,
-                        input: next.input,
-                    });
-                },
+                        expected: v.expected,
+                        input: v.input,
+                    }),
+                    objects: next.objects,
+                    explore: next.explore,
+                    input: next.input,
+                }),
+                failure: (next) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: next.expected,
+                    input: next.input,
+                }),
             },
             generator: {
-                arrays: function (collection) {
-                    return write_array_functions({
-                        config: config,
-                        functor: props.functor,
-                        collection: collection,
-                    });
-                },
-                tuples: function (collection) {
-                    return write_tuple_functions({
-                        config: config,
-                        context: props.context,
-                        functor: props.functor,
-                        collection: collection,
-                    });
-                },
+                arrays: (collection) => write_array_functions({
+                    config,
+                    functor: props.functor,
+                    collection,
+                }),
+                tuples: (collection) => write_tuple_functions({
+                    config,
+                    context: props.context,
+                    functor: props.functor,
+                    collection,
+                }),
             },
         };
         return config;
     };
-    var initializer = function (props) {
-        return JsonMetadataFactory_1.JsonMetadataFactory.analyze({
-            method: props.functor.method,
-            checker: props.context.checker,
-            transformer: props.context.transformer,
-            type: props.type,
-        });
-    };
-    var create_throw_error = function (props) {
-        return typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(props.context.importer.internal("throwTypeGuardError"), [], [
-            typescript_1.default.factory.createObjectLiteralExpression([
-                typescript_1.default.factory.createPropertyAssignment("method", typescript_1.default.factory.createStringLiteral(props.functor.method)),
-                typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(props.expected)),
-                typescript_1.default.factory.createPropertyAssignment("value", props.input),
-            ], true),
-        ]));
-    };
+    const initializer = (props) => JsonMetadataFactory_1.JsonMetadataFactory.analyze({
+        method: props.functor.method,
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        type: props.type,
+    });
+    const create_throw_error = (props) => typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(props.context.importer.internal("throwTypeGuardError"), [], [
+        typescript_1.default.factory.createObjectLiteralExpression([
+            typescript_1.default.factory.createPropertyAssignment("method", typescript_1.default.factory.createStringLiteral(props.functor.method)),
+            typescript_1.default.factory.createPropertyAssignment("expected", typescript_1.default.factory.createStringLiteral(props.expected)),
+            typescript_1.default.factory.createPropertyAssignment("value", props.input),
+        ], true),
+    ]));
 })(JsonStringifyProgrammer || (exports.JsonStringifyProgrammer = JsonStringifyProgrammer = {}));
 //# sourceMappingURL=JsonStringifyProgrammer.js.map