first commit

node_modules/tsyringe/dist/esm5/decorators/auto-injectable.js

@@ -0,0 +1,48 @@
+import { __extends, __read, __spread } from "tslib";
+import { getParamInfo } from "../reflection-helpers";
+import { instance as globalContainer } from "../dependency-container";
+import { isTokenDescriptor, isTransformDescriptor } from "../providers/injection-token";
+import { formatErrorCtor } from "../error-helpers";
+function autoInjectable() {
+    return function (target) {
+        var paramInfo = getParamInfo(target);
+        return (function (_super) {
+            __extends(class_1, _super);
+            function class_1() {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return _super.apply(this, __spread(args.concat(paramInfo.slice(args.length).map(function (type, index) {
+                    var _a, _b, _c;
+                    try {
+                        if (isTokenDescriptor(type)) {
+                            if (isTransformDescriptor(type)) {
+                                return type.multiple
+                                    ? (_a = globalContainer
+                                        .resolve(type.transform)).transform.apply(_a, __spread([globalContainer.resolveAll(type.token)], type.transformArgs)) : (_b = globalContainer
+                                    .resolve(type.transform)).transform.apply(_b, __spread([globalContainer.resolve(type.token)], type.transformArgs));
+                            }
+                            else {
+                                return type.multiple
+                                    ? globalContainer.resolveAll(type.token)
+                                    : globalContainer.resolve(type.token);
+                            }
+                        }
+                        else if (isTransformDescriptor(type)) {
+                            return (_c = globalContainer
+                                .resolve(type.transform)).transform.apply(_c, __spread([globalContainer.resolve(type.token)], type.transformArgs));
+                        }
+                        return globalContainer.resolve(type);
+                    }
+                    catch (e) {
+                        var argIndex = index + args.length;
+                        throw new Error(formatErrorCtor(target, argIndex, e));
+                    }
+                })))) || this;
+            }
+            return class_1;
+        }(target));
+    };
+}
+export default autoInjectable;

node_modules/tsyringe/dist/esm5/decorators/index.js

@@ -0,0 +1,9 @@
+export { default as autoInjectable } from "./auto-injectable";
+export { default as inject } from "./inject";
+export { default as injectable } from "./injectable";
+export { default as registry } from "./registry";
+export { default as singleton } from "./singleton";
+export { default as injectAll } from "./inject-all";
+export { default as injectAllWithTransform } from "./inject-all-with-transform";
+export { default as injectWithTransform } from "./inject-with-transform";
+export { default as scoped } from "./scoped";

node_modules/tsyringe/dist/esm5/decorators/inject-all-with-transform.js

@@ -0,0 +1,15 @@
+import { defineInjectionTokenMetadata } from "../reflection-helpers";
+function injectAllWithTransform(token, transformer) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    var data = {
+        token: token,
+        multiple: true,
+        transform: transformer,
+        transformArgs: args
+    };
+    return defineInjectionTokenMetadata(data);
+}
+export default injectAllWithTransform;

node_modules/tsyringe/dist/esm5/decorators/inject-all.js

@@ -0,0 +1,10 @@
+import { defineInjectionTokenMetadata } from "../reflection-helpers";
+function injectAll(token, options) {
+    var data = {
+        token: token,
+        multiple: true,
+        isOptional: options && options.isOptional
+    };
+    return defineInjectionTokenMetadata(data);
+}
+export default injectAll;

node_modules/tsyringe/dist/esm5/decorators/inject-with-transform.js

@@ -0,0 +1,12 @@
+import { defineInjectionTokenMetadata } from "../reflection-helpers";
+function injectWithTransform(token, transformer) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return defineInjectionTokenMetadata(token, {
+        transformToken: transformer,
+        args: args
+    });
+}
+export default injectWithTransform;

node_modules/tsyringe/dist/esm5/decorators/inject.js

@@ -0,0 +1,10 @@
+import { defineInjectionTokenMetadata } from "../reflection-helpers";
+function inject(token, options) {
+    var data = {
+        token: token,
+        multiple: false,
+        isOptional: options && options.isOptional
+    };
+    return defineInjectionTokenMetadata(data);
+}
+export default inject;

