typia 7.0.0-dev.20241012 → 7.0.0-dev.20241018

package/lib/schemas/metadata/{IMetadataEntry.js → IMetadataMap.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=IMetadataEntry.js.map
+//# sourceMappingURL=IMetadataMap.js.map

package/lib/schemas/metadata/IMetadataMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMetadataMap.js","sourceRoot":"","sources":["../../../src/schemas/metadata/IMetadataMap.ts"],"names":[],"mappings":""}

package/lib/schemas/metadata/IMetadataNative.d.ts

@@ -0,0 +1,5 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataNative {
+    name: string;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataNative.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IMetadataNative.js.map

package/lib/schemas/metadata/IMetadataNative.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMetadataNative.js","sourceRoot":"","sources":["../../../src/schemas/metadata/IMetadataNative.ts"],"names":[],"mappings":""}

package/lib/schemas/metadata/IMetadataSet.d.ts

@@ -0,0 +1,6 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+export interface IMetadataSet {
+    value: IMetadata;
+    tags: IMetadataTypeTag[][];
+}

package/lib/schemas/metadata/IMetadataSet.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IMetadataSet.js.map

package/lib/schemas/metadata/IMetadataSet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMetadataSet.js","sourceRoot":"","sources":["../../../src/schemas/metadata/IMetadataSet.ts"],"names":[],"mappings":""}

package/lib/schemas/metadata/IMetadataTemplate.d.ts

@@ -2,5 +2,5 @@ import { IMetadata } from "./IMetadata";
 import { IMetadataTypeTag } from "./IMetadataTypeTag";
 export interface IMetadataTemplate {
     row: IMetadata[];
-    tags?: IMetadataTypeTag[][] | undefined;
+    tags: IMetadataTypeTag[][];
 }

package/lib/schemas/metadata/IMetadataTypeTag.d.ts

@@ -1,5 +1,5 @@
 export interface IMetadataTypeTag {
-    target: "boolean" | "bigint" | "number" | "string" | "array";
+    target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
     name: string;
     kind: string;
     exclusive: boolean | string[];

package/lib/schemas/metadata/Metadata.d.ts

@@ -6,7 +6,10 @@ import { MetadataAtomic } from "./MetadataAtomic";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataFunction } from "./MetadataFunction";
+import { MetadataMap } from "./MetadataMap";
+import { MetadataNative } from "./MetadataNative";
 import { MetadataObject } from "./MetadataObject";
+import { MetadataSet } from "./MetadataSet";
 import { MetadataTemplate } from "./MetadataTemplate";
 import { MetadataTuple } from "./MetadataTuple";
 export declare class Metadata {
@@ -24,9 +27,9 @@ export declare class Metadata {
     tuples: MetadataTuple[];
     objects: MetadataObject[];
     functions: MetadataFunction[];
-    natives: string[];
-    sets: Metadata[];
-    maps: Metadata.Entry[];
+    natives: MetadataNative[];
+    sets: MetadataSet[];
+    maps: MetadataMap[];
     /**
      * @hidden
      */
@@ -45,9 +48,3 @@ export declare namespace Metadata {
     const intersects: (x: Metadata, y: Metadata) => boolean;
     const covers: (x: Metadata, y: Metadata, level?: number, escaped?: boolean) => boolean;
 }
-export declare namespace Metadata {
-    interface Entry {
-        key: Metadata;
-        value: Metadata;
-    }
-}

package/lib/schemas/metadata/Metadata.js

@@ -38,13 +38,17 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 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 () {
@@ -122,13 +126,10 @@ var Metadata = /** @class */ (function () {
             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.name; }),
-            natives: this.natives.slice(),
-            sets: this.sets.map(function (meta) { return meta.toJSON(); }),
-            maps: this.maps.map(function (entry) { return ({
-                key: entry.key.toJSON(),
-                value: entry.value.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(); }),
         };
     };
     Metadata.from = function (meta, dict) {
@@ -172,17 +173,28 @@ var Metadata = /** @class */ (function () {
                 });
             }),
             aliases: meta.aliases.map(function (alias) {
-                var found = dict.aliases.get(alias);
-                if (found === undefined)
+                var type = dict.aliases.get(alias.name);
+                if (type === undefined)
                     throw new RangeError("Error on Metadata.from(): failed to find alias \"".concat(alias, "\"."));
-                return found;
+                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(); }),
+                });
             }),
-            natives: meta.natives.slice(),
-            sets: meta.sets.map(function (meta) { return _this.from(meta, dict); }),
-            maps: meta.maps.map(function (entry) { return ({
-                key: _this.from(entry.key, dict),
-                value: _this.from(entry.value, dict),
-            }); }),
         });
     };
     /* -----------------------------------------------------------
@@ -227,6 +239,36 @@ var Metadata = /** @class */ (function () {
             (this.functions.length ? 1 : 0) +
             (this.aliases.length ? 1 : 0));
     };
