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

package/lib/factories/ProtobufFactory.js

@@ -1,64 +1,17 @@
 "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 __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.ProtobufFactory = void 0;
-var ProtobufUtil_1 = require("../programmers/helpers/ProtobufUtil");
-var TransformerError_1 = require("../transformers/TransformerError");
-var MetadataFactory_1 = require("./MetadataFactory");
+const ProtobufUtil_1 = require("../programmers/helpers/ProtobufUtil");
+const TransformerError_1 = require("../transformers/TransformerError");
+const MetadataFactory_1 = require("./MetadataFactory");
 var ProtobufFactory;
 (function (ProtobufFactory) {
     /* -----------------------------------------------------------
       METADATA COMPOSER
     ----------------------------------------------------------- */
-    ProtobufFactory.metadata = function (props) {
+    ProtobufFactory.metadata = (props) => {
         // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
-        var result = MetadataFactory_1.MetadataFactory.analyze(__assign(__assign({}, props), { transformer: props.transformer, options: {
+        const result = MetadataFactory_1.MetadataFactory.analyze(Object.assign(Object.assign({}, props), { transformer: props.transformer, options: {
                 escape: false,
                 constant: true,
                 absorb: true,
@@ -66,7 +19,7 @@ var ProtobufFactory;
             } }));
         if (result.success === false)
             throw TransformerError_1.TransformerError.from({
-                code: "typia.protobuf.".concat(props.method),
+                code: `typia.protobuf.${props.method}`,
                 errors: result.errors,
             });
         return result.data;
@@ -74,341 +27,182 @@ var ProtobufFactory;
     /**
      * @internal
      */
-    ProtobufFactory.emplaceObject = function (object) {
-        var e_1, _a;
-        try {
-            for (var _b = __values(object.properties), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var p = _c.value;
-                emplaceProperty(p);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        var properties = object.properties
-            .map(function (p) { return p.of_protobuf_; })
-            .filter(function (p) { return p !== undefined; });
-        var unique = new Set(properties
-            .filter(function (p) { return p !== undefined; })
-            .filter(function (p) { return p.fixed === true; })
-            .map(function (p) { return p.union.map(function (u) { return u.index; }); })
+    ProtobufFactory.emplaceObject = (object) => {
+        for (const p of object.properties)
+            emplaceProperty(p);
+        const properties = object.properties
+            .map((p) => p.of_protobuf_)
+            .filter((p) => p !== undefined);
+        const unique = new Set(properties
+            .filter((p) => p !== undefined)
+            .filter((p) => p.fixed === true)
+            .map((p) => p.union.map((u) => u.index))
             .flat());
-        var index = 1;
-        properties.forEach(function (schema) {
-            var e_2, _a;
+        let index = 1;
+        properties.forEach((schema) => {
             if (schema.fixed === true)
-                index = Math.max(index, Math.max.apply(Math, __spreadArray([], __read(schema.union.map(function (u) { return u.index; })), false)) + 1);
+                index = Math.max(index, Math.max(...schema.union.map((u) => u.index)) + 1);
             else {
-                try {
-                    for (var _b = __values(schema.union), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var u = _c.value;
-                        while (unique.has(index) === true)
-                            ++index;
-                        u.index = index;
-                        unique.add(index);
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_2) throw e_2.error; }
+                for (const u of schema.union) {
+                    while (unique.has(index) === true)
+                        ++index;
+                    u.index = index;
+                    unique.add(index);
                 }
                 ++index;
             }
         });
     };
-    var emplaceProperty = function (prop) {
-        var e_3, _a, e_4, _b, e_5, _c, e_6, _d;
-        var _e, _f, _g, _h, _j;
-        var union = [];
-        try {
-            for (var _k = __values(prop.value.natives), _l = _k.next(); !_l.done; _l = _k.next()) {
-                var native = _l.value;
-                if (native.name === "Uint8Array")
-                    union.push({
-                        type: "bytes",
-                        index: ProtobufUtil_1.ProtobufUtil.getSequence((_e = native.tags[0]) !== null && _e !== void 0 ? _e : []),
-                    });
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_l && !_l.done && (_a = _k.return)) _a.call(_k);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        union.push.apply(union, __spreadArray([], __read(emplaceAtomic(prop.value).values()), false));
-        try {
-            for (var _m = __values(prop.value.arrays), _o = _m.next(); !_o.done; _o = _m.next()) {
-                var array = _o.value;
+    const emplaceProperty = (prop) => {
+        var _a, _b, _c, _d, _e;
+        const union = [];
+        for (const native of prop.value.natives)
+            if (native.name === "Uint8Array")
                 union.push({
-                    type: "array",
-                    array: array.type,
-                    value: emplaceSchema(array.type.value),
-                    index: ProtobufUtil_1.ProtobufUtil.getSequence((_f = array.tags[0]) !== null && _f !== void 0 ? _f : []),
+                    type: "bytes",
+                    index: ProtobufUtil_1.ProtobufUtil.getSequence((_a = native.tags[0]) !== null && _a !== void 0 ? _a : []),
                 });
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_o && !_o.done && (_b = _m.return)) _b.call(_m);
-            }
-            finally { if (e_4) throw e_4.error; }
-        }
-        try {
-            for (var _p = __values(prop.value.objects), _q = _p.next(); !_q.done; _q = _p.next()) {
-                var obj = _q.value;
-                if (isDynamicObject(obj.type))
-                    union.push({
-                        type: "map",
-                        map: obj.type,
-                        key: emplaceSchema(obj.type.properties[0].key),
-                        value: emplaceSchema(obj.type.properties[0].value),
-                        index: ProtobufUtil_1.ProtobufUtil.getSequence((_g = obj.tags[0]) !== null && _g !== void 0 ? _g : []),
-                    });
-                else
-                    union.push({
-                        type: "object",
-                        object: obj.type,
-                        index: ProtobufUtil_1.ProtobufUtil.getSequence((_h = obj.tags[0]) !== null && _h !== void 0 ? _h : []),
-                    });
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (_q && !_q.done && (_c = _p.return)) _c.call(_p);
-            }
-            finally { if (e_5) throw e_5.error; }
-        }
-        try {
-            for (var _r = __values(prop.value.maps), _s = _r.next(); !_s.done; _s = _r.next()) {
-                var map = _s.value;
+        union.push(...emplaceAtomic(prop.value).values());
+        for (const array of prop.value.arrays)
+            union.push({
+                type: "array",
+                array: array.type,
+                value: emplaceSchema(array.type.value),
+                index: ProtobufUtil_1.ProtobufUtil.getSequence((_b = array.tags[0]) !== null && _b !== void 0 ? _b : []),
+            });
+        for (const obj of prop.value.objects)
+            if (isDynamicObject(obj.type))
                 union.push({
                     type: "map",
-                    map: map,
-                    key: emplaceSchema(map.key),
-                    value: emplaceSchema(map.value),
-                    index: ProtobufUtil_1.ProtobufUtil.getSequence((_j = map.tags[0]) !== null && _j !== void 0 ? _j : []),
+                    map: obj.type,
+                    key: emplaceSchema(obj.type.properties[0].key),
+                    value: emplaceSchema(obj.type.properties[0].value),
+                    index: ProtobufUtil_1.ProtobufUtil.getSequence((_c = obj.tags[0]) !== null && _c !== void 0 ? _c : []),
                 });
-            }
-        }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-        finally {
-            try {
-                if (_s && !_s.done && (_d = _r.return)) _d.call(_r);
-            }
-            finally { if (e_6) throw e_6.error; }
-        }
+            else
+                union.push({
+                    type: "object",
+                    object: obj.type,
+                    index: ProtobufUtil_1.ProtobufUtil.getSequence((_d = obj.tags[0]) !== null && _d !== void 0 ? _d : []),
+                });
+        for (const map of prop.value.maps)
+            union.push({
+                type: "map",
+                map,
+                key: emplaceSchema(map.key),
+                value: emplaceSchema(map.value),
+                index: ProtobufUtil_1.ProtobufUtil.getSequence((_e = map.tags[0]) !== null && _e !== void 0 ? _e : []),
+            });
         prop.of_protobuf_ = {
-            union: union,
-            fixed: union.every(function (p) { return p.index !== null; }),
+            union,
+            fixed: union.every((p) => p.index !== null),
         };
     };
-    var emplaceSchema = function (metadata) {
-        var e_7, _a, e_8, _b, e_9, _c, e_10, _d;
-        try {
-            for (var _e = __values(metadata.natives), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var native = _f.value;
-                if (native.name === "Uint8Array")
-                    return {
-                        type: "bytes",
-                    };
-            }
-        }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-            }
-            finally { if (e_7) throw e_7.error; }
-        }
-        var atomic = emplaceAtomic(metadata);
+    const emplaceSchema = (metadata) => {
+        for (const native of metadata.natives)
+            if (native.name === "Uint8Array")
+                return {
+                    type: "bytes",
+                };
+        const atomic = emplaceAtomic(metadata);
         if (atomic.size)
             return atomic.values().next().value;
-        try {
-            for (var _g = __values(metadata.arrays), _h = _g.next(); !_h.done; _h = _g.next()) {
-                var array = _h.value;
+        for (const array of metadata.arrays)
+            return {
+                type: "array",
+                array: array.type,
+                value: emplaceSchema(array.type.value),
+            };
+        for (const obj of metadata.objects)
+            if (isDynamicObject(obj.type))
                 return {
-                    type: "array",
-                    array: array.type,
-                    value: emplaceSchema(array.type.value),
+                    type: "map",
+                    map: obj.type,
+                    key: emplaceSchema(obj.type.properties[0].key),
+                    value: emplaceSchema(obj.type.properties[0].value),
                 };
-            }
-        }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-        finally {
-            try {
-                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-            }
-            finally { if (e_8) throw e_8.error; }
-        }
-        try {
-            for (var _j = __values(metadata.objects), _k = _j.next(); !_k.done; _k = _j.next()) {
-                var obj = _k.value;
-                if (isDynamicObject(obj.type))
-                    return {
-                        type: "map",
-                        map: obj.type,
-                        key: emplaceSchema(obj.type.properties[0].key),
-                        value: emplaceSchema(obj.type.properties[0].value),
-                    };
-                else
-                    return {
-                        type: "object",
-                        object: obj.type,
-                    };
-            }
-        }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
-        finally {
-            try {
-                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
-            }
-            finally { if (e_9) throw e_9.error; }
-        }
-        try {
-            for (var _l = __values(metadata.maps), _m = _l.next(); !_m.done; _m = _l.next()) {
-                var map = _m.value;
+            else
                 return {
-                    type: "map",
-                    map: map,
-                    key: emplaceSchema(map.key),
-                    value: emplaceSchema(map.value),
+                    type: "object",
+                    object: obj.type,
                 };
-            }
-        }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
-        finally {
-            try {
-                if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
-            }
-            finally { if (e_10) throw e_10.error; }
-        }
+        for (const map of metadata.maps)
+            return {
+                type: "map",
+                map,
+                key: emplaceSchema(map.key),
+                value: emplaceSchema(map.value),
+            };
         throw new Error("Error on ProtobufFactory.emplaceSchema(): any type detected.");
     };
-    var emplaceAtomic = function (meta) {
-        var e_11, _a, e_12, _b, e_13, _c, e_14, _d;
-        var _e, _f, _g, _h, _j, _k, _l, _m;
-        var map = new Map();
-        try {
-            // CONSTANTS
-            for (var _o = __values(meta.constants), _p = _o.next(); !_p.done; _p = _o.next()) {
-                var c = _p.value;
-                if (c.type === "boolean")
-                    map.set("bool", {
-                        type: "bool",
-                        index: getSequence((_f = (_e = c.values[0]) === null || _e === void 0 ? void 0 : _e.tags[0]) !== null && _f !== void 0 ? _f : []),
-                    });
-                else if (c.type === "bigint") {
-                    var init = getBigintType(c.values.map(function (v) { return BigInt(v.value); }));
-                    try {
-                        for (var _q = (e_12 = void 0, __values(c.values)), _r = _q.next(); !_r.done; _r = _q.next()) {
-                            var value = _r.value;
-                            emplaceBigint({
-                                map: map,
-                                tags: value.tags,
-                                init: init,
-                            });
-                        }
-                    }
-                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
-                    finally {
-                        try {
-                            if (_r && !_r.done && (_b = _q.return)) _b.call(_q);
-                        }
-                        finally { if (e_12) throw e_12.error; }
-                    }
-                }
-                else if (c.type === "number") {
-                    var init = getNumberType(c.values.map(function (v) { return v.value; }));
-                    try {
-                        for (var _s = (e_13 = void 0, __values(c.values)), _t = _s.next(); !_t.done; _t = _s.next()) {
-                            var value = _t.value;
-                            emplaceNumber({
-                                map: map,
-                                tags: value.tags,
-                                init: init,
-                            });
-                        }
-                    }
-                    catch (e_13_1) { e_13 = { error: e_13_1 }; }
-                    finally {
-                        try {
-                            if (_t && !_t.done && (_c = _s.return)) _c.call(_s);
-                        }
-                        finally { if (e_13) throw e_13.error; }
-                    }
-                }
-                else if (c.type === "string")
-                    map.set("string", {
-                        type: "string",
-                        index: getSequence((_h = (_g = c.values[0]) === null || _g === void 0 ? void 0 : _g.tags[0]) !== null && _h !== void 0 ? _h : []),
+    const emplaceAtomic = (meta) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const map = new Map();
+        // CONSTANTS
+        for (const c of meta.constants)
+            if (c.type === "boolean")
+                map.set("bool", {
+                    type: "bool",
+                    index: getSequence((_b = (_a = c.values[0]) === null || _a === void 0 ? void 0 : _a.tags[0]) !== null && _b !== void 0 ? _b : []),
+                });
+            else if (c.type === "bigint") {
+                const init = getBigintType(c.values.map((v) => BigInt(v.value)));
+                for (const value of c.values)
+                    emplaceBigint({
+                        map,
+                        tags: value.tags,
+                        init,
                     });
             }
-        }
-        catch (e_11_1) { e_11 = { error: e_11_1 }; }
-        finally {
-            try {
-                if (_p && !_p.done && (_a = _o.return)) _a.call(_o);
+            else if (c.type === "number") {
+                const init = getNumberType(c.values.map((v) => v.value));
+                for (const value of c.values)
+                    emplaceNumber({
+                        map,
+                        tags: value.tags,
+                        init,
+                    });
             }
-            finally { if (e_11) throw e_11.error; }
-        }
+            else if (c.type === "string")
+                map.set("string", {
+                    type: "string",
+                    index: getSequence((_d = (_c = c.values[0]) === null || _c === void 0 ? void 0 : _c.tags[0]) !== null && _d !== void 0 ? _d : []),
+                });
         // TEMPLATE
         if (meta.templates.length)
             map.set("string", {
                 type: "string",
-                index: getSequence((_k = (_j = meta.templates[0]) === null || _j === void 0 ? void 0 : _j.tags[0]) !== null && _k !== void 0 ? _k : []),
+                index: getSequence((_f = (_e = meta.templates[0]) === null || _e === void 0 ? void 0 : _e.tags[0]) !== null && _f !== void 0 ? _f : []),
             });
-        try {
-            // ATOMICS
-            for (var _u = __values(meta.atomics), _v = _u.next(); !_v.done; _v = _u.next()) {
-                var atomic = _v.value;
-                if (atomic.type === "boolean")
-                    map.set("bool", {
-                        type: "bool",
-                        index: getSequence((_l = atomic.tags[0]) !== null && _l !== void 0 ? _l : []),
-                    });
-                else if (atomic.type === "bigint")
-                    emplaceBigint({
-                        map: map,
-                        tags: atomic.tags,
-                        init: "int64",
-                    });
-                else if (atomic.type === "number")
-                    emplaceNumber({
-                        map: map,
-                        tags: atomic.tags,
-                        init: "double",
-                    });
-                else if (atomic.type === "string")
-                    map.set("string", {
-                        type: "string",
-                        index: getSequence((_m = atomic.tags[0]) !== null && _m !== void 0 ? _m : []),
-                    });
-            }
-        }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
-        finally {
-            try {
-                if (_v && !_v.done && (_d = _u.return)) _d.call(_u);
-            }
-            finally { if (e_14) throw e_14.error; }
-        }
+        // ATOMICS
+        for (const atomic of meta.atomics)
+            if (atomic.type === "boolean")
+                map.set("bool", {
+                    type: "bool",
+                    index: getSequence((_g = atomic.tags[0]) !== null && _g !== void 0 ? _g : []),
+                });
+            else if (atomic.type === "bigint")
+                emplaceBigint({
+                    map,
+                    tags: atomic.tags,
+                    init: "int64",
+                });
+            else if (atomic.type === "number")
+                emplaceNumber({
+                    map,
+                    tags: atomic.tags,
+                    init: "double",
+                });
+            else if (atomic.type === "string")
+                map.set("string", {
+                    type: "string",
+                    index: getSequence((_h = atomic.tags[0]) !== null && _h !== void 0 ? _h : []),
+                });
         // SORTING FOR VALIDATION REASON
-        return new Map(Array.from(map).sort(function (x, y) { return ProtobufUtil_1.ProtobufUtil.compare(x[0], y[0]); }));
+        return new Map(Array.from(map).sort((x, y) => ProtobufUtil_1.ProtobufUtil.compare(x[0], y[0])));
     };
-    var emplaceBigint = function (next) {
-        var e_15, _a;
-        var _b, _c;
+    const emplaceBigint = (next) => {
+        var _a, _b;
         if (next.tags.length === 0) {
             next.map.set(next.init, {
                 type: "bigint",
@@ -417,31 +211,18 @@ var ProtobufFactory;
             });
             return;
         }
-        try {
-            for (var _d = __values(next.tags), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var row = _e.value;
-                var value = (_c = (_b = row.find(function (tag) {
-                    return tag.kind === "type" &&
-                        (tag.value === "int64" || tag.value === "uint64");
-                })) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : next.init;
-                next.map.set(next.init, {
-                    type: "bigint",
-                    name: value,
-                    index: ProtobufUtil_1.ProtobufUtil.getSequence(row),
-                });
-            }
-        }
-        catch (e_15_1) { e_15 = { error: e_15_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_15) throw e_15.error; }
+        for (const row of next.tags) {
+            const value = (_b = (_a = row.find((tag) => tag.kind === "type" &&
+                (tag.value === "int64" || tag.value === "uint64"))) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : next.init;
+            next.map.set(next.init, {
+                type: "bigint",
+                name: value,
+                index: ProtobufUtil_1.ProtobufUtil.getSequence(row),
+            });
         }
     };
-    var emplaceNumber = function (next) {
-        var e_16, _a;
-        var _b, _c;
+    const emplaceNumber = (next) => {
+        var _a, _b;
         if (next.tags.length === 0) {
             next.map.set(next.init, {
                 type: "number",
@@ -450,69 +231,50 @@ var ProtobufFactory;
             });
             return;
         }
-        try {
-            for (var _d = __values(next.tags), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var row = _e.value;
-                var value = (_c = (_b = row.find(function (tag) {
-                    return tag.kind === "type" &&
-                        (tag.value === "int32" ||
-                            tag.value === "uint32" ||
-                            tag.value === "int64" ||
-                            tag.value === "uint64" ||
-                            tag.value === "float" ||
-                            tag.value === "double");
-                })) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : next.init;
-                next.map.set(value, {
-                    type: "number",
-                    name: value,
-                    index: ProtobufUtil_1.ProtobufUtil.getSequence(row),
-                });
-            }
-        }
-        catch (e_16_1) { e_16 = { error: e_16_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_16) throw e_16.error; }
+        for (const row of next.tags) {
+            const value = (_b = (_a = row.find((tag) => tag.kind === "type" &&
+                (tag.value === "int32" ||
+                    tag.value === "uint32" ||
+                    tag.value === "int64" ||
+                    tag.value === "uint64" ||
+                    tag.value === "float" ||
+                    tag.value === "double"))) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : next.init;
+            next.map.set(value, {
+                type: "number",
+                name: value,
+                index: ProtobufUtil_1.ProtobufUtil.getSequence(row),
+            });
         }
     };
-    var getBigintType = function (values) {
-        return values.some(function (v) { return v < 0; }) ? "int64" : "uint64";
-    };
-    var getNumberType = function (values) {
-        return values.every(function (v) { return Math.floor(v) === v; })
-            ? values.every(function (v) { return -2147483648 <= v && v <= 2147483647; })
-                ? "int32"
-                : "int64"
-            : "double";
-    };
-    var getSequence = function (tags) {
-        var sequence = tags.find(function (t) {
+    const getBigintType = (values) => values.some((v) => v < 0) ? "int64" : "uint64";
+    const getNumberType = (values) => values.every((v) => Math.floor(v) === v)
+        ? values.every((v) => -2147483648 <= v && v <= 2147483647)
+            ? "int32"
+            : "int64"
+        : "double";
+    const getSequence = (tags) => {
+        const sequence = tags.find((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 null;
-        var value = Number(sequence.schema["x-protobuf-sequence"]);
+        const value = Number(sequence.schema["x-protobuf-sequence"]);
         return Number.isNaN(value) ? null : value;
     };
     /* -----------------------------------------------------------
       VALIDATORS
     ----------------------------------------------------------- */
-    var validate = function () {
-        var visited = new WeakSet();
-        return function (meta, explore) {
-            var e_17, _a, e_18, _b;
-            var errors = [];
-            var insert = function (msg) { return errors.push(msg); };
+    const validate = () => {
+        const visited = new WeakSet();
+        return (meta, explore) => {
+            const errors = [];
+            const insert = (msg) => errors.push(msg);
             if (explore.top === true) {
-                var onlyObject = meta.size() === 1 &&
+                const onlyObject = meta.size() === 1 &&
                     meta.objects.length === 1 &&
-                    meta.objects[0].type.properties.every(function (p) {
-                        return p.key.isSoleLiteral();
-                    }) &&
+                    meta.objects[0].type.properties.every((p) => p.key.isSoleLiteral()) &&
                     meta.isRequired() === true &&
                     meta.nullable === false;
                 if (onlyObject === false)
@@ -522,17 +284,17 @@ var ProtobufFactory;
                 visited.add(explore.object);
                 validateObject({
                     object: explore.object,
-                    errors: errors,
+                    errors,
                 });
                 try {
                     ProtobufFactory.emplaceObject(explore.object);
                 }
-                catch (_c) { }
+                catch (_a) { }
             }
             //----
             // NOT SUPPORTED TYPES
             //----
-            var noSupport = function (msg) { return insert("does not support ".concat(msg)); };
+            const noSupport = (msg) => insert(`does not support ${msg}`);
             // PROHIBIT ANY TYPE
             if (meta.any)
                 noSupport("any type");
@@ -547,63 +309,40 @@ var ProtobufFactory;
                 noSupport("Set type");
             // NATIVE TYPE, BUT NOT Uint8Array
             if (meta.natives.length)
-                try {
-                    for (var _d = __values(meta.natives), _e = _d.next(); !_e.done; _e = _d.next()) {
-                        var native = _e.value;
-                        if (native.name === "Uint8Array")
-                            continue;
-                        var instead = BANNED_NATIVE_TYPES.get(native.name);
-                        if (instead === undefined)
-                            noSupport("".concat(native.name, " type"));
-                        else
-                            noSupport("".concat(native.name, " type. Use ").concat(instead, " type instead."));
-                    }
-                }
-                catch (e_17_1) { e_17 = { error: e_17_1 }; }
-                finally {
-                    try {
-                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-                    }
-                    finally { if (e_17) throw e_17.error; }
+                for (const native of meta.natives) {
+                    if (native.name === "Uint8Array")
+                        continue;
+                    const instead = BANNED_NATIVE_TYPES.get(native.name);
+                    if (instead === undefined)
+                        noSupport(`${native.name} type`);
+                    else
+                        noSupport(`${native.name} type. Use ${instead} type instead.`);
                 }
             //----
             // ATOMIC CASES
             //----
             if (meta.atomics.length) {
-                var numbers = ProtobufUtil_1.ProtobufUtil.getNumbers(meta);
-                var bigints = ProtobufUtil_1.ProtobufUtil.getBigints(meta);
-                try {
-                    for (var _f = __values(["int64", "uint64"]), _g = _f.next(); !_g.done; _g = _f.next()) {
-                        var type = _g.value;
-                        if (numbers.has(type) && bigints.has(type))
-                            insert("tags.Type<\"".concat(type, "\"> cannot be used in both number and bigint types. Recommend to remove from number type"));
-                    }
-                }
-                catch (e_18_1) { e_18 = { error: e_18_1 }; }
-                finally {
-                    try {
-                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-                    }
-                    finally { if (e_18) throw e_18.error; }
-                }
+                const numbers = ProtobufUtil_1.ProtobufUtil.getNumbers(meta);
+                const bigints = ProtobufUtil_1.ProtobufUtil.getBigints(meta);
+                for (const type of ["int64", "uint64"])
+                    if (numbers.has(type) && bigints.has(type))
+                        insert(`tags.Type<"${type}"> cannot be used in both number and bigint types. Recommend to remove from number type`);
             }
             //----
             // ARRRAY CASES
             //----
             // DO NOT ALLOW MULTI-DIMENTIONAL ARRAY
             if (meta.arrays.length &&
-                meta.arrays.some(function (array) { return !!array.type.value.arrays.length; }))
+                meta.arrays.some((array) => !!array.type.value.arrays.length))
                 noSupport("over two dimenstional array type");
             // CHILD OF ARRAY TYPE MUST BE REQUIRED
             if (meta.arrays.length &&
-                meta.arrays.some(function (array) {
-                    return array.type.value.isRequired() === false ||
-                        array.type.value.nullable === true;
-                }))
+                meta.arrays.some((array) => array.type.value.isRequired() === false ||
+                    array.type.value.nullable === true))
                 noSupport("optional type in array");
             // UNION IN ARRAY
             if (meta.arrays.length &&
-                meta.arrays.some(function (a) {
+                meta.arrays.some((a) => {
                     var _a;
                     return a.type.value.size() > 1 &&
                         a.type.value.constants.length !== 1 &&
@@ -612,11 +351,9 @@ var ProtobufFactory;
                 noSupport("union type in array");
             // DO DYNAMIC OBJECT IN ARRAY
             if (meta.arrays.length &&
-                meta.arrays.some(function (a) {
-                    return a.type.value.maps.length ||
-                        (a.type.value.objects.length &&
-                            a.type.value.objects.some(function (o) { return ProtobufUtil_1.ProtobufUtil.isStaticObject(o.type) === false; }));
-                }))
+                meta.arrays.some((a) => a.type.value.maps.length ||
+                    (a.type.value.objects.length &&
+                        a.type.value.objects.some((o) => ProtobufUtil_1.ProtobufUtil.isStaticObject(o.type) === false))))
                 noSupport("dynamic object in array");
             // UNION WITH ARRAY
             if (meta.size() > 1 && meta.arrays.length)
@@ -626,26 +363,22 @@ var ProtobufFactory;
             //----
             // EMPTY PROPERTY
             if (meta.objects.length &&
-                meta.objects.some(function (obj) { return obj.type.properties.length === 0; }))
+                meta.objects.some((obj) => obj.type.properties.length === 0))
                 noSupport("empty object type");
             // MULTIPLE DYNAMIC KEY TYPED PROPERTIES
             if (meta.objects.length &&
-                meta.objects.some(function (obj) {
-                    return obj.type.properties.filter(function (p) { return !p.key.isSoleLiteral(); }).length >
-                        1;
-                }))
+                meta.objects.some((obj) => obj.type.properties.filter((p) => !p.key.isSoleLiteral()).length >
+                    1))
                 noSupport("object type with multiple dynamic key typed properties. Keep only one.");
             // STATIC AND DYNAMIC PROPERTIES ARE COMPATIBLE
             if (meta.objects.length &&
-                meta.objects.some(function (obj) {
-                    return obj.type.properties.some(function (p) { return p.key.isSoleLiteral(); }) &&
-                        obj.type.properties.some(function (p) { return !p.key.isSoleLiteral(); });
-                }))
+                meta.objects.some((obj) => obj.type.properties.some((p) => p.key.isSoleLiteral()) &&
+                    obj.type.properties.some((p) => !p.key.isSoleLiteral())))
                 noSupport("object type with mixed static and dynamic key typed properties. Keep statics or dynamic only.");
             // DYNAMIC OBJECT, BUT PROPERTY VALUE TYPE IS ARRAY
             if (meta.objects.length &&
                 isDynamicObject(meta.objects[0].type) &&
-                meta.objects[0].type.properties.some(function (p) { return !!p.value.arrays.length; }))
+                meta.objects[0].type.properties.some((p) => !!p.value.arrays.length))
                 noSupport("dynamic object with array value type");
             // UNION WITH DYNAMIC OBJECTa
             if (meta.size() > 1 &&
@@ -654,35 +387,33 @@ var ProtobufFactory;
                 noSupport("union type with dynamic object type");
             // UNION IN DYNAMIC PROPERTY VALUE
             if (meta.objects.length &&
-                meta.objects.some(function (obj) {
-                    return isDynamicObject(obj.type) &&
-                        obj.type.properties.some(function (p) { return ProtobufUtil_1.ProtobufUtil.isUnion(p.value); });
-                }))
+                meta.objects.some((obj) => isDynamicObject(obj.type) &&
+                    obj.type.properties.some((p) => ProtobufUtil_1.ProtobufUtil.isUnion(p.value))))
                 noSupport("union type in dynamic property");
             //----
             // MAP CASES
             //----
             // KEY TYPE IS UNION
             if (meta.maps.length &&
-                meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.isUnion(m.key); }))
+                meta.maps.some((m) => ProtobufUtil_1.ProtobufUtil.isUnion(m.key)))
                 noSupport("union key typed map");
             // KEY TYPE IS NOT ATOMIC
             if (meta.maps.length &&
-                meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.getAtomics(m.key).size !== 1; }))
+                meta.maps.some((m) => ProtobufUtil_1.ProtobufUtil.getAtomics(m.key).size !== 1))
                 noSupport("non-atomic key typed map");
             // MAP TYPE, BUT PROPERTY KEY TYPE IS OPTIONAL
             if (meta.maps.length &&
-                meta.maps.some(function (m) { return m.key.isRequired() === false || m.key.nullable; }))
+                meta.maps.some((m) => m.key.isRequired() === false || m.key.nullable))
                 noSupport("optional key typed map");
             // MAP TYPE, BUT VALUE TYPE IS ARRAY
-            if (meta.maps.length && meta.maps.some(function (m) { return !!m.value.arrays.length; }))
+            if (meta.maps.length && meta.maps.some((m) => !!m.value.arrays.length))
                 noSupport("map type with array value type");
             // UNION WITH MAP
             if (meta.size() > 1 && meta.maps.length)
                 noSupport("union type with map type");
             // UNION IN MAP
             if (meta.maps.length &&
-                meta.maps.some(function (m) { return ProtobufUtil_1.ProtobufUtil.isUnion(m.value); }))
+                meta.maps.some((m) => ProtobufUtil_1.ProtobufUtil.isUnion(m.value)))
                 noSupport("union type in map value type");
             return errors;
         };
@@ -690,680 +421,270 @@ var ProtobufFactory;
     /* -----------------------------------------------------------
       SEQUENE VALIDATOR
     ----------------------------------------------------------- */
-    var validateObject = function (next) {
-        var e_19, _a, e_20, _b;
-        try {
-            for (var _c = __values(next.object.properties), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var property = _d.value;
-                validateProperty({
-                    metadata: property.value,
-                    errors: next.errors,
-                });
-            }
-        }
-        catch (e_19_1) { e_19 = { error: e_19_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_19) throw e_19.error; }
-        }
-        var entire = new Map();
-        var visitProperty = function (p) {
-            var e_21, _a, e_22, _b, e_23, _c, e_24, _d, e_25, _e, e_26, _f, e_27, _g;
-            var local = new Set();
-            var tagger = function (matrix) {
-                matrix.forEach(function (tags) {
-                    var value = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
+    const validateObject = (next) => {
+        for (const property of next.object.properties)
+            validateProperty({
+                metadata: property.value,
+                errors: next.errors,
+            });
+        const entire = new Map();
+        const visitProperty = (p) => {
+            const local = new Set();
+            const tagger = (matrix) => {
+                matrix.forEach((tags) => {
+                    const value = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
                     if (value !== null)
                         local.add(value);
                 });
             };
-            try {
-                for (var _h = __values(p.value.constants), _j = _h.next(); !_j.done; _j = _h.next()) {
-                    var c = _j.value;
-                    try {
-                        for (var _k = (e_22 = void 0, __values(c.values)), _l = _k.next(); !_l.done; _l = _k.next()) {
-                            var v = _l.value;
-                            tagger(v.tags);
-                        }
-                    }
-                    catch (e_22_1) { e_22 = { error: e_22_1 }; }
-                    finally {
-                        try {
-                            if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
-                        }
-                        finally { if (e_22) throw e_22.error; }
-                    }
-                }
-            }
-            catch (e_21_1) { e_21 = { error: e_21_1 }; }
-            finally {
-                try {
-                    if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
-                }
-                finally { if (e_21) throw e_21.error; }
-            }
-            try {
-                for (var _m = __values(p.value.atomics), _o = _m.next(); !_o.done; _o = _m.next()) {
-                    var a = _o.value;
-                    tagger(a.tags);
-                }
-            }
-            catch (e_23_1) { e_23 = { error: e_23_1 }; }
-            finally {
-                try {
-                    if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
-                }
-                finally { if (e_23) throw e_23.error; }
-            }
-            try {
-                for (var _p = __values(p.value.templates), _q = _p.next(); !_q.done; _q = _p.next()) {
-                    var t = _q.value;
-                    tagger(t.tags);
-                }
-            }
-            catch (e_24_1) { e_24 = { error: e_24_1 }; }
-            finally {
-                try {
-                    if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
-                }
-                finally { if (e_24) throw e_24.error; }
-            }
-            try {
-                for (var _r = __values(p.value.objects), _s = _r.next(); !_s.done; _s = _r.next()) {
-                    var o = _s.value;
-                    tagger(o.tags);
-                }
-            }
-            catch (e_25_1) { e_25 = { error: e_25_1 }; }
-            finally {
-                try {
-                    if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
-                }
-                finally { if (e_25) throw e_25.error; }
-            }
-            try {
-                for (var _t = __values(p.value.arrays), _u = _t.next(); !_u.done; _u = _t.next()) {
-                    var a = _u.value;
-                    tagger(a.tags);
-                }
-            }
-            catch (e_26_1) { e_26 = { error: e_26_1 }; }
-            finally {
-                try {
-                    if (_u && !_u.done && (_f = _t.return)) _f.call(_t);
-                }
-                finally { if (e_26) throw e_26.error; }
-            }
-            try {
-                for (var local_1 = __values(local), local_1_1 = local_1.next(); !local_1_1.done; local_1_1 = local_1.next()) {
-                    var s = local_1_1.value;
-                    if (entire.has(s))
-                        next.errors.push("The Sequence<".concat(s, "> tag is duplicated in two properties (").concat(JSON.stringify(entire.get(s)), " and ").concat(JSON.stringify(p.key.getSoleLiteral()), ")"));
-                    else
-                        entire.set(s, p.key.getSoleLiteral());
-                }
-            }
-            catch (e_27_1) { e_27 = { error: e_27_1 }; }
-            finally {
-                try {
-                    if (local_1_1 && !local_1_1.done && (_g = local_1.return)) _g.call(local_1);
-                }
-                finally { if (e_27) throw e_27.error; }
-            }
+            for (const c of p.value.constants)
+                for (const v of c.values)
+                    tagger(v.tags);
+            for (const a of p.value.atomics)
+                tagger(a.tags);
+            for (const t of p.value.templates)
+                tagger(t.tags);
+            for (const o of p.value.objects)
+                tagger(o.tags);
+            for (const a of p.value.arrays)
+                tagger(a.tags);
+            for (const s of local)
+                if (entire.has(s))
+                    next.errors.push(`The Sequence<${s}> tag is duplicated in two properties (${JSON.stringify(entire.get(s))} and ${JSON.stringify(p.key.getSoleLiteral())})`);
+                else
+                    entire.set(s, p.key.getSoleLiteral());
         };
-        try {
-            for (var _e = __values(next.object.properties), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var p = _f.value;
-                visitProperty(p);
-            }
-        }
-        catch (e_20_1) { e_20 = { error: e_20_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
-            }
-            finally { if (e_20) throw e_20.error; }
-        }
+        for (const p of next.object.properties)
+            visitProperty(p);
     };
-    var validateProperty = function (next) {
-        var e_28, _a, e_29, _b, e_30, _c, e_31, _d, e_32, _e;
-        var expected = 0;
-        var sequences = new Set();
-        var add = function (value) {
+    const validateProperty = (next) => {
+        let expected = 0;
+        const sequences = new Set();
+        const add = (value) => {
             if (sequences.has(value))
                 return false;
             sequences.add(value);
             ++expected;
             return true;
         };
-        try {
-            for (var _f = __values([
-                validateBooleanSequence,
-                validateNumericSequences({
-                    type: "bigint",
-                    default: "int64",
-                    categories: BIGINT_TYPES,
-                }),
-                validateNumericSequences({
-                    type: "number",
-                    default: "double",
-                    categories: NUMBER_TYPES,
-                }),
-                validateStringSequence,
-            ]), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var validator = _g.value;
-                validator({ metadata: next.metadata, errors: next.errors, add: add });
-            }
-        }
-        catch (e_28_1) { e_28 = { error: e_28_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
-            }
-            finally { if (e_28) throw e_28.error; }
-        }
-        try {
-            for (var _h = __values(next.metadata.arrays), _j = _h.next(); !_j.done; _j = _h.next()) {
-                var array = _j.value;
-                validateInstanceSequence({
-                    type: "array",
-                    tags: array.tags,
-                    errors: next.errors,
-                    add: add,
-                });
-            }
-        }
-        catch (e_29_1) { e_29 = { error: e_29_1 }; }
-        finally {
-            try {
-                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
-            }
-            finally { if (e_29) throw e_29.error; }
-        }
-        try {
-            for (var _k = __values(next.metadata.objects), _l = _k.next(); !_l.done; _l = _k.next()) {
-                var object = _l.value;
-                validateInstanceSequence({
-                    type: "object",
-                    tags: object.tags,
-                    errors: next.errors,
-                    add: add,
-                });
-            }
-        }
-        catch (e_30_1) { e_30 = { error: e_30_1 }; }
-        finally {
-            try {
-                if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
-            }
-            finally { if (e_30) throw e_30.error; }
-        }
-        try {
-            for (var _m = __values(next.metadata.maps), _o = _m.next(); !_o.done; _o = _m.next()) {
-                var map = _o.value;
+        for (const validator of [
+            validateBooleanSequence,
+            validateNumericSequences({
+                type: "bigint",
+                default: "int64",
+                categories: BIGINT_TYPES,
+            }),
+            validateNumericSequences({
+                type: "number",
+                default: "double",
+                categories: NUMBER_TYPES,
+            }),
+            validateStringSequence,
+        ])
+            validator({ metadata: next.metadata, errors: next.errors, add });
+        for (const array of next.metadata.arrays)
+            validateInstanceSequence({
+                type: "array",
+                tags: array.tags,
+                errors: next.errors,
+                add,
+            });
+        for (const object of next.metadata.objects)
+            validateInstanceSequence({
+                type: "object",
+                tags: object.tags,
+                errors: next.errors,
+                add,
+            });
+        for (const map of next.metadata.maps)
+            validateInstanceSequence({
+                type: "map",
+                tags: map.tags,
+                errors: next.errors,
+                add,
+            });
+        for (const native of next.metadata.natives)
+            if (native.name === "Uint8Array")
                 validateInstanceSequence({
-                    type: "map",
-                    tags: map.tags,
+                    type: "Uint8Array",
+                    tags: native.tags,
                     errors: next.errors,
-                    add: add,
+                    add,
                 });
-            }
-        }
-        catch (e_31_1) { e_31 = { error: e_31_1 }; }
-        finally {
-            try {
-                if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
-            }
-            finally { if (e_31) throw e_31.error; }
-        }
-        try {
-            for (var _p = __values(next.metadata.natives), _q = _p.next(); !_q.done; _q = _p.next()) {
-                var native = _q.value;
-                if (native.name === "Uint8Array")
-                    validateInstanceSequence({
-                        type: "Uint8Array",
-                        tags: native.tags,
-                        errors: next.errors,
-                        add: add,
-                    });
-            }
-        }
-        catch (e_32_1) { e_32 = { error: e_32_1 }; }
-        finally {
-            try {
-                if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
-            }
-            finally { if (e_32) throw e_32.error; }
-        }
     };
-    var validateBooleanSequence = function (next) {
-        var e_33, _a, e_34, _b, e_35, _c;
+    const validateBooleanSequence = (next) => {
         // PREPARE EMPLACER
-        var unique = new Set();
-        var expected = 0;
-        var actual = 0;
-        var emplace = function (matrix) {
-            var e_36, _a, e_37, _b;
-            try {
-                for (var matrix_1 = __values(matrix), matrix_1_1 = matrix_1.next(); !matrix_1_1.done; matrix_1_1 = matrix_1.next()) {
-                    var tags = matrix_1_1.value;
-                    try {
-                        for (var tags_1 = (e_37 = void 0, __values(tags)), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) {
-                            var tag = tags_1_1.value;
-                            var sequence = ProtobufUtil_1.ProtobufUtil.getSequence([tag]);
-                            if (sequence !== null) {
-                                unique.add(sequence);
-                                ++actual;
-                            }
-                            ++expected;
-                        }
-                    }
-                    catch (e_37_1) { e_37 = { error: e_37_1 }; }
-                    finally {
-                        try {
-                            if (tags_1_1 && !tags_1_1.done && (_b = tags_1.return)) _b.call(tags_1);
-                        }
-                        finally { if (e_37) throw e_37.error; }
+        const unique = new Set();
+        let expected = 0;
+        let actual = 0;
+        const emplace = (matrix) => {
+            for (const tags of matrix)
+                for (const tag of tags) {
+                    const sequence = ProtobufUtil_1.ProtobufUtil.getSequence([tag]);
+                    if (sequence !== null) {
+                        unique.add(sequence);
+                        ++actual;
                     }
+                    ++expected;
                 }
-            }
-            catch (e_36_1) { e_36 = { error: e_36_1 }; }
-            finally {
-                try {
-                    if (matrix_1_1 && !matrix_1_1.done && (_a = matrix_1.return)) _a.call(matrix_1);
-                }
-                finally { if (e_36) throw e_36.error; }
-            }
         };
-        try {
-            // GATHER SEQUENCE TAGS
-            for (var _d = __values(next.metadata.atomics), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var atomic = _e.value;
-                if (atomic.type === "boolean")
-                    emplace(atomic.tags);
-            }
-        }
-        catch (e_33_1) { e_33 = { error: e_33_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-            }
-            finally { if (e_33) throw e_33.error; }
-        }
-        try {
-            for (var _f = __values(next.metadata.constants), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var constant = _g.value;
-                if (constant.type === "boolean")
-                    try {
-                        for (var _h = (e_35 = void 0, __values(constant.values)), _j = _h.next(); !_j.done; _j = _h.next()) {
-                            var value = _j.value;
-                            emplace(value.tags);
-                        }
-                    }
-                    catch (e_35_1) { e_35 = { error: e_35_1 }; }
-                    finally {
-                        try {
-                            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
-                        }
-                        finally { if (e_35) throw e_35.error; }
-                    }
-            }
-        }
-        catch (e_34_1) { e_34 = { error: e_34_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-            }
-            finally { if (e_34) throw e_34.error; }
-        }
+        // GATHER SEQUENCE TAGS
+        for (const atomic of next.metadata.atomics)
+            if (atomic.type === "boolean")
+                emplace(atomic.tags);
+        for (const constant of next.metadata.constants)
+            if (constant.type === "boolean")
+                for (const value of constant.values)
+                    emplace(value.tags);
         // PREDICATE
         if (unique.size && actual !== expected)
-            next.errors.push("The sequence tag must be declared in every union type members");
+            next.errors.push(`The sequence tag must be declared in every union type members`);
         else if (unique.size > 1)
-            next.errors.push("The sequence tag value must be the same in boolean type (including literal types)");
+            next.errors.push(`The sequence tag value must be the same in boolean type (including literal types)`);
         else if (unique.size === 1) {
-            var value = unique.values().next().value;
+            const value = unique.values().next().value;
             if (next.add(value) === false)
-                next.errors.push("The sequence tag value ".concat(value, " in boolean type is duplicated with other types"));
+                next.errors.push(`The sequence tag value ${value} in boolean type is duplicated with other types`);
         }
     };
-    var validateNumericSequences = function (config) {
-        return function (next) {
-            var e_38, _a, e_39, _b, e_40, _c, e_41, _d;
-            // FIND TYPE CATEGORIES
-            var categories = new Set();
-            var getType = function (tags) {
-                var _a;
-                var found = tags.find(function (t) { return t.kind === "type" && config.categories.has(t.value); });
-                return (_a = found === null || found === void 0 ? void 0 : found.value) !== null && _a !== void 0 ? _a : config.default;
-            };
-            var exploreCategory = function (matrix) {
-                var e_42, _a;
-                try {
-                    for (var matrix_2 = __values(matrix), matrix_2_1 = matrix_2.next(); !matrix_2_1.done; matrix_2_1 = matrix_2.next()) {
-                        var tags = matrix_2_1.value;
-                        categories.add(getType(tags));
-                    }
-                }
-                catch (e_42_1) { e_42 = { error: e_42_1 }; }
-                finally {
-                    try {
-                        if (matrix_2_1 && !matrix_2_1.done && (_a = matrix_2.return)) _a.call(matrix_2);
-                    }
-                    finally { if (e_42) throw e_42.error; }
-                }
+    const validateNumericSequences = (config) => (next) => {
+        // FIND TYPE CATEGORIES
+        const categories = new Set();
+        const getType = (tags) => {
+            var _a;
+            const found = tags.find((t) => t.kind === "type" && config.categories.has(t.value));
+            return (_a = found === null || found === void 0 ? void 0 : found.value) !== null && _a !== void 0 ? _a : config.default;
+        };
+        const exploreCategory = (matrix) => {
+            for (const tags of matrix)
+                categories.add(getType(tags));
+        };
+        for (const atomic of next.metadata.atomics)
+            if (atomic.type === config.type)
+                exploreCategory(atomic.tags);
+        for (const constant of next.metadata.constants)
+            if (constant.type === config.type)
+                for (const value of constant.values)
+                    exploreCategory(value.tags);
+        // ITERATE TYPE CATEGORIES
+        for (const category of categories) {
+            const unique = new Set();
+            let expected = 0;
+            let actual = 0;
+            const emplace = (tags) => {
+                const sequence = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
+                if (sequence !== null) {
+                    unique.add(sequence);
+                    ++actual;
+                }
+                ++expected;
             };
-            try {
-                for (var _e = __values(next.metadata.atomics), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var atomic = _f.value;
-                    if (atomic.type === config.type)
-                        exploreCategory(atomic.tags);
-                }
-            }
-            catch (e_38_1) { e_38 = { error: e_38_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-                }
-                finally { if (e_38) throw e_38.error; }
-            }
-            try {
-                for (var _g = __values(next.metadata.constants), _h = _g.next(); !_h.done; _h = _g.next()) {
-                    var constant = _h.value;
-                    if (constant.type === config.type)
-                        try {
-                            for (var _j = (e_40 = void 0, __values(constant.values)), _k = _j.next(); !_k.done; _k = _j.next()) {
-                                var value = _k.value;
-                                exploreCategory(value.tags);
-                            }
-                        }
-                        catch (e_40_1) { e_40 = { error: e_40_1 }; }
-                        finally {
-                            try {
-                                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
-                            }
-                            finally { if (e_40) throw e_40.error; }
-                        }
-                }
+            for (const atomic of next.metadata.atomics)
+                if (atomic.type === config.type)
+                    for (const tags of atomic.tags)
+                        if (getType(tags) === category)
+                            emplace(tags);
+            for (const constant of next.metadata.constants)
+                if (constant.type === config.type)
+                    for (const value of constant.values)
+                        for (const tags of value.tags)
+                            if (getType(tags) === category)
+                                emplace(tags);
+            if (unique.size && actual !== expected) {
+                console.log(category, actual, expected, unique);
+                next.errors.push(`The sequence tag must be declared in every union type members`);
+            }
+            else if (unique.size > 1)
+                next.errors.push(`The sequence tag value must be the same in ${config.type} type (including literal types)`);
+            else if (unique.size === 1) {
+                const value = unique.values().next().value;
+                if (next.add(value) === false)
+                    next.errors.push(`The sequence tag value ${value} in ${config.type} type is duplicated with other types`);
             }
-            catch (e_39_1) { e_39 = { error: e_39_1 }; }
-            finally {
-                try {
-                    if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-                }
-                finally { if (e_39) throw e_39.error; }
-            }
-            var _loop_1 = function (category) {
-                var e_43, _l, e_44, _m, e_45, _o, e_46, _p, e_47, _q;
-                var unique = new Set();
-                var expected = 0;
-                var actual = 0;
-                var emplace = function (tags) {
-                    var sequence = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
+        }
+    };
+    const validateStringSequence = (next) => {
+        const unique = new Set();
+        let expected = 0;
+        let actual = 0;
+        const emplace = (matrix) => {
+            for (const tags of matrix)
+                for (const tag of tags) {
+                    const sequence = ProtobufUtil_1.ProtobufUtil.getSequence([tag]);
                     if (sequence !== null) {
                         unique.add(sequence);
                         ++actual;
                     }
                     ++expected;
-                };
-                try {
-                    for (var _r = (e_43 = void 0, __values(next.metadata.atomics)), _s = _r.next(); !_s.done; _s = _r.next()) {
-                        var atomic = _s.value;
-                        if (atomic.type === config.type)
-                            try {
-                                for (var _t = (e_44 = void 0, __values(atomic.tags)), _u = _t.next(); !_u.done; _u = _t.next()) {
-                                    var tags = _u.value;
-                                    if (getType(tags) === category)
-                                        emplace(tags);
-                                }
-                            }
-                            catch (e_44_1) { e_44 = { error: e_44_1 }; }
-                            finally {
-                                try {
-                                    if (_u && !_u.done && (_m = _t.return)) _m.call(_t);
-                                }
-                                finally { if (e_44) throw e_44.error; }
-                            }
-                    }
-                }
-                catch (e_43_1) { e_43 = { error: e_43_1 }; }
-                finally {
-                    try {
-                        if (_s && !_s.done && (_l = _r.return)) _l.call(_r);
-                    }
-                    finally { if (e_43) throw e_43.error; }
-                }
-                try {
-                    for (var _v = (e_45 = void 0, __values(next.metadata.constants)), _w = _v.next(); !_w.done; _w = _v.next()) {
-                        var constant = _w.value;
-                        if (constant.type === config.type)
-                            try {
-                                for (var _x = (e_46 = void 0, __values(constant.values)), _y = _x.next(); !_y.done; _y = _x.next()) {
-                                    var value = _y.value;
-                                    try {
-                                        for (var _z = (e_47 = void 0, __values(value.tags)), _0 = _z.next(); !_0.done; _0 = _z.next()) {
-                                            var tags = _0.value;
-                                            if (getType(tags) === category)
-                                                emplace(tags);
-                                        }
-                                    }
-                                    catch (e_47_1) { e_47 = { error: e_47_1 }; }
-                                    finally {
-                                        try {
-                                            if (_0 && !_0.done && (_q = _z.return)) _q.call(_z);
-                                        }
-                                        finally { if (e_47) throw e_47.error; }
-                                    }
-                                }
-                            }
-                            catch (e_46_1) { e_46 = { error: e_46_1 }; }
-                            finally {
-                                try {
-                                    if (_y && !_y.done && (_p = _x.return)) _p.call(_x);
-                                }
-                                finally { if (e_46) throw e_46.error; }
-                            }
-                    }
-                }
-                catch (e_45_1) { e_45 = { error: e_45_1 }; }
-                finally {
-                    try {
-                        if (_w && !_w.done && (_o = _v.return)) _o.call(_v);
-                    }
-                    finally { if (e_45) throw e_45.error; }
                 }
-                if (unique.size && actual !== expected) {
-                    console.log(category, actual, expected, unique);
-                    next.errors.push("The sequence tag must be declared in every union type members");
-                }
-                else if (unique.size > 1)
-                    next.errors.push("The sequence tag value must be the same in ".concat(config.type, " type (including literal types)"));
-                else if (unique.size === 1) {
-                    var value = unique.values().next().value;
-                    if (next.add(value) === false)
-                        next.errors.push("The sequence tag value ".concat(value, " in ").concat(config.type, " type is duplicated with other types"));
-                }
-            };
-            try {
-                // ITERATE TYPE CATEGORIES
-                for (var categories_1 = __values(categories), categories_1_1 = categories_1.next(); !categories_1_1.done; categories_1_1 = categories_1.next()) {
-                    var category = categories_1_1.value;
-                    _loop_1(category);
-                }
-            }
-            catch (e_41_1) { e_41 = { error: e_41_1 }; }
-            finally {
-                try {
-                    if (categories_1_1 && !categories_1_1.done && (_d = categories_1.return)) _d.call(categories_1);
-                }
-                finally { if (e_41) throw e_41.error; }
-            }
-        };
-    };
-    var validateStringSequence = function (next) {
-        var e_48, _a, e_49, _b, e_50, _c, e_51, _d;
-        var unique = new Set();
-        var expected = 0;
-        var actual = 0;
-        var emplace = function (matrix) {
-            var e_52, _a, e_53, _b;
-            try {
-                for (var matrix_3 = __values(matrix), matrix_3_1 = matrix_3.next(); !matrix_3_1.done; matrix_3_1 = matrix_3.next()) {
-                    var tags = matrix_3_1.value;
-                    try {
-                        for (var tags_2 = (e_53 = void 0, __values(tags)), tags_2_1 = tags_2.next(); !tags_2_1.done; tags_2_1 = tags_2.next()) {
-                            var tag = tags_2_1.value;
-                            var sequence = ProtobufUtil_1.ProtobufUtil.getSequence([tag]);
-                            if (sequence !== null) {
-                                unique.add(sequence);
-                                ++actual;
-                            }
-                            ++expected;
-                        }
-                    }
-                    catch (e_53_1) { e_53 = { error: e_53_1 }; }
-                    finally {
-                        try {
-                            if (tags_2_1 && !tags_2_1.done && (_b = tags_2.return)) _b.call(tags_2);
-                        }
-                        finally { if (e_53) throw e_53.error; }
-                    }
-                }
-            }
-            catch (e_52_1) { e_52 = { error: e_52_1 }; }
-            finally {
-                try {
-                    if (matrix_3_1 && !matrix_3_1.done && (_a = matrix_3.return)) _a.call(matrix_3);
-                }
-                finally { if (e_52) throw e_52.error; }
-            }
         };
-        try {
-            for (var _e = __values(next.metadata.atomics), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var atomic = _f.value;
-                if (atomic.type === "string")
-                    emplace(atomic.tags);
-            }
-        }
-        catch (e_48_1) { e_48 = { error: e_48_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-            }
-            finally { if (e_48) throw e_48.error; }
-        }
-        try {
-            for (var _g = __values(next.metadata.constants), _h = _g.next(); !_h.done; _h = _g.next()) {
-                var constant = _h.value;
-                if (constant.type === "string")
-                    try {
-                        for (var _j = (e_50 = void 0, __values(constant.values)), _k = _j.next(); !_k.done; _k = _j.next()) {
-                            var value = _k.value;
-                            emplace(value.tags);
-                        }
-                    }
-                    catch (e_50_1) { e_50 = { error: e_50_1 }; }
-                    finally {
-                        try {
-                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
-                        }
-                        finally { if (e_50) throw e_50.error; }
-                    }
-            }
-        }
-        catch (e_49_1) { e_49 = { error: e_49_1 }; }
-        finally {
-            try {
-                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-            }
-            finally { if (e_49) throw e_49.error; }
-        }
-        try {
-            for (var _l = __values(next.metadata.templates), _m = _l.next(); !_m.done; _m = _l.next()) {
-                var template = _m.value;
-                emplace(template.tags);
-            }
-        }
-        catch (e_51_1) { e_51 = { error: e_51_1 }; }
-        finally {
-            try {
-                if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
-            }
-            finally { if (e_51) throw e_51.error; }
-        }
+        for (const atomic of next.metadata.atomics)
+            if (atomic.type === "string")
+                emplace(atomic.tags);
+        for (const constant of next.metadata.constants)
+            if (constant.type === "string")
+                for (const value of constant.values)
+                    emplace(value.tags);
+        for (const template of next.metadata.templates)
+            emplace(template.tags);
         if (unique.size && actual !== expected)
-            next.errors.push("The sequence tag must be declared in every union type members");
+            next.errors.push(`The sequence tag must be declared in every union type members`);
         else if (unique.size > 1)
-            next.errors.push("The sequence tag value must be the same in string types including literal and template types");
+            next.errors.push(`The sequence tag value must be the same in string types including literal and template types`);
         else if (unique.size === 1) {
-            var value = unique.values().next().value;
+            const value = unique.values().next().value;
             if (next.add(value) === false)
-                next.errors.push("The sequence tag value ".concat(value, " in string type is duplicated with other types"));
+                next.errors.push(`The sequence tag value ${value} in string type is duplicated with other types`);
         }
     };
-    var validateInstanceSequence = function (next) {
-        var e_54, _a;
-        var unique = new Set();
-        var count = 0;
-        try {
-            for (var _b = __values(next.tags), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var tags = _c.value;
-                var value = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
-                if (value === null)
-                    continue;
-                unique.add(value);
-                ++count;
-            }
-        }
-        catch (e_54_1) { e_54 = { error: e_54_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_54) throw e_54.error; }
+    const validateInstanceSequence = (next) => {
+        const unique = new Set();
+        let count = 0;
+        for (const tags of next.tags) {
+            const value = ProtobufUtil_1.ProtobufUtil.getSequence(tags);
+            if (value === null)
+                continue;
+            unique.add(value);
+            ++count;
         }
         if (unique.size && count !== next.tags.length)
-            next.errors.push("The sequence tag must be declared in every union type members");
+            next.errors.push(`The sequence tag must be declared in every union type members`);
         else if (unique.size > 1)
-            next.errors.push("The sequence tag value must be the same in ".concat(next.type === "array" ? "an array" : "object", " type."));
+            next.errors.push(`The sequence tag value must be the same in ${next.type === "array" ? "an array" : "object"} type.`);
         else if (unique.size === 1) {
-            var value = unique.values().next().value;
+            const value = unique.values().next().value;
             if (next.add(value) === false)
-                next.errors.push("The sequence tag value ".concat(value, " in ").concat(next.type, " type is duplicated with other types"));
+                next.errors.push(`The sequence tag value ${value} in ${next.type} type is duplicated with other types`);
         }
     };
 })(ProtobufFactory || (exports.ProtobufFactory = ProtobufFactory = {}));
-var isDynamicObject = function (obj) {
-    return obj.properties[0].key.isSoleLiteral() === false;
-};
-var BANNED_NATIVE_TYPES = new Map(__spreadArray(__spreadArray([
+const isDynamicObject = (obj) => obj.properties[0].key.isSoleLiteral() === false;
+const BANNED_NATIVE_TYPES = new Map([
     ["Date", "string"],
     ["Boolean", "boolean"],
     ["BigInt", "bigint"],
     ["Number", "number"],
-    ["String", "string"]
-], __read([
-    "Buffer",
-    "Uint8ClampedArray",
-    "Uint16Array",
-    "Uint32Array",
-    "BigUint64Array",
-    "Int8Array",
-    "Int16Array",
-    "Int32Array",
-    "BigInt64Array",
-    "Float32Array",
-    "Float64Array",
-    "DataView",
-    "ArrayBuffer",
-    "SharedArrayBuffer",
-].map(function (name) { return [name, "Uint8Array"]; })), false), [
+    ["String", "string"],
+    ...[
+        "Buffer",
+        "Uint8ClampedArray",
+        "Uint16Array",
+        "Uint32Array",
+        "BigUint64Array",
+        "Int8Array",
+        "Int16Array",
+        "Int32Array",
+        "BigInt64Array",
+        "Float32Array",
+        "Float64Array",
+        "DataView",
+        "ArrayBuffer",
+        "SharedArrayBuffer",
+    ].map((name) => [name, "Uint8Array"]),
     ["WeakSet", "Array"],
     ["WeakMap", "Map"],
-], false));
-var NUMBER_TYPES = new Set([
+]);
+const NUMBER_TYPES = new Set([
     "int32",
     "uint32",
     "int64",
@@ -1371,5 +692,5 @@ var NUMBER_TYPES = new Set([
     "float",
     "double",
 ]);
-var BIGINT_TYPES = new Set(["int64", "uint64"]);
+const BIGINT_TYPES = new Set(["int64", "uint64"]);
 //# sourceMappingURL=ProtobufFactory.js.map