node_modules/tsyringe/dist/esm5/decorators/injectable.js

@@ -0,0 +1,19 @@
+import { getParamInfo } from "../reflection-helpers";
+import { typeInfo } from "../dependency-container";
+import { instance as globalContainer } from "../dependency-container";
+function injectable(options) {
+    return function (target) {
+        typeInfo.set(target, getParamInfo(target));
+        if (options && options.token) {
+            if (!Array.isArray(options.token)) {
+                globalContainer.register(options.token, target);
+            }
+            else {
+                options.token.forEach(function (token) {
+                    globalContainer.register(token, target);
+                });
+            }
+        }
+    };
+}
+export default injectable;

node_modules/tsyringe/dist/esm5/decorators/registry.js

@@ -0,0 +1,13 @@
+import { __rest } from "tslib";
+import { instance as globalContainer } from "../dependency-container";
+function registry(registrations) {
+    if (registrations === void 0) { registrations = []; }
+    return function (target) {
+        registrations.forEach(function (_a) {
+            var token = _a.token, options = _a.options, provider = __rest(_a, ["token", "options"]);
+            return globalContainer.register(token, provider, options);
+        });
+        return target;
+    };
+}
+export default registry;

node_modules/tsyringe/dist/esm5/decorators/scoped.js

@@ -0,0 +1,10 @@
+import injectable from "./injectable";
+import { instance as globalContainer } from "../dependency-container";
+export default function scoped(lifecycle, token) {
+    return function (target) {
+        injectable()(target);
+        globalContainer.register(token || target, target, {
+            lifecycle: lifecycle
+        });
+    };
+}

node_modules/tsyringe/dist/esm5/decorators/singleton.js

@@ -0,0 +1,9 @@
+import injectable from "./injectable";
+import { instance as globalContainer } from "../dependency-container";
+function singleton() {
+    return function (target) {
+        injectable()(target);
+        globalContainer.registerSingleton(target);
+    };
+}
+export default singleton;

node_modules/tsyringe/dist/esm5/dependency-container.js

