typia 7.0.0-dev.20240929 → 7.0.0-dev.20241001

package/lib/programmers/notations/NotationGeneralProgrammer.js

@@ -47,9 +47,7 @@ var postfix_of_tuple_1 = require("../internal/postfix_of_tuple");
 var wrap_metadata_rest_tuple_1 = require("../internal/wrap_metadata_rest_tuple");
 var NotationGeneralProgrammer;
 (function (NotationGeneralProgrammer) {
-    NotationGeneralProgrammer.returnType = function (rename) { return function (type) {
-        return "typia.".concat(StringUtil_1.StringUtil.capitalize(rename.name), "Case<").concat(type, ">");
-    }; };
+    NotationGeneralProgrammer.returnType = function (props) { return "typia.".concat(StringUtil_1.StringUtil.capitalize(props.rename.name), "Case<").concat(props.type, ">"); };
     NotationGeneralProgrammer.decompose = function (props) {
         var _a;
         var config = configure(props);
@@ -65,7 +63,10 @@ var NotationGeneralProgrammer;
         return {
             functions: composed.functions,
             statements: composed.statements,
-            arrow: typescript_1.default.factory.createArrowFunction(undefined, undefined, composed.parameters, typescript_1.default.factory.createTypeReferenceNode(NotationGeneralProgrammer.returnType(props.rename)((_a = props.name) !== null && _a !== void 0 ? _a : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(props.type))), undefined, composed.body),
+            arrow: typescript_1.default.factory.createArrowFunction(undefined, undefined, composed.parameters, typescript_1.default.factory.createTypeReferenceNode(NotationGeneralProgrammer.returnType({
+                rename: props.rename,
+                type: (_a = props.name) !== null && _a !== void 0 ? _a : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(props.type),
+            })), undefined, composed.body),
         };
     };
     NotationGeneralProgrammer.write = function (props) {
@@ -82,7 +83,11 @@ var NotationGeneralProgrammer;
             .arrays()
             .filter(function (a) { return a.recursive; })
             .map(function (type, i) {
-            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "a").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input"), array: MetadataArray_1.MetadataArray.create({
+            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "a").concat(i), 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(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input"), array: MetadataArray_1.MetadataArray.create({
                     type: type,
                     tags: [],
                 }), explore: {
@@ -98,7 +103,11 @@ var NotationGeneralProgrammer;
             .tuples()
             .filter(function (t) { return t.recursive; })
             .map(function (tuple, i) {
-            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "t").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input"), tuple: tuple, explore: {
+            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "t").concat(i), 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(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input"), tuple: tuple, explore: {
                     tracable: props.config.trace,
                     source: "function",
                     from: "array",
@@ -164,7 +173,7 @@ var NotationGeneralProgrammer;
                 type: "array",
                 is: function () { return ExpressionFactory_1.ExpressionFactory.isArray(props.input); },
                 value: function () {
-                    return explore_arrays(__assign(__assign({}, props), { elements: props.metadata.arrays, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
+                    return explore_arrays(__assign(__assign({}, props), { arrays: props.metadata.arrays, explore: __assign(__assign({}, props.explore), { from: "array" }) }));
                 },
             });
         // NATIVE TYPES
@@ -255,24 +264,45 @@ var NotationGeneralProgrammer;
             return typescript_1.default.factory.createAsExpression(last, TypeFactory_1.TypeFactory.keyword("any"));
         }
     };
-    var decode_object = function (importer) {
+    var decode_object = function (props) {
         return FeatureProgrammer_1.FeatureProgrammer.decode_object({
-            trace: false,
-            path: false,
-            prefix: PREFIX,
-        })(importer);
+            config: {
+                trace: false,
+                path: false,
+                prefix: PREFIX,
+            },
+            importer: props.importer,
+            object: props.object,
+            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.importer.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, props.explore), { source: "function", from: "array" }))(props.input))
+            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+                config: props.config,
+                explore: __assign(__assign({}, props.explore), { source: "function", from: "array" }),
+                input: props.input,
+            }))
             : decode_array_inline(props);
     };
     var decode_array_inline = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_array(props.config)(props.importer)(NotationJoiner_1.NotationJoiner.array)(props.input, props.array, props.explore);
