mana-syringe/dist/index.umd.js

IoC library for mana, easily to use.

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.manaSyringe = {}));
}(this, (function (exports) { 'use strict';

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      enumerableOnly && (symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      })), keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = null != arguments[i] ? arguments[i] : {};
      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }

    return target;
  }

  function _typeof(obj) {
    "@babel/helpers - typeof";

    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    }, _typeof(obj);
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    Object.defineProperty(Constructor, "prototype", {
      writable: false
    });
    return Constructor;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
  }

  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
  }

  function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
  }

  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }

  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

    return arr2;
  }

  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  var NAMED_TAG = "named";
  var NAME_TAG = "name";
  var UNMANAGED_TAG = "unmanaged";
  var OPTIONAL_TAG = "optional";
  var INJECT_TAG = "inject";
  var MULTI_INJECT_TAG = "multi_inject";
  var TAGGED = "inversify:tagged";
  var TAGGED_PROP = "inversify:tagged_props";
  var PARAM_TYPES = "inversify:paramtypes";
  var DESIGN_PARAM_TYPES = "design:paramtypes";
  var POST_CONSTRUCT = "post_construct";
  function getNonCustomTagKeys() {
      return [
          INJECT_TAG,
          MULTI_INJECT_TAG,
          NAME_TAG,
          UNMANAGED_TAG,
          NAMED_TAG,
          OPTIONAL_TAG,
      ];
  }
  var NON_CUSTOM_TAG_KEYS = getNonCustomTagKeys();

  var BindingScopeEnum = {
      Request: "Request",
      Singleton: "Singleton",
      Transient: "Transient"
  };
  var BindingTypeEnum = {
      ConstantValue: "ConstantValue",
      Constructor: "Constructor",
      DynamicValue: "DynamicValue",
      Factory: "Factory",
      Function: "Function",
      Instance: "Instance",
      Invalid: "Invalid",
      Provider: "Provider"
  };
  var TargetTypeEnum = {
      ClassProperty: "ClassProperty",
      ConstructorArgument: "ConstructorArgument",
      Variable: "Variable"
  };

  var idCounter = 0;
  function id() {
      return idCounter++;
  }

  var Binding = (function () {
      function Binding(serviceIdentifier, scope) {
          this.id = id();
          this.activated = false;
          this.serviceIdentifier = serviceIdentifier;
          this.scope = scope;
          this.type = BindingTypeEnum.Invalid;
          this.constraint = function (request) { return true; };
          this.implementationType = null;
          this.cache = null;
          this.factory = null;
          this.provider = null;
          this.onActivation = null;
          this.dynamicValue = null;
      }
      Binding.prototype.clone = function () {
          var clone = new Binding(this.serviceIdentifier, this.scope);
          clone.activated = (clone.scope === BindingScopeEnum.Singleton) ? this.activated : false;
          clone.implementationType = this.implementationType;
          clone.dynamicValue = this.dynamicValue;
          clone.scope = this.scope;
          clone.type = this.type;
          clone.factory = this.factory;
          clone.provider = this.provider;
          clone.constraint = this.constraint;
          clone.onActivation = this.onActivation;
          clone.cache = this.cache;
          return clone;
      };
      return Binding;
  }());

  var DUPLICATED_INJECTABLE_DECORATOR = "Cannot apply @injectable decorator multiple times.";
  var DUPLICATED_METADATA = "Metadata key was used more than once in a parameter:";
  var NULL_ARGUMENT = "NULL argument";
  var KEY_NOT_FOUND = "Key Not Found";
  var AMBIGUOUS_MATCH = "Ambiguous match found for serviceIdentifier:";
  var CANNOT_UNBIND = "Could not unbind serviceIdentifier:";
  var NOT_REGISTERED = "No matching bindings found for serviceIdentifier:";
  var MISSING_INJECTABLE_ANNOTATION = "Missing required @injectable annotation in:";
  var MISSING_INJECT_ANNOTATION = "Missing required @inject or @multiInject annotation in:";
  var UNDEFINED_INJECT_ANNOTATION = function (name) {
      return "@inject called with undefined this could mean that the class " + name + " has " +
          "a circular dependency problem. You can use a LazyServiceIdentifer to  " +
          "overcome this limitation.";
  };
  var CIRCULAR_DEPENDENCY = "Circular dependency found:";
  var INVALID_BINDING_TYPE = "Invalid binding type:";
  var NO_MORE_SNAPSHOTS_AVAILABLE = "No snapshot available to restore.";
  var INVALID_MIDDLEWARE_RETURN = "Invalid return type in middleware. Middleware must return!";
  var INVALID_FUNCTION_BINDING = "Value provided to function binding must be a function!";
  var INVALID_TO_SELF_VALUE = "The toSelf function can only be applied when a constructor is " +
      "used as service identifier";
  var INVALID_DECORATOR_OPERATION = "The @inject @multiInject @tagged and @named decorators " +
      "must be applied to the parameters of a class constructor or a class property.";
  var ARGUMENTS_LENGTH_MISMATCH = function () {
      var values = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          values[_i] = arguments[_i];
      }
      return "The number of constructor arguments in the derived class " +
          (values[0] + " must be >= than the number of constructor arguments of its base class.");
  };
  var CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = "Invalid Container constructor argument. Container options " +
      "must be an object.";
  var CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = "Invalid Container option. Default scope must " +
      "be a string ('singleton' or 'transient').";
  var CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = "Invalid Container option. Auto bind injectable must " +
      "be a boolean";
  var CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = "Invalid Container option. Skip base check must " +
      "be a boolean";
  var MULTIPLE_POST_CONSTRUCT_METHODS = "Cannot apply @postConstruct decorator multiple times in the same class";
  var POST_CONSTRUCT_ERROR = function () {
      var values = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          values[_i] = arguments[_i];
      }
      return "@postConstruct error in class " + values[0] + ": " + values[1];
  };
  var CIRCULAR_DEPENDENCY_IN_FACTORY = function () {
      var values = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          values[_i] = arguments[_i];
      }
      return "It looks like there is a circular dependency " +
          ("in one of the '" + values[0] + "' bindings. Please investigate bindings with") +
          ("service identifier '" + values[1] + "'.");
  };
  var STACK_OVERFLOW = "Maximum call stack size exceeded";

  var MetadataReader = (function () {
      function MetadataReader() {
      }
      MetadataReader.prototype.getConstructorMetadata = function (constructorFunc) {
          var compilerGeneratedMetadata = Reflect.getMetadata(PARAM_TYPES, constructorFunc);
          var userGeneratedMetadata = Reflect.getMetadata(TAGGED, constructorFunc);
          return {
              compilerGeneratedMetadata: compilerGeneratedMetadata,
              userGeneratedMetadata: userGeneratedMetadata || {}
          };
      };
      MetadataReader.prototype.getPropertiesMetadata = function (constructorFunc) {
          var userGeneratedMetadata = Reflect.getMetadata(TAGGED_PROP, constructorFunc) || [];
          return userGeneratedMetadata;
      };
      return MetadataReader;
  }());

  var BindingCount = {
      MultipleBindingsAvailable: 2,
      NoBindingsAvailable: 0,
      OnlyOneBindingAvailable: 1
  };

  function isStackOverflowExeption(error) {
      return (error instanceof RangeError ||
          error.message === STACK_OVERFLOW);
  }

  function getServiceIdentifierAsString(serviceIdentifier) {
      if (typeof serviceIdentifier === "function") {
          var _serviceIdentifier = serviceIdentifier;
          return _serviceIdentifier.name;
      }
      else if (typeof serviceIdentifier === "symbol") {
          return serviceIdentifier.toString();
      }
      else {
          var _serviceIdentifier = serviceIdentifier;
          return _serviceIdentifier;
      }
  }
  function listRegisteredBindingsForServiceIdentifier(container, serviceIdentifier, getBindings) {
      var registeredBindingsList = "";
      var registeredBindings = getBindings(container, serviceIdentifier);
      if (registeredBindings.length !== 0) {
          registeredBindingsList = "\nRegistered bindings:";
          registeredBindings.forEach(function (binding) {
              var name = "Object";
              if (binding.implementationType !== null) {
                  name = getFunctionName(binding.implementationType);
              }
              registeredBindingsList = registeredBindingsList + "\n " + name;
              if (binding.constraint.metaData) {
                  registeredBindingsList = registeredBindingsList + " - " + binding.constraint.metaData;
              }
          });
      }
      return registeredBindingsList;
  }
  function alreadyDependencyChain(request, serviceIdentifier) {
      if (request.parentRequest === null) {
          return false;
      }
      else if (request.parentRequest.serviceIdentifier === serviceIdentifier) {
          return true;
      }
      else {
          return alreadyDependencyChain(request.parentRequest, serviceIdentifier);
      }
  }
  function dependencyChainToString(request) {
      function _createStringArr(req, result) {
          if (result === void 0) { result = []; }
          var serviceIdentifier = getServiceIdentifierAsString(req.serviceIdentifier);
          result.push(serviceIdentifier);
          if (req.parentRequest !== null) {
              return _createStringArr(req.parentRequest, result);
          }
          return result;
      }
      var stringArr = _createStringArr(request);
      return stringArr.reverse().join(" --> ");
  }
  function circularDependencyToException(request) {
      request.childRequests.forEach(function (childRequest) {
          if (alreadyDependencyChain(childRequest, childRequest.serviceIdentifier)) {
              var services = dependencyChainToString(childRequest);
              throw new Error(CIRCULAR_DEPENDENCY + " " + services);
          }
          else {
              circularDependencyToException(childRequest);
          }
      });
  }
  function listMetadataForTarget(serviceIdentifierString, target) {
      if (target.isTagged() || target.isNamed()) {
          var m_1 = "";
          var namedTag = target.getNamedTag();
          var otherTags = target.getCustomTags();
          if (namedTag !== null) {
              m_1 += namedTag.toString() + "\n";
          }
          if (otherTags !== null) {
              otherTags.forEach(function (tag) {
                  m_1 += tag.toString() + "\n";
              });
          }
          return " " + serviceIdentifierString + "\n " + serviceIdentifierString + " - " + m_1;
      }
      else {
          return " " + serviceIdentifierString;
      }
  }
  function getFunctionName(v) {
      if (v.name) {
          return v.name;
      }
      else {
          var name_1 = v.toString();
          var match = name_1.match(/^function\s*([^\s(]+)/);
          return match ? match[1] : "Anonymous function: " + name_1;
      }
  }

  var Context = (function () {
      function Context(container) {
          this.id = id();
          this.container = container;
      }
      Context.prototype.addPlan = function (plan) {
          this.plan = plan;
      };
      Context.prototype.setCurrentRequest = function (currentRequest) {
          this.currentRequest = currentRequest;
      };
      return Context;
  }());

  var Metadata = (function () {
      function Metadata(key, value) {
          this.key = key;
          this.value = value;
      }
      Metadata.prototype.toString = function () {
          if (this.key === NAMED_TAG) {
              return "named: " + this.value.toString() + " ";
          }
          else {
              return "tagged: { key:" + this.key.toString() + ", value: " + this.value + " }";
          }
      };
      return Metadata;
  }());

  var Plan = (function () {
      function Plan(parentContext, rootRequest) {
          this.parentContext = parentContext;
          this.rootRequest = rootRequest;
      }
      return Plan;
  }());

  function tagParameter(annotationTarget, propertyName, parameterIndex, metadata) {
      var metadataKey = TAGGED;
      _tagParameterOrProperty(metadataKey, annotationTarget, propertyName, metadata, parameterIndex);
  }
  function tagProperty(annotationTarget, propertyName, metadata) {
      var metadataKey = TAGGED_PROP;
      _tagParameterOrProperty(metadataKey, annotationTarget.constructor, propertyName, metadata);
  }
  function _tagParameterOrProperty(metadataKey, annotationTarget, propertyName, metadata, parameterIndex) {
      var paramsOrPropertiesMetadata = {};
      var isParameterDecorator = (typeof parameterIndex === "number");
      var key = (parameterIndex !== undefined && isParameterDecorator) ? parameterIndex.toString() : propertyName;
      if (isParameterDecorator && propertyName !== undefined) {
          throw new Error(INVALID_DECORATOR_OPERATION);
      }
      if (Reflect.hasOwnMetadata(metadataKey, annotationTarget)) {
          paramsOrPropertiesMetadata = Reflect.getMetadata(metadataKey, annotationTarget);
      }
      var paramOrPropertyMetadata = paramsOrPropertiesMetadata[key];
      if (!Array.isArray(paramOrPropertyMetadata)) {
          paramOrPropertyMetadata = [];
      }
      else {
          for (var _i = 0, paramOrPropertyMetadata_1 = paramOrPropertyMetadata; _i < paramOrPropertyMetadata_1.length; _i++) {
              var m = paramOrPropertyMetadata_1[_i];
              if (m.key === metadata.key) {
                  throw new Error(DUPLICATED_METADATA + " " + m.key.toString());
              }
          }
      }
      paramOrPropertyMetadata.push(metadata);
      paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata;
      Reflect.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);
  }
  function _decorate(decorators, target) {
      Reflect.decorate(decorators, target);
  }
  function _param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); };
  }
  function decorate(decorator, target, parameterIndex) {
      if (typeof parameterIndex === "number") {
          _decorate([_param(parameterIndex, decorator)], target);
      }
      else if (typeof parameterIndex === "string") {
          Reflect.decorate([decorator], target, parameterIndex);
      }
      else {
          _decorate([decorator], target);
      }
  }

  var LazyServiceIdentifer = (function () {
      function LazyServiceIdentifer(cb) {
          this._cb = cb;
      }
      LazyServiceIdentifer.prototype.unwrap = function () {
          return this._cb();
      };
      return LazyServiceIdentifer;
  }());
  function inject(serviceIdentifier) {
      return function (target, targetKey, index) {
          if (serviceIdentifier === undefined) {
              throw new Error(UNDEFINED_INJECT_ANNOTATION(target.name));
          }
          var metadata = new Metadata(INJECT_TAG, serviceIdentifier);
          if (typeof index === "number") {
              tagParameter(target, targetKey, index, metadata);
          }
          else {
              tagProperty(target, targetKey, metadata);
          }
      };
  }

  var QueryableString = (function () {
      function QueryableString(str) {
          this.str = str;
      }
      QueryableString.prototype.startsWith = function (searchString) {
          return this.str.indexOf(searchString) === 0;
      };
      QueryableString.prototype.endsWith = function (searchString) {
          var reverseString = "";
          var reverseSearchString = searchString.split("").reverse().join("");
          reverseString = this.str.split("").reverse().join("");
          return this.startsWith.call({ str: reverseString }, reverseSearchString);
      };
      QueryableString.prototype.contains = function (searchString) {
          return (this.str.indexOf(searchString) !== -1);
      };
      QueryableString.prototype.equals = function (compareString) {
          return this.str === compareString;
      };
      QueryableString.prototype.value = function () {
          return this.str;
      };
      return QueryableString;
  }());

  var Target = (function () {
      function Target(type, name, serviceIdentifier, namedOrTagged) {
          this.id = id();
          this.type = type;
          this.serviceIdentifier = serviceIdentifier;
          this.name = new QueryableString(name || "");
          this.metadata = new Array();
          var metadataItem = null;
          if (typeof namedOrTagged === "string") {
              metadataItem = new Metadata(NAMED_TAG, namedOrTagged);
          }
          else if (namedOrTagged instanceof Metadata) {
              metadataItem = namedOrTagged;
          }
          if (metadataItem !== null) {
              this.metadata.push(metadataItem);
          }
      }
      Target.prototype.hasTag = function (key) {
          for (var _i = 0, _a = this.metadata; _i < _a.length; _i++) {
              var m = _a[_i];
              if (m.key === key) {
                  return true;
              }
          }
          return false;
      };
      Target.prototype.isArray = function () {
          return this.hasTag(MULTI_INJECT_TAG);
      };
      Target.prototype.matchesArray = function (name) {
          return this.matchesTag(MULTI_INJECT_TAG)(name);
      };
      Target.prototype.isNamed = function () {
          return this.hasTag(NAMED_TAG);
      };
      Target.prototype.isTagged = function () {
          return this.metadata.some(function (metadata) { return NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; }); });
      };
      Target.prototype.isOptional = function () {
          return this.matchesTag(OPTIONAL_TAG)(true);
      };
      Target.prototype.getNamedTag = function () {
          if (this.isNamed()) {
              return this.metadata.filter(function (m) { return m.key === NAMED_TAG; })[0];
          }
          return null;
      };
      Target.prototype.getCustomTags = function () {
          if (this.isTagged()) {
              return this.metadata.filter(function (metadata) { return NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; }); });
          }
          else {
              return null;
          }
      };
      Target.prototype.matchesNamedTag = function (name) {
          return this.matchesTag(NAMED_TAG)(name);
      };
      Target.prototype.matchesTag = function (key) {
          var _this = this;
          return function (value) {
              for (var _i = 0, _a = _this.metadata; _i < _a.length; _i++) {
                  var m = _a[_i];
                  if (m.key === key && m.value === value) {
                      return true;
                  }
              }
              return false;
          };
      };
      return Target;
  }());

  var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from) {
      for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
          to[j] = from[i];
      return to;
  };
  function getDependencies(metadataReader, func) {
      var constructorName = getFunctionName(func);
      var targets = getTargets(metadataReader, constructorName, func, false);
      return targets;
  }
  function getTargets(metadataReader, constructorName, func, isBaseClass) {
      var metadata = metadataReader.getConstructorMetadata(func);
      var serviceIdentifiers = metadata.compilerGeneratedMetadata;
      if (serviceIdentifiers === undefined) {
          var msg = MISSING_INJECTABLE_ANNOTATION + " " + constructorName + ".";
          throw new Error(msg);
      }
      var constructorArgsMetadata = metadata.userGeneratedMetadata;
      var keys = Object.keys(constructorArgsMetadata);
      var hasUserDeclaredUnknownInjections = (func.length === 0 && keys.length > 0);
      var hasOptionalParameters = keys.length > func.length;
      var iterations = (hasUserDeclaredUnknownInjections || hasOptionalParameters) ? keys.length : func.length;
      var constructorTargets = getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations);
      var propertyTargets = getClassPropsAsTargets(metadataReader, func);
      var targets = __spreadArray(__spreadArray([], constructorTargets), propertyTargets);
      return targets;
  }
  function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {
      var targetMetadata = constructorArgsMetadata[index.toString()] || [];
      var metadata = formatTargetMetadata(targetMetadata);
      var isManaged = metadata.unmanaged !== true;
      var serviceIdentifier = serviceIdentifiers[index];
      var injectIdentifier = (metadata.inject || metadata.multiInject);
      serviceIdentifier = (injectIdentifier) ? (injectIdentifier) : serviceIdentifier;
      if (serviceIdentifier instanceof LazyServiceIdentifer) {
          serviceIdentifier = serviceIdentifier.unwrap();
      }
      if (isManaged) {
          var isObject = serviceIdentifier === Object;
          var isFunction = serviceIdentifier === Function;
          var isUndefined = serviceIdentifier === undefined;
          var isUnknownType = (isObject || isFunction || isUndefined);
          if (!isBaseClass && isUnknownType) {
              var msg = MISSING_INJECT_ANNOTATION + " argument " + index + " in class " + constructorName + ".";
              throw new Error(msg);
          }
          var target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
          target.metadata = targetMetadata;
          return target;
      }
      return null;
  }
  function getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations) {
      var targets = [];
      for (var i = 0; i < iterations; i++) {
          var index = i;
          var target = getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata);
          if (target !== null) {
              targets.push(target);
          }
      }
      return targets;
  }
  function getClassPropsAsTargets(metadataReader, constructorFunc) {
      var classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);
      var targets = [];
      var keys = Object.keys(classPropsMetadata);
      for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
          var key = keys_1[_i];
          var targetMetadata = classPropsMetadata[key];
          var metadata = formatTargetMetadata(classPropsMetadata[key]);
          var targetName = metadata.targetName || key;
          var serviceIdentifier = (metadata.inject || metadata.multiInject);
          var target = new Target(TargetTypeEnum.ClassProperty, targetName, serviceIdentifier);
          target.metadata = targetMetadata;
          targets.push(target);
      }
      var baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor;
      if (baseConstructor !== Object) {
          var baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor);
          targets = __spreadArray(__spreadArray([], targets), baseTargets);
      }
      return targets;
  }
  function getBaseClassDependencyCount(metadataReader, func) {
      var baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
      if (baseConstructor !== Object) {
          var baseConstructorName = getFunctionName(baseConstructor);
          var targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true);
          var metadata = targets.map(function (t) {
              return t.metadata.filter(function (m) {
                  return m.key === UNMANAGED_TAG;
              });
          });
          var unmanagedCount = [].concat.apply([], metadata).length;
          var dependencyCount = targets.length - unmanagedCount;
          if (dependencyCount > 0) {
              return dependencyCount;
          }
          else {
              return getBaseClassDependencyCount(metadataReader, baseConstructor);
          }
      }
      else {
          return 0;
      }
  }
  function formatTargetMetadata(targetMetadata) {
      var targetMetadataMap = {};
      targetMetadata.forEach(function (m) {
          targetMetadataMap[m.key.toString()] = m.value;
      });
      return {
          inject: targetMetadataMap[INJECT_TAG],
          multiInject: targetMetadataMap[MULTI_INJECT_TAG],
          targetName: targetMetadataMap[NAME_TAG],
          unmanaged: targetMetadataMap[UNMANAGED_TAG]
      };
  }

  var Request = (function () {
      function Request(serviceIdentifier, parentContext, parentRequest, bindings, target) {
          this.id = id();
          this.serviceIdentifier = serviceIdentifier;
          this.parentContext = parentContext;
          this.parentRequest = parentRequest;
          this.target = target;
          this.childRequests = [];
          this.bindings = (Array.isArray(bindings) ? bindings : [bindings]);
          this.requestScope = parentRequest === null
              ? new Map()
              : null;
      }
      Request.prototype.addChildRequest = function (serviceIdentifier, bindings, target) {
          var child = new Request(serviceIdentifier, this.parentContext, this, bindings, target);
          this.childRequests.push(child);
          return child;
      };
      return Request;
  }());

  function getBindingDictionary(cntnr) {
      return cntnr._bindingDictionary;
  }
  function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {
      var metadataKey = isMultiInject ? MULTI_INJECT_TAG : INJECT_TAG;
      var injectMetadata = new Metadata(metadataKey, serviceIdentifier);
      var target = new Target(targetType, name, serviceIdentifier, injectMetadata);
      if (key !== undefined) {
          var tagMetadata = new Metadata(key, value);
          target.metadata.push(tagMetadata);
      }
      return target;
  }
  function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
      var bindings = getBindings(context.container, target.serviceIdentifier);
      var activeBindings = [];
      if (bindings.length === BindingCount.NoBindingsAvailable &&
          context.container.options.autoBindInjectable &&
          typeof target.serviceIdentifier === "function" &&
          metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata) {
          context.container.bind(target.serviceIdentifier).toSelf();
          bindings = getBindings(context.container, target.serviceIdentifier);
      }
      if (!avoidConstraints) {
          activeBindings = bindings.filter(function (binding) {
              var request = new Request(binding.serviceIdentifier, context, parentRequest, binding, target);
              return binding.constraint(request);
          });
      }
      else {
          activeBindings = bindings;
      }
      _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
      return activeBindings;
  }
  function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
      switch (bindings.length) {
          case BindingCount.NoBindingsAvailable:
              if (target.isOptional()) {
                  return bindings;
              }
              else {
                  var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
                  var msg = NOT_REGISTERED;
                  msg += listMetadataForTarget(serviceIdentifierString, target);
                  msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
                  throw new Error(msg);
              }
          case BindingCount.OnlyOneBindingAvailable:
              if (!target.isArray()) {
                  return bindings;
              }
          case BindingCount.MultipleBindingsAvailable:
          default:
              if (!target.isArray()) {
                  var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
                  var msg = AMBIGUOUS_MATCH + " " + serviceIdentifierString;
                  msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
                  throw new Error(msg);
              }
              else {
                  return bindings;
              }
      }
  }
  function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {
      var activeBindings;
      var childRequest;
      if (parentRequest === null) {
          activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);
          childRequest = new Request(serviceIdentifier, context, null, activeBindings, target);
          var thePlan = new Plan(context, childRequest);
          context.addPlan(thePlan);
      }
      else {
          activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target);
          childRequest = parentRequest.addChildRequest(target.serviceIdentifier, activeBindings, target);
      }
      activeBindings.forEach(function (binding) {
          var subChildRequest = null;
          if (target.isArray()) {
              subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);
          }
          else {
              if (binding.cache) {
                  return;
              }
              subChildRequest = childRequest;
          }
          if (binding.type === BindingTypeEnum.Instance && binding.implementationType !== null) {
              var dependencies = getDependencies(metadataReader, binding.implementationType);
              if (!context.container.options.skipBaseClassChecks) {
                  var baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType);
                  if (dependencies.length < baseClassDependencyCount) {
                      var error = ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType));
                      throw new Error(error);
                  }
              }
              dependencies.forEach(function (dependency) {
                  _createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);
              });
          }
      });
  }
  function getBindings(container, serviceIdentifier) {
      var bindings = [];
      var bindingDictionary = getBindingDictionary(container);
      if (bindingDictionary.hasKey(serviceIdentifier)) {
          bindings = bindingDictionary.get(serviceIdentifier);
      }
      else if (container.parent !== null) {
          bindings = getBindings(container.parent, serviceIdentifier);
      }
      return bindings;
  }
  function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints) {
      if (avoidConstraints === void 0) { avoidConstraints = false; }
      var context = new Context(container);
      var target = _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value);
      try {
          _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);
          return context;
      }
      catch (error) {
          if (isStackOverflowExeption(error)) {
              if (context.plan) {
                  circularDependencyToException(context.plan.rootRequest);
              }
          }
          throw error;
      }
  }
  function createMockRequest(container, serviceIdentifier, key, value) {
      var target = new Target(TargetTypeEnum.Variable, "", serviceIdentifier, new Metadata(key, value));
      var context = new Context(container);
      var request = new Request(serviceIdentifier, context, null, [], target);
      return request;
  }

  var __spreadArray$1 = (undefined && undefined.__spreadArray) || function (to, from) {
      for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
          to[j] = from[i];
      return to;
  };
  function _injectProperties(instance, childRequests, resolveRequest) {
      var propertyInjectionsRequests = childRequests.filter(function (childRequest) {
          return (childRequest.target !== null &&
              childRequest.target.type === TargetTypeEnum.ClassProperty);
      });
      var propertyInjections = propertyInjectionsRequests.map(resolveRequest);
      propertyInjectionsRequests.forEach(function (r, index) {
          var propertyName = "";
          propertyName = r.target.name.value();
          var injection = propertyInjections[index];
          instance[propertyName] = injection;
      });
      return instance;
  }
  function _createInstance(Func, injections) {
      return new (Func.bind.apply(Func, __spreadArray$1([void 0], injections)))();
  }
  function _postConstruct(constr, result) {
      if (Reflect.hasMetadata(POST_CONSTRUCT, constr)) {
          var data = Reflect.getMetadata(POST_CONSTRUCT, constr);
          try {
              result[data.value]();
          }
          catch (e) {
              throw new Error(POST_CONSTRUCT_ERROR(constr.name, e.message));
          }
      }
  }
  function resolveInstance(constr, childRequests, resolveRequest) {
      var result = null;
      if (childRequests.length > 0) {
          var constructorInjectionsRequests = childRequests.filter(function (childRequest) {
              return (childRequest.target !== null && childRequest.target.type === TargetTypeEnum.ConstructorArgument);
          });
          var constructorInjections = constructorInjectionsRequests.map(resolveRequest);
          result = _createInstance(constr, constructorInjections);
          result = _injectProperties(result, childRequests, resolveRequest);
      }
      else {
          result = new constr();
      }
      _postConstruct(constr, result);
      return result;
  }

  var invokeFactory = function (factoryType, serviceIdentifier, fn) {
      try {
          return fn();
      }
      catch (error) {
          if (isStackOverflowExeption(error)) {
              throw new Error(CIRCULAR_DEPENDENCY_IN_FACTORY(factoryType, serviceIdentifier.toString()));
          }
          else {
              throw error;
          }
      }
  };
  var _resolveRequest = function (requestScope) {
      return function (request) {
          request.parentContext.setCurrentRequest(request);
          var bindings = request.bindings;
          var childRequests = request.childRequests;
          var targetIsAnArray = request.target && request.target.isArray();
          var targetParentIsNotAnArray = !request.parentRequest ||
              !request.parentRequest.target ||
              !request.target ||
              !request.parentRequest.target.matchesArray(request.target.serviceIdentifier);
          if (targetIsAnArray && targetParentIsNotAnArray) {
              return childRequests.map(function (childRequest) {
                  var _f = _resolveRequest(requestScope);
                  return _f(childRequest);
              });
          }
          else {
              var result = null;
              if (request.target.isOptional() && bindings.length === 0) {
                  return undefined;
              }
              var binding_1 = bindings[0];
              var isSingleton = binding_1.scope === BindingScopeEnum.Singleton;
              var isRequestSingleton = binding_1.scope === BindingScopeEnum.Request;
              if (isSingleton && binding_1.activated) {
                  return binding_1.cache;
              }
              if (isRequestSingleton &&
                  requestScope !== null &&
                  requestScope.has(binding_1.id)) {
                  return requestScope.get(binding_1.id);
              }
              if (binding_1.type === BindingTypeEnum.ConstantValue) {
                  result = binding_1.cache;
                  binding_1.activated = true;
              }
              else if (binding_1.type === BindingTypeEnum.Function) {
                  result = binding_1.cache;
                  binding_1.activated = true;
              }
              else if (binding_1.type === BindingTypeEnum.Constructor) {
                  result = binding_1.implementationType;
              }
              else if (binding_1.type === BindingTypeEnum.DynamicValue && binding_1.dynamicValue !== null) {
                  result = invokeFactory("toDynamicValue", binding_1.serviceIdentifier, function () { return binding_1.dynamicValue(request.parentContext); });
              }
              else if (binding_1.type === BindingTypeEnum.Factory && binding_1.factory !== null) {
                  result = invokeFactory("toFactory", binding_1.serviceIdentifier, function () { return binding_1.factory(request.parentContext); });
              }
              else if (binding_1.type === BindingTypeEnum.Provider && binding_1.provider !== null) {
                  result = invokeFactory("toProvider", binding_1.serviceIdentifier, function () { return binding_1.provider(request.parentContext); });
              }
              else if (binding_1.type === BindingTypeEnum.Instance && binding_1.implementationType !== null) {
                  result = resolveInstance(binding_1.implementationType, childRequests, _resolveRequest(requestScope));
              }
              else {
                  var serviceIdentifier = getServiceIdentifierAsString(request.serviceIdentifier);
                  throw new Error(INVALID_BINDING_TYPE + " " + serviceIdentifier);
              }
              if (typeof binding_1.onActivation === "function") {
                  result = binding_1.onActivation(request.parentContext, result);
              }
              if (isSingleton) {
                  binding_1.cache = result;
                  binding_1.activated = true;
              }
              if (isRequestSingleton &&
                  requestScope !== null &&
                  !requestScope.has(binding_1.id)) {
                  requestScope.set(binding_1.id, result);
              }
              return result;
          }
      };
  };
  function resolve(context) {
      var _f = _resolveRequest(context.plan.rootRequest.requestScope);
      return _f(context.plan.rootRequest);
  }

  var traverseAncerstors = function (request, constraint) {
      var parent = request.parentRequest;
      if (parent !== null) {
          return constraint(parent) ? true : traverseAncerstors(parent, constraint);
      }
      else {
          return false;
      }
  };
  var taggedConstraint = function (key) { return function (value) {
      var constraint = function (request) {
          return request !== null && request.target !== null && request.target.matchesTag(key)(value);
      };
      constraint.metaData = new Metadata(key, value);
      return constraint;
  }; };
  var namedConstraint = taggedConstraint(NAMED_TAG);
  var typeConstraint = function (type) { return function (request) {
      var binding = null;
      if (request !== null) {
          binding = request.bindings[0];
          if (typeof type === "string") {
              var serviceIdentifier = binding.serviceIdentifier;
              return serviceIdentifier === type;
          }
          else {
              var constructor = request.bindings[0].implementationType;
              return type === constructor;
          }
      }
      return false;
  }; };

  var BindingWhenSyntax = (function () {
      function BindingWhenSyntax(binding) {
          this._binding = binding;
      }
      BindingWhenSyntax.prototype.when = function (constraint) {
          this._binding.constraint = constraint;
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenTargetNamed = function (name) {
          this._binding.constraint = namedConstraint(name);
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenTargetIsDefault = function () {
          this._binding.constraint = function (request) {
              var targetIsDefault = (request.target !== null) &&
                  (!request.target.isNamed()) &&
                  (!request.target.isTagged());
              return targetIsDefault;
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenTargetTagged = function (tag, value) {
          this._binding.constraint = taggedConstraint(tag)(value);
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenInjectedInto = function (parent) {
          this._binding.constraint = function (request) {
              return typeConstraint(parent)(request.parentRequest);
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenParentNamed = function (name) {
          this._binding.constraint = function (request) {
              return namedConstraint(name)(request.parentRequest);
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenParentTagged = function (tag, value) {
          this._binding.constraint = function (request) {
              return taggedConstraint(tag)(value)(request.parentRequest);
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
          this._binding.constraint = function (request) {
              return traverseAncerstors(request, typeConstraint(ancestor));
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenNoAncestorIs = function (ancestor) {
          this._binding.constraint = function (request) {
              return !traverseAncerstors(request, typeConstraint(ancestor));
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenAnyAncestorNamed = function (name) {
          this._binding.constraint = function (request) {
              return traverseAncerstors(request, namedConstraint(name));
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenNoAncestorNamed = function (name) {
          this._binding.constraint = function (request) {
              return !traverseAncerstors(request, namedConstraint(name));
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
          this._binding.constraint = function (request) {
              return traverseAncerstors(request, taggedConstraint(tag)(value));
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
          this._binding.constraint = function (request) {
              return !traverseAncerstors(request, taggedConstraint(tag)(value));
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
          this._binding.constraint = function (request) {
              return traverseAncerstors(request, constraint);
          };
          return new BindingOnSyntax(this._binding);
      };
      BindingWhenSyntax.prototype.whenNoAncestorMatches = function (constraint) {
          this._binding.constraint = function (request) {
              return !traverseAncerstors(request, constraint);
          };
          return new BindingOnSyntax(this._binding);
      };
      return BindingWhenSyntax;
  }());

  var BindingOnSyntax = (function () {
      function BindingOnSyntax(binding) {
          this._binding = binding;
      }
      BindingOnSyntax.prototype.onActivation = function (handler) {
          this._binding.onActivation = handler;
          return new BindingWhenSyntax(this._binding);
      };
      return BindingOnSyntax;
  }());

  var BindingWhenOnSyntax = (function () {
      function BindingWhenOnSyntax(binding) {
          this._binding = binding;
          this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
          this._bindingOnSyntax = new BindingOnSyntax(this._binding);
      }
      BindingWhenOnSyntax.prototype.when = function (constraint) {
          return this._bindingWhenSyntax.when(constraint);
      };
      BindingWhenOnSyntax.prototype.whenTargetNamed = function (name) {
          return this._bindingWhenSyntax.whenTargetNamed(name);
      };
      BindingWhenOnSyntax.prototype.whenTargetIsDefault = function () {
          return this._bindingWhenSyntax.whenTargetIsDefault();
      };
      BindingWhenOnSyntax.prototype.whenTargetTagged = function (tag, value) {
          return this._bindingWhenSyntax.whenTargetTagged(tag, value);
      };
      BindingWhenOnSyntax.prototype.whenInjectedInto = function (parent) {
          return this._bindingWhenSyntax.whenInjectedInto(parent);
      };
      BindingWhenOnSyntax.prototype.whenParentNamed = function (name) {
          return this._bindingWhenSyntax.whenParentNamed(name);
      };
      BindingWhenOnSyntax.prototype.whenParentTagged = function (tag, value) {
          return this._bindingWhenSyntax.whenParentTagged(tag, value);
      };
      BindingWhenOnSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
          return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
      };
      BindingWhenOnSyntax.prototype.whenNoAncestorIs = function (ancestor) {
          return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
      };
      BindingWhenOnSyntax.prototype.whenAnyAncestorNamed = function (name) {
          return this._bindingWhenSyntax.whenAnyAncestorNamed(name);
      };
      BindingWhenOnSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
          return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
      };
      BindingWhenOnSyntax.prototype.whenNoAncestorNamed = function (name) {
          return this._bindingWhenSyntax.whenNoAncestorNamed(name);
      };
      BindingWhenOnSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
          return this._bindingWhenSyntax.