xml-model 1.2.0 → 1.3.1

package/dist/node_modules/reflect-metadata/Reflect.js

@@ -0,0 +1,867 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { commonjsGlobal } from "../../_virtual/_commonjsHelpers.js";
+import { __exports as _Reflect } from "../../_virtual/Reflect2.js";
+var hasRequired_Reflect;
+function require_Reflect() {
+  if (hasRequired_Reflect) return _Reflect;
+  hasRequired_Reflect = 1;
+  var Reflect2;
+  (function(Reflect3) {
+    (function(factory) {
+      var root = typeof commonjsGlobal === "object" ? commonjsGlobal : typeof self === "object" ? self : typeof this === "object" ? this : Function("return this;")();
+      var exporter = makeExporter(Reflect3);
+      if (typeof root.Reflect === "undefined") {
+        root.Reflect = Reflect3;
+      } else {
+        exporter = makeExporter(root.Reflect, exporter);
+      }
+      factory(exporter);
+      function makeExporter(target, previous) {
+        return function(key, value) {
+          if (typeof target[key] !== "function") {
+            Object.defineProperty(target, key, { configurable: true, writable: true, value });
+          }
+          if (previous)
+            previous(key, value);
+        };
+      }
+      __name(makeExporter, "makeExporter");
+    })(function(exporter) {
+      var hasOwn = Object.prototype.hasOwnProperty;
+      var supportsSymbol = typeof Symbol === "function";
+      var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+      var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+      var supportsCreate = typeof Object.create === "function";
+      var supportsProto = { __proto__: [] } instanceof Array;
+      var downLevel = !supportsCreate && !supportsProto;
+      var HashMap = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: supportsCreate ? function() {
+          return MakeDictionary(/* @__PURE__ */ Object.create(null));
+        } : supportsProto ? function() {
+          return MakeDictionary({ __proto__: null });
+        } : function() {
+          return MakeDictionary({});
+        },
+        has: downLevel ? function(map, key) {
+          return hasOwn.call(map, key);
+        } : function(map, key) {
+          return key in map;
+        },
+        get: downLevel ? function(map, key) {
+          return hasOwn.call(map, key) ? map[key] : void 0;
+        } : function(map, key) {
+          return map[key];
+        }
+      };
+      var functionPrototype = Object.getPrototypeOf(Function);
+      var usePolyfill = typeof process === "object" && process["env"] && process["env"]["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true";
+      var _Map = !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+      var _Set = !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+      var _WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+      var Metadata = new _WeakMap();
+      function decorate(decorators, target, propertyKey, attributes) {
+        if (!IsUndefined(propertyKey)) {
+          if (!IsArray(decorators))
+            throw new TypeError();
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+            throw new TypeError();
+          if (IsNull(attributes))
+            attributes = void 0;
+          propertyKey = ToPropertyKey(propertyKey);
+          return DecorateProperty(decorators, target, propertyKey, attributes);
+        } else {
+          if (!IsArray(decorators))
+            throw new TypeError();
+          if (!IsConstructor(target))
+            throw new TypeError();
+          return DecorateConstructor(decorators, target);
+        }
+      }
+      __name(decorate, "decorate");
+      exporter("decorate", decorate);
+      function metadata(metadataKey, metadataValue) {
+        function decorator(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+            throw new TypeError();
+          OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        __name(decorator, "decorator");
+        return decorator;
+      }
+      __name(metadata, "metadata");
+      exporter("metadata", metadata);
+      function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      __name(defineMetadata, "defineMetadata");
+      exporter("defineMetadata", defineMetadata);
+      function hasMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+      }
+      __name(hasMetadata, "hasMetadata");
+      exporter("hasMetadata", hasMetadata);
+      function hasOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+      }
+      __name(hasOwnMetadata, "hasOwnMetadata");
+      exporter("hasOwnMetadata", hasOwnMetadata);
+      function getMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+      }
+      __name(getMetadata, "getMetadata");
+      exporter("getMetadata", getMetadata);
+      function getOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+      }
+      __name(getOwnMetadata, "getOwnMetadata");
+      exporter("getOwnMetadata", getOwnMetadata);
+      function getMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryMetadataKeys(target, propertyKey);
+      }
+      __name(getMetadataKeys, "getMetadataKeys");
+      exporter("getMetadataKeys", getMetadataKeys);
+      function getOwnMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryOwnMetadataKeys(target, propertyKey);
+      }
+      __name(getOwnMetadataKeys, "getOwnMetadataKeys");
+      exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+      function deleteMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        var metadataMap = GetOrCreateMetadataMap(
+          target,
+          propertyKey,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return false;
+        if (!metadataMap.delete(metadataKey))
+          return false;
+        if (metadataMap.size > 0)
+          return true;
+        var targetMetadata = Metadata.get(target);
+        targetMetadata.delete(propertyKey);
+        if (targetMetadata.size > 0)
+          return true;
+        Metadata.delete(target);
+        return true;
+      }
+      __name(deleteMetadata, "deleteMetadata");
+      exporter("deleteMetadata", deleteMetadata);
+      function DecorateConstructor(decorators, target) {
+        for (var i = decorators.length - 1; i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsConstructor(decorated))
+              throw new TypeError();
+            target = decorated;
+          }
+        }
+        return target;
+      }
+      __name(DecorateConstructor, "DecorateConstructor");
+      function DecorateProperty(decorators, target, propertyKey, descriptor) {
+        for (var i = decorators.length - 1; i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target, propertyKey, descriptor);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsObject(decorated))
+              throw new TypeError();
+            descriptor = decorated;
+          }
+        }
+        return descriptor;
+      }
+      __name(DecorateProperty, "DecorateProperty");
+      function GetOrCreateMetadataMap(O, P, Create) {
+        var targetMetadata = Metadata.get(O);
+        if (IsUndefined(targetMetadata)) {
+          if (!Create)
+            return void 0;
+          targetMetadata = new _Map();
+          Metadata.set(O, targetMetadata);
+        }
+        var metadataMap = targetMetadata.get(P);
+        if (IsUndefined(metadataMap)) {
+          if (!Create)
+            return void 0;
+          metadataMap = new _Map();
+          targetMetadata.set(P, metadataMap);
+        }
+        return metadataMap;
+      }
+      __name(GetOrCreateMetadataMap, "GetOrCreateMetadataMap");
+      function OrdinaryHasMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return true;
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryHasMetadata(MetadataKey, parent, P);
+        return false;
+      }
+      __name(OrdinaryHasMetadata, "OrdinaryHasMetadata");
+      function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return false;
+        return ToBoolean(metadataMap.has(MetadataKey));
+      }
+      __name(OrdinaryHasOwnMetadata, "OrdinaryHasOwnMetadata");
+      function OrdinaryGetMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryGetMetadata(MetadataKey, parent, P);
+        return void 0;
+      }
+      __name(OrdinaryGetMetadata, "OrdinaryGetMetadata");
+      function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return void 0;
+        return metadataMap.get(MetadataKey);
+      }
+      __name(OrdinaryGetOwnMetadata, "OrdinaryGetOwnMetadata");
+      function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          true
+        );
+        metadataMap.set(MetadataKey, MetadataValue);
+      }
+      __name(OrdinaryDefineOwnMetadata, "OrdinaryDefineOwnMetadata");
+      function OrdinaryMetadataKeys(O, P) {
+        var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (parent === null)
+          return ownKeys;
+        var parentKeys = OrdinaryMetadataKeys(parent, P);
+        if (parentKeys.length <= 0)
+          return ownKeys;
+        if (ownKeys.length <= 0)
+          return parentKeys;
+        var set = new _Set();
+        var keys = [];
+        for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
+          var key = ownKeys_1[_i];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
+          var key = parentKeys_1[_a];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        return keys;
+      }
+      __name(OrdinaryMetadataKeys, "OrdinaryMetadataKeys");
+      function OrdinaryOwnMetadataKeys(O, P) {
+        var keys = [];
+        var metadataMap = GetOrCreateMetadataMap(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(metadataMap))
+          return keys;
+        var keysObj = metadataMap.keys();
+        var iterator = GetIterator(keysObj);
+        var k = 0;
+        while (true) {
+          var next = IteratorStep(iterator);
+          if (!next) {
+            keys.length = k;
+            return keys;
+          }
+          var nextValue = IteratorValue(next);
+          try {
+            keys[k] = nextValue;
+          } catch (e) {
+            try {
+              IteratorClose(iterator);
+            } finally {
+              throw e;
+            }
+          }
+          k++;
+        }
+      }
+      __name(OrdinaryOwnMetadataKeys, "OrdinaryOwnMetadataKeys");
+      function Type(x) {
+        if (x === null)
+          return 1;
+        switch (typeof x) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return x === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      __name(Type, "Type");
+      function IsUndefined(x) {
+        return x === void 0;
+      }
+      __name(IsUndefined, "IsUndefined");
+      function IsNull(x) {
+        return x === null;
+      }
+      __name(IsNull, "IsNull");
+      function IsSymbol(x) {
+        return typeof x === "symbol";
+      }
+      __name(IsSymbol, "IsSymbol");
+      function IsObject(x) {
+        return typeof x === "object" ? x !== null : typeof x === "function";
+      }
+      __name(IsObject, "IsObject");
+      function ToPrimitive(input, PreferredType) {
+        switch (Type(input)) {
+          case 0:
+            return input;
+          case 1:
+            return input;
+          case 2:
+            return input;
+          case 3:
+            return input;
+          case 4:
+            return input;
+          case 5:
+            return input;
+        }
+        var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+        var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+        if (exoticToPrim !== void 0) {
+          var result = exoticToPrim.call(input, hint);
+          if (IsObject(result))
+            throw new TypeError();
+          return result;
+        }
+        return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+      }
+      __name(ToPrimitive, "ToPrimitive");
+      function OrdinaryToPrimitive(O, hint) {
+        if (hint === "string") {
+          var toString_1 = O.toString;
+          if (IsCallable(toString_1)) {
+            var result = toString_1.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        } else {
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var toString_2 = O.toString;
+          if (IsCallable(toString_2)) {
+            var result = toString_2.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        }
+        throw new TypeError();
+      }
+      __name(OrdinaryToPrimitive, "OrdinaryToPrimitive");
+      function ToBoolean(argument) {
+        return !!argument;
+      }
+      __name(ToBoolean, "ToBoolean");
+      function ToString(argument) {
+        return "" + argument;
+      }
+      __name(ToString, "ToString");
+      function ToPropertyKey(argument) {
+        var key = ToPrimitive(
+          argument,
+          3
+          /* String */
+        );
+        if (IsSymbol(key))
+          return key;
+        return ToString(key);
+      }
+      __name(ToPropertyKey, "ToPropertyKey");
+      function IsArray(argument) {
+        return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+      }
+      __name(IsArray, "IsArray");
+      function IsCallable(argument) {
+        return typeof argument === "function";
+      }
+      __name(IsCallable, "IsCallable");
+      function IsConstructor(argument) {
+        return typeof argument === "function";
+      }
+      __name(IsConstructor, "IsConstructor");
+      function IsPropertyKey(argument) {
+        switch (Type(argument)) {
+          case 3:
+            return true;
+          case 4:
+            return true;
+          default:
+            return false;
+        }
+      }
+      __name(IsPropertyKey, "IsPropertyKey");
+      function GetMethod(V, P) {
+        var func = V[P];
+        if (func === void 0 || func === null)
+          return void 0;
+        if (!IsCallable(func))
+          throw new TypeError();
+        return func;
+      }
+      __name(GetMethod, "GetMethod");
+      function GetIterator(obj) {
+        var method = GetMethod(obj, iteratorSymbol);
+        if (!IsCallable(method))
+          throw new TypeError();
+        var iterator = method.call(obj);
+        if (!IsObject(iterator))
+          throw new TypeError();
+        return iterator;
+      }
+      __name(GetIterator, "GetIterator");
+      function IteratorValue(iterResult) {
+        return iterResult.value;
+      }
+      __name(IteratorValue, "IteratorValue");
+      function IteratorStep(iterator) {
+        var result = iterator.next();
+        return result.done ? false : result;
+      }
+      __name(IteratorStep, "IteratorStep");
+      function IteratorClose(iterator) {
+        var f = iterator["return"];
+        if (f)
+          f.call(iterator);
+      }
+      __name(IteratorClose, "IteratorClose");
+      function OrdinaryGetPrototypeOf(O) {
+        var proto = Object.getPrototypeOf(O);
+        if (typeof O !== "function" || O === functionPrototype)
+          return proto;
+        if (proto !== functionPrototype)
+          return proto;
+        var prototype = O.prototype;
+        var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+        if (prototypeProto == null || prototypeProto === Object.prototype)
+          return proto;
+        var constructor = prototypeProto.constructor;
+        if (typeof constructor !== "function")
+          return proto;
+        if (constructor === O)
+          return proto;
+        return constructor;
+      }
+      __name(OrdinaryGetPrototypeOf, "OrdinaryGetPrototypeOf");
+      function CreateMapPolyfill() {
+        var cacheSentinel = {};
+        var arraySentinel = [];
+        var MapIterator = (
+          /** @class */
+          (function() {
+            function MapIterator2(keys, values, selector) {
+              this._index = 0;
+              this._keys = keys;
+              this._values = values;
+              this._selector = selector;
+            }
+            __name(MapIterator2, "MapIterator");
+            MapIterator2.prototype["@@iterator"] = function() {
+              return this;
+            };
+            MapIterator2.prototype[iteratorSymbol] = function() {
+              return this;
+            };
+            MapIterator2.prototype.next = function() {
+              var index = this._index;
+              if (index >= 0 && index < this._keys.length) {
+                var result = this._selector(this._keys[index], this._values[index]);
+                if (index + 1 >= this._keys.length) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                } else {
+                  this._index++;
+                }
+                return { value: result, done: false };
+              }
+              return { value: void 0, done: true };
+            };
+            MapIterator2.prototype.throw = function(error) {
+              if (this._index >= 0) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              }
+              throw error;
+            };
+            MapIterator2.prototype.return = function(value) {
+              if (this._index >= 0) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              }
+              return { value, done: true };
+            };
+            return MapIterator2;
+          })()
+        );
+        return (
+          /** @class */
+          (function() {
+            function Map2() {
+              this._keys = [];
+              this._values = [];
+              this._cacheKey = cacheSentinel;
+              this._cacheIndex = -2;
+            }
+            __name(Map2, "Map");
+            Object.defineProperty(Map2.prototype, "size", {
+              get: /* @__PURE__ */ __name(function() {
+                return this._keys.length;
+              }, "get"),
+              enumerable: true,
+              configurable: true
+            });
+            Map2.prototype.has = function(key) {
+              return this._find(
+                key,
+                /*insert*/
+                false
+              ) >= 0;
+            };
+            Map2.prototype.get = function(key) {
+              var index = this._find(
+                key,
+                /*insert*/
+                false
+              );
+              return index >= 0 ? this._values[index] : void 0;
+            };
+            Map2.prototype.set = function(key, value) {
+              var index = this._find(
+                key,
+                /*insert*/
+                true
+              );
+              this._values[index] = value;
+              return this;
+            };
+            Map2.prototype.delete = function(key) {
+              var index = this._find(
+                key,
+                /*insert*/
+                false
+              );
+              if (index >= 0) {
+                var size = this._keys.length;
+                for (var i = index + 1; i < size; i++) {
+                  this._keys[i - 1] = this._keys[i];
+                  this._values[i - 1] = this._values[i];
+                }
+                this._keys.length--;
+                this._values.length--;
+                if (key === this._cacheKey) {
+                  this._cacheKey = cacheSentinel;
+                  this._cacheIndex = -2;
+                }
+                return true;
+              }
+              return false;
+            };
+            Map2.prototype.clear = function() {
+              this._keys.length = 0;
+              this._values.length = 0;
+              this._cacheKey = cacheSentinel;
+              this._cacheIndex = -2;
+            };
+            Map2.prototype.keys = function() {
+              return new MapIterator(this._keys, this._values, getKey);
+            };
+            Map2.prototype.values = function() {
+              return new MapIterator(this._keys, this._values, getValue);
+            };
+            Map2.prototype.entries = function() {
+              return new MapIterator(this._keys, this._values, getEntry);
+            };
+            Map2.prototype["@@iterator"] = function() {
+              return this.entries();
+            };
+            Map2.prototype[iteratorSymbol] = function() {
+              return this.entries();
+            };
+            Map2.prototype._find = function(key, insert) {
+              if (this._cacheKey !== key) {
+                this._cacheIndex = this._keys.indexOf(this._cacheKey = key);
+              }
+              if (this._cacheIndex < 0 && insert) {
+                this._cacheIndex = this._keys.length;
+                this._keys.push(key);
+                this._values.push(void 0);
+              }
+              return this._cacheIndex;
+            };
+            return Map2;
+          })()
+        );
+        function getKey(key, _) {
+          return key;
+        }
+        __name(getKey, "getKey");
+        function getValue(_, value) {
+          return value;
+        }
+        __name(getValue, "getValue");
+        function getEntry(key, value) {
+          return [key, value];
+        }
+        __name(getEntry, "getEntry");
+      }
+      __name(CreateMapPolyfill, "CreateMapPolyfill");
+      function CreateSetPolyfill() {
+        return (
+          /** @class */
+          (function() {
+            function Set2() {
+              this._map = new _Map();
+            }
+            __name(Set2, "Set");
+            Object.defineProperty(Set2.prototype, "size", {
+              get: /* @__PURE__ */ __name(function() {
+                return this._map.size;
+              }, "get"),
+              enumerable: true,
+              configurable: true
+            });
+            Set2.prototype.has = function(value) {
+              return this._map.has(value);
+            };
+            Set2.prototype.add = function(value) {
+              return this._map.set(value, value), this;
+            };
+            Set2.prototype.delete = function(value) {
+              return this._map.delete(value);
+            };
+            Set2.prototype.clear = function() {
+              this._map.clear();
+            };
+            Set2.prototype.keys = function() {
+              return this._map.keys();
+            };
+            Set2.prototype.values = function() {
+              return this._map.values();
+            };
+            Set2.prototype.entries = function() {
+              return this._map.entries();
+            };
+            Set2.prototype["@@iterator"] = function() {
+              return this.keys();
+            };
+            Set2.prototype[iteratorSymbol] = function() {
+              return this.keys();
+            };
+            return Set2;
+          })()
+        );
+      }
+      __name(CreateSetPolyfill, "CreateSetPolyfill");
+      function CreateWeakMapPolyfill() {
+        var UUID_SIZE = 16;
+        var keys = HashMap.create();
+        var rootKey = CreateUniqueKey();
+        return (
+          /** @class */
+          (function() {
+            function WeakMap2() {
+              this._key = CreateUniqueKey();
+            }
+            __name(WeakMap2, "WeakMap");
+            WeakMap2.prototype.has = function(target) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                false
+              );
+              return table !== void 0 ? HashMap.has(table, this._key) : false;
+            };
+            WeakMap2.prototype.get = function(target) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                false
+              );
+              return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+            };
+            WeakMap2.prototype.set = function(target, value) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                true
+              );
+              table[this._key] = value;
+              return this;
+            };
+            WeakMap2.prototype.delete = function(target) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                false
+              );
+              return table !== void 0 ? delete table[this._key] : false;
+            };
+            WeakMap2.prototype.clear = function() {
+              this._key = CreateUniqueKey();
+            };
+            return WeakMap2;
+          })()
+        );
+        function CreateUniqueKey() {
+          var key;
+          do
+            key = "@@WeakMap@@" + CreateUUID();
+          while (HashMap.has(keys, key));
+          keys[key] = true;
+          return key;
+        }
+        __name(CreateUniqueKey, "CreateUniqueKey");
+        function GetOrCreateWeakMapTable(target, create) {
+          if (!hasOwn.call(target, rootKey)) {
+            if (!create)
+              return void 0;
+            Object.defineProperty(target, rootKey, { value: HashMap.create() });
+          }
+          return target[rootKey];
+        }
+        __name(GetOrCreateWeakMapTable, "GetOrCreateWeakMapTable");
+        function FillRandomBytes(buffer, size) {
+          for (var i = 0; i < size; ++i)
+            buffer[i] = Math.random() * 255 | 0;
+          return buffer;
+        }
+        __name(FillRandomBytes, "FillRandomBytes");
+        function GenRandomBytes(size) {
+          if (typeof Uint8Array === "function") {
+            if (typeof crypto !== "undefined")
+              return crypto.getRandomValues(new Uint8Array(size));
+            if (typeof msCrypto !== "undefined")
+              return msCrypto.getRandomValues(new Uint8Array(size));
+            return FillRandomBytes(new Uint8Array(size), size);
+          }
+          return FillRandomBytes(new Array(size), size);
+        }
+        __name(GenRandomBytes, "GenRandomBytes");
+        function CreateUUID() {
+          var data = GenRandomBytes(UUID_SIZE);
+          data[6] = data[6] & 79 | 64;
+          data[8] = data[8] & 191 | 128;
+          var result = "";
+          for (var offset = 0; offset < UUID_SIZE; ++offset) {
+            var byte = data[offset];
+            if (offset === 4 || offset === 6 || offset === 8)
+              result += "-";
+            if (byte < 16)
+              result += "0";
+            result += byte.toString(16).toLowerCase();
+          }
+          return result;
+        }
+        __name(CreateUUID, "CreateUUID");
+      }
+      __name(CreateWeakMapPolyfill, "CreateWeakMapPolyfill");
+      function MakeDictionary(obj) {
+        obj.__ = void 0;
+        delete obj.__;
+        return obj;
+      }
+      __name(MakeDictionary, "MakeDictionary");
+    });
+  })(Reflect2 || (Reflect2 = {}));
+  return _Reflect;
+}
+__name(require_Reflect, "require_Reflect");
+export {
+  require_Reflect as __require
+};
+//# sourceMappingURL=Reflect.js.map