+        return FeatureProgrammer_1.FeatureProgrammer.decode_array({
+            config: props.config,
+            importer: props.importer,
+            combiner: NotationJoiner_1.NotationJoiner.array,
+            array: props.array,
+            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.importer.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, props.explore), { source: "function" }))(props.input))
+            ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+                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) {
@@ -310,118 +340,164 @@ var NotationGeneralProgrammer;
       ----------------------------------------------------------- */
     var explore_sets = function (props) {
         return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
-            checker: function (input, metadata, explore) {
-                return IsProgrammer_1.IsProgrammer.decode({
-                    context: props.context,
-                    importer: props.importer,
-                    input: input,
-                    metadata: metadata,
-                    explore: explore,
-                });
-            },
-            decoder: function (input, array, explore) {
-                return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], [
-                    decode_array({
-                        config: props.config,
+            config: {
+                checker: function (v) {
+                    return IsProgrammer_1.IsProgrammer.decode({
+                        context: props.context,
                         importer: props.importer,
-                        input: input,
-                        array: array,
-                        explore: explore,
-                    }),
-                ]);
-            },
-            empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], []),
-            success: typescript_1.default.factory.createTrue(),
-            failure: function (input, expected) {
-                return create_throw_error({ importer: props.importer, expected: expected, input: input });
+                        input: v.input,
+                        metadata: v.definition,
+                        explore: v.explore,
+                    });
+                },
+                decoder: function (v) {
+                    return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], [
+                        decode_array({
+                            config: props.config,
+                            importer: props.importer,
+                            input: v.input,
+                            array: v.definition,
+                            explore: v.explore,
+                        }),
+                    ]);
+                },
+                empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), [TypeFactory_1.TypeFactory.keyword("any")], []),
+                success: typescript_1.default.factory.createTrue(),
+                failure: function (v) {
+                    return create_throw_error({
+                        importer: props.importer,
+                        expected: v.expected,
+                        input: v.input,
+                    });
+                },
             },
-        })([])(props.input, props.sets, props.explore), undefined, undefined);
+            parameters: [],
+            input: props.input,
+            sets: props.sets,
+            explore: props.explore,
+        }), undefined, undefined);
     };
     var explore_maps = function (props) {
         return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
-            checker: function (top, entry, explore) {
-                return typescript_1.default.factory.createLogicalAnd(IsProgrammer_1.IsProgrammer.decode({
-                    context: props.context,
-                    importer: props.importer,
-                    input: typescript_1.default.factory.createElementAccessExpression(top, 0),
-                    metadata: entry[0],
-                    explore: __assign(__assign({}, props.explore), { postfix: "".concat(explore.postfix, "[0]") }),
-                }), IsProgrammer_1.IsProgrammer.decode({
-                    context: props.context,
-                    importer: props.importer,
-                    input: typescript_1.default.factory.createElementAccessExpression(top, 1),
-                    metadata: entry[1],
-                    explore: __assign(__assign({}, props.explore), { postfix: "".concat(props.explore.postfix, "[1]") }),
-                }));
-            },
-            decoder: function (input, array, explore) {
-                return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], [
-                    decode_array({
-                        config: props.config,
+            config: {
+                checker: function (v) {
+                    return typescript_1.default.factory.createLogicalAnd(IsProgrammer_1.IsProgrammer.decode({
+                        context: props.context,
                         importer: props.importer,
-                        input: input,
-                        array: array,
-                        explore: explore,
-                    }),
-                ]);
-            },
-            empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], []),
-            success: typescript_1.default.factory.createTrue(),
-            failure: function (input, expected) {
-                return create_throw_error({ importer: props.importer, expected: expected, input: input });
-            },
-        })([])(props.input, props.maps, props.explore), undefined, undefined);
-    };
-    var explore_objects = function (props) {
-        if (props.metadata.objects.length === 1)
-            return decode_object(props.importer)(props.input, props.metadata.objects[0], props.explore);
-        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(PREFIX, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(props.explore)(props.input));
-    };
-    var explore_arrays = function (props) {
-        return explore_array_like_union_types(__assign(__assign({}, props), { factory: UnionExplorer_1.UnionExplorer.array({
-                checker: function (input, metadata, explore) {
-                    return IsProgrammer_1.IsProgrammer.decode({
+                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 0),
+                        metadata: v.definition[0],
+                        explore: __assign(__assign({}, props.explore), { postfix: "".concat(v.explore.postfix, "[0]") }),
+                    }), IsProgrammer_1.IsProgrammer.decode({
                         context: props.context,
                         importer: props.importer,
-                        input: input,
-                        metadata: metadata,
-                        explore: explore,
-                    });
+                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 1),
+                        metadata: v.definition[1],
+                        explore: __assign(__assign({}, props.explore), { postfix: "".concat(props.explore.postfix, "[1]") }),
+                    }));
                 },
-                decoder: function (input, array, explore) {
-                    return decode_array({
-                        config: props.config,
-                        importer: props.importer,
-                        input: input,
-                        array: array,
-                        explore: explore,
-                    });
+                decoder: function (v) {
+                    return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], [
+                        decode_array({
+                            config: props.config,
+                            importer: props.importer,
+                            input: v.input,
+                            array: v.definition,
+                            explore: v.explore,
+                        }),
+                    ]);
                 },