@@ -0,0 +1,410 @@
+import { __awaiter, __generator, __read, __spread, __values } from "tslib";
+import { isClassProvider, isFactoryProvider, isNormalToken, isTokenProvider, isValueProvider } from "./providers";
+import { isProvider } from "./providers/provider";
+import { isConstructorToken, isTokenDescriptor, isTransformDescriptor } from "./providers/injection-token";
+import Registry from "./registry";
+import Lifecycle from "./types/lifecycle";
+import ResolutionContext from "./resolution-context";
+import { formatErrorCtor } from "./error-helpers";
+import { DelayedConstructor } from "./lazy-helpers";
+import { isDisposable } from "./types/disposable";
+import Interceptors from "./interceptors";
+export var typeInfo = new Map();
+var InternalDependencyContainer = (function () {
+    function InternalDependencyContainer(parent) {
+        this.parent = parent;
+        this._registry = new Registry();
+        this.interceptors = new Interceptors();
+        this.disposed = false;
+        this.disposables = new Set();
+    }
+    InternalDependencyContainer.prototype.register = function (token, providerOrConstructor, options) {
+        if (options === void 0) { options = { lifecycle: Lifecycle.Transient }; }
+        this.ensureNotDisposed();
+        var provider;
+        if (!isProvider(providerOrConstructor)) {
+            provider = { useClass: providerOrConstructor };
+        }
+        else {
+            provider = providerOrConstructor;
+        }
+        if (isTokenProvider(provider)) {
+            var path = [token];
+            var tokenProvider = provider;
+            while (tokenProvider != null) {
+                var currentToken = tokenProvider.useToken;
+                if (path.includes(currentToken)) {
+                    throw new Error("Token registration cycle detected! " + __spread(path, [currentToken]).join(" -> "));
+                }
+                path.push(currentToken);
+                var registration = this._registry.get(currentToken);
+                if (registration && isTokenProvider(registration.provider)) {
+                    tokenProvider = registration.provider;
+                }
+                else {
+                    tokenProvider = null;
+                }
+            }
+        }
+        if (options.lifecycle === Lifecycle.Singleton ||
+            options.lifecycle == Lifecycle.ContainerScoped ||
+            options.lifecycle == Lifecycle.ResolutionScoped) {
+            if (isValueProvider(provider) || isFactoryProvider(provider)) {
+                throw new Error("Cannot use lifecycle \"" + Lifecycle[options.lifecycle] + "\" with ValueProviders or FactoryProviders");
+            }
+        }
+        this._registry.set(token, { provider: provider, options: options });
+        return this;
+    };
+    InternalDependencyContainer.prototype.registerType = function (from, to) {
+        this.ensureNotDisposed();
+        if (isNormalToken(to)) {
+            return this.register(from, {
+                useToken: to
+            });
+        }
+        return this.register(from, {
+            useClass: to
+        });
+    };
+    InternalDependencyContainer.prototype.registerInstance = function (token, instance) {
+        this.ensureNotDisposed();
+        return this.register(token, {
+            useValue: instance
+        });
+    };
+    InternalDependencyContainer.prototype.registerSingleton = function (from, to) {
+        this.ensureNotDisposed();
+        if (isNormalToken(from)) {
+            if (isNormalToken(to)) {
+                return this.register(from, {
+                    useToken: to
+                }, { lifecycle: Lifecycle.Singleton });
+            }
+            else if (to) {
+                return this.register(from, {
+                    useClass: to
+                }, { lifecycle: Lifecycle.Singleton });
+            }
+            throw new Error('Cannot register a type name as a singleton without a "to" token');
+        }
+        var useClass = from;
+        if (to && !isNormalToken(to)) {
+            useClass = to;
+        }
+        return this.register(from, {
+            useClass: useClass
+        }, { lifecycle: Lifecycle.Singleton });
+    };
+    InternalDependencyContainer.prototype.resolve = function (token, context, isOptional) {
+        if (context === void 0) { context = new ResolutionContext(); }
+        if (isOptional === void 0) { isOptional = false; }
+        this.ensureNotDisposed();
+        var registration = this.getRegistration(token);
+        if (!registration && isNormalToken(token)) {
+            if (isOptional) {
+                return undefined;
+            }
+            throw new Error("Attempted to resolve unregistered dependency token: \"" + token.toString() + "\"");
+        }
+        this.executePreResolutionInterceptor(token, "Single");
+        if (registration) {
+            var result = this.resolveRegistration(registration, context);
+            this.executePostResolutionInterceptor(token, result, "Single");
+            return result;
+        }
+        if (isConstructorToken(token)) {
+            var result = this.construct(token, context);
+            this.executePostResolutionInterceptor(token, result, "Single");
+            return result;
+        }
+        throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
+    };
+    InternalDependencyContainer.prototype.executePreResolutionInterceptor = function (token, resolutionType) {
+        var e_1, _a;
+        if (this.interceptors.preResolution.has(token)) {
+            var remainingInterceptors = [];
+            try {
+                for (var _b = __values(this.interceptors.preResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var interceptor = _c.value;
+                    if (interceptor.options.frequency != "Once") {
+                        remainingInterceptors.push(interceptor);
+                    }
+                    interceptor.callback(token, resolutionType);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            this.interceptors.preResolution.setAll(token, remainingInterceptors);
+        }
+    };
+    InternalDependencyContainer.prototype.executePostResolutionInterceptor = function (token, result, resolutionType) {
+        var e_2, _a;
+        if (this.interceptors.postResolution.has(token)) {
+            var remainingInterceptors = [];
+            try {
+                for (var _b = __values(this.interceptors.postResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var interceptor = _c.value;
+                    if (interceptor.options.frequency != "Once") {
+                        remainingInterceptors.push(interceptor);
+                    }
+                    interceptor.callback(token, result, resolutionType);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            this.interceptors.postResolution.setAll(token, remainingInterceptors);
+        }
+    };
+    InternalDependencyContainer.prototype.resolveRegistration = function (registration, context) {
+        this.ensureNotDisposed();
+        if (registration.options.lifecycle === Lifecycle.ResolutionScoped &&
+            context.scopedResolutions.has(registration)) {
+            return context.scopedResolutions.get(registration);
+        }
+        var isSingleton = registration.options.lifecycle === Lifecycle.Singleton;
+        var isContainerScoped = registration.options.lifecycle === Lifecycle.ContainerScoped;
+        var returnInstance = isSingleton || isContainerScoped;
+        var resolved;
+        if (isValueProvider(registration.provider)) {
+            resolved = registration.provider.useValue;
+        }
+        else if (isTokenProvider(registration.provider)) {
+            resolved = returnInstance
+                ? registration.instance ||
+                    (registration.instance = this.resolve(registration.provider.useToken, context))
+                : this.resolve(registration.provider.useToken, context);
+        }
+        else if (isClassProvider(registration.provider)) {
+            resolved = returnInstance
+                ? registration.instance ||
+                    (registration.instance = this.construct(registration.provider.useClass, context))
+                : this.construct(registration.provider.useClass, context);
+        }
+        else if (isFactoryProvider(registration.provider)) {
+            resolved = registration.provider.useFactory(this);
+        }
+        else {
+            resolved = this.construct(registration.provider, context);
+        }
+        if (registration.options.lifecycle === Lifecycle.ResolutionScoped) {
+            context.scopedResolutions.set(registration, resolved);
+        }
+        return resolved;
+    };
+    InternalDependencyContainer.prototype.resolveAll = function (token, context, isOptional) {
+        var _this = this;
+        if (context === void 0) { context = new ResolutionContext(); }
+        if (isOptional === void 0) { isOptional = false; }
+        this.ensureNotDisposed();
+        var registrations = this.getAllRegistrations(token);
+        if (!registrations && isNormalToken(token)) {
+            if (isOptional) {
+                return [];
+            }
+            throw new Error("Attempted to resolve unregistered dependency token: \"" + token.toString() + "\"");
+        }
+        this.executePreResolutionInterceptor(token, "All");
+        if (registrations) {
+            var result_1 = registrations.map(function (item) {
+                return _this.resolveRegistration(item, context);
+            });
+            this.executePostResolutionInterceptor(token, result_1, "All");
+            return result_1;
+        }
+        var result = [this.construct(token, context)];
+        this.executePostResolutionInterceptor(token, result, "All");
+        return result;
+    };
+    InternalDependencyContainer.prototype.isRegistered = function (token, recursive) {
+        if (recursive === void 0) { recursive = false; }
+        this.ensureNotDisposed();
+        return (this._registry.has(token) ||
+            (recursive &&
+                (this.parent || false) &&
+                this.parent.isRegistered(token, true)));
+    };
+    InternalDependencyContainer.prototype.reset = function () {
+        this.ensureNotDisposed();
+        this._registry.clear();
+        this.interceptors.preResolution.clear();
+        this.interceptors.postResolution.clear();
+    };
+    InternalDependencyContainer.prototype.clearInstances = function () {
+        var e_3, _a;
+        this.ensureNotDisposed();
+        try {
+            for (var _b = __values(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), token = _d[0], registrations = _d[1];
+                this._registry.setAll(token, registrations
+                    .filter(function (registration) { return !isValueProvider(registration.provider); })
+                    .map(function (registration) {
+                    registration.instance = undefined;
+                    return registration;
+                }));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    InternalDependencyContainer.prototype.createChildContainer = function () {
+        var e_4, _a;
+        this.ensureNotDisposed();
+        var childContainer = new InternalDependencyContainer(this);
+        try {
+            for (var _b = __values(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), token = _d[0], registrations = _d[1];
+                if (registrations.some(function (_a) {
+                    var options = _a.options;
+                    return options.lifecycle === Lifecycle.ContainerScoped;
+                })) {
+                    childContainer._registry.setAll(token, registrations.map(function (registration) {
+                        if (registration.options.lifecycle === Lifecycle.ContainerScoped) {
+                            return {
+                                provider: registration.provider,
+                                options: registration.options
+                            };
+                        }
+                        return registration;
+                    }));
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return childContainer;
+    };
+    InternalDependencyContainer.prototype.beforeResolution = function (token, callback, options) {
+        if (options === void 0) { options = { frequency: "Always" }; }
+        this.interceptors.preResolution.set(token, {
+            callback: callback,
+            options: options
+        });
+    };
+    InternalDependencyContainer.prototype.afterResolution = function (token, callback, options) {
+        if (options === void 0) { options = { frequency: "Always" }; }
+        this.interceptors.postResolution.set(token, {
+            callback: callback,
+            options: options
+        });
+    };
+    InternalDependencyContainer.prototype.dispose = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var promises;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.disposed = true;
+                        promises = [];
+                        this.disposables.forEach(function (disposable) {
+                            var maybePromise = disposable.dispose();
+                            if (maybePromise) {
+                                promises.push(maybePromise);
+                            }
+                        });
+                        return [4, Promise.all(promises)];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    InternalDependencyContainer.prototype.getRegistration = function (token) {
+        if (this.isRegistered(token)) {
+            return this._registry.get(token);
+        }
+        if (this.parent) {
+            return this.parent.getRegistration(token);
+        }
+        return null;
+    };
+    InternalDependencyContainer.prototype.getAllRegistrations = function (token) {
+        if (this.isRegistered(token)) {
+            return this._registry.getAll(token);
+        }
+        if (this.parent) {
+            return this.parent.getAllRegistrations(token);
+        }
+        return null;
+    };
+    InternalDependencyContainer.prototype.construct = function (ctor, context) {
+        var _this = this;
+        if (ctor instanceof DelayedConstructor) {
+            return ctor.createProxy(function (target) {
+                return _this.resolve(target, context);
+            });
+        }
+        var instance = (function () {
+            var paramInfo = typeInfo.get(ctor);
+            if (!paramInfo || paramInfo.length === 0) {
+                if (ctor.length === 0) {
+                    return new ctor();
+                }
+                else {
+                    throw new Error("TypeInfo not known for \"" + ctor.name + "\"");
+                }
+            }
+            var params = paramInfo.map(_this.resolveParams(context, ctor));
+            return new (ctor.bind.apply(ctor, __spread([void 0], params)))();
+        })();
+        if (isDisposable(instance)) {
+            this.disposables.add(instance);
+        }
+        return instance;
+    };
+    InternalDependencyContainer.prototype.resolveParams = function (context, ctor) {
+        var _this = this;
+        return function (param, idx) {
+            var _a, _b, _c;
+            try {
+                if (isTokenDescriptor(param)) {
+                    if (isTransformDescriptor(param)) {
+                        return param.multiple
+                            ? (_a = _this.resolve(param.transform)).transform.apply(_a, __spread([_this.resolveAll(param.token, new ResolutionContext(), param.isOptional)], param.transformArgs)) : (_b = _this.resolve(param.transform)).transform.apply(_b, __spread([_this.resolve(param.token, context, param.isOptional)], param.transformArgs));
+                    }
+                    else {
+                        return param.multiple
+                            ? _this.resolveAll(param.token, new ResolutionContext(), param.isOptional)
+                            : _this.resolve(param.token, context, param.isOptional);
+                    }
+                }
+                else if (isTransformDescriptor(param)) {
+                    return (_c = _this.resolve(param.transform, context)).transform.apply(_c, __spread([_this.resolve(param.token, context)], param.transformArgs));
+                }
+                return _this.resolve(param, context);
+            }
+            catch (e) {
+                throw new Error(formatErrorCtor(ctor, idx, e));
+            }
+        };
+    };
+    InternalDependencyContainer.prototype.ensureNotDisposed = function () {
+        if (this.disposed) {
+            throw new Error("This container has been disposed, you cannot interact with a disposed container");
+        }
+    };
+    return InternalDependencyContainer;
+}());
+export var instance = new InternalDependencyContainer();
+export default instance;

node_modules/tsyringe/dist/esm5/error-helpers.js

@@ -0,0 +1,17 @@
+import { __read, __spread } from "tslib";
+function formatDependency(params, idx) {
+    if (params === null) {
+        return "at position #" + idx;
+    }
+    var argName = params.split(",")[idx].trim();
+    return "\"" + argName + "\" at position #" + idx;
+}
+function composeErrorMessage(msg, e, indent) {
+    if (indent === void 0) { indent = "    "; }
+    return __spread([msg], e.message.split("\n").map(function (l) { return indent + l; })).join("\n");
+}
+export function formatErrorCtor(ctor, paramIdx, error) {
+    var _a = __read(ctor.toString().match(/constructor\(([\w, ]+)\)/) || [], 2), _b = _a[1], params = _b === void 0 ? null : _b;
+    var dep = formatDependency(params, paramIdx);
+    return composeErrorMessage("Cannot inject the dependency " + dep + " of \"" + ctor.name + "\" constructor. Reason:", error);
+}

node_modules/tsyringe/dist/esm5/factories/index.js

@@ -0,0 +1,3 @@
+export { default as instanceCachingFactory } from "./instance-caching-factory";
+export { default as instancePerContainerCachingFactory } from "./instance-per-container-caching-factory";
+export { default as predicateAwareClassFactory } from "./predicate-aware-class-factory";

node_modules/tsyringe/dist/esm5/factories/instance-caching-factory.js

@@ -0,0 +1,9 @@
+export default function instanceCachingFactory(factoryFunc) {
+    var instance;
+    return function (dependencyContainer) {
+        if (instance == undefined) {
+            instance = factoryFunc(dependencyContainer);
+        }
+        return instance;
+    };
+}

node_modules/tsyringe/dist/esm5/factories/instance-per-container-caching-factory.js

@@ -0,0 +1,11 @@
+export default function instancePerContainerCachingFactory(factoryFunc) {
+    var cache = new WeakMap();
+    return function (dependencyContainer) {
+        var instance = cache.get(dependencyContainer);
+        if (instance == undefined) {
+            instance = factoryFunc(dependencyContainer);
+            cache.set(dependencyContainer, instance);
+        }
+        return instance;
+    };
+}

node_modules/tsyringe/dist/esm5/factories/predicate-aware-class-factory.js

@@ -0,0 +1,17 @@
+export default function predicateAwareClassFactory(predicate, trueConstructor, falseConstructor, useCaching) {
+    if (useCaching === void 0) { useCaching = true; }
+    var instance;
+    var previousPredicate;
+    return function (dependencyContainer) {
+        var currentPredicate = predicate(dependencyContainer);
+        if (!useCaching || previousPredicate !== currentPredicate) {
+            if ((previousPredicate = currentPredicate)) {
+                instance = dependencyContainer.resolve(trueConstructor);
+            }
+            else {
+                instance = dependencyContainer.resolve(falseConstructor);
+            }
+        }
+        return instance;
+    };
+}

node_modules/tsyringe/dist/esm5/index.js

@@ -0,0 +1,9 @@
+if (typeof Reflect === "undefined" || !Reflect.getMetadata) {
+    throw new Error("tsyringe requires a reflect polyfill. Please add 'import \"reflect-metadata\"' to the top of your entry point.");
+}
+export { Lifecycle } from "./types";
+export * from "./decorators";
+export * from "./factories";
+export * from "./providers";
+export { delay } from "./lazy-helpers";
+export { instance as container } from "./dependency-container";

node_modules/tsyringe/dist/esm5/interceptors.js

@@ -0,0 +1,26 @@
+import { __extends } from "tslib";
+import RegistryBase from "./registry-base";
+var PreResolutionInterceptors = (function (_super) {
+    __extends(PreResolutionInterceptors, _super);
+    function PreResolutionInterceptors() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return PreResolutionInterceptors;
+}(RegistryBase));
+export { PreResolutionInterceptors };
+var PostResolutionInterceptors = (function (_super) {
+    __extends(PostResolutionInterceptors, _super);
+    function PostResolutionInterceptors() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return PostResolutionInterceptors;
+}(RegistryBase));
+export { PostResolutionInterceptors };
+var Interceptors = (function () {
+    function Interceptors() {
+        this.preResolution = new PreResolutionInterceptors();
+        this.postResolution = new PostResolutionInterceptors();
+    }
+    return Interceptors;
+}());
+export default Interceptors;

node_modules/tsyringe/dist/esm5/lazy-helpers.js

@@ -0,0 +1,57 @@
+import { __read, __spread } from "tslib";
+var DelayedConstructor = (function () {
+    function DelayedConstructor(wrap) {
+        this.wrap = wrap;
+        this.reflectMethods = [
+            "get",
+            "getPrototypeOf",
+            "setPrototypeOf",
+            "getOwnPropertyDescriptor",
+            "defineProperty",
+            "has",
+            "set",
+            "deleteProperty",
+            "apply",
+            "construct",
+            "ownKeys"
+        ];
+    }
+    DelayedConstructor.prototype.createProxy = function (createObject) {
+        var _this = this;
+        var target = {};
+        var init = false;
+        var value;
+        var delayedObject = function () {
+            if (!init) {
+                value = createObject(_this.wrap());
+                init = true;
+            }
+            return value;
+        };
+        return new Proxy(target, this.createHandler(delayedObject));
+    };
+    DelayedConstructor.prototype.createHandler = function (delayedObject) {
+        var handler = {};
+        var install = function (name) {
+            handler[name] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                args[0] = delayedObject();
+                var method = Reflect[name];
+                return method.apply(void 0, __spread(args));
+            };
+        };
+        this.reflectMethods.forEach(install);
+        return handler;
+    };
+    return DelayedConstructor;
+}());
+export { DelayedConstructor };
+export function delay(wrappedConstructor) {
+    if (typeof wrappedConstructor === "undefined") {
+        throw new Error("Attempt to `delay` undefined. Constructor must be wrapped in a callback");
+    }
+    return new DelayedConstructor(wrappedConstructor);
+}

node_modules/tsyringe/dist/esm5/providers/class-provider.js

@@ -0,0 +1,3 @@
+export function isClassProvider(provider) {
+    return !!provider.useClass;
+}

node_modules/tsyringe/dist/esm5/providers/factory-provider.js

@@ -0,0 +1,3 @@
+export function isFactoryProvider(provider) {
+    return !!provider.useFactory;
+}

node_modules/tsyringe/dist/esm5/providers/index.js

@@ -0,0 +1,5 @@
+export { isClassProvider } from "./class-provider";
+export { isFactoryProvider } from "./factory-provider";
+export { isNormalToken } from "./injection-token";
+export { isTokenProvider } from "./token-provider";
+export { isValueProvider } from "./value-provider";

node_modules/tsyringe/dist/esm5/providers/injection-token.js

@@ -0,0 +1,17 @@
+import { DelayedConstructor } from "../lazy-helpers";
+export function isNormalToken(token) {
+    return typeof token === "string" || typeof token === "symbol";
+}
+export function isTokenDescriptor(descriptor) {
+    return (typeof descriptor === "object" &&
+        "token" in descriptor &&
+        "multiple" in descriptor);
+}
+export function isTransformDescriptor(descriptor) {
+    return (typeof descriptor === "object" &&
+        "token" in descriptor &&
+        "transform" in descriptor);
+}
+export function isConstructorToken(token) {
+    return typeof token === "function" || token instanceof DelayedConstructor;
+}

node_modules/tsyringe/dist/esm5/providers/provider.js

@@ -0,0 +1,10 @@
+import { isClassProvider } from "./class-provider";
+import { isValueProvider } from "./value-provider";
+import { isTokenProvider } from "./token-provider";
+import { isFactoryProvider } from "./factory-provider";
+export function isProvider(provider) {
+    return (isClassProvider(provider) ||
+        isValueProvider(provider) ||
+        isTokenProvider(provider) ||
+        isFactoryProvider(provider));
+}

node_modules/tsyringe/dist/esm5/providers/token-provider.js

@@ -0,0 +1,3 @@
+export function isTokenProvider(provider) {
+    return !!provider.useToken;
+}

node_modules/tsyringe/dist/esm5/providers/value-provider.js

@@ -0,0 +1,3 @@
+export function isValueProvider(provider) {
+    return provider.useValue != undefined;
+}

node_modules/tsyringe/dist/esm5/reflection-helpers.js

@@ -0,0 +1,22 @@
+export var INJECTION_TOKEN_METADATA_KEY = "injectionTokens";
+export function getParamInfo(target) {
+    var params = Reflect.getMetadata("design:paramtypes", target) || [];
+    var injectionTokens = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
+    Object.keys(injectionTokens).forEach(function (key) {
+        params[+key] = injectionTokens[key];
+    });
+    return params;
+}
+export function defineInjectionTokenMetadata(data, transform) {
+    return function (target, _propertyKey, parameterIndex) {
+        var descriptors = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
+        descriptors[parameterIndex] = transform
+            ? {
+                token: data,
+                transform: transform.transformToken,
+                transformArgs: transform.args || []
+            }
+            : data;
+        Reflect.defineMetadata(INJECTION_TOKEN_METADATA_KEY, descriptors, target);
+    };
+}

node_modules/tsyringe/dist/esm5/registry-base.js

@@ -0,0 +1,38 @@
+var RegistryBase = (function () {
+    function RegistryBase() {
+        this._registryMap = new Map();
+    }
+    RegistryBase.prototype.entries = function () {
+        return this._registryMap.entries();
+    };
+    RegistryBase.prototype.getAll = function (key) {
+        this.ensure(key);
+        return this._registryMap.get(key);
+    };
+    RegistryBase.prototype.get = function (key) {
+        this.ensure(key);
+        var value = this._registryMap.get(key);
+        return value[value.length - 1] || null;
+    };
+    RegistryBase.prototype.set = function (key, value) {
+        this.ensure(key);
+        this._registryMap.get(key).push(value);
+    };
+    RegistryBase.prototype.setAll = function (key, value) {
+        this._registryMap.set(key, value);
+    };
+    RegistryBase.prototype.has = function (key) {
+        this.ensure(key);
+        return this._registryMap.get(key).length > 0;
+    };
+    RegistryBase.prototype.clear = function () {
+        this._registryMap.clear();
+    };
+    RegistryBase.prototype.ensure = function (key) {
+        if (!this._registryMap.has(key)) {
+            this._registryMap.set(key, []);
+        }
+    };
+    return RegistryBase;
+}());
+export default RegistryBase;

node_modules/tsyringe/dist/esm5/registry.js

@@ -0,0 +1,10 @@
+import { __extends } from "tslib";
+import RegistryBase from "./registry-base";
+var Registry = (function (_super) {
+    __extends(Registry, _super);
+    function Registry() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Registry;
+}(RegistryBase));
+export default Registry;

node_modules/tsyringe/dist/esm5/resolution-context.js

@@ -0,0 +1,7 @@
+var ResolutionContext = (function () {
+    function ResolutionContext() {
+        this.scopedResolutions = new Map();
+    }
+    return ResolutionContext;
+}());
+export default ResolutionContext;

node_modules/tsyringe/dist/esm5/types/disposable.js

@@ -0,0 +1,9 @@
+export function isDisposable(value) {
+    if (typeof value.dispose !== "function")
+        return false;
+    var disposeFun = value.dispose;
+    if (disposeFun.length > 0) {
+        return false;
+    }
+    return true;
+}

node_modules/tsyringe/dist/esm5/types/index.js

@@ -0,0 +1 @@
+export { default as Lifecycle } from "./lifecycle";

node_modules/tsyringe/dist/esm5/types/lifecycle.js

@@ -0,0 +1,8 @@
+var Lifecycle;
+(function (Lifecycle) {
+    Lifecycle[Lifecycle["Transient"] = 0] = "Transient";
+    Lifecycle[Lifecycle["Singleton"] = 1] = "Singleton";
+    Lifecycle[Lifecycle["ResolutionScoped"] = 2] = "ResolutionScoped";
+    Lifecycle[Lifecycle["ContainerScoped"] = 3] = "ContainerScoped";
+})(Lifecycle || (Lifecycle = {}));
+export default Lifecycle;