@visactor/vrender-components 0.17.0-alpha.1 → 0.17.0-alpha.2

package/dist/index.js

@@ -517,57 +517,6 @@
   function _nonIterableRest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  function _createForOfIteratorHelper(o, allowArrayLike) {
-    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-    if (!it) {
-      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-        if (it) o = it;
-        var i = 0;
-        var F = function () {};
-        return {
-          s: F,
-          n: function () {
-            if (i >= o.length) return {
-              done: true
-            };
-            return {
-              done: false,
-              value: o[i++]
-            };
-          },
-          e: function (e) {
-            throw e;
-          },
-          f: F
-        };
-      }
-      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    var normalCompletion = true,
-      didErr = false,
-      err;
-    return {
-      s: function () {
-        it = it.call(o);
-      },
-      n: function () {
-        var step = it.next();
-        normalCompletion = step.done;
-        return step;
-      },
-      e: function (e) {
-        didErr = true;
-        err = e;
-      },
-      f: function () {
-        try {
-          if (!normalCompletion && it.return != null) it.return();
-        } finally {
-          if (didErr) throw err;
-        }
-      }
-    };
-  }
   function _toPrimitive(input, hint) {
     if (typeof input !== "object" || input === null) return input;
     var prim = input[Symbol.toPrimitive];
@@ -583,64 +532,30 @@
     return typeof key === "symbol" ? key : String(key);
   }
 
-  var idCounter = 0;
-  function id() {
-    return idCounter++;
-  }
+  var Generator = /*#__PURE__*/function () {
+    function Generator() {
+      _classCallCheck(this, Generator);
+    }
+    _createClass(Generator, null, [{
+      key: "GenAutoIncrementId",
+      value: function GenAutoIncrementId() {
+        return Generator.auto_increment_id++;
+      }
+    }]);
+    return Generator;
+  }();
+  Generator.auto_increment_id = 0;
 
   var ContainerModule = /*#__PURE__*/_createClass(function ContainerModule(registry) {
     _classCallCheck(this, ContainerModule);
-    this.id = id(), this.registry = registry;
+    this.id = Generator.GenAutoIncrementId(), this.registry = registry;
   });
 
   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";
-  var PRE_DESTROY = "pre_destroy";
-  function getNonCustomTagKeys() {
-    return ["inject", "multi_inject", "name", "unmanaged", "named", "optional"];
-  }
-  var NON_CUSTOM_TAG_KEYS = getNonCustomTagKeys();
-
-  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 UNDEFINED_INJECT_ANNOTATION(name) {
-    return "@inject called with undefined this could mean that the class ".concat(name, " has a circular dependency problem. You can use a LazyServiceIdentifer to  overcome this limitation.");
-  };
-  var INVALID_BINDING_TYPE = "Invalid binding type:";
-  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 ARGUMENTS_LENGTH_MISMATCH() {
-    return "The number of constructor arguments in the derived class ".concat(arguments.length <= 0 ? undefined : arguments[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 ASYNC_UNBIND_REQUIRED = "Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)";
-  var PRE_DESTROY_ERROR = function PRE_DESTROY_ERROR(clazz, errorMessage) {
-    return "@preDestroy error in class ".concat(clazz, ": ").concat(errorMessage);
-  };
-  var ON_DEACTIVATION_ERROR = function ON_DEACTIVATION_ERROR(clazz, errorMessage) {
-    return "onDeactivation() error in class ".concat(clazz, ": ").concat(errorMessage);
-  };
 
   var Metadata = /*#__PURE__*/function () {
     function Metadata(key, value) {
@@ -656,23 +571,6 @@
     return Metadata;
   }();
 
-  function getFirstArrayDuplicate(array) {
-    var seenValues = new Set();
-    var _iterator = _createForOfIteratorHelper(array),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var entry = _step.value;
-        if (seenValues.has(entry)) return entry;
-        seenValues.add(entry);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-  }
-
   var Reflect$1;
   var Reflect$2 = (function (Reflect) {
     return function (factory) {
@@ -1060,70 +958,25 @@
     }(), Reflect;
   })(Reflect$1 || (Reflect$1 = {}));
 
-  function targetIsConstructorFunction(target) {
-    return void 0 !== target.prototype;
-  }
-  function _throwIfMethodParameter(parameterName) {
-    if (void 0 !== parameterName) throw new Error(INVALID_DECORATOR_OPERATION);
-  }
-  function tagParameter(annotationTarget, parameterName, parameterIndex, metadata) {
-    _throwIfMethodParameter(parameterName), _tagParameterOrProperty(TAGGED, annotationTarget, parameterIndex.toString(), metadata);
-  }
-  function tagProperty(annotationTarget, propertyName, metadata) {
-    if (targetIsConstructorFunction(annotationTarget)) throw new Error(INVALID_DECORATOR_OPERATION);
-    _tagParameterOrProperty(TAGGED_PROP, annotationTarget.constructor, propertyName, metadata);
-  }
-  function _ensureNoMetadataKeyDuplicates(metadata) {
-    var metadatas = [];
-    if (Array.isArray(metadata)) {
-      metadatas = metadata;
-      var duplicate = getFirstArrayDuplicate(metadatas.map(function (md) {
-        return md.key;
-      }));
-      if (void 0 !== duplicate) throw new Error("".concat(DUPLICATED_METADATA, " ").concat(duplicate.toString()));
-    } else metadatas = [metadata];
-    return metadatas;
-  }
   function _tagParameterOrProperty(metadataKey, annotationTarget, key, metadata) {
     var _paramOrPropertyMetad;
-    var metadatas = _ensureNoMetadataKeyDuplicates(metadata);
+    var metadatas = [metadata];
     var paramsOrPropertiesMetadata = {};
     Reflect$2.hasOwnMetadata(metadataKey, annotationTarget) && (paramsOrPropertiesMetadata = Reflect$2.getMetadata(metadataKey, annotationTarget));
     var paramOrPropertyMetadata = paramsOrPropertiesMetadata[key];
-    if (void 0 === paramOrPropertyMetadata) paramOrPropertyMetadata = [];else {
-      var _iterator = _createForOfIteratorHelper(paramOrPropertyMetadata),
-        _step;
-      try {
-        var _loop = function _loop() {
-          var m = _step.value;
-          if (metadatas.some(function (md) {
-            return md.key === m.key;
-          })) throw new Error("".concat(DUPLICATED_METADATA, " ").concat(m.key.toString()));
-        };
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          _loop();
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-    }
-    (_paramOrPropertyMetad = paramOrPropertyMetadata).push.apply(_paramOrPropertyMetad, _toConsumableArray(metadatas)), paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata, Reflect$2.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);
+    void 0 === paramOrPropertyMetadata && (paramOrPropertyMetadata = []), (_paramOrPropertyMetad = paramOrPropertyMetadata).push.apply(_paramOrPropertyMetad, metadatas), paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata, Reflect$2.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);
+  }
+  function tagParameter(annotationTarget, parameterName, parameterIndex, metadata) {
+    _tagParameterOrProperty(TAGGED, annotationTarget, parameterIndex.toString(), metadata);
   }
   function createTaggedDecorator(metadata) {
     return function (target, targetKey, indexOrPropertyDescriptor) {
-      "number" == typeof indexOrPropertyDescriptor ? tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata) : tagProperty(target, targetKey, metadata);
+      tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);
     };
   }
-
   function injectBase(metadataKey) {
     return function (serviceIdentifier) {
       return function (target, targetKey, indexOrPropertyDescriptor) {
-        if (void 0 === serviceIdentifier) {
-          var className = "function" == typeof target ? target.name : target.constructor.name;
-          throw new Error(UNDEFINED_INJECT_ANNOTATION(className));
-        }
         return createTaggedDecorator(new Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);
       };
     };
@@ -1135,9 +988,7 @@
 
   function injectable() {
     return function (target) {
-      if (Reflect$2.hasOwnMetadata(PARAM_TYPES, target)) throw new Error(DUPLICATED_INJECTABLE_DECORATOR);
-      var types = Reflect$2.getMetadata(DESIGN_PARAM_TYPES, target) || [];
-      return Reflect$2.defineMetadata(PARAM_TYPES, types, target), target;
+      return Reflect$2.defineMetadata(PARAM_TYPES, null, target), target;
     };
   }
 
@@ -1146,7 +997,6 @@
   }
 
   var BindingScopeEnum = {
-      Request: "Request",
       Singleton: "Singleton",
       Transient: "Transient"
     },
@@ -1159,25 +1009,20 @@
       Instance: "Instance",
       Invalid: "Invalid",
       Provider: "Provider"
-    },
-    TargetTypeEnum = {
-      ClassProperty: "ClassProperty",
-      ConstructorArgument: "ConstructorArgument",
-      Variable: "Variable"
     };
 
   var Binding = /*#__PURE__*/function () {
     function Binding(serviceIdentifier, scope) {
       _classCallCheck(this, Binding);
-      this.id = id(), this.activated = !1, this.serviceIdentifier = serviceIdentifier, this.scope = scope, this.type = BindingTypeEnum.Invalid, this.constraint = function (request) {
+      this.id = Generator.GenAutoIncrementId(), this.activated = !1, this.serviceIdentifier = serviceIdentifier, this.scope = scope, this.type = BindingTypeEnum.Invalid, this.constraint = function (request) {
         return !0;
-      }, this.implementationType = null, this.cache = null, this.factory = null, this.provider = null, this.onActivation = null, this.onDeactivation = null, this.dynamicValue = null;
+      }, this.implementationType = null, this.cache = null, this.factory = null, this.provider = null, this.dynamicValue = null;
     }
     _createClass(Binding, [{
       key: "clone",
       value: function clone() {
         var clone = new Binding(this.serviceIdentifier, this.scope);
-        return clone.activated = clone.scope === BindingScopeEnum.Singleton && this.activated, 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.onDeactivation = this.onDeactivation, clone.cache = this.cache, clone;
+        return clone.activated = clone.scope === BindingScopeEnum.Singleton && this.activated, clone.implementationType = this.implementationType, clone.dynamicValue = this.dynamicValue, clone.scope = this.scope, clone.type = this.type, clone.provider = this.provider, clone.constraint = this.constraint, clone.cache = this.cache, clone;
       }
     }]);
     return Binding;
@@ -1198,1450 +1043,321 @@
     }, {
       key: "getPropertiesMetadata",
       value: function getPropertiesMetadata(constructorFunc) {
-        return Reflect$2.getMetadata(TAGGED_PROP, constructorFunc) || [];
+        throw new Error("暂未实现");
       }
     }]);
     return MetadataReader;
   }();
 