-                empty: typescript_1.default.factory.createIdentifier("[]"),
+                empty: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), [TypeFactory_1.TypeFactory.keyword("any"), TypeFactory_1.TypeFactory.keyword("any")], []),
                 success: typescript_1.default.factory.createTrue(),
-                failure: function (input, expected) {
+                failure: function (v) {
                     return create_throw_error({
                         importer: props.importer,
-                        expected: expected,
-                        input: input,
+                        expected: v.expected,
+                        input: v.input,
                     });
                 },
-            }) }));
+            },
+            parameters: [],
+            input: props.input,
+            maps: props.maps,
+            explore: props.explore,
+        }), undefined, undefined);
+    };
+    var explore_objects = function (props) {
+        if (props.metadata.objects.length === 1)
+            return decode_object({
+                importer: props.importer,
+                object: props.metadata.objects[0],
+                input: props.input,
+                explore: props.explore,
+            });
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(PREFIX, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
+    };
+    var explore_arrays = function (props) {
+        return explore_array_like_union_types(__assign(__assign({}, props), { factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.array({
+                    config: {
+                        checker: function (v) {
+                            return IsProgrammer_1.IsProgrammer.decode({
+                                context: props.context,
+                                importer: props.importer,
+                                input: v.input,
+                                metadata: v.definition,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return decode_array({
+                                config: props.config,
+                                importer: props.importer,
+                                input: v.input,
+                                array: v.definition,
+                                explore: v.explore,
+                            });
+                        },
+                        empty: typescript_1.default.factory.createIdentifier("[]"),
+                        success: typescript_1.default.factory.createTrue(),
+                        failure: function (v) {
+                            return create_throw_error({
+                                importer: props.importer,
+                                expected: v.expected,
+                                input: v.input,
+                            });
+                        },
+                    },
+                    parameters: next.parameters,
+                    input: next.input,
+                    arrays: next.definitions,
+                    explore: next.explore,
+                });
+            }, definitions: props.arrays, input: props.input, explore: props.explore }));
     };
     var explore_array_like_union_types = function (props) {
         var arrow = function (parameters) {
             return function (explore) {
                 return function (input) {
-                    return props.factory(parameters)(input, props.elements, explore);
+                    return props.factory({
+                        parameters: parameters,
+                        input: input,
+                        definitions: props.definitions,
+                        explore: explore,
+                    });
                 };
             };
         };
-        if (props.elements.every(function (e) { return e.type.recursive === false; }))
+        if (props.definitions.every(function (e) { return e.type.recursive === false; }))
             typescript_1.default.factory.createCallExpression(arrow([])(props.explore)(props.input), undefined, []);
         var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
-        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.emplaceUnion(props.config.prefix, props.elements.map(function (e) { return e.type.name; }).join(" | "), function () {
-            return arrow(FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")))(__assign(__assign({}, arrayExplore), { postfix: "" }))(typescript_1.default.factory.createIdentifier("input"));
-        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input));
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.emplaceUnion(props.config.prefix, props.definitions.map(function (e) { return e.type.name; }).join(" | "), function () {
+            return arrow(FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory_1.TypeFactory.keyword("any"),
+                input: typescript_1.default.factory.createIdentifier("input"),
+            }))(__assign(__assign({}, arrayExplore), { postfix: "" }))(typescript_1.default.factory.createIdentifier("input"));
+        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: arrayExplore,
+            input: props.input,
+        }));
     };
     /* -----------------------------------------------------------
           CONFIGURATIONS
@@ -434,95 +510,128 @@ var NotationGeneralProgrammer;
                     return typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(type));
                 },
                 output: function (type, name) {
-                    return typescript_1.default.factory.createTypeReferenceNode(NotationGeneralProgrammer.returnType(props.rename)(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(type)));
+                    return typescript_1.default.factory.createTypeReferenceNode(NotationGeneralProgrammer.returnType({
+                        rename: props.rename,
+                        type: name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(type),
+                    }));
                 },
             },
             prefix: PREFIX,
             trace: false,
             path: false,
             initializer: initializer,
-            decoder: function () { return function (input, metadata, explore) {
+            decoder: function (next) {
                 return decode({
                     context: props.context,
                     config: config,
                     importer: props.importer,
-                    metadata: metadata,
-                    explore: explore,
-                    input: input,
+                    metadata: next.metadata,
+                    explore: next.explore,
+                    input: next.input,
                 });
-            }; },
+            },
             objector: {
-                checker: function () { return function (input, metadata, explore) {
+                checker: function (next) {
                     return IsProgrammer_1.IsProgrammer.decode({
                         context: props.context,
                         importer: props.importer,
-                        input: input,
-                        metadata: metadata,
-                        explore: explore,
+                        input: next.input,
+                        metadata: next.metadata,
+                        explore: next.explore,
                     });
-                }; },
-                decoder: function () { return decode_object(props.importer); },
-                joiner: NotationJoiner_1.NotationJoiner.object(props.rename),
-                unionizer: (0, decode_union_object_1.decode_union_object)(function (input, object, explore) {
-                    return IsProgrammer_1.IsProgrammer.decode_object({
-                        context: props.context,
+                },
+                decoder: function (next) {
+                    return decode_object({
                         importer: props.importer,
-                        object: object,
-                        input: input,
-                        explore: explore,
+                        object: next.object,
+                        input: next.input,
+                        explore: next.explore,
                     });
-                })(decode_object(props.importer))(function (exp) { return exp; })(function (input, expected) {
-                    return create_throw_error({
-                        importer: props.importer,
-                        expected: expected,
-                        input: input,
+                },
+                joiner: function (next) {
+                    return NotationJoiner_1.NotationJoiner.object({
+                        rename: props.rename,
+                        input: next.input,
+                        entries: next.entries,
                     });
-                }),
-                failure: function (input, expected) {
+                },
+                unionizer: function (next) {
+                    return (0, decode_union_object_1.decode_union_object)({
+                        checker: function (v) {
+                            return IsProgrammer_1.IsProgrammer.decode_object({
+                                context: props.context,
+                                importer: props.importer,
+                                object: v.object,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return decode_object({
+                                importer: props.importer,
+                                object: v.object,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        success: function (exp) { return exp; },
+                        escaper: function (v) {
+                            return create_throw_error({
+                                importer: props.importer,
+                                expected: v.expected,
+                                input: v.input,
+                            });
+                        },
+                        input: next.input,
+                        objects: next.objects,
+                        explore: next.explore,
+                    });
+                },
+                failure: function (next) {
                     return create_throw_error({
                         importer: props.importer,
-                        expected: expected,
-                        input: input,
+                        expected: next.expected,
+                        input: next.input,
                     });
                 },
             },
             generator: {
-                arrays: function () { return function (collection) {
+                arrays: function (collection) {
                     return write_array_functions({
                         importer: props.importer,
                         config: config,
                         collection: collection,
                     });
-                }; },
-                tuples: function () { return function (collection) {
+                },
+                tuples: function (collection) {
                     return write_tuple_functions({
                         context: props.context,
                         importer: props.importer,
                         config: config,
                         collection: collection,
                     });
-                }; },
+                },
             },
         };
         return config;
     };
-    var initializer = function (project) { return function (importer) { return function (type) {
+    var initializer = function (props) {
         var collection = new MetadataCollection_1.MetadataCollection();
         var result = MetadataFactory_1.MetadataFactory.analyze({
-            checker: project.checker,
-            transformer: project.transformer,
+            checker: props.context.checker,
+            transformer: props.context.transformer,
             options: {
                 escape: false,
                 constant: true,
                 absorb: true,
             },
             collection: collection,
-            type: type,
+            type: props.type,
         });
         if (result.success === false)
-            throw TransformerError_1.TransformerError.from("typia.misc.".concat(importer.method))(result.errors);
+            throw TransformerError_1.TransformerError.from("typia.misc.".concat(props.importer.method))(result.errors);
         return [collection, result.data];
-    }; }; };
+    };
     var create_throw_error = function (props) {
         return typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(props.importer.use("throws"), [], [
             typescript_1.default.factory.createObjectLiteralExpression([
@@ -531,14 +640,14 @@ var NotationGeneralProgrammer;
             ], true),
         ]));
     };
-    var is_instance = function (meta) {
-        return !!meta.objects.length ||
-            !!meta.arrays.length ||
-            !!meta.tuples.length ||
-            !!meta.sets.length ||
-            !!meta.maps.length ||
-            !!meta.natives.length ||
-            (meta.rest !== null && is_instance(meta.rest));
+    var is_instance = function (metadata) {
+        return !!metadata.objects.length ||
+            !!metadata.arrays.length ||
+            !!metadata.tuples.length ||
+            !!metadata.sets.length ||
+            !!metadata.maps.length ||
+            !!metadata.natives.length ||
+            (metadata.rest !== null && is_instance(metadata.rest));
     };
 })(NotationGeneralProgrammer || (exports.NotationGeneralProgrammer = NotationGeneralProgrammer = {}));
 //# sourceMappingURL=NotationGeneralProgrammer.js.map