+    /**
+     * @internal
+     */
+    Metadata.prototype.isSequence = function () {
+        var _this = this;
+        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 (_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); }));
+        })()));
+    };
     Metadata.prototype.isConstant = function () {
         return this.bucket() === (this.constants.length ? 1 : 0);
     };
@@ -453,7 +495,7 @@ exports.Metadata = Metadata;
             finally { if (e_5) throw e_5.error; }
         }
         var _loop_6 = function (yd) {
-            if (x.aliases.some(function (xd) { return xd.name === yd.name; }) === false)
+            if (x.aliases.some(function (xd) { return xd.type.name === yd.type.name; }) === false)
                 return { value: false };
         };
         try {
@@ -493,7 +535,7 @@ exports.Metadata = Metadata;
             finally { if (e_7) throw e_7.error; }
         }
         var _loop_8 = function (ys) {
-            if (x.sets.some(function (xs) { return Metadata.covers(xs, ys); }) === false)
+            if (x.sets.some(function (xs) { return Metadata.covers(xs.value, ys.value); }) === false)
                 return { value: false };
         };
         try {
@@ -553,8 +595,8 @@ exports.Metadata = Metadata;
      * @internal
      */
     Metadata.merge = function (x, y) {
-        var e_10, _a, e_11, _b, e_12, _c;
-        var _d, _e;
+        var e_10, _a;
+        var _b, _c;
         var output = Metadata.create({
             any: x.any || y.any,
             nullable: x.nullable || y.nullable,
@@ -566,7 +608,7 @@ exports.Metadata = Metadata;
                     original: Metadata.merge(x.escaped.original, y.escaped.original),
                     returns: Metadata.merge(x.escaped.returns, y.escaped.returns),
                 })
-                : ((_d = x.escaped) !== null && _d !== void 0 ? _d : y.escaped),
+                : ((_b = x.escaped) !== null && _b !== void 0 ? _b : y.escaped),
             atomics: mergeTaggedTypes({
                 container: x.atomics,
                 equals: function (x, y) { return x.type === y.type; },
@@ -576,8 +618,7 @@ exports.Metadata = Metadata;
             templates: x.templates.slice(),
             rest: x.rest !== null && y.rest !== null
                 ? Metadata.merge(x.rest, y.rest)
-                : ((_e = x.rest) !== null && _e !== void 0 ? _e : y.rest),
-            // arrays: x.arrays.slice(),
+                : ((_c = x.rest) !== null && _c !== void 0 ? _c : y.rest),
             arrays: mergeTaggedTypes({
                 container: x.arrays,
                 equals: function (x, y) { return x.type.name === y.type.name; },
@@ -588,14 +629,37 @@ exports.Metadata = Metadata;
                 equals: function (x, y) { return x.type.name === y.type.name; },
                 getter: function (x) { return x.tags; },
             })(y.tuples),
-            objects: x.objects.slice(),
-            aliases: x.aliases.slice(),
-            natives: __spreadArray([], __read(new Set(__spreadArray(__spreadArray([], __read(x.natives), false), __read(y.natives), false))), false),
-            sets: x.sets.slice(),
-            maps: x.maps.slice(),
+            objects: mergeTaggedTypes({
+                container: x.objects,
+                equals: function (x, y) { return x.type.name === y.type.name; },
+                getter: function (x) { return 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; },
+            })(y.aliases),
+            natives: mergeTaggedTypes({
+                container: x.natives,
+                equals: function (x, y) { return x.name === y.name; },
+                getter: function (x) { return 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; },
+            })(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; },
+            })(y.maps),
         });
         var _loop_10 = function (constant) {
-            var e_13, _m;
+            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,
@@ -603,63 +667,37 @@ exports.Metadata = Metadata;
                 });
             });
             try {
-                for (var _o = (e_13 = void 0, __values(constant.values)), _p = _o.next(); !_p.done; _p = _o.next()) {
-                    var value = _p.value;
+                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_13_1) { e_13 = { error: e_13_1 }; }
+            catch (e_11_1) { e_11 = { error: e_11_1 }; }
             finally {
                 try {
-                    if (_p && !_p.done && (_m = _o.return)) _m.call(_o);
+                    if (_h && !_h.done && (_f = _g.return)) _f.call(_g);
                 }
-                finally { if (e_13) throw e_13.error; }
+                finally { if (e_11) throw e_11.error; }
             }
         };
         try {
-            for (var _f = __values(y.constants), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var constant = _g.value;
+            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 (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
             }
             finally { if (e_10) throw e_10.error; }
         }
-        try {
-            for (var _h = __values(y.objects), _j = _h.next(); !_j.done; _j = _h.next()) {
-                var obj = _j.value;
-                ArrayUtil_1.ArrayUtil.set(output.objects, obj, function (elem) { return elem.type.name; });
-            }
-        }
-        catch (e_11_1) { e_11 = { error: e_11_1 }; }
-        finally {
-            try {
-                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
-            }
-            finally { if (e_11) throw e_11.error; }
-        }
-        try {
-            for (var _k = __values(y.aliases), _l = _k.next(); !_l.done; _l = _k.next()) {
-                var alias = _l.value;
-                ArrayUtil_1.ArrayUtil.set(output.aliases, alias, function (elem) { return elem.name; });
-            }
-        }
-        catch (e_12_1) { e_12 = { error: e_12_1 }; }
-        finally {
-            try {
-                if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
-            }
-            finally { if (e_12) throw e_12.error; }
-        }
         return output;
     };
 })(Metadata || (exports.Metadata = Metadata = {}));
 var getName = function (metadata) {
-    var e_14, _a, e_15, _b, e_16, _c, e_17, _d, e_18, _e, e_19, _f, e_20, _g, e_21, _h, e_22, _j, e_23, _k, e_24, _l;
+    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;
     if (metadata.any === true)
         return "any";
     var elements = [];
@@ -675,37 +713,37 @@ var getName = function (metadata) {
             elements.push(atom.getName());
         }
     }