-  var BindingCount = {
-    MultipleBindingsAvailable: 2,
-    NoBindingsAvailable: 0,
-    OnlyOneBindingAvailable: 1
+  var taggedConstraint = function taggedConstraint(key) {
+    return function (value) {
+      var constraint = function constraint(request) {
+        if (null == request || null == request.constructorArgsMetadata) return !1;
+        var constructorArgsMetadata = request.constructorArgsMetadata;
+        for (var i = 0; i < constructorArgsMetadata.length; i++) if (constructorArgsMetadata[i].key === key && constructorArgsMetadata[i].value === value) return !0;
+        return !1;
+      };
+      return constraint.metaData = new Metadata(key, value), constraint;
+    };
   };
+  var namedConstraint = taggedConstraint(NAMED_TAG);
 
-  function getServiceIdentifierAsString(serviceIdentifier) {
-    if ("function" == typeof serviceIdentifier) {
-      return serviceIdentifier.name;
-    }
-    if ("symbol" == _typeof(serviceIdentifier)) return serviceIdentifier.toString();
-    return serviceIdentifier;
-  }
-  function listRegisteredBindingsForServiceIdentifier(container, serviceIdentifier, getBindings) {
-    var registeredBindingsList = "";
-    var registeredBindings = getBindings(container, serviceIdentifier);
-    return 0 !== registeredBindings.length && (registeredBindingsList = "\nRegistered bindings:", registeredBindings.forEach(function (binding) {
-      var name = "Object";
-      null !== binding.implementationType && (name = getFunctionName(binding.implementationType)), registeredBindingsList = "".concat(registeredBindingsList, "\n ").concat(name), binding.constraint.metaData && (registeredBindingsList = "".concat(registeredBindingsList, " - ").concat(binding.constraint.metaData));
-    })), registeredBindingsList;
-  }
-  function listMetadataForTarget(serviceIdentifierString, target) {
-    if (target.isTagged() || target.isNamed()) {
-      var m = "";
-      var namedTag = target.getNamedTag(),
-        otherTags = target.getCustomTags();
-      return null !== namedTag && (m += namedTag.toString() + "\n"), null !== otherTags && otherTags.forEach(function (tag) {
-        m += tag.toString() + "\n";
-      }), " ".concat(serviceIdentifierString, "\n ").concat(serviceIdentifierString, " - ").concat(m);
-    }
-    return " ".concat(serviceIdentifierString);
-  }
-  function getFunctionName(func) {
-    if (func.name) return func.name;
-    var name = func.toString(),
-      match = name.match(/^function\s*([^\s(]+)/);
-    return match ? match[1] : "Anonymous function: ".concat(name);
-  }
-  function getSymbolDescription(symbol) {
-    return symbol.toString().slice(7, -1);
-  }
-
-  var Context = /*#__PURE__*/function () {
-    function Context(container) {
-      _classCallCheck(this, Context);
-      this.id = id(), this.container = container;
+  var BindingInSyntax = /*#__PURE__*/function () {
+    function BindingInSyntax(binding) {
+      _classCallCheck(this, BindingInSyntax);
+      this._binding = binding;
     }
-    _createClass(Context, [{
-      key: "addPlan",
-      value: function addPlan(plan) {
-        this.plan = plan;
+    _createClass(BindingInSyntax, [{
+      key: "inRequestScope",
+      value: function inRequestScope() {
+        throw new Error("暂未实现");
       }
     }, {
-      key: "setCurrentRequest",
-      value: function setCurrentRequest(currentRequest) {
-        this.currentRequest = currentRequest;
+      key: "inSingletonScope",
+      value: function inSingletonScope() {
+        return this._binding.scope = BindingScopeEnum.Singleton, this;
       }
-    }]);
-    return Context;
-  }();
-
-  var Plan = /*#__PURE__*/_createClass(function Plan(parentContext, rootRequest) {
-    _classCallCheck(this, Plan);
-    this.parentContext = parentContext, this.rootRequest = rootRequest;
-  });
-
-  var LazyServiceIdentifer = /*#__PURE__*/function () {
-    function LazyServiceIdentifer(cb) {
-      _classCallCheck(this, LazyServiceIdentifer);
-      this._cb = cb;
-    }
-    _createClass(LazyServiceIdentifer, [{
-      key: "unwrap",
-      value: function unwrap() {
-        return this._cb();
+    }, {
+      key: "inTransientScope",
+      value: function inTransientScope() {
+        return this._binding.scope = BindingScopeEnum.Transient, this;
+      }
+    }, {
+      key: "whenTargetNamed",
+      value: function whenTargetNamed(name) {
+        return this._binding.constraint = namedConstraint(name), this;
       }
     }]);
-    return LazyServiceIdentifer;
+    return BindingInSyntax;
   }();
 
-  var QueryableString = /*#__PURE__*/function () {
-    function QueryableString(str) {
-      _classCallCheck(this, QueryableString);
-      this.str = str;
+  var BindingToSyntax = /*#__PURE__*/function () {
+    function BindingToSyntax(binding) {
+      _classCallCheck(this, BindingToSyntax);
+      this._binding = binding;
     }
-    _createClass(QueryableString, [{
-      key: "contains",
-      value: function contains(searchString) {
-        return -1 !== this.str.indexOf(searchString);
+    _createClass(BindingToSyntax, [{
+      key: "to",
+      value: function to(constructor) {
+        return this._binding.type = BindingTypeEnum.Instance, this._binding.implementationType = constructor, new BindingInSyntax(this._binding);
+      }
+    }, {
+      key: "toSelf",
+      value: function toSelf() {
+        var self = this._binding.serviceIdentifier;
+        return this.to(self);
+      }
+    }, {
+      key: "toDynamicValue",
+      value: function toDynamicValue(func) {
+        return this._binding.type = BindingTypeEnum.DynamicValue, this._binding.cache = null, this._binding.dynamicValue = func, this._binding.implementationType = null, new BindingInSyntax(this._binding);
+      }
+    }, {
+      key: "toConstantValue",
+      value: function toConstantValue(value) {
+        return this._binding.type = BindingTypeEnum.ConstantValue, this._binding.cache = value, this._binding.dynamicValue = null, this._binding.implementationType = null, this._binding.scope = BindingScopeEnum.Singleton, new BindingInSyntax(this._binding);
       }
     }, {
-      key: "equals",
-      value: function equals(compareString) {
-        return this.str === compareString;
+      key: "toFactory",
+      value: function toFactory(factory) {
+        return this._binding.type = BindingTypeEnum.Factory, this._binding.factory = factory, this._binding.scope = BindingScopeEnum.Singleton, new BindingInSyntax(this._binding);
       }
     }, {
-      key: "value",
-      value: function value() {
-        return this.str;
+      key: "toService",
+      value: function toService(service) {
+        this.toDynamicValue(function (context) {
+          return context.container.get(service);
+        });
       }
     }]);
-    return QueryableString;
+    return BindingToSyntax;
   }();
 
-  var Target = /*#__PURE__*/function () {
-    function Target(type, identifier, serviceIdentifier, namedOrTagged) {
-      _classCallCheck(this, Target);
-      this.id = id(), this.type = type, this.serviceIdentifier = serviceIdentifier;
-      var queryableName = "symbol" == _typeof(identifier) ? getSymbolDescription(identifier) : identifier;
-      this.name = new QueryableString(queryableName || ""), this.identifier = identifier, this.metadata = [];
-      var metadataItem = null;
-      "string" == typeof namedOrTagged ? metadataItem = new Metadata(NAMED_TAG, namedOrTagged) : namedOrTagged instanceof Metadata && (metadataItem = namedOrTagged), null !== metadataItem && this.metadata.push(metadataItem);
-    }
-    _createClass(Target, [{
-      key: "hasTag",
-      value: function hasTag(key) {
-        var _iterator = _createForOfIteratorHelper(this.metadata),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var m = _step.value;
-            if (m.key === key) return !0;
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
-        }
-        return !1;
+  var Container = /*#__PURE__*/function () {
+    function Container(containerOptions) {
+      _classCallCheck(this, Container);
+      var options = containerOptions || {};
+      options.defaultScope = options.defaultScope || BindingScopeEnum.Transient, this.options = options, this.id = Generator.GenAutoIncrementId(), this._bindingDictionary = new Map(), this._metadataReader = new MetadataReader();
+    }
+    _createClass(Container, [{
+      key: "load",
+      value: function load(module) {
+        var containerModuleHelpers = this._getContainerModuleHelpersFactory()(module.id);
+        module.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
       }
     }, {
-      key: "isArray",
-      value: function isArray() {
-        return this.hasTag(MULTI_INJECT_TAG);
+      key: "get",
+      value: function get(serviceIdentifier) {
+        var getArgs = this._getNotAllArgs(serviceIdentifier, !1);
+        return this._get(getArgs);
       }
     }, {
-      key: "matchesArray",
-      value: function matchesArray(name) {
-        return this.matchesTag(MULTI_INJECT_TAG)(name);
+      key: "getAll",
+      value: function getAll(serviceIdentifier) {
+        var getArgs = this._getAllArgs(serviceIdentifier);
+        return this._get(getArgs);
       }
     }, {
-      key: "isNamed",
-      value: function isNamed() {
-        return this.hasTag(NAMED_TAG);
+      key: "getTagged",
+      value: function getTagged(serviceIdentifier, key, value) {
+        var getArgs = this._getNotAllArgs(serviceIdentifier, !1, key, value);
+        return this._get(getArgs);
       }
     }, {
-      key: "isTagged",
-      value: function isTagged() {
-        return this.metadata.some(function (metadata) {
-          return NON_CUSTOM_TAG_KEYS.every(function (key) {
-            return metadata.key !== key;
-          });
-        });
+      key: "getNamed",
+      value: function getNamed(serviceIdentifier, named) {
+        return this.getTagged(serviceIdentifier, NAMED_TAG, named);
       }
     }, {
-      key: "isOptional",
-      value: function isOptional() {
-        return this.matchesTag(OPTIONAL_TAG)(!0);
+      key: "isBound",
+      value: function isBound(serviceIdentifier) {
+        return this._bindingDictionary.has(serviceIdentifier);
       }
     }, {
-      key: "getNamedTag",
-      value: function getNamedTag() {
-        return this.isNamed() ? this.metadata.filter(function (m) {
-          return m.key === NAMED_TAG;
-        })[0] : null;
+      key: "bind",
+      value: function bind(serviceIdentifier) {
+        var scope = this.options.defaultScope,
+          binding = new Binding(serviceIdentifier, scope),
+          list = this._bindingDictionary.get(serviceIdentifier) || [];
+        return list.push(binding), this._bindingDictionary.set(serviceIdentifier, list), new BindingToSyntax(binding);
       }
     }, {
-      key: "getCustomTags",
-      value: function getCustomTags() {
-        return this.isTagged() ? this.metadata.filter(function (metadata) {
-          return NON_CUSTOM_TAG_KEYS.every(function (key) {
-            return metadata.key !== key;
-          });
-        }) : null;
+      key: "unbind",
+      value: function unbind(serviceIdentifier) {
+        this._bindingDictionary["delete"](serviceIdentifier);
       }
     }, {
-      key: "matchesNamedTag",
-      value: function matchesNamedTag(name) {
-        return this.matchesTag(NAMED_TAG)(name);
+      key: "rebind",
+      value: function rebind(serviceIdentifier) {
+        return this.unbind(serviceIdentifier), this.bind(serviceIdentifier);
       }
     }, {
-      key: "matchesTag",
-      value: function matchesTag(key) {
+      key: "_getContainerModuleHelpersFactory",
+      value: function _getContainerModuleHelpersFactory() {
         var _this = this;
-        return function (value) {
-          var _iterator2 = _createForOfIteratorHelper(_this.metadata),
-            _step2;
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var m = _step2.value;
-              if (m.key === key && m.value === value) return !0;
+        var setModuleId = function setModuleId(bindingToSyntax, moduleId) {
+            bindingToSyntax._binding.moduleId = moduleId;
+          },
+          getBindFunction = function getBindFunction(moduleId) {
+            return function (serviceIdentifier) {
+              var bindingToSyntax = _this.bind(serviceIdentifier);
+              return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
+            };
+          },
+          getUnbindFunction = function getUnbindFunction() {
+            return function (serviceIdentifier) {
+              return _this.unbind(serviceIdentifier);
+            };
+          },
+          getIsboundFunction = function getIsboundFunction() {
+            return function (serviceIdentifier) {
+              return _this.isBound(serviceIdentifier);
+            };
+          },
+          getRebindFunction = function getRebindFunction(moduleId) {
+            return function (serviceIdentifier) {
+              var bindingToSyntax = _this.rebind(serviceIdentifier);
+              return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
+            };
+          };
+        return function (mId) {
+          return {
+            bindFunction: getBindFunction(mId),
+            isboundFunction: getIsboundFunction(),
+            rebindFunction: getRebindFunction(mId),
+            unbindFunction: getUnbindFunction(),
+            unbindAsyncFunction: function unbindAsyncFunction(serviceIdentifier) {
+              return null;
             }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
-          }
-          return !1;
+          };
         };
       }
-    }]);
-    return Target;
-  }();
-
-  function getDependencies(metadataReader, func) {
-    return getTargets(metadataReader, getFunctionName(func), func, !1);
-  }
-  function getTargets(metadataReader, constructorName, func, isBaseClass) {
-    var metadata = metadataReader.getConstructorMetadata(func),
-      serviceIdentifiers = metadata.compilerGeneratedMetadata;
-    if (void 0 === serviceIdentifiers) {
-      var msg = "".concat(MISSING_INJECTABLE_ANNOTATION, " ").concat(constructorName, ".");
-      throw new Error(msg);
-    }
-    var constructorArgsMetadata = metadata.userGeneratedMetadata,
-      keys = Object.keys(constructorArgsMetadata),
-      hasUserDeclaredUnknownInjections = 0 === func.length && keys.length > 0,
-      hasOptionalParameters = keys.length > func.length;
-    return [].concat(_toConsumableArray(getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, hasUserDeclaredUnknownInjections || hasOptionalParameters ? keys.length : func.length)), _toConsumableArray(getClassPropsAsTargets(metadataReader, func, constructorName)));
-  }
-  function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {
-    var targetMetadata = constructorArgsMetadata[index.toString()] || [],
-      metadata = formatTargetMetadata(targetMetadata),
-      isManaged = !0 !== metadata.unmanaged;
-    var serviceIdentifier = serviceIdentifiers[index];
-    var injectIdentifier = metadata.inject || metadata.multiInject;
-    if (serviceIdentifier = injectIdentifier || serviceIdentifier, serviceIdentifier instanceof LazyServiceIdentifer && (serviceIdentifier = serviceIdentifier.unwrap()), isManaged) {
-      if (!isBaseClass && (serviceIdentifier === Object || serviceIdentifier === Function || void 0 === serviceIdentifier)) {
-        var msg = "".concat(MISSING_INJECT_ANNOTATION, " argument ").concat(index, " in class ").concat(constructorName, ".");
-        throw new Error(msg);
-      }
-      var target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
-      return target.metadata = targetMetadata, target;
-    }
-    return null;
-  }
-  function getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations) {
-    var targets = [];
-    for (var i = 0; i < iterations; i++) {
-      var target = getConstructorArgsAsTarget(i, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata);
-      null !== target && targets.push(target);
-    }
-    return targets;
-  }
-  function _getServiceIdentifierForProperty(inject, multiInject, propertyName, className) {
-    var serviceIdentifier = inject || multiInject;
-    if (void 0 === serviceIdentifier) {
-      var msg = "".concat(MISSING_INJECTABLE_ANNOTATION, " for property ").concat(String(propertyName), " in class ").concat(className, ".");
-      throw new Error(msg);
-    }
-    return serviceIdentifier;
-  }
-  function getClassPropsAsTargets(metadataReader, constructorFunc, constructorName) {
-    var classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);
-    var targets = [];
-    var symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata),
-      keys = Object.keys(classPropsMetadata).concat(symbolKeys);
-    var _iterator = _createForOfIteratorHelper(keys),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var key = _step.value;
-        var targetMetadata = classPropsMetadata[key],
-          metadata = formatTargetMetadata(targetMetadata),
-          identifier = metadata.targetName || key,
-          serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject, metadata.multiInject, key, constructorName),
-          target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
-        target.metadata = targetMetadata, targets.push(target);
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-    var baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor;
-    if (baseConstructor !== Object) {
-      var baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor, constructorName);
-      targets = [].concat(_toConsumableArray(targets), _toConsumableArray(baseTargets));
-    }
-    return targets;
-  }
-  function getBaseClassDependencyCount(metadataReader, func) {
-    var baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
-    if (baseConstructor !== Object) {
-      var targets = getTargets(metadataReader, getFunctionName(baseConstructor), baseConstructor, !0),
-        metadata = targets.map(function (t) {
-          return t.metadata.filter(function (m) {
-            return m.key === UNMANAGED_TAG;
-          });
-        }),
-        unmanagedCount = [].concat.apply([], metadata).length,
-        dependencyCount = targets.length - unmanagedCount;
-      return dependencyCount > 0 ? dependencyCount : getBaseClassDependencyCount(metadataReader, baseConstructor);
-    }
-    return 0;
-  }
-  function formatTargetMetadata(targetMetadata) {
-    var targetMetadataMap = {};
-    return targetMetadata.forEach(function (m) {
-      targetMetadataMap[m.key.toString()] = m.value;
-    }), {
-      inject: targetMetadataMap[INJECT_TAG],
-      multiInject: targetMetadataMap[MULTI_INJECT_TAG],
-      targetName: targetMetadataMap[NAME_TAG],
-      unmanaged: targetMetadataMap[UNMANAGED_TAG]
-    };
-  }
-
-  var Request = /*#__PURE__*/function () {
-    function Request(serviceIdentifier, parentContext, parentRequest, bindings, target) {
-      _classCallCheck(this, Request);
-      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 = null === parentRequest ? new Map() : null;
-    }
-    _createClass(Request, [{
-      key: "addChildRequest",
-      value: function addChildRequest(serviceIdentifier, bindings, target) {
-        var child = new Request(serviceIdentifier, this.parentContext, this, bindings, target);
-        return this.childRequests.push(child), 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,
-      injectMetadata = new Metadata(metadataKey, serviceIdentifier),
-      target = new Target(targetType, name, serviceIdentifier, injectMetadata);
-    if (void 0 !== key) {
-      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),
-      activeBindings = [];
-    return bindings.length === BindingCount.NoBindingsAvailable && context.container.options.autoBindInjectable && "function" == typeof target.serviceIdentifier && metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata && (context.container.bind(target.serviceIdentifier).toSelf(), bindings = getBindings(context.container, target.serviceIdentifier)), activeBindings = avoidConstraints ? bindings : bindings.filter(function (binding) {
-      var request = new Request(binding.serviceIdentifier, context, parentRequest, binding, target);
-      return binding.constraint(request);
-    }), _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container), activeBindings;
-  }
-  function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
-    switch (bindings.length) {
-      case BindingCount.NoBindingsAvailable:
-        if (target.isOptional()) return bindings;
-        var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
-        var msg = NOT_REGISTERED;
-        throw msg += listMetadataForTarget(serviceIdentifierString, target), msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings), new Error(msg);
-      case BindingCount.OnlyOneBindingAvailable:
-        return bindings;
-      case BindingCount.MultipleBindingsAvailable:
-      default:
-        if (target.isArray()) return bindings;
-        {
-          var _serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
-          var _msg = "".concat(AMBIGUOUS_MATCH, " ").concat(_serviceIdentifierString);
-          throw _msg += listRegisteredBindingsForServiceIdentifier(container, _serviceIdentifierString, getBindings), new Error(_msg);
-        }
-    }
-  }
-  function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {
-    var activeBindings, childRequest;
-    if (null === parentRequest) {
-      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 && null !== binding.implementationType) {
-        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, !1, dependency.serviceIdentifier, context, subChildRequest, dependency);
-        });
+    }, {
+      key: "_getNotAllArgs",
+      value: function _getNotAllArgs(serviceIdentifier, isMultiInject, key, value) {
+        return {
+          avoidConstraints: !1,
+          isMultiInject: isMultiInject,
+          serviceIdentifier: serviceIdentifier,
+          key: key,
+          value: value
+        };
       }
-    });
-  }
-  function getBindings(container, serviceIdentifier) {
-    var bindings = [];
-    var bindingDictionary = getBindingDictionary(container);
-    return bindingDictionary.hasKey(serviceIdentifier) ? bindings = bindingDictionary.get(serviceIdentifier) : null !== container.parent && (bindings = getBindings(container.parent, serviceIdentifier)), bindings;
-  }
-  function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value) {
-    var avoidConstraints = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : !1;
-    var context = new Context(container);
-    return _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value)), context;
-  }
-  function createMockRequest(container, serviceIdentifier, key, value) {
-    var target = new Target(TargetTypeEnum.Variable, "", serviceIdentifier, new Metadata(key, value)),
-      context = new Context(container);
-    return new Request(serviceIdentifier, context, null, [], target);
-  }
-
-  function isPromise(object) {
-    return ("object" == _typeof(object) && null !== object || "function" == typeof object) && "function" == typeof object.then;
-  }
-  function isPromiseOrContainsPromise(object) {
-    return !!isPromise(object) || Array.isArray(object) && object.some(isPromise);
-  }
-
-  var __awaiter$6 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-      function fulfilled(value) {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function rejected(value) {
-        try {
-          step(generator["throw"](value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function step(result) {
-        var value;
-        result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P(function (resolve) {
-          resolve(value);
-        })).then(fulfilled, rejected);
-      }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-  };
-  var tryGetFromScope = function tryGetFromScope(requestScope, binding) {
-    return binding.scope === BindingScopeEnum.Singleton && binding.activated ? binding.cache : binding.scope === BindingScopeEnum.Request && requestScope.has(binding.id) ? requestScope.get(binding.id) : null;
-  };
-  var saveToScope = function saveToScope(requestScope, binding, result) {
-    binding.scope === BindingScopeEnum.Singleton && _saveToSingletonScope(binding, result), binding.scope === BindingScopeEnum.Request && _saveToRequestScope(requestScope, binding, result);
-  };
-  var _saveToRequestScope = function _saveToRequestScope(requestScope, binding, result) {
-      requestScope.has(binding.id) || requestScope.set(binding.id, result);
-    },
-    _saveToSingletonScope = function _saveToSingletonScope(binding, result) {
-      binding.cache = result, binding.activated = !0, isPromise(result) && _saveAsyncResultToSingletonScope(binding, result);
-    },
-    _saveAsyncResultToSingletonScope = function _saveAsyncResultToSingletonScope(binding, asyncResult) {
-      return __awaiter$6(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-        var result;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return asyncResult;
-            case 3:
-              result = _context.sent;
-              binding.cache = result;
-              _context.next = 10;
-              break;
-            case 7:
-              _context.prev = 7;
-              _context.t0 = _context["catch"](0);
-              throw binding.cache = null, binding.activated = !1, _context.t0;
-            case 10:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, null, [[0, 7]]);
-      }));
-    };
-
-  var FactoryType;
-  !function (FactoryType) {
-    FactoryType.DynamicValue = "toDynamicValue", FactoryType.Factory = "toFactory", FactoryType.Provider = "toProvider";
-  }(FactoryType || (FactoryType = {}));
-
-  var ensureFullyBound = function ensureFullyBound(binding) {
-    var boundValue = null;
-    switch (binding.type) {
-      case BindingTypeEnum.ConstantValue:
-      case BindingTypeEnum.Function:
-        boundValue = binding.cache;
-        break;
-      case BindingTypeEnum.Constructor:
-      case BindingTypeEnum.Instance:
-        boundValue = binding.implementationType;
-        break;
-      case BindingTypeEnum.DynamicValue:
-        boundValue = binding.dynamicValue;
-        break;
-      case BindingTypeEnum.Provider:
-        boundValue = binding.provider;
-        break;
-      case BindingTypeEnum.Factory:
-        boundValue = binding.factory;
-    }
-    if (null === boundValue) {
-      var serviceIdentifierAsString = getServiceIdentifierAsString(binding.serviceIdentifier);
-      throw new Error("".concat(INVALID_BINDING_TYPE, " ").concat(serviceIdentifierAsString));
-    }
-  };
-  var getFactoryDetails = function getFactoryDetails(binding) {
-    switch (binding.type) {
-      case BindingTypeEnum.Factory:
-        return {
-          factory: binding.factory,
-          factoryType: FactoryType.Factory
-        };
-      case BindingTypeEnum.Provider:
-        return {
-          factory: binding.provider,
-          factoryType: FactoryType.Provider
-        };
-      case BindingTypeEnum.DynamicValue:
-        return {
-          factory: binding.dynamicValue,
-          factoryType: FactoryType.DynamicValue
-        };
-      default:
-        throw new Error("Unexpected factory type ".concat(binding.type));
-    }
-  };
-
-  var tryAndThrowErrorIfStackOverflow = function tryAndThrowErrorIfStackOverflow(fn, errorCallback) {
-    return fn();
-  };
-
-  var __awaiter$5 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-      function fulfilled(value) {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function rejected(value) {
-        try {
-          step(generator["throw"](value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function step(result) {
-        var value;
-        result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P(function (resolve) {
-          resolve(value);
-        })).then(fulfilled, rejected);
-      }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-  };
-  function _resolveRequests(childRequests, resolveRequest) {
-    return childRequests.reduce(function (resolvedRequests, childRequest) {
-      var injection = resolveRequest(childRequest);
-      return childRequest.target.type === TargetTypeEnum.ConstructorArgument ? resolvedRequests.constructorInjections.push(injection) : (resolvedRequests.propertyRequests.push(childRequest), resolvedRequests.propertyInjections.push(injection)), resolvedRequests.isAsync || (resolvedRequests.isAsync = isPromiseOrContainsPromise(injection)), resolvedRequests;
-    }, {
-      constructorInjections: [],
-      propertyInjections: [],
-      propertyRequests: [],
-      isAsync: !1
-    });
-  }
-  function _createInstance(constr, childRequests, resolveRequest) {
-    var result;
-    if (childRequests.length > 0) {
-      var resolved = _resolveRequests(childRequests, resolveRequest),
-        createInstanceWithInjectionsArg = Object.assign(Object.assign({}, resolved), {
-          constr: constr
-        });
-      result = resolved.isAsync ? createInstanceWithInjectionsAsync(createInstanceWithInjectionsArg) : createInstanceWithInjections(createInstanceWithInjectionsArg);
-    } else result = new constr();
-    return result;
-  }
-  function createInstanceWithInjections(args) {
-    var instance = _construct(args.constr, _toConsumableArray(args.constructorInjections));
-    return args.propertyRequests.forEach(function (r, index) {
-      var property = r.target.identifier,
-        injection = args.propertyInjections[index];
-      instance[property] = injection;
-    }), instance;
-  }
-  function createInstanceWithInjectionsAsync(args) {
-    return __awaiter$5(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-      var constructorInjections, propertyInjections;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return possiblyWaitInjections(args.constructorInjections);
-          case 2:
-            constructorInjections = _context.sent;
-            _context.next = 5;
-            return possiblyWaitInjections(args.propertyInjections);
-          case 5:
-            propertyInjections = _context.sent;
-            return _context.abrupt("return", createInstanceWithInjections(Object.assign(Object.assign({}, args), {
-              constructorInjections: constructorInjections,
-              propertyInjections: propertyInjections
-            })));
-          case 7:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee);
-    }));
-  }
-  function possiblyWaitInjections(possiblePromiseinjections) {
-    return __awaiter$5(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-      var injections, _iterator, _step, injection;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            injections = [];
-            _iterator = _createForOfIteratorHelper(possiblePromiseinjections);
-            try {
-              for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                injection = _step.value;
-                Array.isArray(injection) ? injections.push(Promise.all(injection)) : injections.push(injection);
-              }
-            } catch (err) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
-            }
-            return _context2.abrupt("return", Promise.all(injections));
-          case 4:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2);
-    }));
-  }
-  function _getInstanceAfterPostConstruct(constr, result) {
-    var postConstructResult = _postConstruct(constr, result);
-    return isPromise(postConstructResult) ? postConstructResult.then(function () {
-      return result;
-    }) : result;
-  }
-  function _postConstruct(constr, instance) {
-    var _a, _b;
-    if (Reflect$2.hasMetadata(POST_CONSTRUCT, constr)) {
-      return null === (_b = (_a = instance)[Reflect$2.getMetadata(POST_CONSTRUCT, constr).value]) || void 0 === _b ? void 0 : _b.call(_a);
-    }
-  }
-  function _validateInstanceResolution(binding, constr) {
-    binding.scope !== BindingScopeEnum.Singleton && _throwIfHandlingDeactivation(binding, constr);
-  }
-  function _throwIfHandlingDeactivation(binding, constr) {
-    var scopeErrorMessage = "Class cannot be instantiated in ".concat(binding.scope === BindingScopeEnum.Request ? "request" : "transient", " scope.");
-    if ("function" == typeof binding.onDeactivation) throw new Error(ON_DEACTIVATION_ERROR(constr.name, scopeErrorMessage));
-    if (Reflect$2.hasMetadata(PRE_DESTROY, constr)) throw new Error(PRE_DESTROY_ERROR(constr.name, scopeErrorMessage));
-  }
-  function resolveInstance(binding, constr, childRequests, resolveRequest) {
-    _validateInstanceResolution(binding, constr);
-    var result = _createInstance(constr, childRequests, resolveRequest);
-    return isPromise(result) ? result.then(function (resolvedResult) {
-      return _getInstanceAfterPostConstruct(constr, resolvedResult);
-    }) : _getInstanceAfterPostConstruct(constr, result);
-  }
-
-  var _resolveRequest = function _resolveRequest(requestScope) {
-      return function (request) {
-        request.parentContext.setCurrentRequest(request);
-        var bindings = request.bindings,
-          childRequests = request.childRequests,
-          targetIsAnArray = request.target && request.target.isArray(),
-          targetParentIsNotAnArray = !(request.parentRequest && request.parentRequest.target && request.target && request.parentRequest.target.matchesArray(request.target.serviceIdentifier));
-        if (targetIsAnArray && targetParentIsNotAnArray) return childRequests.map(function (childRequest) {
-          return _resolveRequest(requestScope)(childRequest);
-        });
-        if (request.target.isOptional() && 0 === bindings.length) return;
-        var binding = bindings[0];
-        return _resolveBinding(requestScope, request, binding);
-      };
-    },
-    _resolveFactoryFromBinding = function _resolveFactoryFromBinding(binding, context) {
-      var factoryDetails = getFactoryDetails(binding);
-      return tryAndThrowErrorIfStackOverflow(function () {
-        return factoryDetails.factory.bind(binding)(context);
-      });
-    },
-    _getResolvedFromBinding = function _getResolvedFromBinding(requestScope, request, binding) {
-      var result;
-      var childRequests = request.childRequests;
-      switch (ensureFullyBound(binding), binding.type) {
-        case BindingTypeEnum.ConstantValue:
-        case BindingTypeEnum.Function:
-          result = binding.cache;
-          break;
-        case BindingTypeEnum.Constructor:
-          result = binding.implementationType;
-          break;
-        case BindingTypeEnum.Instance:
-          result = resolveInstance(binding, binding.implementationType, childRequests, _resolveRequest(requestScope));
-          break;
-        default:
-          result = _resolveFactoryFromBinding(binding, request.parentContext);
-      }
-      return result;
-    },
-    _resolveInScope = function _resolveInScope(requestScope, binding, resolveFromBinding) {
-      var result = tryGetFromScope(requestScope, binding);
-      return null !== result || (result = resolveFromBinding(), saveToScope(requestScope, binding, result)), result;
-    },
-    _resolveBinding = function _resolveBinding(requestScope, request, binding) {
-      return _resolveInScope(requestScope, binding, function () {
-        return _getResolvedFromBinding(requestScope, request, binding);
-      });
-    };
-  function resolve(context) {
-    return _resolveRequest(context.plan.rootRequest.requestScope)(context.plan.rootRequest);
-  }
-
-  var BindingOnSyntax = /*#__PURE__*/_createClass(function BindingOnSyntax(binding) {
-    _classCallCheck(this, BindingOnSyntax);
-    this._binding = binding;
-  });
-
-  var taggedConstraint = function taggedConstraint(key) {
-      return function (value) {
-        var constraint = function constraint(request) {
-          return null !== request && null !== request.target && request.target.matchesTag(key)(value);
-        };
-        return constraint.metaData = new Metadata(key, value), constraint;
-      };
-    },
-    namedConstraint = taggedConstraint(NAMED_TAG);
-
-  var BindingWhenSyntax = /*#__PURE__*/function () {
-    function BindingWhenSyntax(binding) {
-      _classCallCheck(this, BindingWhenSyntax);
-      this._binding = binding;
-    }
-    _createClass(BindingWhenSyntax, [{
-      key: "whenTargetNamed",
-      value: function whenTargetNamed(name) {
-        return this._binding.constraint = namedConstraint(name), new BindingOnSyntax(this._binding);
-      }
-    }]);
-    return BindingWhenSyntax;
-  }();
-
-  var BindingWhenOnSyntax = /*#__PURE__*/function () {
-    function BindingWhenOnSyntax(binding) {
-      _classCallCheck(this, BindingWhenOnSyntax);
-      this._binding = binding, this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
-    }
-    _createClass(BindingWhenOnSyntax, [{
-      key: "whenTargetNamed",
-      value: function whenTargetNamed(name) {
-        return this._bindingWhenSyntax.whenTargetNamed(name);
-      }
-    }]);
-    return BindingWhenOnSyntax;
-  }();
-
-  var BindingInSyntax = /*#__PURE__*/function () {
-    function BindingInSyntax(binding) {
-      _classCallCheck(this, BindingInSyntax);
-      this._binding = binding;
-    }
-    _createClass(BindingInSyntax, [{
-      key: "inRequestScope",
-      value: function inRequestScope() {
-        return this._binding.scope = BindingScopeEnum.Request, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "inSingletonScope",
-      value: function inSingletonScope() {
-        return this._binding.scope = BindingScopeEnum.Singleton, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "inTransientScope",
-      value: function inTransientScope() {
-        return this._binding.scope = BindingScopeEnum.Transient, new BindingWhenOnSyntax(this._binding);
-      }
-    }]);
-    return BindingInSyntax;
-  }();
-
-  var BindingInWhenOnSyntax = /*#__PURE__*/function () {
-    function BindingInWhenOnSyntax(binding) {
-      _classCallCheck(this, BindingInWhenOnSyntax);
-      this._binding = binding, this._bindingWhenSyntax = new BindingWhenSyntax(this._binding), this._bindingInSyntax = new BindingInSyntax(binding);
-    }
-    _createClass(BindingInWhenOnSyntax, [{
-      key: "inRequestScope",
-      value: function inRequestScope() {
-        return this._bindingInSyntax.inRequestScope();
-      }
-    }, {
-      key: "inSingletonScope",
-      value: function inSingletonScope() {
-        return this._bindingInSyntax.inSingletonScope();
-      }
-    }, {
-      key: "inTransientScope",
-      value: function inTransientScope() {
-        return this._bindingInSyntax.inTransientScope();
-      }
-    }, {
-      key: "whenTargetNamed",
-      value: function whenTargetNamed(name) {
-        return this._bindingWhenSyntax.whenTargetNamed(name);
-      }
-    }]);
-    return BindingInWhenOnSyntax;
-  }();
-
-  var BindingToSyntax = /*#__PURE__*/function () {
-    function BindingToSyntax(binding) {
-      _classCallCheck(this, BindingToSyntax);
-      this._binding = binding;
-    }
-    _createClass(BindingToSyntax, [{
-      key: "to",
-      value: function to(constructor) {
-        return this._binding.type = BindingTypeEnum.Instance, this._binding.implementationType = constructor, new BindingInWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toSelf",
-      value: function toSelf() {
-        if ("function" != typeof this._binding.serviceIdentifier) throw new Error("".concat(INVALID_TO_SELF_VALUE));
-        var self = this._binding.serviceIdentifier;
-        return this.to(self);
-      }
-    }, {
-      key: "toConstantValue",
-      value: function toConstantValue(value) {
-        return this._binding.type = BindingTypeEnum.ConstantValue, this._binding.cache = value, this._binding.dynamicValue = null, this._binding.implementationType = null, this._binding.scope = BindingScopeEnum.Singleton, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toDynamicValue",
-      value: function toDynamicValue(func) {
-        return this._binding.type = BindingTypeEnum.DynamicValue, this._binding.cache = null, this._binding.dynamicValue = func, this._binding.implementationType = null, new BindingInWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toConstructor",
-      value: function toConstructor(constructor) {
-        return this._binding.type = BindingTypeEnum.Constructor, this._binding.implementationType = constructor, this._binding.scope = BindingScopeEnum.Singleton, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toFactory",
-      value: function toFactory(factory) {
-        return this._binding.type = BindingTypeEnum.Factory, this._binding.factory = factory, this._binding.scope = BindingScopeEnum.Singleton, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toFunction",
-      value: function toFunction(func) {
-        if ("function" != typeof func) throw new Error(INVALID_FUNCTION_BINDING);
-        var bindingWhenOnSyntax = this.toConstantValue(func);
-        return this._binding.type = BindingTypeEnum.Function, this._binding.scope = BindingScopeEnum.Singleton, bindingWhenOnSyntax;
-      }
-    }, {
-      key: "toAutoFactory",
-      value: function toAutoFactory(serviceIdentifier) {
-        return this._binding.type = BindingTypeEnum.Factory, this._binding.factory = function (context) {
-          return function () {
-            return context.container.get(serviceIdentifier);
-          };
-        }, this._binding.scope = BindingScopeEnum.Singleton, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toAutoNamedFactory",
-      value: function toAutoNamedFactory(serviceIdentifier) {
-        return this._binding.type = BindingTypeEnum.Factory, this._binding.factory = function (context) {
-          return function (named) {
-            return context.container.getNamed(serviceIdentifier, named);
-          };
-        }, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toProvider",
-      value: function toProvider(provider) {
-        return this._binding.type = BindingTypeEnum.Provider, this._binding.provider = provider, this._binding.scope = BindingScopeEnum.Singleton, new BindingWhenOnSyntax(this._binding);
-      }
-    }, {
-      key: "toService",
-      value: function toService(service) {
-        this.toDynamicValue(function (context) {
-          return context.container.get(service);
-        });
-      }
-    }]);
-    return BindingToSyntax;
-  }();
-
-  function isClonable(obj) {
-    return "object" == _typeof(obj) && null !== obj && "clone" in obj && "function" == typeof obj.clone;
-  }
-
-  var Lookup = /*#__PURE__*/function () {
-    function Lookup() {
-      _classCallCheck(this, Lookup);
-      this._map = new Map();
-    }
-    _createClass(Lookup, [{
-      key: "getMap",
-      value: function getMap() {
-        return this._map;
-      }
-    }, {
-      key: "add",
-      value: function add(serviceIdentifier, value) {
-        if (null == serviceIdentifier) throw new Error(NULL_ARGUMENT);
-        if (null == value) throw new Error(NULL_ARGUMENT);
-        var entry = this._map.get(serviceIdentifier);
-        void 0 !== entry ? entry.push(value) : this._map.set(serviceIdentifier, [value]);
-      }
-    }, {
-      key: "get",
-      value: function get(serviceIdentifier) {
-        if (null == serviceIdentifier) throw new Error(NULL_ARGUMENT);
-        var entry = this._map.get(serviceIdentifier);
-        if (void 0 !== entry) return entry;
-        throw new Error(KEY_NOT_FOUND);
+    }, {
+      key: "_getAllArgs",
+      value: function _getAllArgs(serviceIdentifier) {
+        return {
+          avoidConstraints: !0,
+          isMultiInject: !0,
+          serviceIdentifier: serviceIdentifier
+        };
       }
     }, {
-      key: "remove",
-      value: function remove(serviceIdentifier) {
-        if (null == serviceIdentifier) throw new Error(NULL_ARGUMENT);
-        if (!this._map["delete"](serviceIdentifier)) throw new Error(KEY_NOT_FOUND);
-      }
-    }, {
-      key: "removeIntersection",
-      value: function removeIntersection(lookup) {
-        var _this = this;
-        this.traverse(function (serviceIdentifier, value) {
-          var lookupActivations = lookup.hasKey(serviceIdentifier) ? lookup.get(serviceIdentifier) : void 0;
-          if (void 0 !== lookupActivations) {
-            var filteredValues = value.filter(function (lookupValue) {
-              return !lookupActivations.some(function (moduleActivation) {
-                return lookupValue === moduleActivation;
-              });
-            });
-            _this._setValue(serviceIdentifier, filteredValues);
-          }
-        });
-      }
-    }, {
-      key: "removeByCondition",
-      value: function removeByCondition(condition) {
-        var _this2 = this;
-        var removals = [];
-        return this._map.forEach(function (entries, key) {
-          var updatedEntries = [];
-          var _iterator = _createForOfIteratorHelper(entries),
-            _step;
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var entry = _step.value;
-              condition(entry) ? removals.push(entry) : updatedEntries.push(entry);
-            }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
-          }
-          _this2._setValue(key, updatedEntries);
-        }), removals;
-      }
-    }, {
-      key: "hasKey",
-      value: function hasKey(serviceIdentifier) {
-        if (null == serviceIdentifier) throw new Error(NULL_ARGUMENT);
-        return this._map.has(serviceIdentifier);
-      }
-    }, {
-      key: "clone",
-      value: function clone() {
-        var copy = new Lookup();
-        return this._map.forEach(function (value, key) {
-          value.forEach(function (b) {
-            return copy.add(key, isClonable(b) ? b.clone() : b);
-          });
-        }), copy;
-      }
-    }, {
-      key: "traverse",
-      value: function traverse(func) {
-        this._map.forEach(function (value, key) {
-          func(key, value);
-        });
-      }
-    }, {
-      key: "_setValue",
-      value: function _setValue(serviceIdentifier, value) {
-        value.length > 0 ? this._map.set(serviceIdentifier, value) : this._map["delete"](serviceIdentifier);
-      }
-    }]);
-    return Lookup;
-  }();
-
-  var __awaiter$4 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-      function fulfilled(value) {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function rejected(value) {
-        try {
-          step(generator["throw"](value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function step(result) {
-        var value;
-        result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P(function (resolve) {
-          resolve(value);
-        })).then(fulfilled, rejected);
-      }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-  };
-  var Container = /*#__PURE__*/function () {
-    function Container(containerOptions) {
-      _classCallCheck(this, Container);
-      var options = containerOptions || {};
-      if ("object" != _typeof(options)) throw new Error("".concat(CONTAINER_OPTIONS_MUST_BE_AN_OBJECT));
-      if (void 0 === options.defaultScope) options.defaultScope = BindingScopeEnum.Transient;else if (options.defaultScope !== BindingScopeEnum.Singleton && options.defaultScope !== BindingScopeEnum.Transient && options.defaultScope !== BindingScopeEnum.Request) throw new Error("".concat(CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE));
-      if (void 0 === options.autoBindInjectable) options.autoBindInjectable = !1;else if ("boolean" != typeof options.autoBindInjectable) throw new Error("".concat(CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE));
-      if (void 0 === options.skipBaseClassChecks) options.skipBaseClassChecks = !1;else if ("boolean" != typeof options.skipBaseClassChecks) throw new Error("".concat(CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK));
-      this.options = {
-        autoBindInjectable: options.autoBindInjectable,
-        defaultScope: options.defaultScope,
-        skipBaseClassChecks: options.skipBaseClassChecks
-      }, this.id = id(), this._bindingDictionary = new Lookup(), this.parent = null, this._metadataReader = new MetadataReader();
-    }
-    _createClass(Container, [{
-      key: "load",
-      value: function load() {
-        var getHelpers = this._getContainerModuleHelpersFactory();
-        for (var _len = arguments.length, modules = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
-          modules[_key2] = arguments[_key2];
-        }
-        for (var _i = 0, _modules = modules; _i < _modules.length; _i++) {
-          var currentModule = _modules[_i];
-          var containerModuleHelpers = getHelpers(currentModule.id);
-          currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
-        }
-      }
-    }, {
-      key: "unload",
-      value: function unload() {
-        var _this = this;
-        for (var _len2 = arguments.length, modules = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
-          modules[_key3] = arguments[_key3];
-        }
-        modules.forEach(function (module) {
-          var deactivations = _this._removeModuleBindings(module.id);
-          _this._deactivateSingletons(deactivations);
-        });
-      }
-    }, {
-      key: "bind",
-      value: function bind(serviceIdentifier) {
-        var scope = this.options.defaultScope || BindingScopeEnum.Transient,
-          binding = new Binding(serviceIdentifier, scope);
-        return this._bindingDictionary.add(serviceIdentifier, binding), new BindingToSyntax(binding);
-      }
-    }, {
-      key: "rebind",
-      value: function rebind(serviceIdentifier) {
-        return this.unbind(serviceIdentifier), this.bind(serviceIdentifier);
-      }
-    }, {
-      key: "unbind",
-      value: function unbind(serviceIdentifier) {
-        if (this._bindingDictionary.hasKey(serviceIdentifier)) {
-          var bindings = this._bindingDictionary.get(serviceIdentifier);
-          this._deactivateSingletons(bindings);
-        }
-        this._removeServiceFromDictionary(serviceIdentifier);
-      }
-    }, {
-      key: "unbindAll",
-      value: function unbindAll() {
+      key: "_get",
+      value: function _get(getArgs) {
         var _this2 = this;
-        this._bindingDictionary.traverse(function (_key, value) {
-          _this2._deactivateSingletons(value);
-        }), this._bindingDictionary = new Lookup();
-      }
-    }, {
-      key: "isBound",
-      value: function isBound(serviceIdentifier) {
-        var bound = this._bindingDictionary.hasKey(serviceIdentifier);
-        return !bound && this.parent && (bound = this.parent.isBound(serviceIdentifier)), bound;
-      }
-    }, {
-      key: "isCurrentBound",
-      value: function isCurrentBound(serviceIdentifier) {
-        return this._bindingDictionary.hasKey(serviceIdentifier);
-      }
-    }, {
-      key: "isBoundNamed",
-      value: function isBoundNamed(serviceIdentifier, named) {
-        return this.isBoundTagged(serviceIdentifier, NAMED_TAG, named);
-      }
-    }, {
-      key: "isBoundTagged",
-      value: function isBoundTagged(serviceIdentifier, key, value) {
-        var bound = !1;
-        if (this._bindingDictionary.hasKey(serviceIdentifier)) {
-          var bindings = this._bindingDictionary.get(serviceIdentifier),
-            request = createMockRequest(this, serviceIdentifier, key, value);
-          bound = bindings.some(function (b) {
-            return b.constraint(request);
-          });
-        }
-        return !bound && this.parent && (bound = this.parent.isBoundTagged(serviceIdentifier, key, value)), bound;
-      }
-    }, {
-      key: "applyCustomMetadataReader",
-      value: function applyCustomMetadataReader(metadataReader) {
-        this._metadataReader = metadataReader;
-      }
-    }, {
-      key: "get",
-      value: function get(serviceIdentifier) {
-        var getArgs = this._getNotAllArgs(serviceIdentifier, !1);
-        return this._getButThrowIfAsync(getArgs);
-      }
-    }, {
-      key: "getAsync",
-      value: function getAsync(serviceIdentifier) {
-        return __awaiter$4(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-          var getArgs;
-          return _regeneratorRuntime().wrap(function _callee$(_context) {
-            while (1) switch (_context.prev = _context.next) {
-              case 0:
-                getArgs = this._getNotAllArgs(serviceIdentifier, !1);
-                return _context.abrupt("return", this._get(getArgs));
-              case 2:
-              case "end":
-                return _context.stop();
-            }
-          }, _callee, this);
-        }));
-      }
-    }, {
-      key: "getTagged",
-      value: function getTagged(serviceIdentifier, key, value) {
-        var getArgs = this._getNotAllArgs(serviceIdentifier, !1, key, value);
-        return this._getButThrowIfAsync(getArgs);
-      }
-    }, {
-      key: "getNamed",
-      value: function getNamed(serviceIdentifier, named) {
-        return this.getTagged(serviceIdentifier, NAMED_TAG, named);
-      }
-    }, {
-      key: "getAll",
-      value: function getAll(serviceIdentifier) {
-        var getArgs = this._getAllArgs(serviceIdentifier);
-        return this._getButThrowIfAsync(getArgs);
-      }
-    }, {
-      key: "getAllTagged",
-      value: function getAllTagged(serviceIdentifier, key, value) {
-        var getArgs = this._getNotAllArgs(serviceIdentifier, !0, key, value);
-        return this._getButThrowIfAsync(getArgs);
-      }
-    }, {
-      key: "getAllNamed",
-      value: function getAllNamed(serviceIdentifier, named) {
-        return this.getAllTagged(serviceIdentifier, NAMED_TAG, named);
-      }
-    }, {
-      key: "resolve",
-      value: function resolve(constructorFunction) {
-        var isBound = this.isBound(constructorFunction);
-        isBound || this.bind(constructorFunction).toSelf();
-        var resolved = this.get(constructorFunction);
-        return isBound || this.unbind(constructorFunction), resolved;
-      }
-    }, {
-      key: "_preDestroy",
-      value: function _preDestroy(constructor, instance) {
-        var _a, _b;
-        if (Reflect$2.hasMetadata(PRE_DESTROY, constructor)) {
-          return null === (_b = (_a = instance)[Reflect$2.getMetadata(PRE_DESTROY, constructor).value]) || void 0 === _b ? void 0 : _b.call(_a);
-        }
+        var result = [];
+        return this._bindingDictionary.get(getArgs.serviceIdentifier).forEach(function (binding) {
+          result.push(_this2._resolveFromBinding(binding));
+        }), getArgs.isMultiInject || 1 !== result.length ? result : result[0];
       }
     }, {
-      key: "_removeModuleBindings",
-      value: function _removeModuleBindings(moduleId) {
-        return this._bindingDictionary.removeByCondition(function (binding) {
-          return binding.moduleId === moduleId;
-        });
-      }
-    }, {
-      key: "_deactivate",
-      value: function _deactivate(binding, instance) {
-        var constructor = Object.getPrototypeOf(instance).constructor;
-        try {
-          var propagateDeactivationResult = this._propagateContainerDeactivationThenBindingAndPreDestroy(binding, instance, constructor);
-          if (isPromise(propagateDeactivationResult)) return this._handleDeactivationError(propagateDeactivationResult, constructor);
-        } catch (ex) {
-          if (ex instanceof Error) throw new Error(ON_DEACTIVATION_ERROR(constructor.name, ex.message));
-        }
-      }
-    }, {
-      key: "_handleDeactivationError",
-      value: function _handleDeactivationError(asyncResult, constructor) {
-        return __awaiter$4(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
-          return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-            while (1) switch (_context2.prev = _context2.next) {
-              case 0:
-                _context2.prev = 0;
-                _context2.next = 3;
-                return asyncResult;
-              case 3:
-                _context2.next = 9;
-                break;
-              case 5:
-                _context2.prev = 5;
-                _context2.t0 = _context2["catch"](0);
-                if (!(_context2.t0 instanceof Error)) {
-                  _context2.next = 9;
-                  break;
-                }
-                throw new Error(ON_DEACTIVATION_ERROR(constructor.name, _context2.t0.message));
-              case 9:
-              case "end":
-                return _context2.stop();
-            }
-          }, _callee2, null, [[0, 5]]);
-        }));
-      }
-    }, {
-      key: "_getContainerModuleHelpersFactory",
-      value: function _getContainerModuleHelpersFactory() {
+      key: "_getChildRequest",
+      value: function _getChildRequest(binding) {
         var _this3 = this;
-        var setModuleId = function setModuleId(bindingToSyntax, moduleId) {
-            bindingToSyntax._binding.moduleId = moduleId;
-          },
-          getBindFunction = function getBindFunction(moduleId) {
-            return function (serviceIdentifier) {
-              var bindingToSyntax = _this3.bind(serviceIdentifier);
-              return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
-            };
-          },
-          getUnbindFunction = function getUnbindFunction() {
-            return function (serviceIdentifier) {
-              return _this3.unbind(serviceIdentifier);
-            };
-          },
-          getIsboundFunction = function getIsboundFunction() {
-            return function (serviceIdentifier) {
-              return _this3.isBound(serviceIdentifier);
-            };
-          },
-          getRebindFunction = function getRebindFunction(moduleId) {
-            return function (serviceIdentifier) {
-              var bindingToSyntax = _this3.rebind(serviceIdentifier);
-              return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
+        var constr = binding.implementationType,
+          _this$_metadataReader = this._metadataReader.getConstructorMetadata(constr),
+          userGeneratedMetadata = _this$_metadataReader.userGeneratedMetadata,
+          keys = Object.keys(userGeneratedMetadata),
+          arr = [];
+        var _loop = function _loop() {
+          var constructorArgsMetadata = userGeneratedMetadata[i],
+            targetMetadataMap = {};
+          constructorArgsMetadata.forEach(function (md) {
+            targetMetadataMap[md.key] = md.value;
+          });
+          var metadata = {
+              inject: targetMetadataMap[INJECT_TAG],
+              multiInject: targetMetadataMap[MULTI_INJECT_TAG]
+            },
+            injectIdentifier = metadata.inject || metadata.multiInject,
+            target = {
+              serviceIdentifier: injectIdentifier,
+              constructorArgsMetadata: constructorArgsMetadata
+            },
+            request = {
+              injectIdentifier: injectIdentifier,
+              metadata: constructorArgsMetadata,
+              bindings: _this3._bindingDictionary.get(injectIdentifier).filter(function (b) {
+                return b.constraint(target);
+              })
             };
-          };
-        return function (mId) {
-          return {
-            bindFunction: getBindFunction(mId),
-            isboundFunction: getIsboundFunction(),
-            rebindFunction: getRebindFunction(mId),
-            unbindFunction: getUnbindFunction(),
-            unbindAsyncFunction: function unbindAsyncFunction(serviceIdentifier) {
-              return null;
-            }
-          };
-        };
-      }
-    }, {
-      key: "_get",
-      value: function _get(getArgs) {
-        var planAndResolveArgs = Object.assign(Object.assign({}, getArgs), {
-          contextInterceptor: function contextInterceptor(context) {
-            return context;
-          },
-          targetType: TargetTypeEnum.Variable
-        });
-        return this._planAndResolve()(planAndResolveArgs);
-      }
-    }, {
-      key: "_getButThrowIfAsync",
-      value: function _getButThrowIfAsync(getArgs) {
-        return this._get(getArgs);
-      }
-    }, {
-      key: "_getAllArgs",
-      value: function _getAllArgs(serviceIdentifier) {
-        return {
-          avoidConstraints: !0,
-          isMultiInject: !0,
-          serviceIdentifier: serviceIdentifier
-        };
-      }
-    }, {
-      key: "_getNotAllArgs",
-      value: function _getNotAllArgs(serviceIdentifier, isMultiInject, key, value) {
-        return {
-          avoidConstraints: !1,
-          isMultiInject: isMultiInject,
-          serviceIdentifier: serviceIdentifier,
-          key: key,
-          value: value
-        };
-      }
-    }, {
-      key: "_planAndResolve",
-      value: function _planAndResolve() {
-        var _this4 = this;
-        return function (args) {
-          var context = plan(_this4._metadataReader, _this4, args.isMultiInject, args.targetType, args.serviceIdentifier, args.key, args.value, args.avoidConstraints);
-          context = args.contextInterceptor(context);
-          return resolve(context);
+          arr.push(request);
         };
+        for (var i = 0; i < keys.length; i++) {
+          _loop();
+        }
+        return arr;
       }
     }, {
-      key: "_deactivateIfSingleton",
-      value: function _deactivateIfSingleton(binding) {
-        var _this5 = this;
-        if (binding.activated) return isPromise(binding.cache) ? binding.cache.then(function (resolved) {
-          return _this5._deactivate(binding, resolved);
-        }) : this._deactivate(binding, binding.cache);
+      key: "_resolveFromBinding",
+      value: function _resolveFromBinding(binding) {
+        var result = this._getResolvedFromBinding(binding);
+        return this._saveToScope(binding, result), result;
       }
     }, {
-      key: "_deactivateSingletons",
-      value: function _deactivateSingletons(bindings) {
-        var _iterator = _createForOfIteratorHelper(bindings),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var binding = _step.value;
-            var result = this._deactivateIfSingleton(binding);
-            if (isPromise(result)) throw new Error(ASYNC_UNBIND_REQUIRED);
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
+      key: "_getResolvedFromBinding",
+      value: function _getResolvedFromBinding(binding) {
+        var result;
+        switch (binding.type) {
+          case BindingTypeEnum.ConstantValue:
+          case BindingTypeEnum.Function:
+            result = binding.cache;
+            break;
+          case BindingTypeEnum.Instance:
+            result = this._resolveInstance(binding, binding.implementationType);
+            break;
+          default:
+            result = binding.dynamicValue({
+              container: this
+            });
         }
+        return result;
       }
     }, {
-      key: "_propagateContainerDeactivationThenBindingAndPreDestroy",
-      value: function _propagateContainerDeactivationThenBindingAndPreDestroy(binding, instance, constructor) {
-        return this.parent ? this._deactivate.bind(this.parent)(binding, instance) : this._bindingDeactivationAndPreDestroy(binding, instance, constructor);
+      key: "_resolveInstance",
+      value: function _resolveInstance(binding, constr) {
+        if (binding.activated) return binding.cache;
+        var childRequests = this._getChildRequest(binding);
+        return this._createInstance(constr, childRequests);
       }
     }, {
-      key: "_removeServiceFromDictionary",
-      value: function _removeServiceFromDictionary(serviceIdentifier) {
-        try {
-          this._bindingDictionary.remove(serviceIdentifier);
-        } catch (e) {
-          throw new Error("".concat(CANNOT_UNBIND, " ").concat(getServiceIdentifierAsString(serviceIdentifier)));
+      key: "_createInstance",
+      value: function _createInstance(constr, childRequests) {
+        if (childRequests.length) {
+          return _construct(constr, _toConsumableArray(this._resolveRequests(childRequests)));
         }
+        return new constr();
       }
     }, {
-      key: "_bindingDeactivationAndPreDestroy",
-      value: function _bindingDeactivationAndPreDestroy(binding, instance, constructor) {
-        var _this6 = this;
-        if ("function" == typeof binding.onDeactivation) {
-          var result = binding.onDeactivation(instance);
-          if (isPromise(result)) return result.then(function () {
-            return _this6._preDestroy(constructor, instance);
-          });
-        }
-        return this._preDestroy(constructor, instance);
+      key: "_resolveRequests",
+      value: function _resolveRequests(childRequests) {
+        var _this4 = this;
+        return childRequests.map(function (request) {
+          return request.bindings.length > 1 ? request.bindings.map(function (binding) {
+            return _this4._resolveFromBinding(binding);
+          }) : _this4._resolveFromBinding(request.bindings[0]);
+        });
       }
     }, {
-      key: "_bindingDeactivationAndPreDestroyAsync",
-      value: function _bindingDeactivationAndPreDestroyAsync(binding, instance, constructor) {
-        return __awaiter$4(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-          return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-            while (1) switch (_context3.prev = _context3.next) {
-              case 0:
-                _context3.t0 = "function" == typeof binding.onDeactivation;
-                if (!_context3.t0) {
-                  _context3.next = 4;
-                  break;
-                }
-                _context3.next = 4;
-                return binding.onDeactivation(instance);
-              case 4:
-                _context3.next = 6;
-                return this._preDestroy(constructor, instance);
-              case 6:
-              case "end":
-                return _context3.stop();
-            }
-          }, _callee3, this);
-        }));
-      }
-    }], [{
-      key: "merge",
-      value: function merge(container1, container2) {
-        for (var _len3 = arguments.length, containers = new Array(_len3 > 2 ? _len3 - 2 : 0), _key4 = 2; _key4 < _len3; _key4++) {
-          containers[_key4 - 2] = arguments[_key4];
-        }
-        var container = new Container(),
-          targetContainers = [container1, container2].concat(containers).map(function (targetContainer) {
-            return getBindingDictionary(targetContainer);
-          }),
-          bindingDictionary = getBindingDictionary(container);
-        return targetContainers.forEach(function (targetBindingDictionary) {
-          var destination;
-          destination = bindingDictionary, targetBindingDictionary.traverse(function (_key, value) {
-            value.forEach(function (binding) {
-              destination.add(binding.serviceIdentifier, binding.clone());
-            });
-          });
-        }), container;
+      key: "_saveToScope",
+      value: function _saveToScope(binding, result) {
+        binding.scope === BindingScopeEnum.Singleton && (binding.cache = result, binding.activated = !0);
       }
     }]);
     return Container;
   }();
 
-  function propertyEventDecorator(eventKey, errorMessage) {
-    return function () {
-      return function (target, propertyKey) {
-        var metadata = new Metadata(eventKey, propertyKey);
-        if (Reflect$2.hasOwnMetadata(eventKey, target.constructor)) throw new Error(errorMessage);
-        Reflect$2.defineMetadata(eventKey, metadata, target.constructor);
-      };
-    };
-  }
-
-  var postConstruct = propertyEventDecorator(POST_CONSTRUCT, MULTIPLE_POST_CONSTRUCT_METHODS);
-
   var ContributionProvider = Symbol("ContributionProvider");
   var ContributionProviderCache = /*#__PURE__*/function () {
     function ContributionProviderCache(serviceIdentifier, container) {
@@ -2781,9 +1497,9 @@
   var DefaultGlobal = /*#__PURE__*/function () {
     function DefaultGlobal(contributions) {
       _classCallCheck(this, DefaultGlobal);
-      this.contributions = contributions, this.hooks = {
+      this.contributions = contributions, this.id = Generator.GenAutoIncrementId(), this.hooks = {
         onSetEnv: new SyncHook(["lastEnv", "env", "global"])
-      }, this.measureTextMethod = "native", this.optimizeVisible = !1;
+      }, this.measureTextMethod = "native", this.optimizeVisible = !1, this.optmizeSkipCheckBoundariesThreshold = 0;
     }
     _createClass(DefaultGlobal, [{
       key: "env",
@@ -4451,7 +3167,10 @@
     direction: "horizontal",
     wordBreak: "break-all",
     ignoreBuf: !1,
-    verticalMode: 0
+    verticalMode: 0,
+    whiteSpace: "no-wrap",
+    heightLimit: 1 / 0,
+    lineClamp: 1 / 0
   };
   var DefaultStyle = Object.assign(Object.assign(Object.assign({
     opacity: 1,
@@ -5329,9 +4048,14 @@
   var DefaultCanvasAllocate = /*#__PURE__*/function () {
     function DefaultCanvasAllocate() {
       _classCallCheck(this, DefaultCanvasAllocate);
-      this.pools = [];
+      this.pools = [], this.allocatedCanvas = [];
     }
     _createClass(DefaultCanvasAllocate, [{
+      key: "shareCanvas",
+      value: function shareCanvas() {
+        return this.allocatedCanvas.length ? this.allocatedCanvas[0] : this.getCommonCanvas();
+      }
+    }, {
       key: "getCommonCanvas",
       value: function getCommonCanvas() {
         return this._commonCanvas || (this._commonCanvas = this.allocate({
@@ -5343,9 +4067,12 @@
     }, {
       key: "allocate",
       value: function allocate(data) {
-        if (!this.pools.length) return wrapCanvas(Object.assign({
-          nativeCanvas: application.global.createCanvas(data)
-        }, data));
+        if (!this.pools.length) {
+          var c = wrapCanvas(Object.assign({
+            nativeCanvas: application.global.createCanvas(data)
+          }, data));
+          return this.allocatedCanvas.push(c), c;
+        }
         var m = this.pools.pop();
         return m.resize(data.width, data.height), m.dpr = data.dpr, m;
       }
@@ -5354,13 +4081,14 @@
       value: function allocateByObj(canvas) {
         if (!this.pools.length) {
           var data = {
-            width: canvas.width / canvas.dpr,
-            height: canvas.height / canvas.dpr,
-            dpr: canvas.dpr
-          };
-          return wrapCanvas(Object.assign({
-            nativeCanvas: application.global.createCanvas(data)
-          }, data));
+              width: canvas.width / canvas.dpr,
+              height: canvas.height / canvas.dpr,
+              dpr: canvas.dpr
+            },
+            c = wrapCanvas(Object.assign({
+              nativeCanvas: application.global.createCanvas(data)
+            }, data));
+          return this.allocatedCanvas.push(c), c;
         }
         var m = this.pools.pop();
         return m.width = canvas.width, m.height = canvas.height, m;
@@ -5409,6 +4137,16 @@
       });
     }
     _createClass(DefaultGraphicUtil, [{
+      key: "canvas",
+      get: function get() {
+        return this.tryInitCanvas(), this._canvas;
+      }
+    }, {
+      key: "context",
+      get: function get() {
+        return this.tryInitCanvas(), this._context;
+      }
+    }, {
       key: "textMeasure",
       get: function get() {
         return this._textMeasure || this.configure(this.global, this.global.env), this._textMeasure;
@@ -5417,11 +4155,17 @@
       key: "configure",
       value: function configure(global, env) {
         var _this2 = this;
-        if (this.configured) return;
-        var canvas = canvasAllocate.getCommonCanvas();
-        this.canvas = canvas, this.context = canvas.getContext("2d"), this.contributions.getContributions().forEach(function (contribution) {
+        this.configured || (this.contributions.getContributions().forEach(function (contribution) {
           contribution.configure(_this2, env);
-        }), this.configured = !0;
+        }), this.configured = !0);
+      }
+    }, {
+      key: "tryInitCanvas",
+      value: function tryInitCanvas() {
+        if (!this._canvas) {
+          var canvas = canvasAllocate.shareCanvas();
+          this._canvas = canvas, this._context = canvas.getContext("2d");
+        }
       }
     }, {
       key: "bindTextMeasure",
@@ -5675,20 +4419,6 @@
     return null;
   }
 
-  var Generator = /*#__PURE__*/function () {
-    function Generator() {
-      _classCallCheck(this, Generator);
-    }
-    _createClass(Generator, null, [{
-      key: "GenAutoIncrementId",
-      value: function GenAutoIncrementId() {
-        return Generator.auto_increment_id++;
-      }
-    }]);
-    return Generator;
-  }();
-  Generator.auto_increment_id = 0;
-
   var __awaiter$3 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
       function fulfilled(value) {
@@ -7492,6 +6222,12 @@
   }();
   RafBasedSTO.TimeOut = 1e3 / 60;
   new RafBasedSTO();
+  var calculateLineHeight = function calculateLineHeight(lineHeight, fontSize) {
+    if (vutils.isString(lineHeight) && "%" === lineHeight[lineHeight.length - 1]) {
+      return fontSize * (Number.parseFloat(lineHeight.substring(0, lineHeight.length - 1)) / 100);
+    }
+    return lineHeight;
+  };
 
   var IncreaseCount = /*#__PURE__*/function (_ACustomAnimate) {
     _inherits(IncreaseCount, _ACustomAnimate);
@@ -8609,8 +7345,7 @@
     }, {
       key: "addChild",
       value: function addChild(node) {
-        var _this$child$push2;
-        "__proto__" === node.tagname && (node.tagname = "#__proto__"), node[":@"] && Object.keys(node[":@"]).length > 0 ? this.child.push((_this$child$push2 = {}, _defineProperty(_this$child$push2, node.tagname, node.child), _defineProperty(_this$child$push2, ":@", node[":@"]), _this$child$push2)) : this.child.push(_defineProperty({}, node.tagname, node.child));
+        "__proto__" === node.tagname && (node.tagname = "#__proto__"), node[":@"] && Object.keys(node[":@"]).length > 0 ? this.child.push(_defineProperty(_defineProperty({}, node.tagname, node.child), ":@", node[":@"])) : this.child.push(_defineProperty({}, node.tagname, node.child));
       }
     }]);
     return XmlNode;
@@ -9459,7 +8194,7 @@
       _classCallCheck(this, DefaultWindow);
       this.hooks = {
         onChange: new SyncHook(["x", "y", "width", "height"])
-      }, this._uid = Generator.GenAutoIncrementId(), this.global = application.global;
+      }, this._uid = Generator.GenAutoIncrementId(), this.global = application.global, this.postInit();
     }
     _createClass(DefaultWindow, [{
       key: "width",
@@ -9602,7 +8337,7 @@
     }]);
     return DefaultWindow;
   }();
-  __decorate$C([postConstruct(), __metadata$o("design:type", Function), __metadata$o("design:paramtypes", []), __metadata$o("design:returntype", void 0)], DefaultWindow.prototype, "postInit", null), DefaultWindow = __decorate$C([injectable(), __metadata$o("design:paramtypes", [])], DefaultWindow);
+  DefaultWindow = __decorate$C([injectable(), __metadata$o("design:paramtypes", [])], DefaultWindow);
 
   var coreModule = new ContainerModule(function (bind) {
     bind(VGlobal).to(DefaultGlobal).inSingletonScope(), bind(VWindow).to(DefaultWindow), bind(GraphicUtil).to(DefaultGraphicUtil).inSingletonScope(), bind(TransformUtil).to(DefaultTransformUtil).inSingletonScope(), bind(LayerService).to(DefaultLayerService).inSingletonScope();
@@ -10008,7 +8743,7 @@
     return CanvasTextLayout;
   }();
 
-  var TEXT_UPDATE_TAG_KEY = ["text", "maxLineWidth", "fontSize", "fontFamily", "fontWeight", "ellipsis", "lineHeight", "direction", "wordBreak"].concat(_toConsumableArray(GRAPHIC_UPDATE_TAG_KEY));
+  var TEXT_UPDATE_TAG_KEY = ["text", "maxLineWidth", "heightLimit", "lineClamp", "fontSize", "fontFamily", "fontWeight", "ellipsis", "lineHeight", "direction", "wordBreak"].concat(_toConsumableArray(GRAPHIC_UPDATE_TAG_KEY));
   var Text = /*#__PURE__*/function (_Graphic) {
     _inherits(Text, _Graphic);
     var _super = _createSuper(Text);
@@ -10082,6 +8817,117 @@
           paddingArray = parsePadding(boundsPadding);
         return paddingArray && bounds.expand(paddingArray), this.clearUpdateBoundTag(), bounds;
       }
+    }, {
+      key: "updateWrapAABBBounds",
+      value: function updateWrapAABBBounds(text) {
+        var _a, _b, _c, _d;
+        var textTheme = getTheme(this).text,
+          _this$attribute = this.attribute,
+          _this$attribute$fontF = _this$attribute.fontFamily,
+          fontFamily = _this$attribute$fontF === void 0 ? textTheme.fontFamily : _this$attribute$fontF,
+          _this$attribute$textA = _this$attribute.textAlign,
+          textAlign = _this$attribute$textA === void 0 ? textTheme.textAlign : _this$attribute$textA,
+          _this$attribute$textB = _this$attribute.textBaseline,
+          textBaseline = _this$attribute$textB === void 0 ? textTheme.textBaseline : _this$attribute$textB,
+          _this$attribute$fontS = _this$attribute.fontSize,
+          fontSize = _this$attribute$fontS === void 0 ? textTheme.fontSize : _this$attribute$fontS,
+          _this$attribute$ellip = _this$attribute.ellipsis,
+          ellipsis = _this$attribute$ellip === void 0 ? textTheme.ellipsis : _this$attribute$ellip,
+          maxLineWidth = _this$attribute.maxLineWidth,
+          _this$attribute$strok = _this$attribute.stroke,
+          stroke = _this$attribute$strok === void 0 ? textTheme.stroke : _this$attribute$strok,
+          _this$attribute$lineW = _this$attribute.lineWidth,
+          lineWidth = _this$attribute$lineW === void 0 ? textTheme.lineWidth : _this$attribute$lineW,
+          _this$attribute$wordB = _this$attribute.wordBreak,
+          wordBreak = _this$attribute$wordB === void 0 ? textTheme.wordBreak : _this$attribute$wordB,
+          _this$attribute$fontW = _this$attribute.fontWeight,
+          fontWeight = _this$attribute$fontW === void 0 ? textTheme.fontWeight : _this$attribute$fontW,
+          _this$attribute$ignor = _this$attribute.ignoreBuf,
+          ignoreBuf = _this$attribute$ignor === void 0 ? textTheme.ignoreBuf : _this$attribute$ignor,
+          _this$attribute$heigh = _this$attribute.heightLimit,
+          heightLimit = _this$attribute$heigh === void 0 ? 0 : _this$attribute$heigh,
+          lineClamp = _this$attribute.lineClamp,
+          lineHeight = null !== (_a = calculateLineHeight(this.attribute.lineHeight, this.attribute.fontSize || textTheme.fontSize)) && void 0 !== _a ? _a : this.attribute.fontSize || textTheme.fontSize,
+          buf = ignoreBuf ? 0 : 2;
+        if (!this.shouldUpdateShape() && (null === (_b = this.cache) || void 0 === _b ? void 0 : _b.layoutData)) {
+          var _bbox = this.cache.layoutData.bbox;
+          return this._AABBBounds.set(_bbox.xOffset, _bbox.yOffset, _bbox.xOffset + _bbox.width, _bbox.yOffset + _bbox.height), stroke && this._AABBBounds.expand(lineWidth / 2), this._AABBBounds;
+        }
+        var textMeasure = application.graphicUtil.textMeasure,
+          layoutObj = new CanvasTextLayout(fontFamily, {
+            fontSize: fontSize,
+            fontWeight: fontWeight,
+            fontFamily: fontFamily
+          }, textMeasure),
+          lines = vutils.isArray(text) ? text.map(function (l) {
+            return l.toString();
+          }) : [text.toString()],
+          linesLayout = [],
+          bboxWH = [0, 0];
+        var lineCountLimit = 1 / 0;
+        if (heightLimit > 0 && (lineCountLimit = Math.max(Math.floor(heightLimit / lineHeight), 1)), lineClamp && (lineCountLimit = Math.min(lineCountLimit, lineClamp)), "number" == typeof maxLineWidth && maxLineWidth !== 1 / 0) {
+          if (maxLineWidth > 0) for (var i = 0; i < lines.length; i++) {
+            var str = lines[i];
+            var needCut = !0;
+            if (i === lineCountLimit - 1) {
+              var _clip = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, !1);
+              linesLayout.push({
+                str: _clip.str,
+                width: _clip.width
+              });
+              break;
+            }
+            var clip = layoutObj.textMeasure.clipText(str, layoutObj.textOptions, maxLineWidth, "break-word" === wordBreak);
+            if ("" !== str && "" === clip.str) {
+              if (ellipsis) {
+                var clipEllipsis = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, !1);
+                clip.str = null !== (_c = clipEllipsis.str) && void 0 !== _c ? _c : "", clip.width = null !== (_d = clipEllipsis.width) && void 0 !== _d ? _d : 0;
+              } else clip.str = "", clip.width = 0;
+              needCut = !1;
+            }
+            if (linesLayout.push({
+              str: clip.str,
+              width: clip.width
+            }), clip.str.length === str.length) ;else if (needCut) {
+              var newStr = str.substring(clip.str.length);
+              lines.splice(i + 1, 0, newStr);
+            }
+          }
+          var maxWidth = 0;
+          linesLayout.forEach(function (layout) {
+            maxWidth = Math.max(maxWidth, layout.width);
+          }), bboxWH[0] = maxWidth;
+        } else {
+          var width,
+            _text,
+            _lineWidth = 0;
+          for (var _i = 0, len = lines.length; _i < len; _i++) {
+            if (_i === lineCountLimit - 1) {
+              var _clip2 = layoutObj.textMeasure.clipTextWithSuffix(lines[_i], layoutObj.textOptions, maxLineWidth, ellipsis, !1);
+              linesLayout.push({
+                str: _clip2.str,
+                width: _clip2.width
+              }), _lineWidth = Math.max(_lineWidth, _clip2.width);
+              break;
+            }
+            _text = lines[_i], width = layoutObj.textMeasure.measureTextWidth(_text, layoutObj.textOptions, "break-word" === wordBreak), _lineWidth = Math.max(_lineWidth, width), linesLayout.push({
+              str: _text,
+              width: width
+            });
+          }
+          bboxWH[0] = _lineWidth;
+        }
+        bboxWH[1] = linesLayout.length * (lineHeight + buf);
+        var bbox = {
+          xOffset: 0,
+          yOffset: 0,
+          width: bboxWH[0],
+          height: bboxWH[1]
+        };
+        layoutObj.LayoutBBox(bbox, textAlign, textBaseline);
+        var layoutData = layoutObj.layoutWithBBox(bbox, linesLayout, textAlign, textBaseline, lineHeight);
+        return this.cache.layoutData = layoutData, this.clearUpdateShapeTag(), this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height), stroke && this._AABBBounds.expand(lineWidth / 2), this._AABBBounds;
+      }
     }, {
       key: "updateSingallineAABBBounds",
       value: function updateSingallineAABBBounds(text) {
@@ -10128,9 +8974,12 @@
           _attribute$wordBreak === void 0 ? textTheme.wordBreak : _attribute$wordBreak;
           var _attribute$ignoreBuf = attribute.ignoreBuf,
           ignoreBuf = _attribute$ignoreBuf === void 0 ? textTheme.ignoreBuf : _attribute$ignoreBuf,
-          buf = ignoreBuf ? 0 : Math.max(2, .075 * fontSize),
-          _attribute$lineHeight = attribute.lineHeight,
-          lineHeight = _attribute$lineHeight === void 0 ? null !== (_a = attribute.lineHeight) && void 0 !== _a ? _a : (attribute.fontSize || textTheme.fontSize) + buf : _attribute$lineHeight;
+          _attribute$whiteSpace = attribute.whiteSpace,
+          whiteSpace = _attribute$whiteSpace === void 0 ? textTheme.whiteSpace : _attribute$whiteSpace;
+        if ("normal" === whiteSpace) return this.updateWrapAABBBounds(text);
+        var buf = ignoreBuf ? 0 : Math.max(2, .075 * fontSize),
+          textFontSize = attribute.fontSize || textTheme.fontSize,
+          lineHeight = null !== (_a = calculateLineHeight(attribute.lineHeight, textFontSize)) && void 0 !== _a ? _a : textFontSize + buf;
         if (!this.shouldUpdateShape() && this.cache) {
           width = null !== (_b = this.cache.clipedWidth) && void 0 !== _b ? _b : 0;
           var _dx = textDrawOffsetX(textAlign, width),
@@ -10200,12 +9049,11 @@
           fontFamily = _attribute$fontFamily2 === void 0 ? textTheme.fontFamily : _attribute$fontFamily2,
           _attribute$stroke2 = attribute.stroke,
           stroke = _attribute$stroke2 === void 0 ? textTheme.stroke : _attribute$stroke2,
-          _attribute$lineHeight2 = attribute.lineHeight,
-          lineHeight = _attribute$lineHeight2 === void 0 ? null !== (_a = attribute.lineHeight) && void 0 !== _a ? _a : (attribute.fontSize || textTheme.fontSize) + buf : _attribute$lineHeight2,
           _attribute$lineWidth2 = attribute.lineWidth,
           lineWidth = _attribute$lineWidth2 === void 0 ? textTheme.lineWidth : _attribute$lineWidth2,
           _attribute$verticalMo = attribute.verticalMode,
-          verticalMode = _attribute$verticalMo === void 0 ? textTheme.verticalMode : _attribute$verticalMo;
+          verticalMode = _attribute$verticalMo === void 0 ? textTheme.verticalMode : _attribute$verticalMo,
+          lineHeight = null !== (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) && void 0 !== _a ? _a : (attribute.fontSize || textTheme.fontSize) + buf;
         var _attribute$textAlign2 = attribute.textAlign,
           textAlign = _attribute$textAlign2 === void 0 ? textTheme.textAlign : _attribute$textAlign2,
           _attribute$textBaseli2 = attribute.textBaseline,
@@ -10255,7 +9103,7 @@
     }, {
       key: "updateHorizontalMultilineAABBBounds",
       value: function updateHorizontalMultilineAABBBounds(text) {
-        var _a;
+        var _a, _b;
         var textTheme = getTheme(this).text,
           attribute = this.attribute,
           _attribute$fontFamily3 = attribute.fontFamily,
@@ -10268,8 +9116,6 @@
           fontSize = _attribute$fontSize3 === void 0 ? textTheme.fontSize : _attribute$fontSize3,
           _attribute$fontWeight3 = attribute.fontWeight,
           fontWeight = _attribute$fontWeight3 === void 0 ? textTheme.fontWeight : _attribute$fontWeight3,
-          _attribute$lineHeight3 = attribute.lineHeight,
-          lineHeight = _attribute$lineHeight3 === void 0 ? attribute.lineHeight || attribute.fontSize || textTheme.fontSize : _attribute$lineHeight3,
           _attribute$ellipsis3 = attribute.ellipsis,
           ellipsis = _attribute$ellipsis3 === void 0 ? textTheme.ellipsis : _attribute$ellipsis3,
           maxLineWidth = attribute.maxLineWidth,
@@ -10277,11 +9123,13 @@
           stroke = _attribute$stroke3 === void 0 ? textTheme.stroke : _attribute$stroke3,
           _attribute$lineWidth3 = attribute.lineWidth,
           lineWidth = _attribute$lineWidth3 === void 0 ? textTheme.lineWidth : _attribute$lineWidth3,
-          _attribute$wordBreak2 = attribute.wordBreak;
-          _attribute$wordBreak2 === void 0 ? textTheme.wordBreak : _attribute$wordBreak2;
-        if (!this.shouldUpdateShape() && (null === (_a = this.cache) || void 0 === _a ? void 0 : _a.layoutData)) {
-          var _bbox = this.cache.layoutData.bbox;
-          return this._AABBBounds.set(_bbox.xOffset, _bbox.yOffset, _bbox.xOffset + _bbox.width, _bbox.yOffset + _bbox.height), stroke && this._AABBBounds.expand(lineWidth / 2), this._AABBBounds;
+          _attribute$whiteSpace2 = attribute.whiteSpace,
+          whiteSpace = _attribute$whiteSpace2 === void 0 ? textTheme.whiteSpace : _attribute$whiteSpace2,
+          lineHeight = null !== (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) && void 0 !== _a ? _a : attribute.fontSize || textTheme.fontSize;
+        if ("normal" === whiteSpace) return this.updateWrapAABBBounds(text);
+        if (!this.shouldUpdateShape() && (null === (_b = this.cache) || void 0 === _b ? void 0 : _b.layoutData)) {
+          var _bbox2 = this.cache.layoutData.bbox;
+          return this._AABBBounds.set(_bbox2.xOffset, _bbox2.yOffset, _bbox2.xOffset + _bbox2.width, _bbox2.yOffset + _bbox2.height), stroke && this._AABBBounds.expand(lineWidth / 2), this._AABBBounds;
         }
         var textMeasure = application.graphicUtil.textMeasure,
           layoutData = new CanvasTextLayout(fontFamily, {
@@ -10315,12 +9163,11 @@
           fontWeight = _attribute$fontWeight4 === void 0 ? textTheme.fontWeight : _attribute$fontWeight4,
           _attribute$stroke4 = attribute.stroke,
           stroke = _attribute$stroke4 === void 0 ? textTheme.stroke : _attribute$stroke4,
-          _attribute$lineHeight4 = attribute.lineHeight,
-          lineHeight = _attribute$lineHeight4 === void 0 ? null !== (_a = attribute.lineHeight) && void 0 !== _a ? _a : (attribute.fontSize || textTheme.fontSize) + buf : _attribute$lineHeight4,
           _attribute$lineWidth4 = attribute.lineWidth,
           lineWidth = _attribute$lineWidth4 === void 0 ? textTheme.lineWidth : _attribute$lineWidth4,
           _attribute$verticalMo2 = attribute.verticalMode,
-          verticalMode = _attribute$verticalMo2 === void 0 ? textTheme.verticalMode : _attribute$verticalMo2;
+          verticalMode = _attribute$verticalMo2 === void 0 ? textTheme.verticalMode : _attribute$verticalMo2,
+          lineHeight = null !== (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) && void 0 !== _a ? _a : (attribute.fontSize || textTheme.fontSize) + buf;
         var _attribute$textAlign4 = attribute.textAlign,
           textAlign = _attribute$textAlign4 === void 0 ? textTheme.textAlign : _attribute$textAlign4,
           _attribute$textBaseli4 = attribute.textBaseline,
@@ -10453,7 +9300,7 @@
     }, {
       key: "updateMultilineAABBBounds",
       value: function updateMultilineAABBBounds(text) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         var textTheme = getTheme(this).text,
           _this$attribute = this.attribute,
           _this$attribute$fontF = _this$attribute.fontFamily,
@@ -10464,8 +9311,6 @@
           textBaseline = _this$attribute$textB === void 0 ? textTheme.textBaseline : _this$attribute$textB,
           _this$attribute$fontS = _this$attribute.fontSize,
           fontSize = _this$attribute$fontS === void 0 ? textTheme.fontSize : _this$attribute$fontS,
-          _this$attribute$lineH = _this$attribute.lineHeight,
-          lineHeight = _this$attribute$lineH === void 0 ? this.attribute.lineHeight || this.attribute.fontSize || textTheme.fontSize : _this$attribute$lineH,
           _this$attribute$ellip = _this$attribute.ellipsis,
           ellipsis = _this$attribute$ellip === void 0 ? textTheme.ellipsis : _this$attribute$ellip,
           maxLineWidth = _this$attribute.maxLineWidth,
@@ -10482,8 +9327,9 @@
           _this$attribute$heigh = _this$attribute.heightLimit,
           heightLimit = _this$attribute$heigh === void 0 ? 0 : _this$attribute$heigh,
           lineClamp = _this$attribute.lineClamp,
+          lineHeight = null !== (_a = calculateLineHeight(this.attribute.lineHeight, this.attribute.fontSize || textTheme.fontSize)) && void 0 !== _a ? _a : this.attribute.fontSize || textTheme.fontSize,
           buf = ignoreBuf ? 0 : 2;
-        if (!this.shouldUpdateShape() && (null === (_a = this.cache) || void 0 === _a ? void 0 : _a.layoutData)) {
+        if (!this.shouldUpdateShape() && (null === (_b = this.cache) || void 0 === _b ? void 0 : _b.layoutData)) {
           var _bbox = this.cache.layoutData.bbox;
           return this._AABBBounds.set(_bbox.xOffset, _bbox.yOffset, _bbox.xOffset + _bbox.width, _bbox.yOffset + _bbox.height), stroke && this._AABBBounds.expand(lineWidth / 2), this._AABBBounds;
         }
@@ -10515,7 +9361,7 @@
             if ("" !== str && "" === clip.str) {
               if (ellipsis) {
                 var clipEllipsis = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, !1);
-                clip.str = null !== (_b = clipEllipsis.str) && void 0 !== _b ? _b : "", clip.width = null !== (_c = clipEllipsis.width) && void 0 !== _c ? _c : 0;
+                clip.str = null !== (_c = clipEllipsis.str) && void 0 !== _c ? _c : "", clip.width = null !== (_d = clipEllipsis.width) && void 0 !== _d ? _d : 0;
               } else clip.str = "", clip.width = 0;
               needCut = !1;
             }
@@ -11331,6 +10177,13 @@
   builtinSymbols.forEach(function (symbol) {
     builtinSymbolsMap[symbol.type] = symbol;
   });
+  var builtInSymbolStrMap = {
+    arrowLeft: "M 0.25 -0.5 L -0.25 0 l 0.5 0.5",
+    arrowRight: "M -0.25 -0.5 l 0.5 0.5 l -0.5 0.5",
+    rect: "M -0.5,0.25 L 0.5,0.25 L 0.5,-0.25,L -0.5,-0.25 Z",
+    rectRound: "M 0.3 -0.5 C 0.41 -0.5 0.5 -0.41 0.5 -0.3 C 0.5 -0.3 0.5 0.3 0.5 0.3 C 0.5 0.41 0.41 0.5 0.3 0.5 C 0.3 0.5 -0.3 0.5 -0.3 0.5 C -0.41 0.5 -0.5 0.41 -0.5 0.3 C -0.5 0.3 -0.5 -0.3 -0.5 -0.3 C -0.5 -0.41 -0.41 -0.5 -0.3 -0.5 C -0.3 -0.5 0.3 -0.5 0.3 -0.5 Z",
+    roundLine: "M 1.2392 -0.258 L -1.3432 -0.258 C -1.4784 -0.258 -1.588 -0.1436 -1.588 -0.002 c 0 0.1416 0.1096 0.256 0.2448 0.256 l 2.5824 0 c 0.1352 0 0.2448 -0.1144 0.2448 -0.256 C 1.484 -0.1436 1.3744 -0.258 1.2392 -0.258 z"
+  };
 
   var _tempBounds = new vutils.AABBBounds(),
     SYMBOL_UPDATE_TAG_KEY = ["symbolType", "size"].concat(_toConsumableArray(GRAPHIC_UPDATE_TAG_KEY));
@@ -11365,12 +10218,13 @@
     }, {
       key: "doUpdateParsedPath",
       value: function doUpdateParsedPath() {
-        var symbolTheme = getTheme(this).symbol,
-          _this$attribute$symbo = this.attribute.symbolType,
-          symbolType = _this$attribute$symbo === void 0 ? symbolTheme.symbolType : _this$attribute$symbo;
-        var path = builtinSymbolsMap[symbolType];
+        var symbolTheme = getTheme(this).symbol;
+        var _this$attribute$symbo = this.attribute.symbolType,
+          symbolType = _this$attribute$symbo === void 0 ? symbolTheme.symbolType : _this$attribute$symbo,
+          path = builtinSymbolsMap[symbolType];
         if (path) return this._parsedPath = path, path;
         if (path = _Symbol.userSymbolMap[symbolType], path) return this._parsedPath = path, path;
+        symbolType = builtInSymbolStrMap[symbolType] || symbolType;
         if (!0 === isSvg(symbolType)) {
           var parser = new XMLParser(),
             _parser$parse = parser.parse(symbolType),
@@ -11856,7 +10710,9 @@
   var Paragraph = /*#__PURE__*/function () {
     function Paragraph(text, newLine, character) {
       _classCallCheck(this, Paragraph);
-      this.fontSize = character.fontSize || 16, this.textBaseline = character.textBaseline || "alphabetic", "number" == typeof character.lineHeight ? this.lineHeight = character.lineHeight > this.fontSize ? character.lineHeight : this.fontSize : this.lineHeight = Math.floor(1.2 * this.fontSize), this.height = this.lineHeight;
+      this.fontSize = character.fontSize || 16, this.textBaseline = character.textBaseline || "alphabetic";
+      var lineHeight = calculateLineHeight(character.lineHeight, this.fontSize);
+      this.lineHeight = "number" == typeof lineHeight ? lineHeight > this.fontSize ? lineHeight : this.fontSize : Math.floor(1.2 * this.fontSize), this.height = this.lineHeight;
       var _measureTextCanvas = measureTextCanvas(text, character),
         ascent = _measureTextCanvas.ascent,
         height = _measureTextCanvas.height,
@@ -15253,33 +14109,64 @@
         }
         return !1;
       }
+    }, {
+      key: "drawLinearLineHighPerformance",
+      value: function drawLinearLineHighPerformance(line, context, fill, stroke, fillOpacity, strokeOpacity, offsetX, offsetY, lineAttribute, drawContext, params, fillCb, strokeCb) {
+        var _a;
+        context.beginPath();
+        var z = null !== (_a = this.z) && void 0 !== _a ? _a : 0,
+          points = line.attribute.points,
+          startP = points[0];
+        context.moveTo(startP.x, startP.y, z);
+        for (var i = 1; i < points.length; i++) {
+          var p = points[i];
+          context.lineTo(p.x, p.y, z);
+        }
+        context.setShadowBlendStyle && context.setShadowBlendStyle(line, line.attribute, lineAttribute);
+        var _line$attribute = line.attribute,
+          _line$attribute$x = _line$attribute.x,
+          originX = _line$attribute$x === void 0 ? 0 : _line$attribute$x,
+          _line$attribute$x2 = _line$attribute.x,
+          originY = _line$attribute$x2 === void 0 ? 0 : _line$attribute$x2;
+        !1 !== fill && (fillCb ? fillCb(context, line.attribute, lineAttribute) : fillOpacity && (context.setCommonStyle(line, line.attribute, originX - offsetX, originY - offsetY, lineAttribute), context.fill())), !1 !== stroke && (strokeCb ? strokeCb(context, line.attribute, lineAttribute) : strokeOpacity && (context.setStrokeStyle(line, line.attribute, originX - offsetX, originY - offsetY, lineAttribute), context.stroke()));
+      }
     }, {
       key: "drawShape",
       value: function drawShape(line, context, x, y, drawContext, params, fillCb, strokeCb) {
         var _this2 = this;
         var lineAttribute = getTheme(line, null == params ? void 0 : params.theme).line,
-          _line$attribute = line.attribute,
-          _line$attribute$fill = _line$attribute.fill,
-          fill = _line$attribute$fill === void 0 ? lineAttribute.fill : _line$attribute$fill,
-          _line$attribute$strok = _line$attribute.stroke,
-          stroke = _line$attribute$strok === void 0 ? lineAttribute.stroke : _line$attribute$strok,
-          _line$attribute$fillO = _line$attribute.fillOpacity,
-          fillOpacity = _line$attribute$fillO === void 0 ? lineAttribute.fillOpacity : _line$attribute$fillO,
-          _line$attribute$strok2 = _line$attribute.strokeOpacity,
-          strokeOpacity = _line$attribute$strok2 === void 0 ? lineAttribute.strokeOpacity : _line$attribute$strok2;
+          _line$attribute2 = line.attribute,
+          _line$attribute2$fill = _line$attribute2.fill,
+          fill = _line$attribute2$fill === void 0 ? lineAttribute.fill : _line$attribute2$fill,
+          _line$attribute2$stro = _line$attribute2.stroke,
+          stroke = _line$attribute2$stro === void 0 ? lineAttribute.stroke : _line$attribute2$stro,
+          _line$attribute2$fill2 = _line$attribute2.fillOpacity,
+          fillOpacity = _line$attribute2$fill2 === void 0 ? lineAttribute.fillOpacity : _line$attribute2$fill2,
+          _line$attribute2$stro2 = _line$attribute2.strokeOpacity,
+          strokeOpacity = _line$attribute2$stro2 === void 0 ? lineAttribute.strokeOpacity : _line$attribute2$stro2,
+          segments = _line$attribute2.segments,
+          points = _line$attribute2.points,
+          closePath = _line$attribute2.closePath;
         if (!this.valid(line, lineAttribute, fillCb, strokeCb)) return;
+        var _line$attribute$curve = line.attribute.curveType,
+          curveType = _line$attribute$curve === void 0 ? lineAttribute.curveType : _line$attribute$curve;
+        closePath && "linear" === curveType && (curveType = "linearClosed");
+        var _line$attribute3 = line.attribute,
+          _line$attribute3$clip = _line$attribute3.clipRange,
+          clipRange = _line$attribute3$clip === void 0 ? lineAttribute.clipRange : _line$attribute3$clip,
+          _line$attribute3$clip2 = _line$attribute3.clipRangeByDimension,
+          clipRangeByDimension = _line$attribute3$clip2 === void 0 ? lineAttribute.clipRangeByDimension : _line$attribute3$clip2;
+        if (1 === clipRange && !segments && !points.some(function (p) {
+          return !1 === p.defined;
+        }) && "linear" === curveType) return this.drawLinearLineHighPerformance(line, context, !!fill, !!stroke, fillOpacity, strokeOpacity, x, y, lineAttribute, drawContext, params, fillCb, strokeCb);
         if (line.shouldUpdateShape()) {
-          var _line$attribute2 = line.attribute,
-            points = _line$attribute2.points,
-            segments = _line$attribute2.segments,
-            closePath = _line$attribute2.closePath;
-          var _line$attribute$curve = line.attribute.curveType,
-            curveType = _line$attribute$curve === void 0 ? lineAttribute.curveType : _line$attribute$curve;
-          closePath && "linear" === curveType && (curveType = "linearClosed");
-          var _points = points;
-          if (segments && segments.length) {
+          var _line$attribute4 = line.attribute,
+            _points2 = _line$attribute4.points,
+            _segments = _line$attribute4.segments,
+            _points = _points2;
+          if (_segments && _segments.length) {
             var startPoint, lastSeg;
-            if (line.cache = segments.map(function (seg, index) {
+            if (line.cache = _segments.map(function (seg, index) {
               if (seg.points.length <= 1 && 0 === index) return seg.points[0] && (lastSeg = {
                 endX: seg.points[0].x,
                 endY: seg.points[0].y,
@@ -15311,24 +14198,19 @@
               line.cache[line.cache.length - 1] && line.cache[line.cache.length - 1].lineTo(startP.x, startP.y, !0);
             }
           } else {
-            if (!points || !points.length) return line.cache = null, void line.clearUpdateShapeTag();
+            if (!_points2 || !_points2.length) return line.cache = null, void line.clearUpdateShapeTag();
             line.cache = calcLineCache$1(_points, curveType);
           }
           line.clearUpdateShapeTag();
         }
-        var _line$attribute3 = line.attribute,
-          _line$attribute3$clip = _line$attribute3.clipRange,
-          clipRange = _line$attribute3$clip === void 0 ? lineAttribute.clipRange : _line$attribute3$clip,
-          _line$attribute3$clip2 = _line$attribute3.clipRangeByDimension,
-          clipRangeByDimension = _line$attribute3$clip2 === void 0 ? lineAttribute.clipRangeByDimension : _line$attribute3$clip2;
         if (Array.isArray(line.cache)) {
-          var _segments = line.attribute.segments.filter(function (item) {
+          var _segments2 = line.attribute.segments.filter(function (item) {
             return item.points.length;
           });
-          if (1 === _segments[0].points.length && _segments.shift(), 1 === clipRange) {
+          if (1 === _segments2[0].points.length && _segments2.shift(), 1 === clipRange) {
             var skip = !1;
             line.cache.forEach(function (cache, index) {
-              skip || (skip = _this2.drawSegmentItem(context, cache, !!fill, !!stroke, fillOpacity, strokeOpacity, _segments[index], [lineAttribute, line.attribute], clipRange, clipRangeByDimension, x, y, line, fillCb, strokeCb));
+              skip || (skip = _this2.drawSegmentItem(context, cache, !!fill, !!stroke, fillOpacity, strokeOpacity, _segments2[index], [lineAttribute, line.attribute], clipRange, clipRangeByDimension, x, y, line, fillCb, strokeCb));
             });
           } else {
             var totalLength = line.cache.reduce(function (l, c) {
@@ -15341,7 +14223,7 @@
               if (_skip) return;
               var curSegLength = cache.getLength(),
                 _cr = (totalDrawLength - drawedLengthUntilLast) / curSegLength;
-              drawedLengthUntilLast += curSegLength, _cr > 0 && (_skip = _this2.drawSegmentItem(context, cache, !!fill, !!stroke, fillOpacity, strokeOpacity, _segments[index], [lineAttribute, line.attribute], vutils.min(_cr, 1), clipRangeByDimension, x, y, line, fillCb, strokeCb));
+              drawedLengthUntilLast += curSegLength, _cr > 0 && (_skip = _this2.drawSegmentItem(context, cache, !!fill, !!stroke, fillOpacity, strokeOpacity, _segments2[index], [lineAttribute, line.attribute], vutils.min(_cr, 1), clipRangeByDimension, x, y, line, fillCb, strokeCb));
             });
           }
         } else this.drawSegmentItem(context, line.cache, !!fill, !!stroke, fillOpacity, strokeOpacity, line.attribute, lineAttribute, clipRange, clipRangeByDimension, x, y, line, fillCb, strokeCb);
@@ -16029,21 +14911,7 @@
         var textAttribute = getTheme(text, null == params ? void 0 : params.theme).text,
           _text$attribute = text.attribute,
           str = _text$attribute.text,
-          _text$attribute$fill = _text$attribute.fill;
-          _text$attribute$fill === void 0 ? textAttribute.fill : _text$attribute$fill;
-          var _text$attribute$strok = _text$attribute.stroke;
-          _text$attribute$strok === void 0 ? textAttribute.stroke : _text$attribute$strok;
-          var _text$attribute$fillO = _text$attribute.fillOpacity;
-          _text$attribute$fillO === void 0 ? textAttribute.fillOpacity : _text$attribute$fillO;
-          var _text$attribute$strok2 = _text$attribute.strokeOpacity;
-          _text$attribute$strok2 === void 0 ? textAttribute.strokeOpacity : _text$attribute$strok2;
-          var _text$attribute$opaci = _text$attribute.opacity;
-          _text$attribute$opaci === void 0 ? textAttribute.opacity : _text$attribute$opaci;
-          var _text$attribute$lineW = _text$attribute.lineWidth;
-          _text$attribute$lineW === void 0 ? textAttribute.lineWidth : _text$attribute$lineW;
-          var _text$attribute$visib = _text$attribute.visible;
-          _text$attribute$visib === void 0 ? textAttribute.visible : _text$attribute$visib;
-          var _text$attribute$under = _text$attribute.underline,
+          _text$attribute$under = _text$attribute.underline,
           underline = _text$attribute$under === void 0 ? textAttribute.underline : _text$attribute$under,
           _text$attribute$lineT = _text$attribute.lineThrough,
           lineThrough = _text$attribute$lineT === void 0 ? textAttribute.lineThrough : _text$attribute$lineT,
@@ -16068,7 +14936,7 @@
           var t = textAlign;
           textAlign = null !== (_a = text.getBaselineMapAlign()[textBaseline]) && void 0 !== _a ? _a : "left", textBaseline = null !== (_b = text.getAlignMapBaseline()[t]) && void 0 !== _b ? _b : "top";
         }
-        var lineHeight = null !== (_c = text.attribute.lineHeight) && void 0 !== _c ? _c : fontSize,
+        var lineHeight = null !== (_c = calculateLineHeight(text.attribute.lineHeight, fontSize)) && void 0 !== _c ? _c : fontSize,
           data = this.valid(text, textAttribute, fillCb, strokeCb);
         if (!data) return;
         var fVisible = data.fVisible,
@@ -16101,6 +14969,7 @@
               context.fillText(line.str, (line.leftOffset || 0) + xOffset + x, (line.topOffset || 0) + yOffset + y, z), _this2.drawMultiUnderLine(underline, lineThrough, text, (line.leftOffset || 0) + x, (line.topOffset || 0) + yOffset + y, z, line.width, textAttribute, context);
             })));
           } else {
+            text.tryUpdateAABBBounds();
             var cache = text.cache,
               verticalList = cache.verticalList;
             context.textAlign = "left", context.textBaseline = "top";
@@ -16128,14 +14997,15 @@
               });
             });
           }
+        } else if ("horizontal" === direction) {
+          context.setTextStyle(text.attribute, textAttribute, z);
+          var _t = text.clipedText;
+          var dy = 0;
+          lineHeight !== fontSize && ("top" === textBaseline ? dy = (lineHeight - fontSize) / 2 : "middle" === textBaseline || "bottom" === textBaseline && (dy = -(lineHeight - fontSize) / 2)), drawText(_t, 0, dy, 0);
         } else {
+          text.tryUpdateAABBBounds();
           var _cache = text.cache;
-          if ("horizontal" === direction) {
-            context.setTextStyle(text.attribute, textAttribute, z);
-            var _t = text.clipedText;
-            var dy = 0;
-            lineHeight !== fontSize && ("top" === textBaseline ? dy = (lineHeight - fontSize) / 2 : "middle" === textBaseline || "bottom" === textBaseline && (dy = -(lineHeight - fontSize) / 2)), drawText(_t, 0, dy, 0);
-          } else if (_cache) {
+          if (_cache) {
             context.setTextStyleWithoutAlignBaseline(text.attribute, textAttribute, z);
             var _verticalList = _cache.verticalList;
             var _offsetY = 0;
@@ -17437,7 +16307,7 @@
   var DefaultDrawContribution = /*#__PURE__*/function () {
     function DefaultDrawContribution(contributions, drawItemInterceptorContributions) {
       _classCallCheck(this, DefaultDrawContribution);
-      this.contributions = contributions, this.drawItemInterceptorContributions = drawItemInterceptorContributions, this.currentRenderMap = new Map(), this.defaultRenderMap = new Map(), this.styleRenderMap = new Map(), this.dirtyBounds = new vutils.Bounds(), this.backupDirtyBounds = new vutils.Bounds(), this.global = application.global, this.layerService = application.layerService;
+      this.contributions = contributions, this.drawItemInterceptorContributions = drawItemInterceptorContributions, this.currentRenderMap = new Map(), this.defaultRenderMap = new Map(), this.styleRenderMap = new Map(), this.dirtyBounds = new vutils.Bounds(), this.backupDirtyBounds = new vutils.Bounds(), this.global = application.global, this.layerService = application.layerService, this.init();
     }
     _createClass(DefaultDrawContribution, [{
       key: "init",
@@ -17452,11 +16322,18 @@
           return a.order - b.order;
         });
       }
+    }, {
+      key: "prepareForDraw",
+      value: function prepareForDraw(renderService, drawContext) {
+        renderService.renderTreeRoots.reduce(function (a, b) {
+          return a + b.count;
+        }, 0) < this.global.optmizeSkipCheckBoundariesThreshold ? this.useDirtyBounds = !1 : this.useDirtyBounds = !0;
+      }
     }, {
       key: "draw",
       value: function draw(renderService, drawContext) {
         var _this2 = this;
-        drawContext.drawContribution = this, this.currentRenderMap = this.styleRenderMap.get(drawContext.renderStyle) || this.defaultRenderMap, this.currentRenderService = renderService;
+        this.prepareForDraw(renderService, drawContext), drawContext.drawContribution = this, this.currentRenderMap = this.styleRenderMap.get(drawContext.renderStyle) || this.defaultRenderMap, this.currentRenderService = renderService;
         var context = drawContext.context,
           stage = drawContext.stage,
           _drawContext$x = drawContext.x,
@@ -17503,11 +16380,14 @@
         var _this3 = this;
         if (drawContext["break"] || !1 === group.attribute.visibleAll) return;
         if (group.incremental && (null == drawContext.startAtId || drawContext.startAtId === group._uid)) return drawContext["break"] = !0, void this._increaseRender(group, drawContext);
-        if (!vutils.isRectIntersect(group.AABBBounds, this.dirtyBounds, !1)) return;
-        var tempBounds = boundsAllocate.allocateByObj(this.dirtyBounds),
-          gm = group.transMatrix,
-          nextM = matrixAllocate.allocateByObj(parentMatrix).multiply(gm.a, gm.b, gm.c, gm.d, gm.e, gm.f);
-        this.dirtyBounds.copy(this.backupDirtyBounds).transformWithMatrix(nextM.getInverse()), this.renderItem(group, drawContext, {
+        if (this.useDirtyBounds && !vutils.isRectIntersect(group.AABBBounds, this.dirtyBounds, !1)) return;
+        var nextM, tempBounds;
+        if (this.useDirtyBounds) {
+          tempBounds = boundsAllocate.allocateByObj(this.dirtyBounds);
+          var gm = group.transMatrix;
+          nextM = matrixAllocate.allocateByObj(parentMatrix).multiply(gm.a, gm.b, gm.c, gm.d, gm.e, gm.f), this.dirtyBounds.copy(this.backupDirtyBounds).transformWithMatrix(nextM.getInverse());
+        }
+        this.renderItem(group, drawContext, {
           drawingCb: function drawingCb() {
             var _a;
             skipSort ? group.forEachChildren(function (item) {
@@ -17516,7 +16396,7 @@
               drawContext["break"] || (item.isContainer ? _this3.renderGroup(item, drawContext, nextM) : _this3.renderItem(item, drawContext));
             }, !1, !!(null === (_a = drawContext.context) || void 0 === _a ? void 0 : _a.camera));
           }
-        }), this.dirtyBounds.copy(tempBounds), boundsAllocate.free(tempBounds), matrixAllocate.free(nextM);
+        }), this.useDirtyBounds && (this.dirtyBounds.copy(tempBounds), boundsAllocate.free(tempBounds), matrixAllocate.free(nextM));
       }
     }, {
       key: "_increaseRender",
@@ -17587,7 +16467,7 @@
             this.dirtyBounds.copy(this.backupDirtyBounds).transformWithMatrix(m), this.dirtyBounds.translate(-scrollX, -scrollY);
           }
         }
-        if (!graphic.isContainer && !vutils.isRectIntersect(graphic.AABBBounds, this.dirtyBounds, !1)) return void (retrans && this.dirtyBounds.copy(tempBounds));
+        if (this.useDirtyBounds && !graphic.isContainer && !vutils.isRectIntersect(graphic.AABBBounds, this.dirtyBounds, !1)) return void (retrans && this.dirtyBounds.copy(tempBounds));
         var skipDraw = null != drawContext.startAtId && graphic._uid !== drawContext.startAtId;
         if (graphic._uid === drawContext.startAtId && (drawContext.startAtId = null), params && (params.skipDraw = skipDraw), skipDraw ? graphic.isContainer && renderer.draw(graphic, this.currentRenderService, drawContext, params) : renderer.draw(graphic, this.currentRenderService, drawContext, params), retrans && this.dirtyBounds.copy(tempBounds), this.InterceptorContributions.length) for (var _i = 0; _i < this.InterceptorContributions.length; _i++) {
           var _drawContribution = this.InterceptorContributions[_i];
@@ -17638,7 +16518,7 @@
     }]);
     return DefaultDrawContribution;
   }();
-  __decorate$g([postConstruct(), __metadata$7("design:type", Function), __metadata$7("design:paramtypes", []), __metadata$7("design:returntype", void 0)], DefaultDrawContribution.prototype, "init", null), DefaultDrawContribution = __decorate$g([injectable(), __param$3(0, multiInject(GraphicRender)), __param$3(1, inject(ContributionProvider)), __param$3(1, named(DrawItemInterceptor)), __metadata$7("design:paramtypes", [Array, Object])], DefaultDrawContribution);
+  DefaultDrawContribution = __decorate$g([injectable(), __param$3(0, multiInject(GraphicRender)), __param$3(1, inject(ContributionProvider)), __param$3(1, named(DrawItemInterceptor)), __metadata$7("design:paramtypes", [Array, Object])], DefaultDrawContribution);
 
   var __decorate$f = undefined && undefined.__decorate || function (decorators, target, key, desc) {
       var d,
@@ -19979,9 +18859,15 @@
       'cursor'
   ];
   class AbstractComponent extends Group {
-      constructor(attributes, mode = '2d') {
+      constructor(attributes, options) {
           super(attributes);
-          this.mode = mode;
+          if (options === null || options === void 0 ? void 0 : options.mode) {
+              this.mode = options.mode;
+              this.setMode(options.mode);
+          }
+          if (options === null || options === void 0 ? void 0 : options.skipDefault) {
+              this.skipDefault = true;
+          }
           this.setTheme({
               common: {
                   strokeBoundsBuffer: 0
@@ -20058,8 +18944,8 @@
       throttle: vutils.throttle
   };
   class ScrollBar extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, ScrollBar.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, ScrollBar.defaultAttributes, attributes));
           this.name = 'scrollbar';
           this._onRailPointerDown = (e) => {
               var _a, _b;
@@ -20802,8 +19688,8 @@
   }
 
   class Tag extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, Tag.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Tag.defaultAttributes, attributes));
           this.name = 'tag';
       }
       render() {
@@ -20920,8 +19806,8 @@
 
   const _tBounds = new vutils.AABBBounds();
   class PopTip extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, PopTip.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, PopTip.defaultAttributes, attributes));
           this.name = 'poptip';
           this.positionList = ['top', 'tl', 'tr', 'bottom', 'bl', 'br', 'left', 'lt', 'lb', 'right', 'rt', 'rb'];
       }
@@ -21322,8 +20208,8 @@
   }
 
   class LineCrosshair extends CrosshairBase {
-      constructor(attributes) {
-          super(vutils.merge({}, LineCrosshair.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, LineCrosshair.defaultAttributes, attributes));
       }
       renderCrosshair(container) {
           const { start, end, lineStyle } = this.attribute;
@@ -21347,8 +20233,8 @@
   };
 
   class RectCrosshair extends CrosshairBase {
-      constructor(attributes) {
-          super(vutils.merge({}, RectCrosshair.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, RectCrosshair.defaultAttributes, attributes));
       }
       renderCrosshair(container) {
           const { start, end, rectStyle } = this.attribute;
@@ -21371,8 +20257,8 @@
   };
 
   class CircleCrosshair extends CrosshairBase {
-      constructor(attributes) {
-          super(vutils.merge({}, CircleCrosshair.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, CircleCrosshair.defaultAttributes, attributes));
       }
       renderCrosshair(container) {
           const { center, radius, lineStyle } = this.attribute;
@@ -21394,8 +20280,8 @@
   };
 
   class SectorCrosshair extends CrosshairBase {
-      constructor(attributes) {
-          super(vutils.merge({}, SectorCrosshair.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, SectorCrosshair.defaultAttributes, attributes));
       }
       renderCrosshair(container) {
           const { center, radius, innerRadius = 0, sectorStyle } = this.attribute;
@@ -21423,8 +20309,8 @@
   };
 
   class PolygonCrosshair extends CrosshairBase {
-      constructor(attributes) {
-          super(vutils.merge({}, PolygonCrosshair.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, PolygonCrosshair.defaultAttributes, attributes));
       }
       renderCrosshair(container) {
           const { center, radius, sides = 6, lineStyle } = this.attribute;
@@ -21971,8 +20857,8 @@
       setBitmapTool(bmpTool) {
           this._bmpTool = bmpTool;
       }
-      constructor(attributes) {
-          super(vutils.merge({}, LabelBase.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, LabelBase.defaultAttributes, attributes));
           this.name = 'label';
           this._onHover = (e) => {
               const target = e.target;
@@ -22584,8 +21470,8 @@
   };
 
   class SymbolLabel extends LabelBase {
-      constructor(attributes) {
-          super(vutils.merge({}, SymbolLabel.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, SymbolLabel.defaultAttributes, attributes));
           this.name = 'symbol-label';
       }
       labeling(textBounds, graphicBounds, position = 'top', offset = 0) {
@@ -22606,8 +21492,8 @@
   };
 
   class RectLabel extends LabelBase {
-      constructor(attributes) {
-          super(vutils.merge({}, RectLabel.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, RectLabel.defaultAttributes, attributes));
       }
       labeling(textBounds, graphicBounds, position = 'top', offset = 0) {
           if (!textBounds || !graphicBounds) {
@@ -22702,8 +21588,8 @@
   };
 
   class LineLabel extends LabelBase {
-      constructor(attributes) {
-          super(vutils.merge({}, LineLabel.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, LineLabel.defaultAttributes, attributes));
           this.name = 'line-label';
       }
       getGraphicBounds(graphic, point = {}) {
@@ -22780,8 +21666,8 @@
       }
   }
   class ArcLabel extends LabelBase {
-      constructor(attributes) {
-          super(vutils.merge({}, ArcLabel.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, ArcLabel.defaultAttributes, attributes));
           this.name = 'arc-label';
           this._ellipsisWidth = 0;
           this._arcLeft = new Map();
@@ -23478,8 +22364,8 @@
   };
 
   class LineDataLabel extends LabelBase {
-      constructor(attributes) {
-          super(vutils.merge({}, LineDataLabel.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, LineDataLabel.defaultAttributes, attributes));
           this.name = 'line-data-label';
       }
       labeling(textBounds, graphicBounds, position = 'top', offset = 0) {
@@ -23506,8 +22392,8 @@
       'line-data': LineDataLabel
   };
   class DataLabel extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, DataLabel.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, DataLabel.defaultAttributes, attributes));
           this.name = 'data-label';
       }
       render() {
@@ -23582,8 +22468,8 @@
       getMainSegmentPoints() {
           return this._mainSegmentPoints;
       }
-      constructor(attributes) {
-          super(vutils.merge({}, Segment.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Segment.defaultAttributes, attributes));
           this.name = 'segment';
       }
       render() {
@@ -24609,11 +23495,8 @@
   }
 
   class LineAxis extends AxisBase {
-      constructor(attributes, mode) {
-          super(vutils.merge({}, LineAxis.defaultAttributes, attributes), mode);
-          if (mode === '3d') {
-              this.setMode(mode);
-          }
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, LineAxis.defaultAttributes, attributes), options);
       }
       _renderInner(container) {
           var _a;
@@ -25093,8 +23976,8 @@
   }
 
   class CircleAxis extends AxisBase {
-      constructor(attributes) {
-          super(vutils.merge({}, CircleAxis.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, CircleAxis.defaultAttributes, attributes));
       }
       renderLine(container) {
           const { startAngle = POLAR_START_ANGLE, endAngle = POLAR_END_ANGLE, radius, center, innerRadius = 0, line, inside = false } = this.attribute;
@@ -25520,7 +24403,9 @@
                   const { center } = this.attribute;
                   path = getArcPath(center, points, false, !!closed);
               }
-              const shape = createPath(Object.assign({ path, z: depth }, (vutils.isFunction(style) ? vutils.merge({}, BaseGrid.defaultAttributes.style, style(item, index)) : style)));
+              const shape = createPath(Object.assign({ path, z: depth }, (vutils.isFunction(style)
+                  ? vutils.merge({}, this.skipDefault ? null : BaseGrid.defaultAttributes.style, style(item, index))
+                  : style)));
               shape.name = `${name}-line`;
               shape.id = this._getNodeId(`${name}-path-${id}`);
               container.add(shape);
@@ -25537,7 +24422,9 @@
                   const path = getLinePath(nextPoints, !!closed);
                   const deltaX = vutils.abs(nextPoints[0].x - nextPoints[1].x);
                   const deltaY = vutils.abs(nextPoints[0].y - nextPoints[1].y);
-                  const shape = createPath(Object.assign({ path, z: 0, alpha: deltaX > deltaY ? ((points[1].x - points[0].x > 0 ? -1 : 1) * vutils.pi) / 2 : 0, beta: deltaX < deltaY ? -vutils.pi / 2 : 0, anchor3d: deltaX > deltaY ? [nextPoints[0].x, 0] : [0, nextPoints[0].y] }, (vutils.isFunction(style) ? vutils.merge({}, BaseGrid.defaultAttributes.style, style(item, index)) : style)));
+                  const shape = createPath(Object.assign({ path, z: 0, alpha: deltaX > deltaY ? ((points[1].x - points[0].x > 0 ? -1 : 1) * vutils.pi) / 2 : 0, beta: deltaX < deltaY ? -vutils.pi / 2 : 0, anchor3d: deltaX > deltaY ? [nextPoints[0].x, 0] : [0, nextPoints[0].y] }, (vutils.isFunction(style)
+                      ? vutils.merge({}, this.skipDefault ? null : BaseGrid.defaultAttributes.style, style(item, index))
+                      : style)));
                   shape.name = `${name}-line`;
                   shape.id = this._getNodeId(`${name}-path-${id}`);
                   container.add(shape);
@@ -25593,11 +24480,8 @@
       return points;
   }
   class LineAxisGrid extends BaseGrid {
-      constructor(attributes, mode) {
-          super(vutils.merge({}, BaseGrid.defaultAttributes, attributes), mode);
-          if (mode === '3d') {
-              this.setMode(mode);
-          }
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, BaseGrid.defaultAttributes, attributes), options);
       }
       _getGridPoint(gridType, point) {
           let gridPoints;
@@ -25697,8 +24581,8 @@
   vutils.mixin(LineAxisGrid, LineAxisMixin);
 
   class CircleAxisGrid extends BaseGrid {
-      constructor(attributes) {
-          super(vutils.merge({}, BaseGrid.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, BaseGrid.defaultAttributes, attributes), options);
       }
       getGridAttribute(isSubGrid) {
           let gridAttribute;
@@ -25791,6 +24675,13 @@
   }
   vutils.mixin(CircleAxisGrid, CircleAxisMixin);
 
+  var DataZoomActiveTag;
+  (function (DataZoomActiveTag) {
+      DataZoomActiveTag["startHandler"] = "startHandler";
+      DataZoomActiveTag["endHandler"] = "endHandler";
+      DataZoomActiveTag["middleHandler"] = "middleHandler";
+      DataZoomActiveTag["background"] = "background";
+  })(DataZoomActiveTag || (DataZoomActiveTag = {}));
   const DEFAULT_DATA_ZOOM_ATTRIBUTES = {
       orient: 'bottom',
       showDetail: 'auto',
@@ -25889,21 +24780,13 @@
       }
   };
 
-  exports.DataZoomActiveTag = void 0;
-  (function (DataZoomActiveTag) {
-      DataZoomActiveTag["startHandler"] = "startHandler";
-      DataZoomActiveTag["endHandler"] = "endHandler";
-      DataZoomActiveTag["middleHandler"] = "middleHandler";
-      DataZoomActiveTag["background"] = "background";
-  })(exports.DataZoomActiveTag || (exports.DataZoomActiveTag = {}));
-
   const delayMap$1 = {
       debounce: vutils.debounce,
       throttle: vutils.throttle
   };
   class DataZoom extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, DataZoom.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, DataZoom.defaultAttributes, attributes));
           this.name = 'dataZoom';
           this._previewData = [];
           this._activeState = false;
@@ -25924,23 +24807,23 @@
           this._onHandlerPointerDown = (e, tag) => {
               e.stopPropagation();
               if (tag === 'start') {
-                  this._activeTag = exports.DataZoomActiveTag.startHandler;
+                  this._activeTag = DataZoomActiveTag.startHandler;
                   this._activeItem = this._startHandler;
               }
               else if (tag === 'end') {
-                  this._activeTag = exports.DataZoomActiveTag.endHandler;
+                  this._activeTag = DataZoomActiveTag.endHandler;
                   this._activeItem = this._endHandler;
               }
               else if (tag === 'middleRect') {
-                  this._activeTag = exports.DataZoomActiveTag.middleHandler;
+                  this._activeTag = DataZoomActiveTag.middleHandler;
                   this._activeItem = this._middleHandlerRect;
               }
               else if (tag === 'middleSymbol') {
-                  this._activeTag = exports.DataZoomActiveTag.middleHandler;
+                  this._activeTag = DataZoomActiveTag.middleHandler;
                   this._activeItem = this._middleHandlerSymbol;
               }
               else if (tag === 'background') {
-                  this._activeTag = exports.DataZoomActiveTag.background;
+                  this._activeTag = DataZoomActiveTag.background;
                   this._activeItem = this._background;
               }
               this._activeState = true;
@@ -25948,7 +24831,6 @@
               this._activeCache.lastPos = this.eventPosToStagePos(e);
           };
           this._onHandlerPointerMove = (e) => {
-              var _a;
               e.stopPropagation();
               const { start: startAttr, end: endAttr, brushSelect, realTime = true } = this.attribute;
               const pos = this.eventPosToStagePos(e);
@@ -25956,24 +24838,24 @@
               const dis = (pos[attPos] - this._activeCache.lastPos[attPos]) / max;
               let { start, end } = this.state;
               if (this._activeState) {
-                  if (this._activeTag === exports.DataZoomActiveTag.middleHandler) {
+                  if (this._activeTag === DataZoomActiveTag.middleHandler) {
                       this.moveZoomWithMiddle((this.state.start + this.state.end) / 2 + dis);
                   }
-                  else if (this._activeTag === exports.DataZoomActiveTag.startHandler) {
+                  else if (this._activeTag === DataZoomActiveTag.startHandler) {
                       if (start + dis > end) {
                           start = end;
                           end = start + dis;
-                          this._activeTag = exports.DataZoomActiveTag.endHandler;
+                          this._activeTag = DataZoomActiveTag.endHandler;
                       }
                       else {
                           start = start + dis;
                       }
                   }
-                  else if (this._activeTag === exports.DataZoomActiveTag.endHandler) {
+                  else if (this._activeTag === DataZoomActiveTag.endHandler) {
                       if (end + dis < start) {
                           end = start;
                           start = end + dis;
-                          this._activeTag = exports.DataZoomActiveTag.startHandler;
+                          this._activeTag = DataZoomActiveTag.startHandler;
                       }
                       else {
                           end = end + dis;
@@ -25986,7 +24868,7 @@
               end = Math.min(Math.max(end, 0), 1);
               if (startAttr !== start || endAttr !== end) {
                   this.setStateAttr(start, end, true);
-                  realTime && ((_a = this._updateStateCallback) === null || _a === void 0 ? void 0 : _a.call(this, start, end, this._activeTag));
+                  realTime && this._updateStateCallback && this._updateStateCallback(start, end);
                   this._dispatchChangeEvent(start, end);
               }
           };
@@ -26091,11 +24973,10 @@
           };
       }
       _onHandlerPointerUp(e) {
-          var _a;
           e.preventDefault();
           const { start, end, brushSelect, realTime = true } = this.attribute;
           if (this._activeState) {
-              if (this._activeTag === exports.DataZoomActiveTag.background) {
+              if (this._activeTag === DataZoomActiveTag.background) {
                   const pos = this.eventPosToStagePos(e);
                   this.backgroundDragZoom(this._activeCache.startPos, pos);
               }
@@ -26104,7 +24985,7 @@
           brushSelect && this.renderDragMask();
           if (!realTime || start !== this.state.start || end !== this.state.end) {
               this.setStateAttr(this.state.start, this.state.end, true);
-              (_a = this._updateStateCallback) === null || _a === void 0 ? void 0 : _a.call(this, this.state.start, this.state.end, this._activeTag);
+              this._updateStateCallback && this._updateStateCallback(this.state.start, this.state.end);
               this._dispatchChangeEvent(this.state.start, this.state.end);
           }
       }
@@ -26154,11 +25035,11 @@
           const { dragMaskStyle } = this.attribute;
           const { position, width, height } = this.getLayoutAttrFromConfig();
           if (this._isHorizontal) {
-              this._dragMask = this._container.createOrUpdateChild('dragMask', Object.assign({ x: vutils.clamp(this.dragMaskSize() < 0 ? this._activeCache.lastPos.x : this._activeCache.startPos.x, position.x, position.x + width), y: position.y, width: (this._activeState && this._activeTag === exports.DataZoomActiveTag.background && Math.abs(this.dragMaskSize())) ||
+              this._dragMask = this._container.createOrUpdateChild('dragMask', Object.assign({ x: vutils.clamp(this.dragMaskSize() < 0 ? this._activeCache.lastPos.x : this._activeCache.startPos.x, position.x, position.x + width), y: position.y, width: (this._activeState && this._activeTag === DataZoomActiveTag.background && Math.abs(this.dragMaskSize())) ||
                       0, height }, dragMaskStyle), 'rect');
           }
           else {
-              this._dragMask = this._container.createOrUpdateChild('dragMask', Object.assign({ x: position.x, y: vutils.clamp(this.dragMaskSize() < 0 ? this._activeCache.lastPos.y : this._activeCache.startPos.y, position.y, position.y + height), width, height: (this._activeState && this._activeTag === exports.DataZoomActiveTag.background && Math.abs(this.dragMaskSize())) ||
+              this._dragMask = this._container.createOrUpdateChild('dragMask', Object.assign({ x: position.x, y: vutils.clamp(this.dragMaskSize() < 0 ? this._activeCache.lastPos.y : this._activeCache.startPos.y, position.y, position.y + height), width, height: (this._activeState && this._activeTag === DataZoomActiveTag.background && Math.abs(this.dragMaskSize())) ||
                       0 }, dragMaskStyle), 'rect');
           }
       }
@@ -26477,14 +25358,13 @@
           this.dispatchEvent(changeEvent);
       }
       setStartAndEnd(start, end) {
-          var _a;
           const { start: startAttr, end: endAttr } = this.attribute;
           if (vutils.isValid(start) && vutils.isValid(end) && (start !== this.state.start || end !== this.state.end)) {
               this.state.start = start;
               this.state.end = end;
               if (startAttr !== this.state.start || endAttr !== this.state.end) {
                   this.setStateAttr(start, end, true);
-                  (_a = this._updateStateCallback) === null || _a === void 0 ? void 0 : _a.call(this, start, end, this._activeTag);
+                  this._updateStateCallback && this._updateStateCallback(start, end);
                   this._dispatchChangeEvent(start, end);
               }
           }
@@ -26892,8 +25772,8 @@
       getLabel() {
           return this._label;
       }
-      constructor(attributes) {
-          super(vutils.merge({}, MarkLine.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, MarkLine.defaultAttributes, attributes));
           this.name = 'markLine';
       }
       setLabelPos() {
@@ -26987,8 +25867,8 @@
       getLabel() {
           return this._label;
       }
-      constructor(attributes) {
-          super(vutils.merge({}, MarkArea.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, MarkArea.defaultAttributes, attributes));
           this.name = 'markArea';
       }
       _getPositionByDirection(area, direction) {
@@ -27070,8 +25950,8 @@
   MarkArea.defaultAttributes = DEFAULT_MARK_AREA_THEME;
 
   class MarkPoint extends Marker {
-      constructor(attributes) {
-          super(vutils.merge({}, MarkPoint.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, MarkPoint.defaultAttributes, attributes));
           this.name = 'markPoint';
       }
       setLabelPos() {
@@ -27292,8 +26172,8 @@
       getCurrent() {
           return this._current;
       }
-      constructor(attributes) {
-          super(vutils.merge({}, Pager.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Pager.defaultAttributes, attributes));
           this.name = 'pager';
           this._current = 1;
           this._onHover = (e) => {
@@ -27559,8 +26439,8 @@
       [exports.LegendStateValue.unSelectedHover]: {}
   };
   class DiscreteLegend extends LegendBase {
-      constructor(attributes) {
-          super(vutils.merge({}, DiscreteLegend.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, DiscreteLegend.defaultAttributes, attributes));
           this.name = 'discreteLegend';
           this._itemsContainer = null;
           this._itemHeightByUser = undefined;
@@ -28277,8 +27157,8 @@
       get endHandler() {
           return this._endHandler;
       }
-      constructor(attributes) {
-          super(vutils.merge({}, Slider.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Slider.defaultAttributes, attributes));
           this.name = 'slider';
           this._isHorizontal = true;
           this._startHandler = null;
@@ -28897,8 +27777,8 @@
   };
 
   class ColorContinuousLegend extends LegendBase {
-      constructor(attributes) {
-          super(vutils.merge({}, ColorContinuousLegend.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, ColorContinuousLegend.defaultAttributes, attributes));
           this.name = 'colorLegend';
           this._onSliderChange = (e) => {
               this._updateColor();
@@ -29093,8 +27973,8 @@
 `;
   }
   class SizeContinuousLegend extends LegendBase {
-      constructor(attributes) {
-          super(vutils.merge({}, SizeContinuousLegend.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, SizeContinuousLegend.defaultAttributes, attributes));
           this.name = 'sizeLegend';
           this._onSliderChange = (e) => {
               this.dispatchEvent(e);
@@ -29203,8 +28083,8 @@
   };
 
   class Title extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, Title.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Title.defaultAttributes, attributes));
           this.name = 'title';
       }
       render() {
@@ -29563,8 +28443,8 @@
   Z`;
   };
   class LinkPath extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, LinkPath.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, LinkPath.defaultAttributes, attributes));
       }
       render() {
           const { direction = 'horizontal' } = this.attribute;
@@ -29642,8 +28522,8 @@
   })(ControllerTypeEnum || (ControllerTypeEnum = {}));
 
   class Controller extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, Controller.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Controller.defaultAttributes, attributes));
           this._isPaused = true;
           this.updateAttributes = () => {
               this._startAttr = {
@@ -29861,8 +28741,8 @@
   };
 
   class BasePlayer extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, BasePlayer.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, BasePlayer.defaultAttributes, attributes));
           this._data = [];
           this._layoutInfo = {};
           this._updateSliderAttrs = () => {
@@ -30062,8 +28942,8 @@
   };
 
   class DiscretePlayer extends BasePlayer {
-      constructor(attributes) {
-          super(vutils.merge({}, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, attributes));
           this._activeIndex = -1;
           this._isReachEnd = false;
           this._initAttributes = () => {
@@ -30403,8 +29283,8 @@
       throttle: vutils.throttle
   };
   class Brush extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, Brush.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Brush.defaultAttributes, attributes));
           this.name = 'brush';
           this._activeDrawState = false;
           this._cacheDrawPoints = [];
@@ -30794,8 +29674,8 @@
   const TOOLTIP_KEY_NAME_SUFFIX = 'key';
   const TOOLTIP_VALUE_NAME_SUFFIX = 'value';
   class Tooltip extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, Tooltip.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, Tooltip.defaultAttributes, attributes), options);
           this.name = 'tooltip';
       }
       render() {
@@ -30862,7 +29742,9 @@
                   let x = 0;
                   if (isVisible(itemAttr.shape)) {
                       itemGroup.createOrUpdateChild(`${itemGroupName}-${TOOLTIP_SHAPE_NAME_SUFFIX}`, Object.assign({ visible: true, x: itemAttr.shape.size / 2, y: itemAttr.shape.size / 2 +
-                              (((_a = itemAttr.key.lineHeight) !== null && _a !== void 0 ? _a : itemAttr.key.fontSize) - itemAttr.shape.size) / 2 }, itemAttr.shape), 'symbol');
+                              (((_a = calculateLineHeight(itemAttr.key.lineHeight, itemAttr.key.fontSize)) !== null && _a !== void 0 ? _a : itemAttr.key.fontSize) -
+                                  itemAttr.shape.size) /
+                                  2 }, itemAttr.shape), 'symbol');
                   }
                   if (hasContentShape) {
                       x += itemAttr.shape.size + itemAttr.shape.spacing;
@@ -31080,8 +29962,8 @@
   const checkSvg = '<svg width="200" height="200" viewBox="0 0 1024 1024" fill="#fff" xmlns="http://www.w3.org/2000/svg"><path d="M877.44815445 206.10060629a64.72691371 64.72691371 0 0 0-95.14856334 4.01306852L380.73381888 685.46812814 235.22771741 533.48933518a64.72691371 64.72691371 0 0 0-92.43003222-1.03563036l-45.82665557 45.82665443a64.72691371 64.72691371 0 0 0-0.90617629 90.61767965l239.61903446 250.10479331a64.72691371 64.72691371 0 0 0 71.19960405 15.14609778 64.33855261 64.33855261 0 0 0 35.08198741-21.23042702l36.24707186-42.71976334 40.5190474-40.77795556-3.36579926-3.49525333 411.40426297-486.74638962a64.72691371 64.72691371 0 0 0-3.88361443-87.64024149l-45.3088404-45.43829334z"></path></svg>';
   const indeterminateSvg = '<svg width="200" height="200" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" fill="none"><path stroke="#fff" stroke-linecap="round" stroke-linejoin="round" stroke-width="5" d="M5 12h14"/></svg>';
   class CheckBox extends AbstractComponent {
-      constructor(attributes) {
-          super(vutils.merge({}, CheckBox.defaultAttributes, attributes));
+      constructor(attributes, options) {
+          super((options === null || options === void 0 ? void 0 : options.skipDefault) ? attributes : vutils.merge({}, CheckBox.defaultAttributes, attributes));
           this.renderGroup();
           this.onBeforeAttributeUpdate = (val, attributes, key) => {
               if ('interactive' in val) {
@@ -31243,7 +30125,7 @@
       }
   };
 
-  const version = "0.17.0-alpha.1";
+  const version = "0.17.0-alpha.2";
 
   exports.AbstractComponent = AbstractComponent;
   exports.ArcInfo = ArcInfo;