typia 7.0.0-dev.20241111-2 → 7.0.0-dev.20241114

package/lib/schemas/metadata/Metadata.js

@@ -1,64 +1,28 @@
 "use strict";
-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 __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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Metadata = void 0;
-var ArrayUtil_1 = require("../../utils/ArrayUtil");
-var MetadataAlias_1 = require("./MetadataAlias");
-var MetadataArray_1 = require("./MetadataArray");
-var MetadataAtomic_1 = require("./MetadataAtomic");
-var MetadataConstant_1 = require("./MetadataConstant");
-var MetadataEscaped_1 = require("./MetadataEscaped");
-var MetadataFunction_1 = require("./MetadataFunction");
-var MetadataMap_1 = require("./MetadataMap");
-var MetadataNative_1 = require("./MetadataNative");
-var MetadataObject_1 = require("./MetadataObject");
-var MetadataObjectType_1 = require("./MetadataObjectType");
-var MetadataSet_1 = require("./MetadataSet");
-var MetadataTemplate_1 = require("./MetadataTemplate");
-var MetadataTuple_1 = require("./MetadataTuple");
-var Metadata = /** @class */ (function () {
+const ArrayUtil_1 = require("../../utils/ArrayUtil");
+const MetadataAlias_1 = require("./MetadataAlias");
+const MetadataArray_1 = require("./MetadataArray");
+const MetadataAtomic_1 = require("./MetadataAtomic");
+const MetadataConstant_1 = require("./MetadataConstant");
+const MetadataEscaped_1 = require("./MetadataEscaped");
+const MetadataFunction_1 = require("./MetadataFunction");
+const MetadataMap_1 = require("./MetadataMap");
+const MetadataNative_1 = require("./MetadataNative");
+const MetadataObject_1 = require("./MetadataObject");
+const MetadataObjectType_1 = require("./MetadataObjectType");
+const MetadataSet_1 = require("./MetadataSet");
+const MetadataTemplate_1 = require("./MetadataTemplate");
+const MetadataTuple_1 = require("./MetadataTuple");
+class Metadata {
     /* -----------------------------------------------------------
       CONSTRUCTORS
     ----------------------------------------------------------- */
     /**
      * @hidden
      */
-    function Metadata(props) {
+    constructor(props) {
         /** @internal */ this.parent_resolved_ = false;
         this.any = props.any;
         this.required = props.required;
@@ -81,15 +45,14 @@ var Metadata = /** @class */ (function () {
     /**
      * @internal
      */
-    Metadata.create = function (props) {
+    static create(props) {
         return new Metadata(props);
-    };
+    }
     /**
      * @internal
      */
-    Metadata.initialize = function (parentResolved) {
-        if (parentResolved === void 0) { parentResolved = false; }
-        var meta = Metadata.create({
+    static initialize(parentResolved = false) {
+        const meta = Metadata.create({
             any: false,
             nullable: false,
             required: true,
@@ -110,110 +73,105 @@ var Metadata = /** @class */ (function () {
         });
         meta.parent_resolved_ = parentResolved;
         return meta;
-    };
-    Metadata.prototype.toJSON = function () {
+    }
+    toJSON() {
         return {
             any: this.any,
             required: this.required,
             optional: this.optional,
             nullable: this.nullable,
-            functions: this.functions.map(function (f) { return f.toJSON(); }),
-            atomics: this.atomics.map(function (a) { return a.toJSON(); }),
-            constants: this.constants.map(function (c) { return c.toJSON(); }),
-            templates: this.templates.map(function (tpl) { return tpl.toJSON(); }),
+            functions: this.functions.map((f) => f.toJSON()),
+            atomics: this.atomics.map((a) => a.toJSON()),
+            constants: this.constants.map((c) => c.toJSON()),
+            templates: this.templates.map((tpl) => tpl.toJSON()),
             escaped: this.escaped ? this.escaped.toJSON() : null,
             rest: this.rest ? this.rest.toJSON() : null,
-            arrays: this.arrays.map(function (array) { return array.toJSON(); }),
-            tuples: this.tuples.map(function (tuple) { return tuple.toJSON(); }),
-            objects: this.objects.map(function (obj) { return obj.toJSON(); }),
-            aliases: this.aliases.map(function (alias) { return alias.toJSON(); }),
-            natives: this.natives.map(function (native) { return native.toJSON(); }),
-            sets: this.sets.map(function (set) { return set.toJSON(); }),
-            maps: this.maps.map(function (map) { return map.toJSON(); }),
+            arrays: this.arrays.map((array) => array.toJSON()),
+            tuples: this.tuples.map((tuple) => tuple.toJSON()),
+            objects: this.objects.map((obj) => obj.toJSON()),
+            aliases: this.aliases.map((alias) => alias.toJSON()),
+            natives: this.natives.map((native) => native.toJSON()),
+            sets: this.sets.map((set) => set.toJSON()),
+            maps: this.maps.map((map) => map.toJSON()),
         };
-    };
-    Metadata.from = function (meta, dict) {
-        var _this = this;
+    }
+    static from(meta, dict) {
         return Metadata.create({
             any: meta.any,
             required: meta.required,
             optional: meta.optional,
             nullable: meta.nullable,
-            functions: meta.functions.map(function (f) { return MetadataFunction_1.MetadataFunction.from(f, dict); }),
+            functions: meta.functions.map((f) => MetadataFunction_1.MetadataFunction.from(f, dict)),
             constants: meta.constants.map(MetadataConstant_1.MetadataConstant.from),
             atomics: meta.atomics.map(MetadataAtomic_1.MetadataAtomic.from),
-            templates: meta.templates.map(function (tpl) { return MetadataTemplate_1.MetadataTemplate.from(tpl, dict); }),
+            templates: meta.templates.map((tpl) => MetadataTemplate_1.MetadataTemplate.from(tpl, dict)),
             escaped: meta.escaped ? MetadataEscaped_1.MetadataEscaped.from(meta.escaped, dict) : null,
             rest: meta.rest ? this.from(meta.rest, dict) : null,
-            arrays: meta.arrays.map(function (ref) {
-                var type = dict.arrays.get(ref.name);
+            arrays: meta.arrays.map((ref) => {
+                const type = dict.arrays.get(ref.name);
                 if (type === undefined)
-                    throw new RangeError("Error on Metadata.from(): failed to find array \"".concat(ref.name, "\"."));
+                    throw new RangeError(`Error on Metadata.from(): failed to find array "${ref.name}".`);
                 return MetadataArray_1.MetadataArray.create({
-                    type: type,
-                    tags: ref.tags.map(function (row) { return row.slice(); }),
+                    type,
+                    tags: ref.tags.map((row) => row.slice()),
                 });
             }),
-            tuples: meta.tuples.map(function (t) {
-                var type = dict.tuples.get(t.name);
+            tuples: meta.tuples.map((t) => {
+                const type = dict.tuples.get(t.name);
                 if (type === undefined)
-                    throw new RangeError("Error on Metadata.from(): failed to find tuple \"".concat(t.name, "\"."));
+                    throw new RangeError(`Error on Metadata.from(): failed to find tuple "${t.name}".`);
                 return MetadataTuple_1.MetadataTuple.create({
-                    type: type,
-                    tags: t.tags.map(function (r) { return r.slice(); }),
+                    type,
+                    tags: t.tags.map((r) => r.slice()),
                 });
             }),
-            objects: meta.objects.map(function (obj) {
-                var found = dict.objects.get(obj.name);
+            objects: meta.objects.map((obj) => {
+                const found = dict.objects.get(obj.name);
                 if (found === undefined)
-                    throw new RangeError("Error on Metadata.from(): failed to find object \"".concat(name, "\"."));
+                    throw new RangeError(`Error on Metadata.from(): failed to find object "${name}".`);
                 return MetadataObject_1.MetadataObject.create({
                     type: found,
-                    tags: obj.tags.map(function (r) { return r.slice(); }),
+                    tags: obj.tags.map((r) => r.slice()),
                 });
             }),
-            aliases: meta.aliases.map(function (alias) {
-                var type = dict.aliases.get(alias.name);
+            aliases: meta.aliases.map((alias) => {
+                const type = dict.aliases.get(alias.name);
                 if (type === undefined)
-                    throw new RangeError("Error on Metadata.from(): failed to find alias \"".concat(alias, "\"."));
+                    throw new RangeError(`Error on Metadata.from(): failed to find alias "${alias}".`);
                 return MetadataAlias_1.MetadataAlias.create({
-                    type: type,
-                    tags: alias.tags.map(function (r) { return r.slice(); }),
-                });
-            }),
-            natives: meta.natives.map(function (native) { return MetadataNative_1.MetadataNative.create(native); }),
-            sets: meta.sets.map(function (set) {
-                return MetadataSet_1.MetadataSet.create({
-                    value: Metadata.from(set.value, dict),
-                    tags: set.tags.map(function (r) { return r.slice(); }),
-                });
-            }),
-            maps: meta.maps.map(function (map) {
-                return MetadataMap_1.MetadataMap.create({
-                    key: _this.from(map.key, dict),
-                    value: _this.from(map.value, dict),
-                    tags: map.tags.map(function (r) { return r.slice(); }),
+                    type,
+                    tags: alias.tags.map((r) => r.slice()),
                 });
             }),
+            natives: meta.natives.map((native) => MetadataNative_1.MetadataNative.create(native)),
+            sets: meta.sets.map((set) => MetadataSet_1.MetadataSet.create({
+                value: Metadata.from(set.value, dict),
+                tags: set.tags.map((r) => r.slice()),
+            })),
+            maps: meta.maps.map((map) => MetadataMap_1.MetadataMap.create({
+                key: this.from(map.key, dict),
+                value: this.from(map.value, dict),
+                tags: map.tags.map((r) => r.slice()),
+            })),
         });
-    };
+    }
     /* -----------------------------------------------------------
       ACCESSORS
     ----------------------------------------------------------- */
-    Metadata.prototype.getName = function () {
+    getName() {
         var _a;
         return ((_a = this.name_) !== null && _a !== void 0 ? _a : (this.name_ = getName(this)));
-    };
-    Metadata.prototype.empty = function () {
+    }
+    empty() {
         return this.bucket() === 0 || this.size() === 0;
-    };
-    Metadata.prototype.size = function () {
+    }
+    size() {
         return ((this.any ? 1 : 0) +
             (this.escaped ? 1 : 0) +
             (this.rest ? this.rest.size() : 0) +
             this.templates.length +
             this.atomics.length +
-            this.constants.map(function (c) { return c.values.length; }).reduce(function (x, y) { return x + y; }, 0) +
+            this.constants.map((c) => c.values.length).reduce((x, y) => x + y, 0) +
             this.arrays.length +
             this.tuples.length +
             this.natives.length +
@@ -222,8 +180,8 @@ var Metadata = /** @class */ (function () {
             this.objects.length +
             this.functions.length +
             this.aliases.length);
-    };
-    Metadata.prototype.bucket = function () {
+    }
+    bucket() {
         return ((this.any ? 1 : 0) +
             (this.escaped ? 1 : 0) +
             (this.templates.length ? 1 : 0) +
@@ -238,55 +196,50 @@ var Metadata = /** @class */ (function () {
             (this.objects.length ? 1 : 0) +
             (this.functions.length ? 1 : 0) +
             (this.aliases.length ? 1 : 0));
-    };
+    }
     /**
      * @internal
      */
-    Metadata.prototype.isSequence = function () {
-        var _this = this;
+    isSequence() {
         var _a;
-        return ((_a = this.is_sequence_) !== null && _a !== void 0 ? _a : (this.is_sequence_ = (function () {
-            var exists = function (tags) {
-                return tags.some(function (row) {
-                    var sequence = row.find(function (t) {
-                        var _a;
-                        return t.kind === "sequence" &&
-                            typeof ((_a = t.schema) === null || _a === void 0 ? void 0 : _a["x-protobuf-sequence"]) === "number";
-                    });
-                    if (sequence === undefined)
-                        return false;
-                    var value = Number(sequence.schema["x-protobuf-sequence"]);
-                    return !Number.isNaN(value);
+        return ((_a = this.is_sequence_) !== null && _a !== void 0 ? _a : (this.is_sequence_ = (() => {
+            const exists = (tags) => tags.some((row) => {
+                const sequence = row.find((t) => {
+                    var _a;
+                    return t.kind === "sequence" &&
+                        typeof ((_a = t.schema) === null || _a === void 0 ? void 0 : _a["x-protobuf-sequence"]) === "number";
                 });
-            };
-            return (_this.atomics.some(function (atomic) { return exists(atomic.tags); }) &&
-                _this.constants.some(function (c) {
-                    return c.values.some(function (v) { var _a; return exists((_a = v.tags) !== null && _a !== void 0 ? _a : []); });
-                }) &&
-                _this.templates.some(function (tpl) { return exists(tpl.tags); }) &&
-                _this.arrays.some(function (array) { return exists(array.tags); }) &&
-                _this.objects.some(function (object) { return exists(object.tags); }) &&
-                _this.natives.some(function (native) { return native.name === "Uint8Array" && exists(native.tags); }));
+                if (sequence === undefined)
+                    return false;
+                const value = Number(sequence.schema["x-protobuf-sequence"]);
+                return !Number.isNaN(value);
+            });
+            return (this.atomics.some((atomic) => exists(atomic.tags)) &&
+                this.constants.some((c) => c.values.some((v) => { var _a; return exists((_a = v.tags) !== null && _a !== void 0 ? _a : []); })) &&
+                this.templates.some((tpl) => exists(tpl.tags)) &&
+                this.arrays.some((array) => exists(array.tags)) &&
+                this.objects.some((object) => exists(object.tags)) &&
+                this.natives.some((native) => native.name === "Uint8Array" && exists(native.tags)));
         })()));
-    };
-    Metadata.prototype.isConstant = function () {
+    }
+    isConstant() {
         return this.bucket() === (this.constants.length ? 1 : 0);
-    };
-    Metadata.prototype.isRequired = function () {
+    }
+    isRequired() {
         return this.required === true && this.optional === false;
-    };
+    }
     /**
      * @internal
      */
-    Metadata.prototype.isUnionBucket = function () {
-        var size = this.bucket();
-        var emended = !!this.atomics.length && !!this.constants.length ? size - 1 : size;
+    isUnionBucket() {
+        const size = this.bucket();
+        const emended = !!this.atomics.length && !!this.constants.length ? size - 1 : size;
         return emended > 1;
-    };
+    }
     /**
      * @internal
      */
-    Metadata.prototype.getSoleLiteral = function () {
+    getSoleLiteral() {
         if (this.size() === 1 &&
             this.constants.length === 1 &&
             this.constants[0].type === "string" &&
@@ -294,22 +247,20 @@ var Metadata = /** @class */ (function () {
             return this.constants[0].values[0].value;
         else
             return null;
-    };
-    Metadata.prototype.isSoleLiteral = function () {
+    }
+    isSoleLiteral() {
         return this.getSoleLiteral() !== null;
-    };
+    }
     /**
      * @internal
      */
-    Metadata.prototype.isParentResolved = function () {
+    isParentResolved() {
         return this.parent_resolved_;
-    };
-    return Metadata;
-}());
+    }
+}
 exports.Metadata = Metadata;
 (function (Metadata) {
-    Metadata.intersects = function (x, y) {
-        var e_1, _a, e_2, _b;
+    Metadata.intersects = (x, y) => {
         // CHECK ANY & OPTIONAL
         if (x.any || y.any)
             return true;
@@ -333,76 +284,46 @@ exports.Metadata = Metadata;
             return true;
         // NATIVES
         if (x.natives.length && y.natives.length)
-            if (x.natives.some(function (xn) { return y.natives.some(function (yn) { return xn === yn; }); }))
+            if (x.natives.some((xn) => y.natives.some((yn) => xn === yn)))
                 return true;
         // ESCAPED
         if (x.escaped && y.escaped)
             return (Metadata.intersects(x.escaped.original, y.escaped.original) ||
                 Metadata.intersects(x.escaped.returns, y.escaped.returns));
-        var _loop_1 = function (atomic) {
-            if (y.atomics.some(function (ya) { return atomic.type === ya.type; }))
-                return { value: true };
-            if (y.constants.some(function (yc) { return atomic.type === yc.type; }))
-                return { value: true };
-        };
-        try {
-            //----
-            // VALUES
-            //----
-            // ATOMICS
-            for (var _c = __values(x.atomics), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var atomic = _d.value;
-                var state_1 = _loop_1(atomic);
-                if (typeof state_1 === "object")
-                    return state_1.value;
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
+        //----
+        // VALUES
+        //----
+        // ATOMICS
+        for (const atomic of x.atomics) {
+            if (y.atomics.some((ya) => atomic.type === ya.type))
+                return true;
+            if (y.constants.some((yc) => atomic.type === yc.type))
+                return true;
         }
-        var _loop_2 = function (constant) {
-            var atomic = y.atomics.find(function (elem) { return elem.type === constant.type; });
+        // CONSTANTS
+        for (const constant of x.constants) {
+            const atomic = y.atomics.find((elem) => elem.type === constant.type);
             if (atomic !== undefined)
-                return { value: true };
-            var opposite = y.constants.find(function (elem) { return elem.type === constant.type; });
+                return true;
+            const opposite = y.constants.find((elem) => elem.type === constant.type);
             if (opposite === undefined)
-                return "continue";
-            var values = new Set(__spreadArray(__spreadArray([], __read(constant.values.map(function (e) { return e.value; })), false), __read(opposite.values.map(function (e) { return e.value; })), false));
+                continue;
+            const values = new Set([
+                ...constant.values.map((e) => e.value),
+                ...opposite.values.map((e) => e.value),
+            ]);
             if (values.size !== constant.values.length + opposite.values.length)
-                return { value: true };
-        };
-        try {
-            // CONSTANTS
-            for (var _e = __values(x.constants), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var constant = _f.value;
-                var state_2 = _loop_2(constant);
-                if (typeof state_2 === "object")
-                    return state_2.value;
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-            }
-            finally { if (e_2) throw e_2.error; }
+                return true;
         }
         // TEMPLATES
-        if (!!x.templates.length && y.atomics.some(function (ya) { return ya.type === "string"; }))
+        if (!!x.templates.length && y.atomics.some((ya) => ya.type === "string"))
             return true;
         else if (!!y.templates.length &&
-            x.atomics.some(function (xa) { return xa.type === "string"; }))
+            x.atomics.some((xa) => xa.type === "string"))
             return true;
         return false;
     };
-    Metadata.covers = function (x, y, level, escaped) {
-        var e_3, _a, e_4, _b, e_5, _c, e_6, _d, e_7, _e, e_8, _f, e_9, _g;
-        if (level === void 0) { level = 0; }
-        if (escaped === void 0) { escaped = false; }
+    Metadata.covers = (x, y, level = 0, escaped = false) => {
         // CHECK ANY
         if (x === y)
             return false;
@@ -423,167 +344,52 @@ exports.Metadata = Metadata;
         // INSTANCES
         //----
         if (level === 0) {
-            var _loop_3 = function (ya) {
-                if (!x.arrays.some(function (xa) {
-                    return Metadata.covers(xa.type.value, ya.type.value, level + 1);
-                })) {
-                    return { value: false };
+            // ARRAYS
+            for (const ya of y.arrays)
+                if (!x.arrays.some((xa) => Metadata.covers(xa.type.value, ya.type.value, level + 1))) {
+                    return false;
                 }
-            };
-            try {
-                // ARRAYS
-                for (var _h = __values(y.arrays), _j = _h.next(); !_j.done; _j = _h.next()) {
-                    var ya = _j.value;
-                    var state_3 = _loop_3(ya);
-                    if (typeof state_3 === "object")
-                        return state_3.value;
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            var _loop_4 = function (yt) {
+            // TUPLES
+            for (const yt of y.tuples)
                 if (yt.type.elements.length !== 0 &&
-                    x.tuples.some(function (xt) {
-                        return xt.type.elements.length >= yt.type.elements.length &&
-                            xt.type.elements
-                                .slice(yt.type.elements.length)
-                                .every(function (xv, i) { return Metadata.covers(xv, yt.type.elements[i], level + 1); });
-                    }) === false)
-                    return { value: false };
-            };
-            try {
-                // TUPLES
-                for (var _k = __values(y.tuples), _l = _k.next(); !_l.done; _l = _k.next()) {
-                    var yt = _l.value;
-                    var state_4 = _loop_4(yt);
-                    if (typeof state_4 === "object")
-                        return state_4.value;
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
-        }
-        var _loop_5 = function (yo) {
-            if (x.objects.some(function (xo) { return MetadataObjectType_1.MetadataObjectType.covers(xo.type, yo.type); }) ===
+                    x.tuples.some((xt) => xt.type.elements.length >= yt.type.elements.length &&
+                        xt.type.elements
+                            .slice(yt.type.elements.length)
+                            .every((xv, i) => Metadata.covers(xv, yt.type.elements[i], level + 1))) === false)
+                    return false;
+        }
+        // OBJECTS
+        for (const yo of y.objects)
+            if (x.objects.some((xo) => MetadataObjectType_1.MetadataObjectType.covers(xo.type, yo.type)) ===
                 false)
-                return { value: false };
-        };
-        try {
-            // OBJECTS
-            for (var _m = __values(y.objects), _o = _m.next(); !_o.done; _o = _m.next()) {
-                var yo = _o.value;
-                var state_5 = _loop_5(yo);
-                if (typeof state_5 === "object")
-                    return state_5.value;
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
-            }
-            finally { if (e_5) throw e_5.error; }
-        }
-        var _loop_6 = function (yd) {
-            if (x.aliases.some(function (xd) { return xd.type.name === yd.type.name; }) === false)
-                return { value: false };
-        };
-        try {
-            // ALIASES
-            for (var _p = __values(y.aliases), _q = _p.next(); !_q.done; _q = _p.next()) {
-                var yd = _q.value;
-                var state_6 = _loop_6(yd);
-                if (typeof state_6 === "object")
-                    return state_6.value;
-            }
-        }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
-            }
-            finally { if (e_6) throw e_6.error; }
-        }
-        var _loop_7 = function (yn) {
-            if (x.natives.some(function (xn) { return xn === yn; }) === false)
-                return { value: false };
-        };
-        try {
-            // NATIVES
-            for (var _r = __values(y.natives), _s = _r.next(); !_s.done; _s = _r.next()) {
-                var yn = _s.value;
-                var state_7 = _loop_7(yn);
-                if (typeof state_7 === "object")
-                    return state_7.value;
-            }
-        }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-        finally {
-            try {
-                if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
-            }
-            finally { if (e_7) throw e_7.error; }
-        }
-        var _loop_8 = function (ys) {
-            if (x.sets.some(function (xs) { return Metadata.covers(xs.value, ys.value); }) === false)
-                return { value: false };
-        };
-        try {
-            // SETS
-            for (var _t = __values(y.sets), _u = _t.next(); !_u.done; _u = _t.next()) {
-                var ys = _u.value;
-                var state_8 = _loop_8(ys);
-                if (typeof state_8 === "object")
-                    return state_8.value;
-            }
-        }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-        finally {
-            try {
-                if (_u && !_u.done && (_f = _t.return)) _f.call(_t);
-            }
-            finally { if (e_8) throw e_8.error; }
-        }
+                return false;
+        // ALIASES
+        for (const yd of y.aliases)
+            if (x.aliases.some((xd) => xd.type.name === yd.type.name) === false)
+                return false;
+        // NATIVES
+        for (const yn of y.natives)
+            if (x.natives.some((xn) => xn === yn) === false)
+                return false;
+        // SETS
+        for (const ys of y.sets)
+            if (x.sets.some((xs) => Metadata.covers(xs.value, ys.value)) === false)
+                return false;
         //----
         // VALUES
         //----
         // ATOMICS
-        if (y.atomics.some(function (ya) { return x.atomics.some(function (xa) { return xa.type === ya.type; }) === false; }))
+        if (y.atomics.some((ya) => x.atomics.some((xa) => xa.type === ya.type) === false))
             return false;
-        var _loop_9 = function (yc) {
-            if (x.atomics.some(function (atom) { return yc.type === atom.type; }))
-                return "continue";
-            var xc = x.constants.find(function (elem) { return elem.type === yc.type; });
+        // CONSTANTS
+        for (const yc of y.constants) {
+            if (x.atomics.some((atom) => yc.type === atom.type))
+                continue;
+            const xc = x.constants.find((elem) => elem.type === yc.type);
             if (xc === undefined)
-                return { value: false };
-            else if (yc.values.map(function (e) { return e.value; }).some(function (yv) { return xc.values.includes(yv) === false; }))
-                return { value: false };
-        };
-        try {
-            // CONSTANTS
-            for (var _v = __values(y.constants), _w = _v.next(); !_w.done; _w = _v.next()) {
-                var yc = _w.value;
-                var state_9 = _loop_9(yc);
-                if (typeof state_9 === "object")
-                    return state_9.value;
-            }
-        }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
-        finally {
-            try {
-                if (_w && !_w.done && (_g = _v.return)) _g.call(_v);
-            }
-            finally { if (e_9) throw e_9.error; }
+                return false;
+            else if (yc.values.map((e) => e.value).some((yv) => xc.values.includes(yv) === false))
+                return false;
         }
         // FUNCTIONAL
         if (!!x.functions.length === false && !!y.functions.length)
@@ -594,10 +400,9 @@ exports.Metadata = Metadata;
     /**
      * @internal
      */
-    Metadata.merge = function (x, y) {
-        var e_10, _a;
-        var _b, _c;
-        var output = Metadata.create({
+    Metadata.merge = (x, y) => {
+        var _a, _b;
+        const output = Metadata.create({
             any: x.any || y.any,
             nullable: x.nullable || y.nullable,
             required: x.required && y.required,
@@ -608,251 +413,101 @@ exports.Metadata = Metadata;
                     original: Metadata.merge(x.escaped.original, y.escaped.original),
                     returns: Metadata.merge(x.escaped.returns, y.escaped.returns),
                 })
-                : ((_b = x.escaped) !== null && _b !== void 0 ? _b : y.escaped),
+                : ((_a = x.escaped) !== null && _a !== void 0 ? _a : y.escaped),
             atomics: mergeTaggedTypes({
                 container: x.atomics,
-                equals: function (x, y) { return x.type === y.type; },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.type === y.type,
+                getter: (x) => x.tags,
             })(y.atomics),
-            constants: __spreadArray([], __read(x.constants), false),
+            constants: [...x.constants],
             templates: x.templates.slice(),
             rest: x.rest !== null && y.rest !== null
                 ? Metadata.merge(x.rest, y.rest)
-                : ((_c = x.rest) !== null && _c !== void 0 ? _c : y.rest),
+                : ((_b = x.rest) !== null && _b !== void 0 ? _b : y.rest),
             arrays: mergeTaggedTypes({
                 container: x.arrays,
-                equals: function (x, y) { return x.type.name === y.type.name; },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
             })(y.arrays),
             tuples: mergeTaggedTypes({
                 container: x.tuples,
-                equals: function (x, y) { return x.type.name === y.type.name; },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
             })(y.tuples),
             objects: mergeTaggedTypes({
                 container: x.objects,
-                equals: function (x, y) { return x.type.name === y.type.name; },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
             })(y.objects),
             aliases: mergeTaggedTypes({
                 container: x.aliases,
-                equals: function (x, y) { return x.type.name === y.type.name; },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
             })(y.aliases),
             natives: mergeTaggedTypes({
                 container: x.natives,
-                equals: function (x, y) { return x.name === y.name; },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.name === y.name,
+                getter: (x) => x.tags,
             })(y.natives),
             sets: mergeTaggedTypes({
                 container: x.sets,
-                equals: function (x, y) { return x.value.getName() === y.value.getName(); },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.value.getName() === y.value.getName(),
+                getter: (x) => x.tags,
             })(y.sets),
             maps: mergeTaggedTypes({
                 container: x.maps,
-                equals: function (x, y) {
-                    return x.key.getName() === y.key.getName() &&
-                        x.value.getName() === y.value.getName();
-                },
-                getter: function (x) { return x.tags; },
+                equals: (x, y) => x.key.getName() === y.key.getName() &&
+                    x.value.getName() === y.value.getName(),
+                getter: (x) => x.tags,
             })(y.maps),
         });
-        var _loop_10 = function (constant) {
-            var e_11, _f;
-            var target = ArrayUtil_1.ArrayUtil.take(output.constants, function (elem) { return elem.type === constant.type; }, function () {
-                return MetadataConstant_1.MetadataConstant.create({
-                    type: constant.type,
-                    values: [],
-                });
-            });
-            try {
-                for (var _g = (e_11 = void 0, __values(constant.values)), _h = _g.next(); !_h.done; _h = _g.next()) {
-                    var value = _h.value;
-                    ArrayUtil_1.ArrayUtil.add(target.values, value, function (a, b) { return a.value === b.value; });
-                }
-            }
-            catch (e_11_1) { e_11 = { error: e_11_1 }; }
-            finally {
-                try {
-                    if (_h && !_h.done && (_f = _g.return)) _f.call(_g);
-                }
-                finally { if (e_11) throw e_11.error; }
-            }
-        };
-        try {
-            for (var _d = __values(y.constants), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var constant = _e.value;
-                _loop_10(constant);
-            }
-        }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_10) throw e_10.error; }
+        for (const constant of y.constants) {
+            const target = ArrayUtil_1.ArrayUtil.take(output.constants, (elem) => elem.type === constant.type, () => MetadataConstant_1.MetadataConstant.create({
+                type: constant.type,
+                values: [],
+            }));
+            for (const value of constant.values)
+                ArrayUtil_1.ArrayUtil.add(target.values, value, (a, b) => a.value === b.value);
         }
         return output;
     };
 })(Metadata || (exports.Metadata = Metadata = {}));
-var getName = function (metadata) {
-    var e_12, _a, e_13, _b, e_14, _c, e_15, _d, e_16, _e, e_17, _f, e_18, _g, e_19, _h, e_20, _j, e_21, _k, e_22, _l;
+const getName = (metadata) => {
     if (metadata.any === true)
         return "any";
-    var elements = [];
+    const elements = [];
     // OPTIONAL
     if (metadata.nullable === true)
         elements.push("null");
     if (metadata.isRequired() === false)
         elements.push("undefined");
-    try {
-        // ATOMIC
-        for (var _m = __values(metadata.atomics), _o = _m.next(); !_o.done; _o = _m.next()) {
-            var atom = _o.value;
-            elements.push(atom.getName());
-        }
-    }
-    catch (e_12_1) { e_12 = { error: e_12_1 }; }
-    finally {
-        try {
-            if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
-        }
-        finally { if (e_12) throw e_12.error; }
-    }
-    try {
-        for (var _p = __values(metadata.constants), _q = _p.next(); !_q.done; _q = _p.next()) {
-            var constant = _q.value;
-            try {
-                for (var _r = (e_14 = void 0, __values(constant.values)), _s = _r.next(); !_s.done; _s = _r.next()) {
-                    var value = _s.value;
-                    elements.push(value.getName());
-                }
-            }
-            catch (e_14_1) { e_14 = { error: e_14_1 }; }
-            finally {
-                try {
-                    if (_s && !_s.done && (_c = _r.return)) _c.call(_r);
-                }
-                finally { if (e_14) throw e_14.error; }
-            }
-        }
-    }
-    catch (e_13_1) { e_13 = { error: e_13_1 }; }
-    finally {
-        try {
-            if (_q && !_q.done && (_b = _p.return)) _b.call(_p);
-        }
-        finally { if (e_13) throw e_13.error; }
-    }
-    try {
-        for (var _t = __values(metadata.templates), _u = _t.next(); !_u.done; _u = _t.next()) {
-            var template = _u.value;
-            elements.push(template.getName());
-        }
-    }
-    catch (e_15_1) { e_15 = { error: e_15_1 }; }
-    finally {
-        try {
-            if (_u && !_u.done && (_d = _t.return)) _d.call(_t);
-        }
-        finally { if (e_15) throw e_15.error; }
-    }
-    try {
-        // NATIVES
-        for (var _v = __values(metadata.natives), _w = _v.next(); !_w.done; _w = _v.next()) {
-            var native = _w.value;
-            elements.push(native.getName());
-        }
-    }
-    catch (e_16_1) { e_16 = { error: e_16_1 }; }
-    finally {
-        try {
-            if (_w && !_w.done && (_e = _v.return)) _e.call(_v);
-        }
-        finally { if (e_16) throw e_16.error; }
-    }
-    try {
-        for (var _x = __values(metadata.sets), _y = _x.next(); !_y.done; _y = _x.next()) {
-            var set = _y.value;
-            elements.push(set.getName());
-        }
-    }
-    catch (e_17_1) { e_17 = { error: e_17_1 }; }
-    finally {
-        try {
-            if (_y && !_y.done && (_f = _x.return)) _f.call(_x);
-        }
-        finally { if (e_17) throw e_17.error; }
-    }
-    try {
-        for (var _z = __values(metadata.maps), _0 = _z.next(); !_0.done; _0 = _z.next()) {
-            var map = _0.value;
-            elements.push(map.getName());
-        }
-    }
-    catch (e_18_1) { e_18 = { error: e_18_1 }; }
-    finally {
-        try {
-            if (_0 && !_0.done && (_g = _z.return)) _g.call(_z);
-        }
-        finally { if (e_18) throw e_18.error; }
+    // ATOMIC
+    for (const atom of metadata.atomics) {
+        elements.push(atom.getName());
     }
+    for (const constant of metadata.constants)
+        for (const value of constant.values)
+            elements.push(value.getName());
+    for (const template of metadata.templates)
+        elements.push(template.getName());
+    // NATIVES
+    for (const native of metadata.natives)
+        elements.push(native.getName());
+    for (const set of metadata.sets)
+        elements.push(set.getName());
+    for (const map of metadata.maps)
+        elements.push(map.getName());
     // INSTANCES
     if (metadata.rest !== null)
-        elements.push("...".concat(metadata.rest.getName()));
-    try {
-        for (var _1 = __values(metadata.tuples), _2 = _1.next(); !_2.done; _2 = _1.next()) {
-            var tuple = _2.value;
-            elements.push(tuple.type.name);
-        }
-    }
-    catch (e_19_1) { e_19 = { error: e_19_1 }; }
-    finally {
-        try {
-            if (_2 && !_2.done && (_h = _1.return)) _h.call(_1);
-        }
-        finally { if (e_19) throw e_19.error; }
-    }
-    try {
-        for (var _3 = __values(metadata.arrays), _4 = _3.next(); !_4.done; _4 = _3.next()) {
-            var array = _4.value;
-            elements.push(array.getName());
-        }
-    }
-    catch (e_20_1) { e_20 = { error: e_20_1 }; }
-    finally {
-        try {
-            if (_4 && !_4.done && (_j = _3.return)) _j.call(_3);
-        }
-        finally { if (e_20) throw e_20.error; }
-    }
-    try {
-        for (var _5 = __values(metadata.objects), _6 = _5.next(); !_6.done; _6 = _5.next()) {
-            var object = _6.value;
-            elements.push(object.getName());
-        }
-    }
-    catch (e_21_1) { e_21 = { error: e_21_1 }; }
-    finally {
-        try {
-            if (_6 && !_6.done && (_k = _5.return)) _k.call(_5);
-        }
-        finally { if (e_21) throw e_21.error; }
-    }
-    try {
-        for (var _7 = __values(metadata.aliases), _8 = _7.next(); !_8.done; _8 = _7.next()) {
-            var alias = _8.value;
-            elements.push(alias.getName());
-        }
-    }
-    catch (e_22_1) { e_22 = { error: e_22_1 }; }
-    finally {
-        try {
-            if (_8 && !_8.done && (_l = _7.return)) _l.call(_7);
-        }
-        finally { if (e_22) throw e_22.error; }
-    }
+        elements.push(`...${metadata.rest.getName()}`);
+    for (const tuple of metadata.tuples)
+        elements.push(tuple.type.name);
+    for (const array of metadata.arrays)
+        elements.push(array.getName());
+    for (const object of metadata.objects)
+        elements.push(object.getName());
+    for (const alias of metadata.aliases)
+        elements.push(alias.getName());
     if (metadata.escaped !== null)
         elements.push(metadata.escaped.getName());
     // RETURNS
@@ -861,59 +516,27 @@ var getName = function (metadata) {
     else if (elements.length === 1)
         return elements[0];
     elements.sort();
-    return "(".concat(elements.join(" | "), ")");
+    return `(${elements.join(" | ")})`;
 };
-var mergeTaggedTypes = function (props) {
-    return function (opposite) {
-        var e_23, _a;
-        var output = __spreadArray([], __read(props.container), false);
-        var _loop_11 = function (elem) {
-            var e_24, _b;
-            var equal = props.container.find(function (x) { return props.equals(x, elem); });
-            if (equal === undefined) {
-                output.push(elem);
-                return "continue";
-            }
-            var matrix = props
-                .getter(equal)
-                .map(function (tags) { return tags.map(function (t) { return t.name; }); })
-                .sort();
-            var _loop_12 = function (tags) {
-                var names = tags.map(function (t) { return t.name; }).sort();
-                if (matrix.some(function (m) {
-                    return m.length === names.length && m.every(function (s, i) { return s === names[i]; });
-                }))
-                    return "continue";
-                props.getter(equal).push(tags);
-            };
-            try {
-                for (var _c = (e_24 = void 0, __values(props.getter(elem))), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var tags = _d.value;
-                    _loop_12(tags);
-                }
-            }
-            catch (e_24_1) { e_24 = { error: e_24_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-                }
-                finally { if (e_24) throw e_24.error; }
-            }
-        };
-        try {
-            for (var opposite_1 = __values(opposite), opposite_1_1 = opposite_1.next(); !opposite_1_1.done; opposite_1_1 = opposite_1.next()) {
-                var elem = opposite_1_1.value;
-                _loop_11(elem);
-            }
+const mergeTaggedTypes = (props) => (opposite) => {
+    const output = [...props.container];
+    for (const elem of opposite) {
+        const equal = props.container.find((x) => props.equals(x, elem));
+        if (equal === undefined) {
+            output.push(elem);
+            continue;
+        }
+        const matrix = props
+            .getter(equal)
+            .map((tags) => tags.map((t) => t.name))
+            .sort();
+        for (const tags of props.getter(elem)) {
+            const names = tags.map((t) => t.name).sort();
+            if (matrix.some((m) => m.length === names.length && m.every((s, i) => s === names[i])))
+                continue;
+            props.getter(equal).push(tags);
         }
-        catch (e_23_1) { e_23 = { error: e_23_1 }; }
-        finally {
-            try {
-                if (opposite_1_1 && !opposite_1_1.done && (_a = opposite_1.return)) _a.call(opposite_1);
-            }
-            finally { if (e_23) throw e_23.error; }
-        }
-        return output;
-    };
+    }
+    return output;
 };
 //# sourceMappingURL=Metadata.js.map