-    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    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_14) throw e_14.error; }
+        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_16 = void 0, __values(constant.values)), _s = _r.next(); !_s.done; _s = _r.next()) {
+                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_16_1) { e_16 = { error: e_16_1 }; }
+            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_16) throw e_16.error; }
+                finally { if (e_14) throw e_14.error; }
             }
         }
     }
-    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    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_15) throw e_15.error; }
+        finally { if (e_13) throw e_13.error; }
     }
     try {
         for (var _t = __values(metadata.templates), _u = _t.next(); !_u.done; _u = _t.next()) {
@@ -713,52 +751,52 @@ var getName = function (metadata) {
             elements.push(template.getName());
         }
     }
-    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    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_17) throw e_17.error; }
+        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);
+            elements.push(native.getName());
         }
     }
-    catch (e_18_1) { e_18 = { error: e_18_1 }; }
+    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_18) throw e_18.error; }
+        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<".concat(set.getName(), ">"));
+            elements.push(set.getName());
         }
     }
-    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+    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_19) throw e_19.error; }
+        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<".concat(map.key.getName(), ", ").concat(map.value.getName(), ">"));
+            elements.push(map.getName());
         }
     }
-    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+    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_20) throw e_20.error; }
+        finally { if (e_18) throw e_18.error; }
     }
     // INSTANCES
     if (metadata.rest !== null)
@@ -769,12 +807,12 @@ var getName = function (metadata) {
             elements.push(tuple.type.name);
         }
     }
-    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    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_21) throw e_21.error; }
+        finally { if (e_19) throw e_19.error; }
     }
     try {
         for (var _3 = __values(metadata.arrays), _4 = _3.next(); !_4.done; _4 = _3.next()) {
@@ -782,12 +820,12 @@ var getName = function (metadata) {
             elements.push(array.getName());
         }
     }
-    catch (e_22_1) { e_22 = { error: e_22_1 }; }
+    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_22) throw e_22.error; }
+        finally { if (e_20) throw e_20.error; }
     }
     try {
         for (var _5 = __values(metadata.objects), _6 = _5.next(); !_6.done; _6 = _5.next()) {
@@ -795,25 +833,25 @@ var getName = function (metadata) {
             elements.push(object.getName());
         }
     }
-    catch (e_23_1) { e_23 = { error: e_23_1 }; }
+    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_23) throw e_23.error; }
+        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.name);
+            elements.push(alias.getName());
         }
     }
-    catch (e_24_1) { e_24 = { error: e_24_1 }; }
+    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_24) throw e_24.error; }
+        finally { if (e_22) throw e_22.error; }
     }
     if (metadata.escaped !== null)
         elements.push(metadata.escaped.getName());
@@ -827,10 +865,10 @@ var getName = function (metadata) {
 };
 var mergeTaggedTypes = function (props) {
     return function (opposite) {
-        var e_25, _a;
+        var e_23, _a;
         var output = __spreadArray([], __read(props.container), false);
         var _loop_11 = function (elem) {
-            var e_26, _b;
+            var e_24, _b;
             var equal = props.container.find(function (x) { return props.equals(x, elem); });
             if (equal === undefined) {
                 output.push(elem);
@@ -849,17 +887,17 @@ var mergeTaggedTypes = function (props) {
                 props.getter(equal).push(tags);
             };
             try {
-                for (var _c = (e_26 = void 0, __values(props.getter(elem))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                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_26_1) { e_26 = { error: e_26_1 }; }
+            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_26) throw e_26.error; }
+                finally { if (e_24) throw e_24.error; }
             }
         };
         try {
@@ -868,12 +906,12 @@ var mergeTaggedTypes = function (props) {
                 _loop_11(elem);
             }
         }
-        catch (e_25_1) { e_25 = { error: e_25_1 }; }
+        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_25) throw e_25.error; }
+            finally { if (e_23) throw e_23.error; }
         }
         return output;
     };