typia 5.0.0-dev.2023084 → 5.0.0

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

@@ -1,8 +1,8 @@
 import { IMetadata } from "./IMetadata";
-import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataCollection } from "./IMetadataCollection";
 import { MetadataAlias } from "./MetadataAlias";
 import { MetadataArray } from "./MetadataArray";
+import { MetadataAtomic } from "./MetadataAtomic";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataObject } from "./MetadataObject";
@@ -14,7 +14,7 @@ export declare class Metadata {
     nullable: boolean;
     functional: boolean;
     escaped: MetadataEscaped | null;
-    atomics: IMetadataAtomic[];
+    atomics: MetadataAtomic[];
     constants: MetadataConstant[];
     templates: Metadata[][];
     rest: Metadata | null;

package/lib/schemas/metadata/Metadata.js

@@ -41,10 +41,13 @@ var Writable_1 = require("../../typings/Writable");
 var ArrayUtil_1 = require("../../utils/ArrayUtil");
 var MetadataAlias_1 = require("./MetadataAlias");
 var MetadataArray_1 = require("./MetadataArray");
+var MetadataArrayType_1 = require("./MetadataArrayType");
+var MetadataAtomic_1 = require("./MetadataAtomic");
 var MetadataEscaped_1 = require("./MetadataEscaped");
 var MetadataObject_1 = require("./MetadataObject");
 var MetadataProperty_1 = require("./MetadataProperty");
 var MetadataTuple_1 = require("./MetadataTuple");
+var MetadataTupleType_1 = require("./MetadataTupleType");
 var Metadata = (function () {
     function Metadata(props) {
         this.parent_resolved_ = false;
@@ -100,15 +103,29 @@ var Metadata = (function () {
             optional: this.optional,
             nullable: this.nullable,
             functional: this.functional,
-            atomics: JSON.parse(JSON.stringify(this.atomics)),
-            constants: JSON.parse(JSON.stringify(this.constants)),
+            atomics: this.atomics.map(function (a) {
+                return MetadataAtomic_1.MetadataAtomic.create({
+                    type: a.type,
+                    tags: a.tags.map(function (r) { return r.slice(); }),
+                });
+            }),
+            constants: this.constants.map(function (c) { return ({
+                type: c.type,
+                values: c.values.slice(),
+            }); }),
             templates: this.templates.map(function (tpl) {
                 return tpl.map(function (meta) { return meta.toJSON(); });
             }),
             escaped: this.escaped ? this.escaped.toJSON() : null,
             rest: this.rest ? this.rest.toJSON() : null,
-            arrays: this.arrays.map(function (array) { return array.name; }),
-            tuples: this.tuples.map(function (tuple) { return tuple.name; }),
+            arrays: this.arrays.map(function (array) { return ({
+                name: array.type.name,
+                tags: array.tags.map(function (r) { return r.slice(); }),
+            }); }),
+            tuples: this.tuples.map(function (tuple) { return ({
+                name: tuple.type.name,
+                tags: tuple.tags.map(function (r) { return r.slice(); }),
+            }); }),
             objects: this.objects.map(function (obj) { return obj.name; }),
             aliases: this.aliases.map(function (alias) { return alias.name; }),
             natives: this.natives.slice(),
@@ -133,11 +150,11 @@ var Metadata = (function () {
             ]; })),
             arrays: new Map(collection.arrays.map(function (arr) { return [
                 arr.name,
-                MetadataArray_1.MetadataArray._From_without_value(arr),
+                MetadataArrayType_1.MetadataArrayType._From_without_value(arr),
             ]; })),
             tuples: new Map(collection.tuples.map(function (tpl) { return [
                 tpl.name,
-                MetadataTuple_1.MetadataTuple._From_without_elements(tpl),
+                MetadataTupleType_1.MetadataTupleType._From_without_elements(tpl),
             ]; })),
         };
         try {
@@ -206,8 +223,10 @@ var Metadata = (function () {
             optional: meta.optional,
             nullable: meta.nullable,
             functional: meta.functional,
-            constants: JSON.parse(JSON.stringify(meta.constants)),
-            atomics: JSON.parse(JSON.stringify(meta.atomics)),
+            constants: meta.constants.slice(),
+            atomics: meta.atomics.map(function (a) {
+                return MetadataAtomic_1.MetadataAtomic.create({ type: a.type, tags: a.tags });
+            }),
             templates: meta.templates.map(function (tpl) {
                 return tpl.map(function (meta) { return _this._From(meta, dict); });
             }),
@@ -215,28 +234,34 @@ var Metadata = (function () {
                 ? MetadataEscaped_1.MetadataEscaped._From(meta.escaped, dict)
                 : null,
             rest: meta.rest ? this._From(meta.rest, dict) : null,
-            arrays: meta.arrays.map(function (id) {
-                var array = dict.arrays.get(id);
-                if (array === undefined)
-                    throw new Error("Error on Metadata.from(): failed to find array \"".concat(id, "\"."));
-                return array;
+            arrays: meta.arrays.map(function (ref) {
+                var type = dict.arrays.get(ref.name);
+                if (type === undefined)
+                    throw new RangeError("Error on Metadata.from(): failed to find array \"".concat(ref.name, "\"."));
+                return MetadataArray_1.MetadataArray.create({
+                    type: type,
+                    tags: ref.tags.map(function (row) { return row.slice(); }),
+                });
             }),
-            tuples: meta.tuples.map(function (id) {
-                var tuple = dict.tuples.get(id);
-                if (tuple === undefined)
-                    throw new Error("Error on Metadata.from(): failed to find tuple \"".concat(id, "\"."));
-                return tuple;
+            tuples: meta.tuples.map(function (t) {
+                var type = dict.tuples.get(t.name);
+                if (type === undefined)
+                    throw new RangeError("Error on Metadata.from(): failed to find tuple \"".concat(t.name, "\"."));
+                return MetadataTuple_1.MetadataTuple.create({
+                    type: type,
+                    tags: t.tags.map(function (r) { return r.slice(); }),
+                });
             }),
             objects: meta.objects.map(function (name) {
                 var found = dict.objects.get(name);
                 if (found === undefined)
-                    throw new Error("Error on Metadata.from(): failed to find object \"".concat(name, "\"."));
+                    throw new RangeError("Error on Metadata.from(): failed to find object \"".concat(name, "\"."));
                 return found;
             }),
             aliases: meta.aliases.map(function (alias) {
                 var found = dict.aliases.get(alias);
                 if (found === undefined)
-                    throw new Error("Error on Metadata.from(): failed to find alias \"".concat(alias, "\"."));
+                    throw new RangeError("Error on Metadata.from(): failed to find alias \"".concat(alias, "\"."));
                 return found;
             }),
             natives: meta.natives.slice(),
@@ -249,8 +274,7 @@ var Metadata = (function () {
     };
     Metadata.prototype.getName = function () {
         var _a;
-        (_a = this.name_) !== null && _a !== void 0 ? _a : (this.name_ = getName(this));
-        return this.name_;
+        return ((_a = this.name_) !== null && _a !== void 0 ? _a : (this.name_ = getName(this)));
     };
     Metadata.prototype.empty = function () {
         return this.bucket() === 0 || this.size() === 0;
@@ -273,14 +297,6 @@ var Metadata = (function () {
             this.objects.length +
             this.aliases.length);
     };
-    Metadata.prototype.binarySize = function () {
-        return (new Set(__spreadArray(__spreadArray(__spreadArray([], __read(this.atomics.map(function (a) { return a.type; })), false), __read(this.constants.map(function (c) { return c.type; })), false), __read((this.templates.length ? ["string"] : [])), false)).size +
-            this.arrays.length +
-            this.tuples.length +
-            this.natives.length +
-            this.objects.length +
-            this.maps.length);
-    };
     Metadata.prototype.bucket = function () {
         return ((this.any ? 1 : 0) +
             (this.escaped ? 1 : 0) +
@@ -308,9 +324,6 @@ var Metadata = (function () {
         var emended = !!this.atomics.length && !!this.constants.length ? size - 1 : size;
         return emended > 1;
     };
-    Metadata.prototype.isBinaryUnion = function () {
-        return this.binarySize() > 1;
-    };
     Metadata.prototype.getSoleLiteral = function () {
         if (this.size() === 1 &&
             this.constants.length === 1 &&
@@ -407,7 +420,7 @@ exports.Metadata = Metadata;
         if (level === 0) {
             var _loop_3 = function (ya) {
                 if (!x.arrays.some(function (xa) {
-                    return Metadata.covers(xa.value, ya.value, level + 1);
+                    return Metadata.covers(xa.type.value, ya.type.value, level + 1);
                 })) {
                     return { value: false };
                 }
@@ -428,13 +441,14 @@ exports.Metadata = Metadata;
                 finally { if (e_7) throw e_7.error; }
             }
             var _loop_4 = function (yt) {
-                if (yt.elements.length !== 0 &&
+                if (yt.type.elements.length !== 0 &&
                     x.tuples.some(function (xt) {
-                        return xt.elements.length >= yt.elements.length &&
-                            xt.elements
-                                .slice(yt.elements.length)
+                        return xt.type.elements.length >=
+                            yt.type.elements.length &&
+                            xt.type.elements
+                                .slice(yt.type.elements.length)
                                 .every(function (xv, i) {
-                                return Metadata.covers(xv, yt.elements[i], level + 1);
+                                return Metadata.covers(xv, yt.type.elements[i], level + 1);
                             });
                     }) === false)
                     return { value: false };
@@ -562,8 +576,8 @@ exports.Metadata = Metadata;
         return true;
     };
     Metadata.merge = function (x, y) {
-        var e_14, _a, e_15, _b, e_16, _c, e_17, _d, e_18, _e;
-        var _f, _g;
+        var e_14, _a, e_15, _b, e_16, _c;
+        var _d, _e;
         var output = Metadata.create({
             any: x.any || y.any,
             nullable: x.nullable || y.nullable,
@@ -571,20 +585,31 @@ exports.Metadata = Metadata;
             optional: x.optional || y.optional,
             functional: x.functional || y.functional,
             escaped: x.escaped !== null && y.escaped !== null
-                ?
-                    MetadataEscaped_1.MetadataEscaped.create({
-                        original: Metadata.merge(x.escaped.original, y.escaped.original),
-                        returns: Metadata.merge(x.escaped.returns, y.escaped.returns),
-                    })
-                : (_f = x.escaped) !== null && _f !== void 0 ? _f : y.escaped,
-            atomics: __spreadArray([], __read(new Set(__spreadArray(__spreadArray([], __read(x.atomics.map(function (a) { return a.type; })), false), __read(y.atomics.map(function (a) { return a.type; })), false))), false).map(function (type) { return ({ type: type, tags: [] }); }),
+                ? MetadataEscaped_1.MetadataEscaped.create({
+                    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,
+            atomics: mergeTaggedTypes({
+                container: x.atomics,
+                equals: function (x, y) { return x.type === y.type; },
+                getter: function (x) { return x.tags; },
+            })(y.atomics),
             constants: __spreadArray([], __read(x.constants), false),
             templates: x.templates.slice(),
             rest: x.rest !== null && y.rest !== null
                 ? Metadata.merge(x.rest, y.rest)
-                : (_g = x.rest) !== null && _g !== void 0 ? _g : y.rest,
-            arrays: x.arrays.slice(),
-            tuples: x.tuples.slice(),
+                : (_e = x.rest) !== null && _e !== void 0 ? _e : y.rest,
+            arrays: mergeTaggedTypes({
+                container: x.arrays,
+                equals: function (x, y) { return x.type.name === y.type.name; },
+                getter: function (x) { return x.tags; },
+            })(y.arrays),
+            tuples: mergeTaggedTypes({
+                container: x.tuples,
+                equals: function (x, y) { return x.type.name === y.type.name; },
+                getter: function (x) { return x.tags; },
+            })(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),
@@ -592,95 +617,69 @@ exports.Metadata = Metadata;
             maps: x.maps.slice(),
         });
         var _loop_10 = function (constant) {
-            var e_19, _t;
+            var e_17, _m;
             var target = ArrayUtil_1.ArrayUtil.take(output.constants, function (elem) { return elem.type === constant.type; }, function () { return ({
                 type: constant.type,
                 values: [],
             }); });
             try {
-                for (var _u = (e_19 = void 0, __values(constant.values)), _v = _u.next(); !_v.done; _v = _u.next()) {
-                    var value = _v.value;
+                for (var _o = (e_17 = void 0, __values(constant.values)), _p = _o.next(); !_p.done; _p = _o.next()) {
+                    var value = _p.value;
                     ArrayUtil_1.ArrayUtil.add(target.values, value);
                 }
             }
-            catch (e_19_1) { e_19 = { error: e_19_1 }; }
+            catch (e_17_1) { e_17 = { error: e_17_1 }; }
             finally {
                 try {
-                    if (_v && !_v.done && (_t = _u.return)) _t.call(_u);
+                    if (_p && !_p.done && (_m = _o.return)) _m.call(_o);
                 }
-                finally { if (e_19) throw e_19.error; }
+                finally { if (e_17) throw e_17.error; }
             }
         };
         try {
-            for (var _h = __values(y.constants), _j = _h.next(); !_j.done; _j = _h.next()) {
-                var constant = _j.value;
+            for (var _f = __values(y.constants), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var constant = _g.value;
                 _loop_10(constant);
             }
         }
         catch (e_14_1) { e_14 = { error: e_14_1 }; }
         finally {
             try {
-                if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
+                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
             }
             finally { if (e_14) throw e_14.error; }
         }
         try {
-            for (var _k = __values(y.arrays), _l = _k.next(); !_l.done; _l = _k.next()) {
-                var array = _l.value;
-                ArrayUtil_1.ArrayUtil.set(output.arrays, array, function (elem) { return elem.name; });
+            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.name; });
             }
         }
         catch (e_15_1) { e_15 = { error: e_15_1 }; }
         finally {
             try {
-                if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
+                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
             }
             finally { if (e_15) throw e_15.error; }
         }
         try {
-            for (var _m = __values(y.tuples), _o = _m.next(); !_o.done; _o = _m.next()) {
-                var tuple = _o.value;
-                ArrayUtil_1.ArrayUtil.set(output.tuples, tuple, function (elem) { return elem.name; });
+            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_16_1) { e_16 = { error: e_16_1 }; }
         finally {
             try {
-                if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
+                if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
             }
             finally { if (e_16) throw e_16.error; }
         }
-        try {
-            for (var _p = __values(y.objects), _q = _p.next(); !_q.done; _q = _p.next()) {
-                var obj = _q.value;
-                ArrayUtil_1.ArrayUtil.set(output.objects, obj, function (elem) { return elem.name; });
-            }
-        }
-        catch (e_17_1) { e_17 = { error: e_17_1 }; }
-        finally {
-            try {
-                if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
-            }
-            finally { if (e_17) throw e_17.error; }
-        }
-        try {
-            for (var _r = __values(y.aliases), _s = _r.next(); !_s.done; _s = _r.next()) {
-                var alias = _s.value;
-                ArrayUtil_1.ArrayUtil.set(output.aliases, alias, function (elem) { return elem.name; });
-            }
-        }
-        catch (e_18_1) { e_18 = { error: e_18_1 }; }
-        finally {
-            try {
-                if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
-            }
-            finally { if (e_18) throw e_18.error; }
-        }
         return output;
     };
 })(Metadata || (exports.Metadata = Metadata = {}));
 var getName = function (metadata) {
-    var e_20, _a, e_21, _b, e_22, _c, e_23, _d, e_24, _e, e_25, _f, e_26, _g, e_27, _h, e_28, _j, e_29, _k, e_30, _l;
+    var e_18, _a, e_19, _b, e_20, _c, e_21, _d, e_22, _e, e_23, _f, e_24, _g, e_25, _h, e_26, _j, e_27, _k, e_28, _l;
     if (metadata.any === true)
         return "any";
     var elements = [];
@@ -691,40 +690,42 @@ var getName = function (metadata) {
     try {
         for (var _m = __values(metadata.atomics), _o = _m.next(); !_o.done; _o = _m.next()) {
             var atom = _o.value;
-            elements.push(atom.type);
+            elements.push(atom.getName());
         }
     }
-    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
     finally {
         try {
             if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
         }
-        finally { if (e_20) throw e_20.error; }
+        finally { if (e_18) throw e_18.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_22 = void 0, __values(constant.values)), _s = _r.next(); !_s.done; _s = _r.next()) {
+                for (var _r = (e_20 = void 0, __values(constant.values)), _s = _r.next(); !_s.done; _s = _r.next()) {
                     var value = _s.value;
-                    elements.push(JSON.stringify(value));
+                    elements.push(constant.type === "string"
+                        ? JSON.stringify(value)
+                        : value.toString());
                 }
             }
-            catch (e_22_1) { e_22 = { error: e_22_1 }; }
+            catch (e_20_1) { e_20 = { error: e_20_1 }; }
             finally {
                 try {
                     if (_s && !_s.done && (_c = _r.return)) _c.call(_r);
                 }
-                finally { if (e_22) throw e_22.error; }
+                finally { if (e_20) throw e_20.error; }
             }
         }
     }
-    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
     finally {
         try {
             if (_q && !_q.done && (_b = _p.return)) _b.call(_p);
         }
-        finally { if (e_21) throw e_21.error; }
+        finally { if (e_19) throw e_19.error; }
     }
     try {
         for (var _t = __values(metadata.templates), _u = _t.next(); !_u.done; _u = _t.next()) {
@@ -742,12 +743,12 @@ var getName = function (metadata) {
                 "`");
         }
     }
-    catch (e_23_1) { e_23 = { error: e_23_1 }; }
+    catch (e_21_1) { e_21 = { error: e_21_1 }; }
     finally {
         try {
             if (_u && !_u.done && (_d = _t.return)) _d.call(_t);
         }
-        finally { if (e_23) throw e_23.error; }
+        finally { if (e_21) throw e_21.error; }
     }
     try {
         for (var _v = __values(metadata.natives), _w = _v.next(); !_w.done; _w = _v.next()) {
@@ -755,12 +756,12 @@ var getName = function (metadata) {
             elements.push(native);
         }
     }
-    catch (e_24_1) { e_24 = { error: e_24_1 }; }
+    catch (e_22_1) { e_22 = { error: e_22_1 }; }
     finally {
         try {
             if (_w && !_w.done && (_e = _v.return)) _e.call(_v);
         }
-        finally { if (e_24) throw e_24.error; }
+        finally { if (e_22) throw e_22.error; }
     }
     try {
         for (var _x = __values(metadata.sets), _y = _x.next(); !_y.done; _y = _x.next()) {
@@ -768,12 +769,12 @@ var getName = function (metadata) {
             elements.push("Set<".concat(set.getName(), ">"));
         }
     }
-    catch (e_25_1) { e_25 = { error: e_25_1 }; }
+    catch (e_23_1) { e_23 = { error: e_23_1 }; }
     finally {
         try {
             if (_y && !_y.done && (_f = _x.return)) _f.call(_x);
         }
-        finally { if (e_25) throw e_25.error; }
+        finally { if (e_23) throw e_23.error; }
     }
     try {
         for (var _z = __values(metadata.maps), _0 = _z.next(); !_0.done; _0 = _z.next()) {
@@ -781,40 +782,40 @@ var getName = function (metadata) {
             elements.push("Map<".concat(map.key.getName(), ", ").concat(map.value.getName(), ">"));
         }
     }
-    catch (e_26_1) { e_26 = { error: e_26_1 }; }
+    catch (e_24_1) { e_24 = { error: e_24_1 }; }
     finally {
         try {
             if (_0 && !_0.done && (_g = _z.return)) _g.call(_z);
         }
-        finally { if (e_26) throw e_26.error; }
+        finally { if (e_24) throw e_24.error; }
     }
     if (metadata.rest !== null)
         elements.push("...".concat(metadata.rest.getName()));
     try {
         for (var _1 = __values(metadata.tuples), _2 = _1.next(); !_2.done; _2 = _1.next()) {
             var tuple = _2.value;
-            elements.push(tuple.name);
+            elements.push(tuple.type.name);
         }
     }
-    catch (e_27_1) { e_27 = { error: e_27_1 }; }
+    catch (e_25_1) { e_25 = { error: e_25_1 }; }
     finally {
         try {
             if (_2 && !_2.done && (_h = _1.return)) _h.call(_1);
         }
-        finally { if (e_27) throw e_27.error; }
+        finally { if (e_25) throw e_25.error; }
     }
     try {
         for (var _3 = __values(metadata.arrays), _4 = _3.next(); !_4.done; _4 = _3.next()) {
             var array = _4.value;
-            elements.push(array.name);
+            elements.push(array.getName());
         }
     }
-    catch (e_28_1) { e_28 = { error: e_28_1 }; }
+    catch (e_26_1) { e_26 = { error: e_26_1 }; }
     finally {
         try {
             if (_4 && !_4.done && (_j = _3.return)) _j.call(_3);
         }
-        finally { if (e_28) throw e_28.error; }
+        finally { if (e_26) throw e_26.error; }
     }
     try {
         for (var _5 = __values(metadata.objects), _6 = _5.next(); !_6.done; _6 = _5.next()) {
@@ -822,12 +823,12 @@ var getName = function (metadata) {
             elements.push(object.name);
         }
     }
-    catch (e_29_1) { e_29 = { error: e_29_1 }; }
+    catch (e_27_1) { e_27 = { error: e_27_1 }; }
     finally {
         try {
             if (_6 && !_6.done && (_k = _5.return)) _k.call(_5);
         }
-        finally { if (e_29) throw e_29.error; }
+        finally { if (e_27) throw e_27.error; }
     }
     try {
         for (var _7 = __values(metadata.aliases), _8 = _7.next(); !_8.done; _8 = _7.next()) {
@@ -835,12 +836,12 @@ var getName = function (metadata) {
             elements.push(alias.name);
         }
     }
-    catch (e_30_1) { e_30 = { error: e_30_1 }; }
+    catch (e_28_1) { e_28 = { error: e_28_1 }; }
     finally {
         try {
             if (_8 && !_8.done && (_l = _7.return)) _l.call(_7);
         }
-        finally { if (e_30) throw e_30.error; }
+        finally { if (e_28) throw e_28.error; }
     }
     if (metadata.escaped !== null)
         elements.push(metadata.escaped.getName());
@@ -851,4 +852,58 @@ var getName = function (metadata) {
     elements.sort();
     return "(".concat(elements.join(" | "), ")");
 };
+var mergeTaggedTypes = function (props) {
+    return function (opposite) {
+        var e_29, _a;
+        var output = __spreadArray([], __read(props.container), false);
+        var _loop_11 = function (elem) {
+            var e_30, _b;
+            var equal = props.container.find(function (x) { return props.equals(x, elem); });
+            if (equal === undefined) {
+                output.push(elem);
+                return "continue";
+            }
+            var matrix = props
+                .getter(equal)
+                .map(function (tags) { return tags.map(function (t) { return t.name; }); })
+                .sort();
+            var _loop_12 = function (tags) {
+                var names = tags.map(function (t) { return t.name; }).sort();
+                if (matrix.some(function (m) {
+                    return m.length === names.length &&
+                        m.every(function (s, i) { return s === names[i]; });
+                }))
+                    return "continue";
+                props.getter(equal).push(tags);
+            };
+            try {
+                for (var _c = (e_30 = void 0, __values(props.getter(elem))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var tags = _d.value;
+                    _loop_12(tags);
+                }
+            }
+            catch (e_30_1) { e_30 = { error: e_30_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_30) throw e_30.error; }
+            }
+        };
+        try {
+            for (var opposite_1 = __values(opposite), opposite_1_1 = opposite_1.next(); !opposite_1_1.done; opposite_1_1 = opposite_1.next()) {
+                var elem = opposite_1_1.value;
+                _loop_11(elem);
+            }
+        }
+        catch (e_29_1) { e_29 = { error: e_29_1 }; }
+        finally {
+            try {
+                if (opposite_1_1 && !opposite_1_1.done && (_a = opposite_1.return)) _a.call(opposite_1);
+            }
+            finally { if (e_29) throw e_29.error; }
+        }
+        return output;
+    };
+};
 //# sourceMappingURL=Metadata.js.map