assemblerjs 1.1.12 → 1.1.13

package/dist/index43.js

@@ -2,33 +2,946 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-class SingletonStrategy {
-    resolve(t, e) {
-        const n = t.identifier;
-        if (this.cache.has(n)) {
-            return this.cache.get(n);
-        }
-        const o = t.build(e);
-        const r = e ? {
-            ...t.configuration,
-            ...e
-        } : t.configuration;
-        t.setSingletonInstance(o, r);
-        this.cache.set(n, o);
-        t.privateContext.prepareInitHook(o, t.configuration);
-        return o;
-    }
-    constructor(){
-        this.cache = new Map();
-    }
-}
-class TransientStrategy {
-    resolve(t, e) {
-        const n = t.build(e);
-        t.privateContext.prepareInitHook(n, t.configuration);
-        return n;
-    }
+const _commonjsHelpers = require('./index44.js');
+const Reflect = require('./index45.js');
+
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+var hasRequired_Reflect;
+
+function require_Reflect () {
+	if (hasRequired_Reflect) return Reflect.__exports;
+	hasRequired_Reflect = 1;
+	var e;
+	(function(e) {
+	    (function(t) {
+	        var r = typeof globalThis === "object" ? globalThis : typeof _commonjsHelpers.commonjsGlobal === "object" ? _commonjsHelpers.commonjsGlobal : typeof self === "object" ? self : typeof this === "object" ? this : f();
+	        var n = i(e);
+	        if (typeof r.Reflect !== "undefined") {
+	            n = i(r.Reflect, n);
+	        }
+	        t(n, r);
+	        if (typeof r.Reflect === "undefined") {
+	            r.Reflect = e;
+	        }
+	        function i(e, t) {
+	            return function(r, n) {
+	                Object.defineProperty(e, r, {
+	                    configurable: true,
+	                    writable: true,
+	                    value: n
+	                });
+	                if (t) t(r, n);
+	            };
+	        }
+	        function a() {
+	            try {
+	                return Function("return this;")();
+	            } catch (e) {}
+	        }
+	        function u() {
+	            try {
+	                return (0, eval)("(function() { return this; })()");
+	            } catch (e) {}
+	        }
+	        function f() {
+	            return a() || u();
+	        }
+	    })(function(e, t) {
+	        var r = Object.prototype.hasOwnProperty;
+	        var n = typeof Symbol === "function";
+	        var i = n && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+	        var a = n && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+	        var u = typeof Object.create === "function";
+	        var f = ({
+	            __proto__: []
+	        }) instanceof Array;
+	        var o = !u && !f;
+	        var s = {
+	            create: u ? function() {
+	                return el(Object.create(null));
+	            } : f ? function() {
+	                return el({
+	                    __proto__: null
+	                });
+	            } : function() {
+	                return el({});
+	            },
+	            has: o ? function(e, t) {
+	                return r.call(e, t);
+	            } : function(e, t) {
+	                return t in e;
+	            },
+	            get: o ? function(e, t) {
+	                return r.call(e, t) ? e[t] : undefined;
+	            } : function(e, t) {
+	                return e[t];
+	            }
+	        };
+	        var c = Object.getPrototypeOf(Function);
+	        var l = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : eo();
+	        var d = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : es();
+	        var h = typeof WeakMap === "function" ? WeakMap : ec();
+	        var y = n ? Symbol.for("@reflect-metadata:registry") : undefined;
+	        var v = ei();
+	        var p = ea(v);
+	        function w(e, t, r, n) {
+	            if (!D(r)) {
+	                if (!B(e)) throw new TypeError();
+	                if (!G(t)) throw new TypeError();
+	                if (!G(n) && !D(n) && !C(n)) throw new TypeError();
+	                if (C(n)) n = undefined;
+	                r = q(r);
+	                return j(e, t, r, n);
+	            } else {
+	                if (!B(e)) throw new TypeError();
+	                if (!N(t)) throw new TypeError();
+	                return P(e, t);
+	            }
+	        }
+	        e("decorate", w);
+	        function _(e, t) {
+	            function r(r, n) {
+	                if (!G(r)) throw new TypeError();
+	                if (!D(n) && !Q(n)) throw new TypeError();
+	                A(e, t, r, n);
+	            }
+	            return r;
+	        }
+	        e("metadata", _);
+	        function g(e, t, r, n) {
+	            if (!G(r)) throw new TypeError();
+	            if (!D(n)) n = q(n);
+	            return A(e, t, r, n);
+	        }
+	        e("defineMetadata", g);
+	        function b(e, t, r) {
+	            if (!G(t)) throw new TypeError();
+	            if (!D(r)) r = q(r);
+	            return x(e, t, r);
+	        }
+	        e("hasMetadata", b);
+	        function O(e, t, r) {
+	            if (!G(t)) throw new TypeError();
+	            if (!D(r)) r = q(r);
+	            return R(e, t, r);
+	        }
+	        e("hasOwnMetadata", O);
+	        function k(e, t, r) {
+	            if (!G(t)) throw new TypeError();
+	            if (!D(r)) r = q(r);
+	            return S(e, t, r);
+	        }
+	        e("getMetadata", k);
+	        function M(e, t, r) {
+	            if (!G(t)) throw new TypeError();
+	            if (!D(r)) r = q(r);
+	            return K(e, t, r);
+	        }
+	        e("getOwnMetadata", M);
+	        function m(e, t) {
+	            if (!G(e)) throw new TypeError();
+	            if (!D(t)) t = q(t);
+	            return I(e, t);
+	        }
+	        e("getMetadataKeys", m);
+	        function E(e, t) {
+	            if (!G(e)) throw new TypeError();
+	            if (!D(t)) t = q(t);
+	            return F(e, t);
+	        }
+	        e("getOwnMetadataKeys", E);
+	        function T(e, t, r) {
+	            if (!G(t)) throw new TypeError();
+	            if (!D(r)) r = q(r);
+	            if (!G(t)) throw new TypeError();
+	            if (!D(r)) r = q(r);
+	            var n = ef(t, r, false);
+	            if (D(n)) return false;
+	            return n.OrdinaryDeleteMetadata(e, t, r);
+	        }
+	        e("deleteMetadata", T);
+	        function P(e, t) {
+	            for(var r = e.length - 1; r >= 0; --r){
+	                var n = e[r];
+	                var i = n(t);
+	                if (!D(i) && !C(i)) {
+	                    if (!N(i)) throw new TypeError();
+	                    t = i;
+	                }
+	            }
+	            return t;
+	        }
+	        function j(e, t, r, n) {
+	            for(var i = e.length - 1; i >= 0; --i){
+	                var a = e[i];
+	                var u = a(t, r, n);
+	                if (!D(u) && !C(u)) {
+	                    if (!G(u)) throw new TypeError();
+	                    n = u;
+	                }
+	            }
+	            return n;
+	        }
+	        function x(e, t, r) {
+	            var n = R(e, t, r);
+	            if (n) return true;
+	            var i = er(t);
+	            if (!C(i)) return x(e, i, r);
+	            return false;
+	        }
+	        function R(e, t, r) {
+	            var n = ef(t, r, false);
+	            if (D(n)) return false;
+	            return V(n.OrdinaryHasOwnMetadata(e, t, r));
+	        }
+	        function S(e, t, r) {
+	            var n = R(e, t, r);
+	            if (n) return K(e, t, r);
+	            var i = er(t);
+	            if (!C(i)) return S(e, i, r);
+	            return undefined;
+	        }
+	        function K(e, t, r) {
+	            var n = ef(t, r, false);
+	            if (D(n)) return;
+	            return n.OrdinaryGetOwnMetadata(e, t, r);
+	        }
+	        function A(e, t, r, n) {
+	            var i = ef(r, n, true);
+	            i.OrdinaryDefineOwnMetadata(e, t, r, n);
+	        }
+	        function I(e, t) {
+	            var r = F(e, t);
+	            var n = er(e);
+	            if (n === null) return r;
+	            var i = I(n, t);
+	            if (i.length <= 0) return r;
+	            if (r.length <= 0) return i;
+	            var a = new d();
+	            var u = [];
+	            for(var f = 0, o = r; f < o.length; f++){
+	                var s = o[f];
+	                var c = a.has(s);
+	                if (!c) {
+	                    a.add(s);
+	                    u.push(s);
+	                }
+	            }
+	            for(var l = 0, h = i; l < h.length; l++){
+	                var s = h[l];
+	                var c = a.has(s);
+	                if (!c) {
+	                    a.add(s);
+	                    u.push(s);
+	                }
+	            }
+	            return u;
+	        }
+	        function F(e, t) {
+	            var r = ef(e, t, false);
+	            if (!r) {
+	                return [];
+	            }
+	            return r.OrdinaryOwnMetadataKeys(e, t);
+	        }
+	        function z(e) {
+	            if (e === null) return 1;
+	            switch(typeof e){
+	                case "undefined":
+	                    return 0;
+	                case "boolean":
+	                    return 2;
+	                case "string":
+	                    return 3;
+	                case "symbol":
+	                    return 4;
+	                case "number":
+	                    return 5;
+	                case "object":
+	                    return e === null ? 1 : 6;
+	                default:
+	                    return 6;
+	            }
+	        }
+	        function D(e) {
+	            return e === undefined;
+	        }
+	        function C(e) {
+	            return e === null;
+	        }
+	        function W(e) {
+	            return typeof e === "symbol";
+	        }
+	        function G(e) {
+	            return typeof e === "object" ? e !== null : typeof e === "function";
+	        }
+	        function H(e, t) {
+	            switch(z(e)){
+	                case 0:
+	                    return e;
+	                case 1:
+	                    return e;
+	                case 2:
+	                    return e;
+	                case 3:
+	                    return e;
+	                case 4:
+	                    return e;
+	                case 5:
+	                    return e;
+	            }
+	            var r = "string" ;
+	            var n = Y(e, i);
+	            if (n !== undefined) {
+	                var a = n.call(e, r);
+	                if (G(a)) throw new TypeError();
+	                return a;
+	            }
+	            return U(e);
+	        }
+	        function U(e, t) {
+	            var i, n, a; {
+	                var r = e.toString;
+	                if (J(r)) {
+	                    var n = r.call(e);
+	                    if (!G(n)) return n;
+	                }
+	                var i = e.valueOf;
+	                if (J(i)) {
+	                    var n = i.call(e);
+	                    if (!G(n)) return n;
+	                }
+	            }
+	            throw new TypeError();
+	        }
+	        function V(e) {
+	            return !!e;
+	        }
+	        function L(e) {
+	            return "" + e;
+	        }
+	        function q(e) {
+	            var t = H(e);
+	            if (W(t)) return t;
+	            return L(t);
+	        }
+	        function B(e) {
+	            return Array.isArray ? Array.isArray(e) : e instanceof Object ? e instanceof Array : Object.prototype.toString.call(e) === "[object Array]";
+	        }
+	        function J(e) {
+	            return typeof e === "function";
+	        }
+	        function N(e) {
+	            return typeof e === "function";
+	        }
+	        function Q(e) {
+	            switch(z(e)){
+	                case 3:
+	                    return true;
+	                case 4:
+	                    return true;
+	                default:
+	                    return false;
+	            }
+	        }
+	        function X(e, t) {
+	            return e === t || e !== e && t !== t;
+	        }
+	        function Y(e, t) {
+	            var r = e[t];
+	            if (r === undefined || r === null) return undefined;
+	            if (!J(r)) throw new TypeError();
+	            return r;
+	        }
+	        function Z(e) {
+	            var t = Y(e, a);
+	            if (!J(t)) throw new TypeError();
+	            var r = t.call(e);
+	            if (!G(r)) throw new TypeError();
+	            return r;
+	        }
+	        function $(e) {
+	            return e.value;
+	        }
+	        function ee(e) {
+	            var t = e.next();
+	            return t.done ? false : t;
+	        }
+	        function et(e) {
+	            var t = e["return"];
+	            if (t) t.call(e);
+	        }
+	        function er(e) {
+	            var t = Object.getPrototypeOf(e);
+	            if (typeof e !== "function" || e === c) return t;
+	            if (t !== c) return t;
+	            var r = e.prototype;
+	            var n = r && Object.getPrototypeOf(r);
+	            if (n == null || n === Object.prototype) return t;
+	            var i = n.constructor;
+	            if (typeof i !== "function") return t;
+	            if (i === e) return t;
+	            return i;
+	        }
+	        function en() {
+	            var e;
+	            if (!D(y) && typeof t.Reflect !== "undefined" && !(y in t.Reflect) && typeof t.Reflect.defineMetadata === "function") {
+	                e = eu(t.Reflect);
+	            }
+	            var r;
+	            var n;
+	            var i;
+	            var a = new h();
+	            var u = {
+	                registerProvider: f,
+	                getProvider: s,
+	                setProvider: v
+	            };
+	            return u;
+	            function f(t) {
+	                if (!Object.isExtensible(u)) {
+	                    throw new Error("Cannot add provider to a frozen registry.");
+	                }
+	                switch(true){
+	                    case e === t:
+	                        break;
+	                    case D(r):
+	                        r = t;
+	                        break;
+	                    case r === t:
+	                        break;
+	                    case D(n):
+	                        n = t;
+	                        break;
+	                    case n === t:
+	                        break;
+	                    default:
+	                        if (i === undefined) i = new d();
+	                        i.add(t);
+	                        break;
+	                }
+	            }
+	            function o(t, a) {
+	                if (!D(r)) {
+	                    if (r.isProviderFor(t, a)) return r;
+	                    if (!D(n)) {
+	                        if (n.isProviderFor(t, a)) return r;
+	                        if (!D(i)) {
+	                            var u = Z(i);
+	                            while(true){
+	                                var f = ee(u);
+	                                if (!f) {
+	                                    return undefined;
+	                                }
+	                                var o = $(f);
+	                                if (o.isProviderFor(t, a)) {
+	                                    et(u);
+	                                    return o;
+	                                }
+	                            }
+	                        }
+	                    }
+	                }
+	                if (!D(e) && e.isProviderFor(t, a)) {
+	                    return e;
+	                }
+	                return undefined;
+	            }
+	            function s(e, t) {
+	                var r = a.get(e);
+	                var n;
+	                if (!D(r)) {
+	                    n = r.get(t);
+	                }
+	                if (!D(n)) {
+	                    return n;
+	                }
+	                n = o(e, t);
+	                if (!D(n)) {
+	                    if (D(r)) {
+	                        r = new l();
+	                        a.set(e, r);
+	                    }
+	                    r.set(t, n);
+	                }
+	                return n;
+	            }
+	            function c(e) {
+	                if (D(e)) throw new TypeError();
+	                return r === e || n === e || !D(i) && i.has(e);
+	            }
+	            function v(e, t, r) {
+	                if (!c(r)) {
+	                    throw new Error("Metadata provider not registered.");
+	                }
+	                var n = s(e, t);
+	                if (n !== r) {
+	                    if (!D(n)) {
+	                        return false;
+	                    }
+	                    var i = a.get(e);
+	                    if (D(i)) {
+	                        i = new l();
+	                        a.set(e, i);
+	                    }
+	                    i.set(t, r);
+	                }
+	                return true;
+	            }
+	        }
+	        function ei() {
+	            var e;
+	            if (!D(y) && G(t.Reflect) && Object.isExtensible(t.Reflect)) {
+	                e = t.Reflect[y];
+	            }
+	            if (D(e)) {
+	                e = en();
+	            }
+	            if (!D(y) && G(t.Reflect) && Object.isExtensible(t.Reflect)) {
+	                Object.defineProperty(t.Reflect, y, {
+	                    enumerable: false,
+	                    configurable: false,
+	                    writable: false,
+	                    value: e
+	                });
+	            }
+	            return e;
+	        }
+	        function ea(e) {
+	            var t = new h();
+	            var r = {
+	                isProviderFor: function(e, r) {
+	                    var n = t.get(e);
+	                    if (D(n)) return false;
+	                    return n.has(r);
+	                },
+	                OrdinaryDefineOwnMetadata: u,
+	                OrdinaryHasOwnMetadata: i,
+	                OrdinaryGetOwnMetadata: a,
+	                OrdinaryOwnMetadataKeys: f,
+	                OrdinaryDeleteMetadata: o
+	            };
+	            v.registerProvider(r);
+	            return r;
+	            function n(n, i, a) {
+	                var u = t.get(n);
+	                var f = false;
+	                if (D(u)) {
+	                    if (!a) return undefined;
+	                    u = new l();
+	                    t.set(n, u);
+	                    f = true;
+	                }
+	                var o = u.get(i);
+	                if (D(o)) {
+	                    if (!a) return undefined;
+	                    o = new l();
+	                    u.set(i, o);
+	                    if (!e.setProvider(n, i, r)) {
+	                        u.delete(i);
+	                        if (f) {
+	                            t.delete(n);
+	                        }
+	                        throw new Error("Wrong provider for target.");
+	                    }
+	                }
+	                return o;
+	            }
+	            function i(e, t, r) {
+	                var i = n(t, r, false);
+	                if (D(i)) return false;
+	                return V(i.has(e));
+	            }
+	            function a(e, t, r) {
+	                var i = n(t, r, false);
+	                if (D(i)) return undefined;
+	                return i.get(e);
+	            }
+	            function u(e, t, r, i) {
+	                var a = n(r, i, true);
+	                a.set(e, t);
+	            }
+	            function f(e, t) {
+	                var r = [];
+	                var i = n(e, t, false);
+	                if (D(i)) return r;
+	                var a = i.keys();
+	                var u = Z(a);
+	                var f = 0;
+	                while(true){
+	                    var o = ee(u);
+	                    if (!o) {
+	                        r.length = f;
+	                        return r;
+	                    }
+	                    var s = $(o);
+	                    try {
+	                        r[f] = s;
+	                    } catch (e) {
+	                        try {
+	                            et(u);
+	                        } finally{
+	                            throw e;
+	                        }
+	                    }
+	                    f++;
+	                }
+	            }
+	            function o(e, r, i) {
+	                var a = n(r, i, false);
+	                if (D(a)) return false;
+	                if (!a.delete(e)) return false;
+	                if (a.size === 0) {
+	                    var u = t.get(r);
+	                    if (!D(u)) {
+	                        u.delete(i);
+	                        if (u.size === 0) {
+	                            t.delete(u);
+	                        }
+	                    }
+	                }
+	                return true;
+	            }
+	        }
+	        function eu(e) {
+	            var t = e.defineMetadata, r = e.hasOwnMetadata, n = e.getOwnMetadata, i = e.getOwnMetadataKeys, a = e.deleteMetadata;
+	            var u = new h();
+	            var f = {
+	                isProviderFor: function(e, t) {
+	                    var r = u.get(e);
+	                    if (!D(r) && r.has(t)) {
+	                        return true;
+	                    }
+	                    if (i(e, t).length) {
+	                        if (D(r)) {
+	                            r = new d();
+	                            u.set(e, r);
+	                        }
+	                        r.add(t);
+	                        return true;
+	                    }
+	                    return false;
+	                },
+	                OrdinaryDefineOwnMetadata: t,
+	                OrdinaryHasOwnMetadata: r,
+	                OrdinaryGetOwnMetadata: n,
+	                OrdinaryOwnMetadataKeys: i,
+	                OrdinaryDeleteMetadata: a
+	            };
+	            return f;
+	        }
+	        function ef(e, t, r) {
+	            var n = v.getProvider(e, t);
+	            if (!D(n)) {
+	                return n;
+	            }
+	            if (r) {
+	                if (v.setProvider(e, t, p)) {
+	                    return p;
+	                }
+	                throw new Error("Illegal state.");
+	            }
+	            return undefined;
+	        }
+	        function eo() {
+	            var e = {};
+	            var t = [];
+	            var r = function() {
+	                function e(e, t, r) {
+	                    this._index = 0;
+	                    this._keys = e;
+	                    this._values = t;
+	                    this._selector = r;
+	                }
+	                e.prototype["@@iterator"] = function() {
+	                    return this;
+	                };
+	                e.prototype[a] = function() {
+	                    return this;
+	                };
+	                e.prototype.next = function() {
+	                    var e = this._index;
+	                    if (e >= 0 && e < this._keys.length) {
+	                        var r = this._selector(this._keys[e], this._values[e]);
+	                        if (e + 1 >= this._keys.length) {
+	                            this._index = -1;
+	                            this._keys = t;
+	                            this._values = t;
+	                        } else {
+	                            this._index++;
+	                        }
+	                        return {
+	                            value: r,
+	                            done: false
+	                        };
+	                    }
+	                    return {
+	                        value: undefined,
+	                        done: true
+	                    };
+	                };
+	                e.prototype.throw = function(e) {
+	                    if (this._index >= 0) {
+	                        this._index = -1;
+	                        this._keys = t;
+	                        this._values = t;
+	                    }
+	                    throw e;
+	                };
+	                e.prototype.return = function(e) {
+	                    if (this._index >= 0) {
+	                        this._index = -1;
+	                        this._keys = t;
+	                        this._values = t;
+	                    }
+	                    return {
+	                        value: e,
+	                        done: true
+	                    };
+	                };
+	                return e;
+	            }();
+	            var n = function() {
+	                function t() {
+	                    this._keys = [];
+	                    this._values = [];
+	                    this._cacheKey = e;
+	                    this._cacheIndex = -2;
+	                }
+	                Object.defineProperty(t.prototype, "size", {
+	                    get: function() {
+	                        return this._keys.length;
+	                    },
+	                    enumerable: true,
+	                    configurable: true
+	                });
+	                t.prototype.has = function(e) {
+	                    return this._find(e, false) >= 0;
+	                };
+	                t.prototype.get = function(e) {
+	                    var t = this._find(e, false);
+	                    return t >= 0 ? this._values[t] : undefined;
+	                };
+	                t.prototype.set = function(e, t) {
+	                    var r = this._find(e, true);
+	                    this._values[r] = t;
+	                    return this;
+	                };
+	                t.prototype.delete = function(t) {
+	                    var r = this._find(t, false);
+	                    if (r >= 0) {
+	                        var n = this._keys.length;
+	                        for(var i = r + 1; i < n; i++){
+	                            this._keys[i - 1] = this._keys[i];
+	                            this._values[i - 1] = this._values[i];
+	                        }
+	                        this._keys.length--;
+	                        this._values.length--;
+	                        if (X(t, this._cacheKey)) {
+	                            this._cacheKey = e;
+	                            this._cacheIndex = -2;
+	                        }
+	                        return true;
+	                    }
+	                    return false;
+	                };
+	                t.prototype.clear = function() {
+	                    this._keys.length = 0;
+	                    this._values.length = 0;
+	                    this._cacheKey = e;
+	                    this._cacheIndex = -2;
+	                };
+	                t.prototype.keys = function() {
+	                    return new r(this._keys, this._values, i);
+	                };
+	                t.prototype.values = function() {
+	                    return new r(this._keys, this._values, u);
+	                };
+	                t.prototype.entries = function() {
+	                    return new r(this._keys, this._values, f);
+	                };
+	                t.prototype["@@iterator"] = function() {
+	                    return this.entries();
+	                };
+	                t.prototype[a] = function() {
+	                    return this.entries();
+	                };
+	                t.prototype._find = function(e, t) {
+	                    if (!X(this._cacheKey, e)) {
+	                        this._cacheIndex = -1;
+	                        for(var r = 0; r < this._keys.length; r++){
+	                            if (X(this._keys[r], e)) {
+	                                this._cacheIndex = r;
+	                                break;
+	                            }
+	                        }
+	                    }
+	                    if (this._cacheIndex < 0 && t) {
+	                        this._cacheIndex = this._keys.length;
+	                        this._keys.push(e);
+	                        this._values.push(undefined);
+	                    }
+	                    return this._cacheIndex;
+	                };
+	                return t;
+	            }();
+	            return n;
+	            function i(e, t) {
+	                return e;
+	            }
+	            function u(e, t) {
+	                return t;
+	            }
+	            function f(e, t) {
+	                return [
+	                    e,
+	                    t
+	                ];
+	            }
+	        }
+	        function es() {
+	            var e = function() {
+	                function e() {
+	                    this._map = new l();
+	                }
+	                Object.defineProperty(e.prototype, "size", {
+	                    get: function() {
+	                        return this._map.size;
+	                    },
+	                    enumerable: true,
+	                    configurable: true
+	                });
+	                e.prototype.has = function(e) {
+	                    return this._map.has(e);
+	                };
+	                e.prototype.add = function(e) {
+	                    return this._map.set(e, e), this;
+	                };
+	                e.prototype.delete = function(e) {
+	                    return this._map.delete(e);
+	                };
+	                e.prototype.clear = function() {
+	                    this._map.clear();
+	                };
+	                e.prototype.keys = function() {
+	                    return this._map.keys();
+	                };
+	                e.prototype.values = function() {
+	                    return this._map.keys();
+	                };
+	                e.prototype.entries = function() {
+	                    return this._map.entries();
+	                };
+	                e.prototype["@@iterator"] = function() {
+	                    return this.keys();
+	                };
+	                e.prototype[a] = function() {
+	                    return this.keys();
+	                };
+	                return e;
+	            }();
+	            return e;
+	        }
+	        function ec() {
+	            var e = 16;
+	            var t = s.create();
+	            var n = i();
+	            return function() {
+	                function e() {
+	                    this._key = i();
+	                }
+	                e.prototype.has = function(e) {
+	                    var t = a(e, false);
+	                    return t !== undefined ? s.has(t, this._key) : false;
+	                };
+	                e.prototype.get = function(e) {
+	                    var t = a(e, false);
+	                    return t !== undefined ? s.get(t, this._key) : undefined;
+	                };
+	                e.prototype.set = function(e, t) {
+	                    var r = a(e, true);
+	                    r[this._key] = t;
+	                    return this;
+	                };
+	                e.prototype.delete = function(e) {
+	                    var t = a(e, false);
+	                    return t !== undefined ? delete t[this._key] : false;
+	                };
+	                e.prototype.clear = function() {
+	                    this._key = i();
+	                };
+	                return e;
+	            }();
+	            function i() {
+	                var e;
+	                do e = "@@WeakMap@@" + o();
+	                while (s.has(t, e))
+	                t[e] = true;
+	                return e;
+	            }
+	            function a(e, t) {
+	                if (!r.call(e, n)) {
+	                    if (!t) return undefined;
+	                    Object.defineProperty(e, n, {
+	                        value: s.create()
+	                    });
+	                }
+	                return e[n];
+	            }
+	            function u(e, t) {
+	                for(var r = 0; r < t; ++r)e[r] = Math.random() * 0xff | 0;
+	                return e;
+	            }
+	            function f(e) {
+	                if (typeof Uint8Array === "function") {
+	                    var t = new Uint8Array(e);
+	                    if (typeof crypto !== "undefined") {
+	                        crypto.getRandomValues(t);
+	                    } else if (typeof msCrypto !== "undefined") {
+	                        msCrypto.getRandomValues(t);
+	                    } else {
+	                        u(t, e);
+	                    }
+	                    return t;
+	                }
+	                return u(new Array(e), e);
+	            }
+	            function o() {
+	                var t = f(e);
+	                t[6] = t[6] & 0x4f | 0x40;
+	                t[8] = t[8] & 0xbf | 0x80;
+	                var r = "";
+	                for(var n = 0; n < e; ++n){
+	                    var i = t[n];
+	                    if (n === 4 || n === 6 || n === 8) r += "-";
+	                    if (i < 16) r += "0";
+	                    r += i.toString(16).toLowerCase();
+	                }
+	                return r;
+	            }
+	        }
+	        function el(e) {
+	            e.__ = undefined;
+	            delete e.__;
+	            return e;
+	        }
+	    });
+	})(e || (e = {}));
+	return Reflect.__exports;
 }
 
-exports.SingletonStrategy = SingletonStrategy;
-exports.TransientStrategy = TransientStrategy;
+exports.__require = require_Reflect;