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

package/dist/index.js

@@ -4,62 +4,25 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VRenderCore = {}, global.VUtils));
 })(this, (function (exports, vutils) { 'use strict';
 
-    let idCounter = 0;
-    function id() {
-        return idCounter++;
+    class Generator {
+        static GenAutoIncrementId() {
+            return Generator.auto_increment_id++;
+        }
     }
+    Generator.auto_increment_id = 0;
 
     class ContainerModule {
         constructor(registry) {
-            this.id = id();
+            this.id = Generator.GenAutoIncrementId();
             this.registry = registry;
         }
     }
 
     const NAMED_TAG = 'named';
-    const NAME_TAG = 'name';
-    const UNMANAGED_TAG = 'unmanaged';
-    const OPTIONAL_TAG = 'optional';
     const INJECT_TAG = 'inject';
     const MULTI_INJECT_TAG = 'multi_inject';
     const TAGGED = 'inversify:tagged';
-    const TAGGED_PROP = 'inversify:tagged_props';
     const PARAM_TYPES = 'inversify:paramtypes';
-    const DESIGN_PARAM_TYPES = 'design:paramtypes';
-    const POST_CONSTRUCT = 'post_construct';
-    const PRE_DESTROY = 'pre_destroy';
-    function getNonCustomTagKeys() {
-        return [INJECT_TAG, MULTI_INJECT_TAG, NAME_TAG, UNMANAGED_TAG, NAMED_TAG, OPTIONAL_TAG];
-    }
-    const NON_CUSTOM_TAG_KEYS = getNonCustomTagKeys();
-
-    const DUPLICATED_INJECTABLE_DECORATOR = 'Cannot apply @injectable decorator multiple times.';
-    const DUPLICATED_METADATA = 'Metadata key was used more than once in a parameter:';
-    const NULL_ARGUMENT = 'NULL argument';
-    const KEY_NOT_FOUND = 'Key Not Found';
-    const AMBIGUOUS_MATCH = 'Ambiguous match found for serviceIdentifier:';
-    const CANNOT_UNBIND = 'Could not unbind serviceIdentifier:';
-    const NOT_REGISTERED = 'No matching bindings found for serviceIdentifier:';
-    const MISSING_INJECTABLE_ANNOTATION = 'Missing required @injectable annotation in:';
-    const MISSING_INJECT_ANNOTATION = 'Missing required @inject or @multiInject annotation in:';
-    const UNDEFINED_INJECT_ANNOTATION = (name) => `@inject called with undefined this could mean that the class ${name} has ` +
-        'a circular dependency problem. You can use a LazyServiceIdentifer to  ' +
-        'overcome this limitation.';
-    const INVALID_BINDING_TYPE = 'Invalid binding type:';
-    const INVALID_FUNCTION_BINDING = 'Value provided to function binding must be a function!';
-    const INVALID_TO_SELF_VALUE = 'The toSelf function can only be applied when a constructor is ' + 'used as service identifier';
-    const INVALID_DECORATOR_OPERATION = 'The @inject @multiInject @tagged and @named decorators ' +
-        'must be applied to the parameters of a class constructor or a class property.';
-    const ARGUMENTS_LENGTH_MISMATCH = (...values) => 'The number of constructor arguments in the derived class ' +
-        `${values[0]} must be >= than the number of constructor arguments of its base class.`;
-    const CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = 'Invalid Container constructor argument. Container options ' + 'must be an object.';
-    const CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = 'Invalid Container option. Default scope must ' + 'be a string ("singleton" or "transient").';
-    const CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = 'Invalid Container option. Auto bind injectable must ' + 'be a boolean';
-    const CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = 'Invalid Container option. Skip base check must ' + 'be a boolean';
-    const MULTIPLE_POST_CONSTRUCT_METHODS = 'Cannot apply @postConstruct decorator multiple times in the same class';
-    const ASYNC_UNBIND_REQUIRED = 'Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)';
-    const PRE_DESTROY_ERROR = (clazz, errorMessage) => `@preDestroy error in class ${clazz}: ${errorMessage}`;
-    const ON_DEACTIVATION_ERROR = (clazz, errorMessage) => `onDeactivation() error in class ${clazz}: ${errorMessage}`;
 
     class Metadata {
         constructor(key, value) {
@@ -74,17 +37,6 @@
         }
     }
 
-    function getFirstArrayDuplicate(array) {
-        const seenValues = new Set();
-        for (const entry of array) {
-            if (seenValues.has(entry)) {
-                return entry;
-            }
-            seenValues.add(entry);
-        }
-        return undefined;
-    }
-
     let Reflect$1;
     var Reflect$2 = (function (Reflect) {
         (function (factory) {
@@ -668,40 +620,8 @@
         return Reflect;
     })(Reflect$1 || (Reflect$1 = {}));
 
-    function targetIsConstructorFunction(target) {
-        return target.prototype !== undefined;
-    }
-    function _throwIfMethodParameter(parameterName) {
-        if (parameterName !== undefined) {
-            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) {
-        let metadatas = [];
-        if (Array.isArray(metadata)) {
-            metadatas = metadata;
-            const duplicate = getFirstArrayDuplicate(metadatas.map(md => md.key));
-            if (duplicate !== undefined) {
-                throw new Error(`${DUPLICATED_METADATA} ${duplicate.toString()}`);
-            }
-        }
-        else {
-            metadatas = [metadata];
-        }
-        return metadatas;
-    }
     function _tagParameterOrProperty(metadataKey, annotationTarget, key, metadata) {
-        const metadatas = _ensureNoMetadataKeyDuplicates(metadata);
+        const metadatas = [metadata];
         let paramsOrPropertiesMetadata = {};
         if (Reflect$2.hasOwnMetadata(metadataKey, annotationTarget)) {
             paramsOrPropertiesMetadata = Reflect$2.getMetadata(metadataKey, annotationTarget);
@@ -710,35 +630,21 @@
         if (paramOrPropertyMetadata === undefined) {
             paramOrPropertyMetadata = [];
         }
-        else {
-            for (const m of paramOrPropertyMetadata) {
-                if (metadatas.some(md => md.key === m.key)) {
-                    throw new Error(`${DUPLICATED_METADATA} ${m.key.toString()}`);
-                }
-            }
-        }
         paramOrPropertyMetadata.push(...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 (target, targetKey, indexOrPropertyDescriptor) => {
-            if (typeof indexOrPropertyDescriptor === 'number') {
-                tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);
-            }
-            else {
-                tagProperty(target, targetKey, metadata);
-            }
+            tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);
         };
     }
-
     function injectBase(metadataKey) {
         return (serviceIdentifier) => {
             return (target, targetKey, indexOrPropertyDescriptor) => {
-                if (serviceIdentifier === undefined) {
-                    const className = typeof target === 'function' ? target.name : target.constructor.name;
-                    throw new Error(UNDEFINED_INJECT_ANNOTATION(className));
-                }
                 return createTaggedDecorator(new Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);
             };
         };
@@ -750,11 +656,7 @@
 
     function injectable() {
         return function (target) {
-            if (Reflect$2.hasOwnMetadata(PARAM_TYPES, target)) {
-                throw new Error(DUPLICATED_INJECTABLE_DECORATOR);
-            }
-            const types = Reflect$2.getMetadata(DESIGN_PARAM_TYPES, target) || [];
-            Reflect$2.defineMetadata(PARAM_TYPES, types, target);
+            Reflect$2.defineMetadata(PARAM_TYPES, null, target);
             return target;
         };
     }
@@ -763,65 +665,7 @@
         return createTaggedDecorator(new Metadata(NAMED_TAG, name));
     }
 
-    function _typeof(o) {
-      "@babel/helpers - typeof";
-
-      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-        return typeof o;
-      } : function (o) {
-        return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-      }, _typeof(o);
-    }
-
-    function __decorate(decorators, target, key, desc) {
-      var c = arguments.length,
-        r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
-        d;
-      if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-      return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-    function __param(paramIndex, decorator) {
-      return function (target, key) {
-        decorator(target, key, paramIndex);
-      };
-    }
-    function __metadata(metadataKey, metadataValue) {
-      if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-    }
-    function __awaiter(thisArg, _arguments, P, generator) {
-      function adopt(value) {
-        return value instanceof P ? value : new P(function (resolve) {
-          resolve(value);
-        });
-      }
-      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) {
-          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-        }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-      });
-    }
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-      var e = new Error(message);
-      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
     const BindingScopeEnum = {
-        Request: 'Request',
         Singleton: 'Singleton',
         Transient: 'Transient'
     };
@@ -835,15 +679,10 @@
         Invalid: 'Invalid',
         Provider: 'Provider'
     };
-    const TargetTypeEnum = {
-        ClassProperty: 'ClassProperty',
-        ConstructorArgument: 'ConstructorArgument',
-        Variable: 'Variable'
-    };
 
     class Binding {
         constructor(serviceIdentifier, scope) {
-            this.id = id();
+            this.id = Generator.GenAutoIncrementId();
             this.activated = false;
             this.serviceIdentifier = serviceIdentifier;
             this.scope = scope;
@@ -853,8 +692,6 @@
             this.cache = null;
             this.factory = null;
             this.provider = null;
-            this.onActivation = null;
-            this.onDeactivation = null;
             this.dynamicValue = null;
         }
         clone() {
@@ -864,11 +701,8 @@
             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;
             return clone;
         }
@@ -884,1290 +718,329 @@
             };
         }
         getPropertiesMetadata(constructorFunc) {
-            const userGeneratedMetadata = Reflect$2.getMetadata(TAGGED_PROP, constructorFunc) || [];
-            return userGeneratedMetadata;
+            throw new Error('暂未实现');
         }
     }
 
-    const BindingCount = {
-        MultipleBindingsAvailable: 2,
-        NoBindingsAvailable: 0,
-        OnlyOneBindingAvailable: 1
-    };
-
-    function getServiceIdentifierAsString(serviceIdentifier) {
-        if (typeof serviceIdentifier === 'function') {
-            const _serviceIdentifier = serviceIdentifier;
-            return _serviceIdentifier.name;
-        }
-        else if (typeof serviceIdentifier === 'symbol') {
-            return serviceIdentifier.toString();
-        }
-        const _serviceIdentifier = serviceIdentifier;
-        return _serviceIdentifier;
-    }
-    function listRegisteredBindingsForServiceIdentifier(container, serviceIdentifier, getBindings) {
-        let registeredBindingsList = '';
-        const registeredBindings = getBindings(container, serviceIdentifier);
-        if (registeredBindings.length !== 0) {
-            registeredBindingsList = '\nRegistered bindings:';
-            registeredBindings.forEach((binding) => {
-                let name = 'Object';
-                if (binding.implementationType !== null) {
-                    name = getFunctionName(binding.implementationType);
-                }
-                registeredBindingsList = `${registeredBindingsList}\n ${name}`;
-                if (binding.constraint.metaData) {
-                    registeredBindingsList = `${registeredBindingsList} - ${binding.constraint.metaData}`;
-                }
-            });
-        }
-        return registeredBindingsList;
-    }
-    function listMetadataForTarget(serviceIdentifierString, target) {
-        if (target.isTagged() || target.isNamed()) {
-            let m = '';
-            const namedTag = target.getNamedTag();
-            const otherTags = target.getCustomTags();
-            if (namedTag !== null) {
-                m += namedTag.toString() + '\n';
+    const taggedConstraint = (key) => (value) => {
+        const constraint = (request) => {
+            if (request == null || request.constructorArgsMetadata == null) {
+                return false;
             }
-            if (otherTags !== null) {
-                otherTags.forEach(tag => {
-                    m += tag.toString() + '\n';
-                });
+            const constructorArgsMetadata = request.constructorArgsMetadata;
+            for (let i = 0; i < constructorArgsMetadata.length; i++) {
+                if (constructorArgsMetadata[i].key === key && constructorArgsMetadata[i].value === value) {
+                    return true;
+                }
             }
-            return ` ${serviceIdentifierString}\n ${serviceIdentifierString} - ${m}`;
+            return false;
+        };
+        constraint.metaData = new Metadata(key, value);
+        return constraint;
+    };
+    const namedConstraint = taggedConstraint(NAMED_TAG);
+
+    class BindingInSyntax {
+        constructor(binding) {
+            this._binding = binding;
         }
-        return ` ${serviceIdentifierString}`;
-    }
-    function getFunctionName(func) {
-        if (func.name) {
-            return func.name;
+        inRequestScope() {
+            throw new Error('暂未实现');
         }
-        const name = func.toString();
-        const match = name.match(/^function\s*([^\s(]+)/);
-        return match ? match[1] : `Anonymous function: ${name}`;
-    }
-    function getSymbolDescription(symbol) {
-        return symbol.toString().slice(7, -1);
-    }
-
-    class Context {
-        constructor(container) {
-            this.id = id();
-            this.container = container;
+        inSingletonScope() {
+            this._binding.scope = BindingScopeEnum.Singleton;
+            return this;
         }
-        addPlan(plan) {
-            this.plan = plan;
+        inTransientScope() {
+            this._binding.scope = BindingScopeEnum.Transient;
+            return this;
         }
-        setCurrentRequest(currentRequest) {
-            this.currentRequest = currentRequest;
+        whenTargetNamed(name) {
+            this._binding.constraint = namedConstraint(name);
+            return this;
         }
     }
 
-    class Plan {
-        constructor(parentContext, rootRequest) {
-            this.parentContext = parentContext;
-            this.rootRequest = rootRequest;
+    class BindingToSyntax {
+        constructor(binding) {
+            this._binding = binding;
         }
-    }
-
-    class LazyServiceIdentifer {
-        constructor(cb) {
-            this._cb = cb;
+        to(constructor) {
+            this._binding.type = BindingTypeEnum.Instance;
+            this._binding.implementationType = constructor;
+            return new BindingInSyntax(this._binding);
         }
-        unwrap() {
-            return this._cb();
+        toSelf() {
+            const self = this._binding.serviceIdentifier;
+            return this.to(self);
         }
-    }
-
-    class QueryableString {
-        constructor(str) {
-            this.str = str;
+        toDynamicValue(func) {
+            this._binding.type = BindingTypeEnum.DynamicValue;
+            this._binding.cache = null;
+            this._binding.dynamicValue = func;
+            this._binding.implementationType = null;
+            return new BindingInSyntax(this._binding);
         }
-        contains(searchString) {
-            return this.str.indexOf(searchString) !== -1;
+        toConstantValue(value) {
+            this._binding.type = BindingTypeEnum.ConstantValue;
+            this._binding.cache = value;
+            this._binding.dynamicValue = null;
+            this._binding.implementationType = null;
+            this._binding.scope = BindingScopeEnum.Singleton;
+            return new BindingInSyntax(this._binding);
         }
-        equals(compareString) {
-            return this.str === compareString;
+        toFactory(factory) {
+            this._binding.type = BindingTypeEnum.Factory;
+            this._binding.factory = factory;
+            this._binding.scope = BindingScopeEnum.Singleton;
+            return new BindingInSyntax(this._binding);
         }
-        value() {
-            return this.str;
+        toService(service) {
+            this.toDynamicValue(context => context.container.get(service));
         }
     }
 
-    class Target {
-        constructor(type, identifier, serviceIdentifier, namedOrTagged) {
-            this.id = id();
-            this.type = type;
-            this.serviceIdentifier = serviceIdentifier;
-            const queryableName = typeof identifier === 'symbol' ? getSymbolDescription(identifier) : identifier;
-            this.name = new QueryableString(queryableName || '');
-            this.identifier = identifier;
-            this.metadata = [];
-            let metadataItem = null;
-            if (typeof namedOrTagged === 'string') {
-                metadataItem = new Metadata(NAMED_TAG, namedOrTagged);
-            }
-            else if (namedOrTagged instanceof Metadata) {
-                metadataItem = namedOrTagged;
-            }
-            if (metadataItem !== null) {
-                this.metadata.push(metadataItem);
-            }
+    class Container {
+        constructor(containerOptions) {
+            const options = containerOptions || {};
+            options.defaultScope = options.defaultScope || BindingScopeEnum.Transient;
+            this.options = options;
+            this.id = Generator.GenAutoIncrementId();
+            this._bindingDictionary = new Map();
+            this._metadataReader = new MetadataReader();
         }
-        hasTag(key) {
-            for (const m of this.metadata) {
-                if (m.key === key) {
-                    return true;
-                }
-            }
-            return false;
+        load(module) {
+            const getHelpers = this._getContainerModuleHelpersFactory();
+            const containerModuleHelpers = getHelpers(module.id);
+            module.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
         }
-        isArray() {
-            return this.hasTag(MULTI_INJECT_TAG);
+        get(serviceIdentifier) {
+            const getArgs = this._getNotAllArgs(serviceIdentifier, false);
+            return this._get(getArgs);
         }
-        matchesArray(name) {
-            return this.matchesTag(MULTI_INJECT_TAG)(name);
+        getAll(serviceIdentifier) {
+            const getArgs = this._getAllArgs(serviceIdentifier);
+            return this._get(getArgs);
         }
-        isNamed() {
-            return this.hasTag(NAMED_TAG);
+        getTagged(serviceIdentifier, key, value) {
+            const getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);
+            return this._get(getArgs);
         }
-        isTagged() {
-            return this.metadata.some(metadata => NON_CUSTOM_TAG_KEYS.every(key => metadata.key !== key));
+        getNamed(serviceIdentifier, named) {
+            return this.getTagged(serviceIdentifier, NAMED_TAG, named);
         }
-        isOptional() {
-            return this.matchesTag(OPTIONAL_TAG)(true);
+        isBound(serviceIdentifier) {
+            return this._bindingDictionary.has(serviceIdentifier);
         }
-        getNamedTag() {
-            if (this.isNamed()) {
-                return this.metadata.filter(m => m.key === NAMED_TAG)[0];
-            }
-            return null;
+        bind(serviceIdentifier) {
+            const scope = this.options.defaultScope;
+            const binding = new Binding(serviceIdentifier, scope);
+            const list = this._bindingDictionary.get(serviceIdentifier) || [];
+            list.push(binding);
+            this._bindingDictionary.set(serviceIdentifier, list);
+            return new BindingToSyntax(binding);
         }
-        getCustomTags() {
-            if (this.isTagged()) {
-                return this.metadata.filter(metadata => NON_CUSTOM_TAG_KEYS.every(key => metadata.key !== key));
-            }
-            return null;
+        unbind(serviceIdentifier) {
+            this._bindingDictionary.delete(serviceIdentifier);
         }
-        matchesNamedTag(name) {
-            return this.matchesTag(NAMED_TAG)(name);
+        rebind(serviceIdentifier) {
+            this.unbind(serviceIdentifier);
+            return this.bind(serviceIdentifier);
         }
-        matchesTag(key) {
-            return (value) => {
-                for (const m of this.metadata) {
-                    if (m.key === key && m.value === value) {
-                        return true;
-                    }
-                }
-                return false;
+        _getContainerModuleHelpersFactory() {
+            const setModuleId = (bindingToSyntax, moduleId) => {
+                bindingToSyntax._binding.moduleId = moduleId;
+            };
+            const getBindFunction = (moduleId) => (serviceIdentifier) => {
+                const bindingToSyntax = this.bind(serviceIdentifier);
+                setModuleId(bindingToSyntax, moduleId);
+                return bindingToSyntax;
+            };
+            const getUnbindFunction = () => (serviceIdentifier) => {
+                return this.unbind(serviceIdentifier);
+            };
+            const getUnbindAsyncFunction = () => (serviceIdentifier) => {
+                return null;
+            };
+            const getIsboundFunction = () => (serviceIdentifier) => {
+                return this.isBound(serviceIdentifier);
+            };
+            const getRebindFunction = (moduleId) => (serviceIdentifier) => {
+                const bindingToSyntax = this.rebind(serviceIdentifier);
+                setModuleId(bindingToSyntax, moduleId);
+                return bindingToSyntax;
             };
+            return (mId) => ({
+                bindFunction: getBindFunction(mId),
+                isboundFunction: getIsboundFunction(),
+                rebindFunction: getRebindFunction(mId),
+                unbindFunction: getUnbindFunction(),
+                unbindAsyncFunction: getUnbindAsyncFunction()
+            });
         }
-    }
-
-    function getDependencies(metadataReader, func) {
-        const constructorName = getFunctionName(func);
-        return getTargets(metadataReader, constructorName, func, false);
-    }
-    function getTargets(metadataReader, constructorName, func, isBaseClass) {
-        const metadata = metadataReader.getConstructorMetadata(func);
-        const serviceIdentifiers = metadata.compilerGeneratedMetadata;
-        if (serviceIdentifiers === undefined) {
-            const msg = `${MISSING_INJECTABLE_ANNOTATION} ${constructorName}.`;
-            throw new Error(msg);
-        }
-        const constructorArgsMetadata = metadata.userGeneratedMetadata;
-        const keys = Object.keys(constructorArgsMetadata);
-        const hasUserDeclaredUnknownInjections = func.length === 0 && keys.length > 0;
-        const hasOptionalParameters = keys.length > func.length;
-        const iterations = hasUserDeclaredUnknownInjections || hasOptionalParameters ? keys.length : func.length;
-        const constructorTargets = getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations);
-        const propertyTargets = getClassPropsAsTargets(metadataReader, func, constructorName);
-        const targets = [...constructorTargets, ...propertyTargets];
-        return targets;
-    }
-    function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {
-        const targetMetadata = constructorArgsMetadata[index.toString()] || [];
-        const metadata = formatTargetMetadata(targetMetadata);
-        const isManaged = metadata.unmanaged !== true;
-        let serviceIdentifier = serviceIdentifiers[index];
-        const injectIdentifier = metadata.inject || metadata.multiInject;
-        serviceIdentifier = (injectIdentifier ? injectIdentifier : serviceIdentifier);
-        if (serviceIdentifier instanceof LazyServiceIdentifer) {
-            serviceIdentifier = serviceIdentifier.unwrap();
-        }
-        if (isManaged) {
-            const isObject = serviceIdentifier === Object;
-            const isFunction = serviceIdentifier === Function;
-            const isUndefined = serviceIdentifier === undefined;
-            const isUnknownType = isObject || isFunction || isUndefined;
-            if (!isBaseClass && isUnknownType) {
-                const msg = `${MISSING_INJECT_ANNOTATION} argument ${index} in class ${constructorName}.`;
-                throw new Error(msg);
-            }
-            const target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
-            target.metadata = targetMetadata;
-            return target;
+        _getNotAllArgs(serviceIdentifier, isMultiInject, key, value) {
+            return {
+                avoidConstraints: false,
+                isMultiInject,
+                serviceIdentifier,
+                key,
+                value
+            };
         }
-        return null;
-    }
-    function getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations) {
-        const targets = [];
-        for (let i = 0; i < iterations; i++) {
-            const index = i;
-            const target = getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata);
-            if (target !== null) {
-                targets.push(target);
-            }
-        }
-        return targets;
-    }
-    function _getServiceIdentifierForProperty(inject, multiInject, propertyName, className) {
-        const serviceIdentifier = inject || multiInject;
-        if (serviceIdentifier === undefined) {
-            const msg = `${MISSING_INJECTABLE_ANNOTATION} for property ${String(propertyName)} in class ${className}.`;
-            throw new Error(msg);
-        }
-        return serviceIdentifier;
-    }
-    function getClassPropsAsTargets(metadataReader, constructorFunc, constructorName) {
-        const classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);
-        let targets = [];
-        const symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata);
-        const stringKeys = Object.keys(classPropsMetadata);
-        const keys = stringKeys.concat(symbolKeys);
-        for (const key of keys) {
-            const targetMetadata = classPropsMetadata[key];
-            const metadata = formatTargetMetadata(targetMetadata);
-            const identifier = metadata.targetName || key;
-            const serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject, metadata.multiInject, key, constructorName);
-            const target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
-            target.metadata = targetMetadata;
-            targets.push(target);
-        }
-        const baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor;
-        if (baseConstructor !== Object) {
-            const baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor, constructorName);
-            targets = [...targets, ...baseTargets];
-        }
-        return targets;
-    }
-    function getBaseClassDependencyCount(metadataReader, func) {
-        const baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
-        if (baseConstructor !== Object) {
-            const baseConstructorName = getFunctionName(baseConstructor);
-            const targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true);
-            const metadata = targets.map(t => t.metadata.filter(m => m.key === UNMANAGED_TAG));
-            const unmanagedCount = [].concat.apply([], metadata).length;
-            const dependencyCount = targets.length - unmanagedCount;
-            if (dependencyCount > 0) {
-                return dependencyCount;
-            }
-            return getBaseClassDependencyCount(metadataReader, baseConstructor);
+        _getAllArgs(serviceIdentifier) {
+            return {
+                avoidConstraints: true,
+                isMultiInject: true,
+                serviceIdentifier
+            };
         }
-        return 0;
-    }
-    function formatTargetMetadata(targetMetadata) {
-        const targetMetadataMap = {};
-        targetMetadata.forEach((m) => {
-            targetMetadataMap[m.key.toString()] = m.value;
-        });
-        return {
-            inject: targetMetadataMap[INJECT_TAG],
-            multiInject: targetMetadataMap[MULTI_INJECT_TAG],
-            targetName: targetMetadataMap[NAME_TAG],
-            unmanaged: targetMetadataMap[UNMANAGED_TAG]
-        };
-    }
-
-    class Request {
-        constructor(serviceIdentifier, parentContext, parentRequest, bindings, target) {
-            this.id = id();
-            this.serviceIdentifier = serviceIdentifier;
-            this.parentContext = parentContext;
-            this.parentRequest = parentRequest;
-            this.target = target;
-            this.childRequests = [];
-            this.bindings = Array.isArray(bindings) ? bindings : [bindings];
-            this.requestScope = parentRequest === null ? new Map() : null;
-        }
-        addChildRequest(serviceIdentifier, bindings, target) {
-            const child = new Request(serviceIdentifier, this.parentContext, this, bindings, target);
-            this.childRequests.push(child);
-            return child;
-        }
-    }
-
-    function getBindingDictionary(cntnr) {
-        return cntnr
-            ._bindingDictionary;
-    }
-    function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {
-        const metadataKey = isMultiInject ? MULTI_INJECT_TAG : INJECT_TAG;
-        const injectMetadata = new Metadata(metadataKey, serviceIdentifier);
-        const target = new Target(targetType, name, serviceIdentifier, injectMetadata);
-        if (key !== undefined) {
-            const tagMetadata = new Metadata(key, value);
-            target.metadata.push(tagMetadata);
-        }
-        return target;
-    }
-    function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
-        let bindings = getBindings(context.container, target.serviceIdentifier);
-        let activeBindings = [];
-        if (bindings.length === BindingCount.NoBindingsAvailable &&
-            context.container.options.autoBindInjectable &&
-            typeof target.serviceIdentifier === 'function' &&
-            metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata) {
-            context.container.bind(target.serviceIdentifier).toSelf();
-            bindings = getBindings(context.container, target.serviceIdentifier);
-        }
-        if (!avoidConstraints) {
-            activeBindings = bindings.filter(binding => {
-                const request = new Request(binding.serviceIdentifier, context, parentRequest, binding, target);
-                return binding.constraint(request);
+        _get(getArgs) {
+            const result = [];
+            const bindings = this._bindingDictionary.get(getArgs.serviceIdentifier);
+            bindings.forEach(binding => {
+                result.push(this._resolveFromBinding(binding));
             });
+            return !getArgs.isMultiInject && result.length === 1 ? result[0] : result;
         }
-        else {
-            activeBindings = bindings;
-        }
-        _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
-        return activeBindings;
-    }
-    function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
-        switch (bindings.length) {
-            case BindingCount.NoBindingsAvailable:
-                if (target.isOptional()) {
-                    return bindings;
-                }
-                const serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
-                let msg = NOT_REGISTERED;
-                msg += listMetadataForTarget(serviceIdentifierString, target);
-                msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
-                throw new Error(msg);
-            case BindingCount.OnlyOneBindingAvailable:
-                return bindings;
-            case BindingCount.MultipleBindingsAvailable:
-            default:
-                if (!target.isArray()) {
-                    const serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
-                    let msg = `${AMBIGUOUS_MATCH} ${serviceIdentifierString}`;
-                    msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
-                    throw new Error(msg);
-                }
-                else {
-                    return bindings;
-                }
-        }
-    }
-    function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {
-        let activeBindings;
-        let childRequest;
-        if (parentRequest === null) {
-            activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);
-            childRequest = new Request(serviceIdentifier, context, null, activeBindings, target);
-            const 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(binding => {
-            let subChildRequest = null;
-            if (target.isArray()) {
-                subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);
-            }
-            else {
-                if (binding.cache) {
-                    return;
-                }
-                subChildRequest = childRequest;
-            }
-            if (binding.type === BindingTypeEnum.Instance && binding.implementationType !== null) {
-                const dependencies = getDependencies(metadataReader, binding.implementationType);
-                if (!context.container.options.skipBaseClassChecks) {
-                    const baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType);
-                    if (dependencies.length < baseClassDependencyCount) {
-                        const error = ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType));
-                        throw new Error(error);
-                    }
-                }
-                dependencies.forEach((dependency) => {
-                    _createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);
+        _getChildRequest(binding) {
+            const constr = binding.implementationType;
+            const { userGeneratedMetadata } = this._metadataReader.getConstructorMetadata(constr);
+            const keys = Object.keys(userGeneratedMetadata);
+            const arr = [];
+            for (let i = 0; i < keys.length; i++) {
+                const constructorArgsMetadata = userGeneratedMetadata[i];
+                const targetMetadataMap = {};
+                constructorArgsMetadata.forEach(md => {
+                    targetMetadataMap[md.key] = md.value;
+                });
+                const metadata = {
+                    inject: targetMetadataMap[INJECT_TAG],
+                    multiInject: targetMetadataMap[MULTI_INJECT_TAG]
+                };
+                const injectIdentifier = metadata.inject || metadata.multiInject;
+                const target = {
+                    serviceIdentifier: injectIdentifier,
+                    constructorArgsMetadata
+                };
+                const bindings = this._bindingDictionary.get(injectIdentifier).filter(b => {
+                    return b.constraint(target);
                 });
+                const request = {
+                    injectIdentifier,
+                    metadata: constructorArgsMetadata,
+                    bindings
+                };
+                arr.push(request);
             }
-        });
-    }
-    function getBindings(container, serviceIdentifier) {
-        let bindings = [];
-        const bindingDictionary = getBindingDictionary(container);
-        if (bindingDictionary.hasKey(serviceIdentifier)) {
-            bindings = bindingDictionary.get(serviceIdentifier);
-        }
-        else if (container.parent !== null) {
-            bindings = getBindings(container.parent, serviceIdentifier);
-        }
-        return bindings;
-    }
-    function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints = false) {
-        const context = new Context(container);
-        const target = _createTarget(isMultiInject, targetType, serviceIdentifier, '', key, value);
-        _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);
-        return context;
-    }
-    function createMockRequest(container, serviceIdentifier, key, value) {
-        const target = new Target(TargetTypeEnum.Variable, '', serviceIdentifier, new Metadata(key, value));
-        const context = new Context(container);
-        const request = new Request(serviceIdentifier, context, null, [], target);
-        return request;
-    }
-
-    function isPromise(object) {
-        const isObjectOrFunction = (typeof object === 'object' && object !== null) || typeof object === 'function';
-        return isObjectOrFunction && typeof object.then === 'function';
-    }
-    function isPromiseOrContainsPromise(object) {
-        if (isPromise(object)) {
-            return true;
-        }
-        return Array.isArray(object) && object.some(isPromise);
-    }
-
-    const tryGetFromScope = (requestScope, binding) => {
-        if (binding.scope === BindingScopeEnum.Singleton && binding.activated) {
-            return binding.cache;
-        }
-        if (binding.scope === BindingScopeEnum.Request && requestScope.has(binding.id)) {
-            return requestScope.get(binding.id);
-        }
-        return null;
-    };
-    const saveToScope = (requestScope, binding, result) => {
-        if (binding.scope === BindingScopeEnum.Singleton) {
-            _saveToSingletonScope(binding, result);
-        }
-        if (binding.scope === BindingScopeEnum.Request) {
-            _saveToRequestScope(requestScope, binding, result);
-        }
-    };
-    const _saveToRequestScope = (requestScope, binding, result) => {
-        if (!requestScope.has(binding.id)) {
-            requestScope.set(binding.id, result);
-        }
-    };
-    const _saveToSingletonScope = (binding, result) => {
-        binding.cache = result;
-        binding.activated = true;
-        if (isPromise(result)) {
-            void _saveAsyncResultToSingletonScope(binding, result);
-        }
-    };
-    const _saveAsyncResultToSingletonScope = (binding, asyncResult) => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            const result = yield asyncResult;
-            binding.cache = result;
-        }
-        catch (ex) {
-            binding.cache = null;
-            binding.activated = false;
-            throw ex;
-        }
-    });
-
-    var FactoryType;
-    (function (FactoryType) {
-        FactoryType["DynamicValue"] = "toDynamicValue";
-        FactoryType["Factory"] = "toFactory";
-        FactoryType["Provider"] = "toProvider";
-    })(FactoryType || (FactoryType = {}));
-
-    const ensureFullyBound = (binding) => {
-        let 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;
-                break;
-        }
-        if (boundValue === null) {
-            const serviceIdentifierAsString = getServiceIdentifierAsString(binding.serviceIdentifier);
-            throw new Error(`${INVALID_BINDING_TYPE} ${serviceIdentifierAsString}`);
+            return arr;
         }
-    };
-    const 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 ${binding.type}`);
+        _resolveFromBinding(binding) {
+            const result = this._getResolvedFromBinding(binding);
+            this._saveToScope(binding, result);
+            return result;
         }
-    };
-
-    const tryAndThrowErrorIfStackOverflow = (fn, errorCallback) => {
-        return fn();
-    };
-
-    function _resolveRequests(childRequests, resolveRequest) {
-        return childRequests.reduce((resolvedRequests, childRequest) => {
-            const injection = resolveRequest(childRequest);
-            const targetType = childRequest.target.type;
-            if (targetType === TargetTypeEnum.ConstructorArgument) {
-                resolvedRequests.constructorInjections.push(injection);
-            }
-            else {
-                resolvedRequests.propertyRequests.push(childRequest);
-                resolvedRequests.propertyInjections.push(injection);
-            }
-            if (!resolvedRequests.isAsync) {
-                resolvedRequests.isAsync = isPromiseOrContainsPromise(injection);
-            }
-            return resolvedRequests;
-        }, { constructorInjections: [], propertyInjections: [], propertyRequests: [], isAsync: false });
-    }
-    function _createInstance(constr, childRequests, resolveRequest) {
-        let result;
-        if (childRequests.length > 0) {
-            const resolved = _resolveRequests(childRequests, resolveRequest);
-            const createInstanceWithInjectionsArg = Object.assign(Object.assign({}, resolved), { constr });
-            if (resolved.isAsync) {
-                result = createInstanceWithInjectionsAsync(createInstanceWithInjectionsArg);
-            }
-            else {
-                result = createInstanceWithInjections(createInstanceWithInjectionsArg);
+        _getResolvedFromBinding(binding) {
+            let 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;
         }
-        else {
-            result = new constr();
-        }
-        return result;
-    }
-    function createInstanceWithInjections(args) {
-        const instance = new args.constr(...args.constructorInjections);
-        args.propertyRequests.forEach((r, index) => {
-            const property = r.target.identifier;
-            const injection = args.propertyInjections[index];
-            instance[property] = injection;
-        });
-        return instance;
-    }
-    function createInstanceWithInjectionsAsync(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const constructorInjections = yield possiblyWaitInjections(args.constructorInjections);
-            const propertyInjections = yield possiblyWaitInjections(args.propertyInjections);
-            return createInstanceWithInjections(Object.assign(Object.assign({}, args), { constructorInjections, propertyInjections }));
-        });
-    }
-    function possiblyWaitInjections(possiblePromiseinjections) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const injections = [];
-            for (const injection of possiblePromiseinjections) {
-                if (Array.isArray(injection)) {
-                    injections.push(Promise.all(injection));
-                }
-                else {
-                    injections.push(injection);
-                }
+        _resolveInstance(binding, constr) {
+            if (binding.activated) {
+                return binding.cache;
             }
-            return Promise.all(injections);
-        });
-    }
-    function _getInstanceAfterPostConstruct(constr, result) {
-        const postConstructResult = _postConstruct(constr, result);
-        if (isPromise(postConstructResult)) {
-            return postConstructResult.then(() => result);
-        }
-        return result;
-    }
-    function _postConstruct(constr, instance) {
-        var _a, _b;
-        if (Reflect$2.hasMetadata(POST_CONSTRUCT, constr)) {
-            const data = Reflect$2.getMetadata(POST_CONSTRUCT, constr);
-            return (_b = (_a = instance)[data.value]) === null || _b === void 0 ? void 0 : _b.call(_a);
-        }
-    }
-    function _validateInstanceResolution(binding, constr) {
-        if (binding.scope !== BindingScopeEnum.Singleton) {
-            _throwIfHandlingDeactivation(binding, constr);
+            const childRequests = this._getChildRequest(binding);
+            return this._createInstance(constr, childRequests);
         }
-    }
-    function _throwIfHandlingDeactivation(binding, constr) {
-        const scopeErrorMessage = `Class cannot be instantiated in ${binding.scope === BindingScopeEnum.Request ? 'request' : 'transient'} scope.`;
-        if (typeof binding.onDeactivation === 'function') {
-            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);
-        const result = _createInstance(constr, childRequests, resolveRequest);
-        if (isPromise(result)) {
-            return result.then(resolvedResult => _getInstanceAfterPostConstruct(constr, resolvedResult));
+        _createInstance(constr, childRequests) {
+            if (childRequests.length) {
+                const resolved = this._resolveRequests(childRequests);
+                const obj = new constr(...resolved);
+                return obj;
+            }
+            const obj = new constr();
+            return obj;
         }
-        return _getInstanceAfterPostConstruct(constr, result);
-    }
-
-    const _resolveRequest = (requestScope) => (request) => {
-        request.parentContext.setCurrentRequest(request);
-        const bindings = request.bindings;
-        const childRequests = request.childRequests;
-        const targetIsAnArray = request.target && request.target.isArray();
-        const targetParentIsNotAnArray = !request.parentRequest ||
-            !request.parentRequest.target ||
-            !request.target ||
-            !request.parentRequest.target.matchesArray(request.target.serviceIdentifier);
-        if (targetIsAnArray && targetParentIsNotAnArray) {
-            return childRequests.map((childRequest) => {
-                const _f = _resolveRequest(requestScope);
-                return _f(childRequest);
+        _resolveRequests(childRequests) {
+            return childRequests.map(request => {
+                return request.bindings.length > 1
+                    ? request.bindings.map(binding => this._resolveFromBinding(binding))
+                    : this._resolveFromBinding(request.bindings[0]);
             });
         }
-        if (request.target.isOptional() && bindings.length === 0) {
-            return undefined;
-        }
-        const binding = bindings[0];
-        return _resolveBinding(requestScope, request, binding);
-    };
-    const _resolveFactoryFromBinding = (binding, context) => {
-        const factoryDetails = getFactoryDetails(binding);
-        return tryAndThrowErrorIfStackOverflow(() => factoryDetails.factory.bind(binding)(context));
-    };
-    const _getResolvedFromBinding = (requestScope, request, binding) => {
-        let result;
-        const childRequests = request.childRequests;
-        ensureFullyBound(binding);
-        switch (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;
-    };
-    const _resolveInScope = (requestScope, binding, resolveFromBinding) => {
-        let result = tryGetFromScope(requestScope, binding);
-        if (result !== null) {
-            return result;
-        }
-        result = resolveFromBinding();
-        saveToScope(requestScope, binding, result);
-        return result;
-    };
-    const _resolveBinding = (requestScope, request, binding) => {
-        return _resolveInScope(requestScope, binding, () => {
-            const result = _getResolvedFromBinding(requestScope, request, binding);
-            return result;
-        });
-    };
-    function resolve(context) {
-        const _f = _resolveRequest(context.plan.rootRequest.requestScope);
-        return _f(context.plan.rootRequest);
-    }
-
-    class BindingOnSyntax {
-        constructor(binding) {
-            this._binding = binding;
-        }
-    }
-
-    const taggedConstraint = (key) => (value) => {
-        const constraint = (request) => request !== null && request.target !== null && request.target.matchesTag(key)(value);
-        constraint.metaData = new Metadata(key, value);
-        return constraint;
-    };
-    const namedConstraint = taggedConstraint(NAMED_TAG);
-
-    class BindingWhenSyntax {
-        constructor(binding) {
-            this._binding = binding;
-        }
-        whenTargetNamed(name) {
-            this._binding.constraint = namedConstraint(name);
-            return new BindingOnSyntax(this._binding);
-        }
-    }
-
-    class BindingWhenOnSyntax {
-        constructor(binding) {
-            this._binding = binding;
-            this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
-        }
-        whenTargetNamed(name) {
-            return this._bindingWhenSyntax.whenTargetNamed(name);
+        _saveToScope(binding, result) {
+            if (binding.scope === BindingScopeEnum.Singleton) {
+                binding.cache = result;
+                binding.activated = true;
+            }
         }
     }
 
-    class BindingInSyntax {
-        constructor(binding) {
-            this._binding = binding;
-        }
-        inRequestScope() {
-            this._binding.scope = BindingScopeEnum.Request;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        inSingletonScope() {
-            this._binding.scope = BindingScopeEnum.Singleton;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        inTransientScope() {
-            this._binding.scope = BindingScopeEnum.Transient;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-    }
+    function _typeof(o) {
+      "@babel/helpers - typeof";
 
-    class BindingInWhenOnSyntax {
-        constructor(binding) {
-            this._binding = binding;
-            this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);
-            this._bindingInSyntax = new BindingInSyntax(binding);
-        }
-        inRequestScope() {
-            return this._bindingInSyntax.inRequestScope();
-        }
-        inSingletonScope() {
-            return this._bindingInSyntax.inSingletonScope();
-        }
-        inTransientScope() {
-            return this._bindingInSyntax.inTransientScope();
-        }
-        whenTargetNamed(name) {
-            return this._bindingWhenSyntax.whenTargetNamed(name);
-        }
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+        return typeof o;
+      } : function (o) {
+        return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+      }, _typeof(o);
     }
 
-    class BindingToSyntax {
-        constructor(binding) {
-            this._binding = binding;
-        }
-        to(constructor) {
-            this._binding.type = BindingTypeEnum.Instance;
-            this._binding.implementationType = constructor;
-            return new BindingInWhenOnSyntax(this._binding);
-        }
-        toSelf() {
-            if (typeof this._binding.serviceIdentifier !== 'function') {
-                throw new Error(`${INVALID_TO_SELF_VALUE}`);
-            }
-            const self = this._binding.serviceIdentifier;
-            return this.to(self);
-        }
-        toConstantValue(value) {
-            this._binding.type = BindingTypeEnum.ConstantValue;
-            this._binding.cache = value;
-            this._binding.dynamicValue = null;
-            this._binding.implementationType = null;
-            this._binding.scope = BindingScopeEnum.Singleton;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        toDynamicValue(func) {
-            this._binding.type = BindingTypeEnum.DynamicValue;
-            this._binding.cache = null;
-            this._binding.dynamicValue = func;
-            this._binding.implementationType = null;
-            return new BindingInWhenOnSyntax(this._binding);
-        }
-        toConstructor(constructor) {
-            this._binding.type = BindingTypeEnum.Constructor;
-            this._binding.implementationType = constructor;
-            this._binding.scope = BindingScopeEnum.Singleton;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        toFactory(factory) {
-            this._binding.type = BindingTypeEnum.Factory;
-            this._binding.factory = factory;
-            this._binding.scope = BindingScopeEnum.Singleton;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        toFunction(func) {
-            if (typeof func !== 'function') {
-                throw new Error(INVALID_FUNCTION_BINDING);
-            }
-            const bindingWhenOnSyntax = this.toConstantValue(func);
-            this._binding.type = BindingTypeEnum.Function;
-            this._binding.scope = BindingScopeEnum.Singleton;
-            return bindingWhenOnSyntax;
-        }
-        toAutoFactory(serviceIdentifier) {
-            this._binding.type = BindingTypeEnum.Factory;
-            this._binding.factory = context => {
-                const autofactory = () => context.container.get(serviceIdentifier);
-                return autofactory;
-            };
-            this._binding.scope = BindingScopeEnum.Singleton;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        toAutoNamedFactory(serviceIdentifier) {
-            this._binding.type = BindingTypeEnum.Factory;
-            this._binding.factory = context => {
-                return (named) => context.container.getNamed(serviceIdentifier, named);
-            };
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        toProvider(provider) {
-            this._binding.type = BindingTypeEnum.Provider;
-            this._binding.provider = provider;
-            this._binding.scope = BindingScopeEnum.Singleton;
-            return new BindingWhenOnSyntax(this._binding);
-        }
-        toService(service) {
-            this.toDynamicValue(context => context.container.get(service));
-        }
+    function __decorate(decorators, target, key, desc) {
+      var c = arguments.length,
+        r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+        d;
+      if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      return c > 3 && r && Object.defineProperty(target, key, r), r;
     }
-
-    function isClonable(obj) {
-        return (typeof obj === 'object' &&
-            obj !== null &&
-            'clone' in obj &&
-            typeof obj.clone === 'function');
+    function __param(paramIndex, decorator) {
+      return function (target, key) {
+        decorator(target, key, paramIndex);
+      };
     }
-
-    class Lookup {
-        constructor() {
-            this._map = new Map();
-        }
-        getMap() {
-            return this._map;
-        }
-        add(serviceIdentifier, value) {
-            if (serviceIdentifier === null || serviceIdentifier === undefined) {
-                throw new Error(NULL_ARGUMENT);
-            }
-            if (value === null || value === undefined) {
-                throw new Error(NULL_ARGUMENT);
-            }
-            const entry = this._map.get(serviceIdentifier);
-            if (entry !== undefined) {
-                entry.push(value);
-            }
-            else {
-                this._map.set(serviceIdentifier, [value]);
-            }
-        }
-        get(serviceIdentifier) {
-            if (serviceIdentifier === null || serviceIdentifier === undefined) {
-                throw new Error(NULL_ARGUMENT);
-            }
-            const entry = this._map.get(serviceIdentifier);
-            if (entry !== undefined) {
-                return entry;
-            }
-            throw new Error(KEY_NOT_FOUND);
-        }
-        remove(serviceIdentifier) {
-            if (serviceIdentifier === null || serviceIdentifier === undefined) {
-                throw new Error(NULL_ARGUMENT);
-            }
-            if (!this._map.delete(serviceIdentifier)) {
-                throw new Error(KEY_NOT_FOUND);
-            }
-        }
-        removeIntersection(lookup) {
-            this.traverse((serviceIdentifier, value) => {
-                const lookupActivations = lookup.hasKey(serviceIdentifier) ? lookup.get(serviceIdentifier) : undefined;
-                if (lookupActivations !== undefined) {
-                    const filteredValues = value.filter(lookupValue => !lookupActivations.some(moduleActivation => lookupValue === moduleActivation));
-                    this._setValue(serviceIdentifier, filteredValues);
-                }
-            });
-        }
-        removeByCondition(condition) {
-            const removals = [];
-            this._map.forEach((entries, key) => {
-                const updatedEntries = [];
-                for (const entry of entries) {
-                    const remove = condition(entry);
-                    if (remove) {
-                        removals.push(entry);
-                    }
-                    else {
-                        updatedEntries.push(entry);
-                    }
-                }
-                this._setValue(key, updatedEntries);
-            });
-            return removals;
-        }
-        hasKey(serviceIdentifier) {
-            if (serviceIdentifier === null || serviceIdentifier === undefined) {
-                throw new Error(NULL_ARGUMENT);
-            }
-            return this._map.has(serviceIdentifier);
-        }
-        clone() {
-            const copy = new Lookup();
-            this._map.forEach((value, key) => {
-                value.forEach(b => copy.add(key, isClonable(b) ? b.clone() : b));
-            });
-            return copy;
-        }
-        traverse(func) {
-            this._map.forEach((value, key) => {
-                func(key, value);
-            });
-        }
-        _setValue(serviceIdentifier, value) {
-            if (value.length > 0) {
-                this._map.set(serviceIdentifier, value);
-            }
-            else {
-                this._map.delete(serviceIdentifier);
-            }
-        }
+    function __metadata(metadataKey, metadataValue) {
+      if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
     }
-
-    class Container {
-        static merge(container1, container2, ...containers) {
-            const container = new Container();
-            const targetContainers = [
-                container1,
-                container2,
-                ...containers
-            ].map(targetContainer => getBindingDictionary(targetContainer));
-            const bindingDictionary = getBindingDictionary(container);
-            function copyDictionary(origin, destination) {
-                origin.traverse((_key, value) => {
-                    value.forEach(binding => {
-                        destination.add(binding.serviceIdentifier, binding.clone());
-                    });
-                });
-            }
-            targetContainers.forEach(targetBindingDictionary => {
-                copyDictionary(targetBindingDictionary, bindingDictionary);
-            });
-            return container;
-        }
-        constructor(containerOptions) {
-            const options = containerOptions || {};
-            if (typeof options !== 'object') {
-                throw new Error(`${CONTAINER_OPTIONS_MUST_BE_AN_OBJECT}`);
-            }
-            if (options.defaultScope === undefined) {
-                options.defaultScope = BindingScopeEnum.Transient;
-            }
-            else if (options.defaultScope !== BindingScopeEnum.Singleton &&
-                options.defaultScope !== BindingScopeEnum.Transient &&
-                options.defaultScope !== BindingScopeEnum.Request) {
-                throw new Error(`${CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE}`);
-            }
-            if (options.autoBindInjectable === undefined) {
-                options.autoBindInjectable = false;
-            }
-            else if (typeof options.autoBindInjectable !== 'boolean') {
-                throw new Error(`${CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE}`);
-            }
-            if (options.skipBaseClassChecks === undefined) {
-                options.skipBaseClassChecks = false;
-            }
-            else if (typeof options.skipBaseClassChecks !== 'boolean') {
-                throw new Error(`${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();
-        }
-        load(...modules) {
-            const getHelpers = this._getContainerModuleHelpersFactory();
-            for (const currentModule of modules) {
-                const containerModuleHelpers = getHelpers(currentModule.id);
-                currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
-            }
-        }
-        unload(...modules) {
-            modules.forEach(module => {
-                const deactivations = this._removeModuleBindings(module.id);
-                this._deactivateSingletons(deactivations);
-            });
-        }
-        bind(serviceIdentifier) {
-            const scope = this.options.defaultScope || BindingScopeEnum.Transient;
-            const binding = new Binding(serviceIdentifier, scope);
-            this._bindingDictionary.add(serviceIdentifier, binding);
-            return new BindingToSyntax(binding);
-        }
-        rebind(serviceIdentifier) {
-            this.unbind(serviceIdentifier);
-            return this.bind(serviceIdentifier);
-        }
-        unbind(serviceIdentifier) {
-            if (this._bindingDictionary.hasKey(serviceIdentifier)) {
-                const bindings = this._bindingDictionary.get(serviceIdentifier);
-                this._deactivateSingletons(bindings);
-            }
-            this._removeServiceFromDictionary(serviceIdentifier);
-        }
-        unbindAll() {
-            this._bindingDictionary.traverse((_key, value) => {
-                this._deactivateSingletons(value);
-            });
-            this._bindingDictionary = new Lookup();
-        }
-        isBound(serviceIdentifier) {
-            let bound = this._bindingDictionary.hasKey(serviceIdentifier);
-            if (!bound && this.parent) {
-                bound = this.parent.isBound(serviceIdentifier);
-            }
-            return bound;
-        }
-        isCurrentBound(serviceIdentifier) {
-            return this._bindingDictionary.hasKey(serviceIdentifier);
-        }
-        isBoundNamed(serviceIdentifier, named) {
-            return this.isBoundTagged(serviceIdentifier, NAMED_TAG, named);
-        }
-        isBoundTagged(serviceIdentifier, key, value) {
-            let bound = false;
-            if (this._bindingDictionary.hasKey(serviceIdentifier)) {
-                const bindings = this._bindingDictionary.get(serviceIdentifier);
-                const request = createMockRequest(this, serviceIdentifier, key, value);
-                bound = bindings.some(b => b.constraint(request));
-            }
-            if (!bound && this.parent) {
-                bound = this.parent.isBoundTagged(serviceIdentifier, key, value);
-            }
-            return bound;
-        }
-        applyCustomMetadataReader(metadataReader) {
-            this._metadataReader = metadataReader;
-        }
-        get(serviceIdentifier) {
-            const getArgs = this._getNotAllArgs(serviceIdentifier, false);
-            const data = this._getButThrowIfAsync(getArgs);
-            return data;
-        }
-        getAsync(serviceIdentifier) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const getArgs = this._getNotAllArgs(serviceIdentifier, false);
-                return this._get(getArgs);
-            });
-        }
-        getTagged(serviceIdentifier, key, value) {
-            const getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);
-            return this._getButThrowIfAsync(getArgs);
-        }
-        getNamed(serviceIdentifier, named) {
-            return this.getTagged(serviceIdentifier, NAMED_TAG, named);
-        }
-        getAll(serviceIdentifier) {
-            const getArgs = this._getAllArgs(serviceIdentifier);
-            return this._getButThrowIfAsync(getArgs);
-        }
-        getAllTagged(serviceIdentifier, key, value) {
-            const getArgs = this._getNotAllArgs(serviceIdentifier, true, key, value);
-            return this._getButThrowIfAsync(getArgs);
-        }
-        getAllNamed(serviceIdentifier, named) {
-            return this.getAllTagged(serviceIdentifier, NAMED_TAG, named);
-        }
-        resolve(constructorFunction) {
-            const isBound = this.isBound(constructorFunction);
-            if (!isBound) {
-                this.bind(constructorFunction).toSelf();
-            }
-            const resolved = this.get(constructorFunction);
-            if (!isBound) {
-                this.unbind(constructorFunction);
-            }
-            return resolved;
-        }
-        _preDestroy(constructor, instance) {
-            var _a, _b;
-            if (Reflect$2.hasMetadata(PRE_DESTROY, constructor)) {
-                const data = Reflect$2.getMetadata(PRE_DESTROY, constructor);
-                return (_b = (_a = instance)[data.value]) === null || _b === void 0 ? void 0 : _b.call(_a);
-            }
-        }
-        _removeModuleBindings(moduleId) {
-            return this._bindingDictionary.removeByCondition(binding => binding.moduleId === moduleId);
-        }
-        _deactivate(binding, instance) {
-            const constructor = Object.getPrototypeOf(instance).constructor;
-            try {
-                const 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));
-                }
-            }
-        }
-        _handleDeactivationError(asyncResult, constructor) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield asyncResult;
-                }
-                catch (ex) {
-                    if (ex instanceof Error) {
-                        throw new Error(ON_DEACTIVATION_ERROR(constructor.name, ex.message));
-                    }
-                }
-            });
-        }
-        _getContainerModuleHelpersFactory() {
-            const setModuleId = (bindingToSyntax, moduleId) => {
-                bindingToSyntax._binding.moduleId = moduleId;
-            };
-            const getBindFunction = (moduleId) => (serviceIdentifier) => {
-                const bindingToSyntax = this.bind(serviceIdentifier);
-                setModuleId(bindingToSyntax, moduleId);
-                return bindingToSyntax;
-            };
-            const getUnbindFunction = () => (serviceIdentifier) => {
-                return this.unbind(serviceIdentifier);
-            };
-            const getUnbindAsyncFunction = () => (serviceIdentifier) => {
-                return null;
-            };
-            const getIsboundFunction = () => (serviceIdentifier) => {
-                return this.isBound(serviceIdentifier);
-            };
-            const getRebindFunction = (moduleId) => (serviceIdentifier) => {
-                const bindingToSyntax = this.rebind(serviceIdentifier);
-                setModuleId(bindingToSyntax, moduleId);
-                return bindingToSyntax;
-            };
-            return (mId) => ({
-                bindFunction: getBindFunction(mId),
-                isboundFunction: getIsboundFunction(),
-                rebindFunction: getRebindFunction(mId),
-                unbindFunction: getUnbindFunction(),
-                unbindAsyncFunction: getUnbindAsyncFunction()
-            });
-        }
-        _get(getArgs) {
-            const planAndResolveArgs = Object.assign(Object.assign({}, getArgs), { contextInterceptor: context => context, targetType: TargetTypeEnum.Variable });
-            return this._planAndResolve()(planAndResolveArgs);
-        }
-        _getButThrowIfAsync(getArgs) {
-            const result = this._get(getArgs);
-            return result;
-        }
-        _getAllArgs(serviceIdentifier) {
-            const getAllArgs = {
-                avoidConstraints: true,
-                isMultiInject: true,
-                serviceIdentifier
-            };
-            return getAllArgs;
-        }
-        _getNotAllArgs(serviceIdentifier, isMultiInject, key, value) {
-            const getNotAllArgs = {
-                avoidConstraints: false,
-                isMultiInject,
-                serviceIdentifier,
-                key,
-                value
-            };
-            return getNotAllArgs;
-        }
-        _planAndResolve() {
-            return (args) => {
-                let context = plan(this._metadataReader, this, args.isMultiInject, args.targetType, args.serviceIdentifier, args.key, args.value, args.avoidConstraints);
-                context = args.contextInterceptor(context);
-                const result = resolve(context);
-                return result;
-            };
-        }
-        _deactivateIfSingleton(binding) {
-            if (!binding.activated) {
-                return;
-            }
-            if (isPromise(binding.cache)) {
-                return binding.cache.then(resolved => this._deactivate(binding, resolved));
-            }
-            return this._deactivate(binding, binding.cache);
-        }
-        _deactivateSingletons(bindings) {
-            for (const binding of bindings) {
-                const result = this._deactivateIfSingleton(binding);
-                if (isPromise(result)) {
-                    throw new Error(ASYNC_UNBIND_REQUIRED);
-                }
-            }
-        }
-        _propagateContainerDeactivationThenBindingAndPreDestroy(binding, instance, constructor) {
-            if (this.parent) {
-                return this._deactivate.bind(this.parent)(binding, instance);
-            }
-            return this._bindingDeactivationAndPreDestroy(binding, instance, constructor);
-        }
-        _removeServiceFromDictionary(serviceIdentifier) {
-            try {
-                this._bindingDictionary.remove(serviceIdentifier);
-            }
-            catch (e) {
-                throw new Error(`${CANNOT_UNBIND} ${getServiceIdentifierAsString(serviceIdentifier)}`);
-            }
+    function __awaiter(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function (resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
         }
-        _bindingDeactivationAndPreDestroy(binding, instance, constructor) {
-            if (typeof binding.onDeactivation === 'function') {
-                const result = binding.onDeactivation(instance);
-                if (isPromise(result)) {
-                    return result.then(() => this._preDestroy(constructor, instance));
-                }
-            }
-            return this._preDestroy(constructor, instance);
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
         }
-        _bindingDeactivationAndPreDestroyAsync(binding, instance, constructor) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (typeof binding.onDeactivation === 'function') {
-                    yield binding.onDeactivation(instance);
-                }
-                yield this._preDestroy(constructor, instance);
-            });
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
     }
-
-    function propertyEventDecorator(eventKey, errorMessage) {
-        return () => {
-            return (target, propertyKey) => {
-                const metadata = new Metadata(eventKey, propertyKey);
-                if (Reflect$2.hasOwnMetadata(eventKey, target.constructor)) {
-                    throw new Error(errorMessage);
-                }
-                Reflect$2.defineMetadata(eventKey, metadata, target.constructor);
-            };
-        };
-    }
-
-    const postConstruct = propertyEventDecorator(POST_CONSTRUCT, MULTIPLE_POST_CONSTRUCT_METHODS);
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
 
     const ContributionProvider = Symbol('ContributionProvider');
     class ContributionProviderCache {
@@ -2352,11 +1225,13 @@
         }
         constructor(contributions) {
             this.contributions = contributions;
+            this.id = Generator.GenAutoIncrementId();
             this.hooks = {
                 onSetEnv: new SyncHook(['lastEnv', 'env', 'global'])
             };
             this.measureTextMethod = 'native';
             this.optimizeVisible = false;
+            this.optmizeSkipCheckBoundariesThreshold = 0;
         }
         bindContribution(params) {
             const promiseArr = [];
@@ -4291,7 +3166,10 @@
         direction: 'horizontal',
         wordBreak: 'break-all',
         ignoreBuf: false,
-        verticalMode: 0
+        verticalMode: 0,
+        whiteSpace: 'no-wrap',
+        heightLimit: Infinity,
+        lineClamp: Infinity
     };
     const DefaultStyle = Object.assign(Object.assign(Object.assign({ opacity: 1, background: null, texture: null, textureColor: 'black', textureSize: 10, texturePadding: 2, backgroundMode: 0, blur: 0, cursor: null, html: null }, DefaultFillStyle), DefaultStrokeStyle), DefaultLayout);
     const DefaultConnectAttribute = {
@@ -5422,6 +4300,13 @@
     class DefaultCanvasAllocate {
         constructor() {
             this.pools = [];
+            this.allocatedCanvas = [];
+        }
+        shareCanvas() {
+            if (this.allocatedCanvas.length) {
+                return this.allocatedCanvas[0];
+            }
+            return this.getCommonCanvas();
         }
         getCommonCanvas() {
             if (!this._commonCanvas) {
@@ -5431,7 +4316,9 @@
         }
         allocate(data) {
             if (!this.pools.length) {
-                return wrapCanvas(Object.assign({ nativeCanvas: application.global.createCanvas(data) }, data));
+                const c = wrapCanvas(Object.assign({ nativeCanvas: application.global.createCanvas(data) }, data));
+                this.allocatedCanvas.push(c);
+                return c;
             }
             const m = this.pools.pop();
             m.resize(data.width, data.height);
@@ -5445,7 +4332,9 @@
                     height: canvas.height / canvas.dpr,
                     dpr: canvas.dpr
                 };
-                return wrapCanvas(Object.assign({ nativeCanvas: application.global.createCanvas(data) }, data));
+                const c = wrapCanvas(Object.assign({ nativeCanvas: application.global.createCanvas(data) }, data));
+                this.allocatedCanvas.push(c);
+                return c;
             }
             const m = this.pools.pop();
             m.width = canvas.width;
@@ -5465,6 +4354,14 @@
     const canvasAllocate = new DefaultCanvasAllocate();
 
     exports.DefaultGraphicUtil = class DefaultGraphicUtil {
+        get canvas() {
+            this.tryInitCanvas();
+            return this._canvas;
+        }
+        get context() {
+            this.tryInitCanvas();
+            return this._context;
+        }
         constructor(contributions) {
             this.contributions = contributions;
             this.configured = false;
@@ -5484,14 +4381,18 @@
             if (this.configured) {
                 return;
             }
-            const canvas = canvasAllocate.getCommonCanvas();
-            this.canvas = canvas;
-            this.context = canvas.getContext('2d');
             this.contributions.getContributions().forEach(contribution => {
                 contribution.configure(this, env);
             });
             this.configured = true;
         }
+        tryInitCanvas() {
+            if (!this._canvas) {
+                const canvas = canvasAllocate.shareCanvas();
+                this._canvas = canvas;
+                this._context = canvas.getContext('2d');
+            }
+        }
         bindTextMeasure(tm) {
             this._textMeasure = tm;
         }
@@ -5816,13 +4717,6 @@
         return null;
     }
 
-    class Generator {
-        static GenAutoIncrementId() {
-            return Generator.auto_increment_id++;
-        }
-    }
-    Generator.auto_increment_id = 0;
-
     class Node extends vutils.EventEmitter {
         get previousSibling() {
             return this._prev;
@@ -9022,6 +7916,13 @@
     }
     RafBasedSTO.TimeOut = 1000 / 60;
     const rafBasedSto = new RafBasedSTO();
+    const calculateLineHeight = (lineHeight, fontSize) => {
+        if (vutils.isString(lineHeight) && lineHeight[lineHeight.length - 1] === '%') {
+            const scale = Number.parseFloat(lineHeight.substring(0, lineHeight.length - 1)) / 100;
+            return fontSize * scale;
+        }
+        return lineHeight;
+    };
 
     class IncreaseCount extends ACustomAnimate {
         constructor(from, to, duration, easing, params) {
@@ -13466,6 +12367,7 @@
             };
             this._uid = Generator.GenAutoIncrementId();
             this.global = application.global;
+            this.postInit();
         }
         postInit() {
             this.global.hooks.onSetEnv.tap('window', () => {
@@ -13551,12 +12453,6 @@
             return this._handler.getTopLeft(baseWindow);
         }
     };
-    __decorate([
-        postConstruct(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], exports.DefaultWindow.prototype, "postInit", null);
     exports.DefaultWindow = __decorate([
         injectable(),
         __metadata("design:paramtypes", [])
@@ -14324,6 +13220,8 @@
     const TEXT_UPDATE_TAG_KEY = [
         'text',
         'maxLineWidth',
+        'heightLimit',
+        'lineClamp',
         'fontSize',
         'fontFamily',
         'fontWeight',
@@ -14408,6 +13306,113 @@
             this.clearUpdateBoundTag();
             return bounds;
         }
+        updateWrapAABBBounds(text) {
+            var _a, _b, _c, _d;
+            const textTheme = getTheme(this).text;
+            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, fontWeight = textTheme.fontWeight, ignoreBuf = textTheme.ignoreBuf, heightLimit = 0, lineClamp } = this.attribute;
+            const lineHeight = (_a = calculateLineHeight(this.attribute.lineHeight, this.attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (this.attribute.fontSize || textTheme.fontSize);
+            const buf = ignoreBuf ? 0 : 2;
+            if (!this.shouldUpdateShape() && ((_b = this.cache) === null || _b === void 0 ? void 0 : _b.layoutData)) {
+                const bbox = this.cache.layoutData.bbox;
+                this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
+                if (stroke) {
+                    this._AABBBounds.expand(lineWidth / 2);
+                }
+                return this._AABBBounds;
+            }
+            const textMeasure = application.graphicUtil.textMeasure;
+            const layoutObj = new CanvasTextLayout(fontFamily, { fontSize, fontWeight, fontFamily }, textMeasure);
+            const lines = vutils.isArray(text) ? text.map(l => l.toString()) : [text.toString()];
+            const linesLayout = [];
+            const bboxWH = [0, 0];
+            let lineCountLimit = Infinity;
+            if (heightLimit > 0) {
+                lineCountLimit = Math.max(Math.floor(heightLimit / lineHeight), 1);
+            }
+            if (lineClamp) {
+                lineCountLimit = Math.min(lineCountLimit, lineClamp);
+            }
+            if (typeof maxLineWidth === 'number' && maxLineWidth !== Infinity) {
+                if (maxLineWidth > 0) {
+                    for (let i = 0; i < lines.length; i++) {
+                        const str = lines[i];
+                        let needCut = true;
+                        if (i === lineCountLimit - 1) {
+                            const clip = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, false);
+                            linesLayout.push({
+                                str: clip.str,
+                                width: clip.width
+                            });
+                            break;
+                        }
+                        const clip = layoutObj.textMeasure.clipText(str, layoutObj.textOptions, maxLineWidth, wordBreak === 'break-word');
+                        if (str !== '' && clip.str === '') {
+                            if (ellipsis) {
+                                const clipEllipsis = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, false);
+                                clip.str = (_c = clipEllipsis.str) !== null && _c !== void 0 ? _c : '';
+                                clip.width = (_d = clipEllipsis.width) !== null && _d !== void 0 ? _d : 0;
+                            }
+                            else {
+                                clip.str = '';
+                                clip.width = 0;
+                            }
+                            needCut = false;
+                        }
+                        linesLayout.push({
+                            str: clip.str,
+                            width: clip.width
+                        });
+                        if (clip.str.length === str.length) ;
+                        else if (needCut) {
+                            const newStr = str.substring(clip.str.length);
+                            lines.splice(i + 1, 0, newStr);
+                        }
+                    }
+                }
+                let maxWidth = 0;
+                linesLayout.forEach(layout => {
+                    maxWidth = Math.max(maxWidth, layout.width);
+                });
+                bboxWH[0] = maxWidth;
+            }
+            else {
+                let lineWidth = 0;
+                let width;
+                let text;
+                for (let i = 0, len = lines.length; i < len; i++) {
+                    if (i === lineCountLimit - 1) {
+                        const clip = layoutObj.textMeasure.clipTextWithSuffix(lines[i], layoutObj.textOptions, maxLineWidth, ellipsis, false);
+                        linesLayout.push({
+                            str: clip.str,
+                            width: clip.width
+                        });
+                        lineWidth = Math.max(lineWidth, clip.width);
+                        break;
+                    }
+                    text = lines[i];
+                    width = layoutObj.textMeasure.measureTextWidth(text, layoutObj.textOptions, wordBreak === 'break-word');
+                    lineWidth = Math.max(lineWidth, width);
+                    linesLayout.push({ str: text, width });
+                }
+                bboxWH[0] = lineWidth;
+            }
+            bboxWH[1] = linesLayout.length * (lineHeight + buf);
+            const bbox = {
+                xOffset: 0,
+                yOffset: 0,
+                width: bboxWH[0],
+                height: bboxWH[1]
+            };
+            layoutObj.LayoutBBox(bbox, textAlign, textBaseline);
+            const layoutData = layoutObj.layoutWithBBox(bbox, linesLayout, textAlign, textBaseline, lineHeight);
+            this.cache.layoutData = layoutData;
+            this.clearUpdateShapeTag();
+            this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
+            if (stroke) {
+                this._AABBBounds.expand(lineWidth / 2);
+            }
+            return this._AABBBounds;
+        }
         updateSingallineAABBBounds(text) {
             const textTheme = getTheme(this).text;
             const { direction = textTheme.direction } = this.attribute;
@@ -14429,9 +13434,13 @@
             let width;
             let str;
             const attribute = this.attribute;
-            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, ignoreBuf = textTheme.ignoreBuf } = attribute;
+            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, ignoreBuf = textTheme.ignoreBuf, whiteSpace = textTheme.whiteSpace } = attribute;
+            if (whiteSpace === 'normal') {
+                return this.updateWrapAABBBounds(text);
+            }
             const buf = ignoreBuf ? 0 : Math.max(2, fontSize * 0.075);
-            const { lineHeight = (_a = attribute.lineHeight) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf } = attribute;
+            const textFontSize = attribute.fontSize || textTheme.fontSize;
+            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, textFontSize)) !== null && _a !== void 0 ? _a : textFontSize + buf;
             if (!this.shouldUpdateShape() && this.cache) {
                 width = (_b = this.cache.clipedWidth) !== null && _b !== void 0 ? _b : 0;
                 const dx = textDrawOffsetX(textAlign, width);
@@ -14489,7 +13498,8 @@
             const attribute = this.attribute;
             const { ignoreBuf = textTheme.ignoreBuf } = attribute;
             const buf = ignoreBuf ? 0 : 2;
-            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, fontFamily = textTheme.fontFamily, stroke = textTheme.stroke, lineHeight = (_a = attribute.lineHeight) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
+            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, fontFamily = textTheme.fontFamily, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
+            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf;
             let { textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline } = attribute;
             if (!verticalMode) {
                 const t = textAlign;
@@ -14546,11 +13556,15 @@
             return this._AABBBounds;
         }
         updateHorizontalMultilineAABBBounds(text) {
-            var _a;
+            var _a, _b;
             const textTheme = getTheme(this).text;
             const attribute = this.attribute;
-            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, lineHeight = attribute.lineHeight || attribute.fontSize || textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak } = attribute;
-            if (!this.shouldUpdateShape() && ((_a = this.cache) === null || _a === void 0 ? void 0 : _a.layoutData)) {
+            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, whiteSpace = textTheme.whiteSpace } = attribute;
+            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize);
+            if (whiteSpace === 'normal') {
+                return this.updateWrapAABBBounds(text);
+            }
+            if (!this.shouldUpdateShape() && ((_b = this.cache) === null || _b === void 0 ? void 0 : _b.layoutData)) {
                 const bbox = this.cache.layoutData.bbox;
                 this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
                 if (stroke) {
@@ -14578,7 +13592,8 @@
             const attribute = this.attribute;
             const { ignoreBuf = textTheme.ignoreBuf } = attribute;
             const buf = ignoreBuf ? 0 : 2;
-            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineHeight = (_a = attribute.lineHeight) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
+            const { maxLineWidth = textTheme.maxLineWidth, ellipsis = textTheme.ellipsis, fontFamily = textTheme.fontFamily, fontSize = textTheme.fontSize, fontWeight = textTheme.fontWeight, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, verticalMode = textTheme.verticalMode } = attribute;
+            const lineHeight = (_a = calculateLineHeight(attribute.lineHeight, attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (attribute.fontSize || textTheme.fontSize) + buf;
             let { textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline } = attribute;
             if (!verticalMode) {
                 const t = textAlign;
@@ -14685,11 +13700,12 @@
             return text != null && text !== '';
         }
         updateMultilineAABBBounds(text) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             const textTheme = getTheme(this).text;
-            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, lineHeight = this.attribute.lineHeight || this.attribute.fontSize || textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, fontWeight = textTheme.fontWeight, ignoreBuf = textTheme.ignoreBuf, heightLimit = 0, lineClamp } = this.attribute;
+            const { fontFamily = textTheme.fontFamily, textAlign = textTheme.textAlign, textBaseline = textTheme.textBaseline, fontSize = textTheme.fontSize, ellipsis = textTheme.ellipsis, maxLineWidth, stroke = textTheme.stroke, lineWidth = textTheme.lineWidth, wordBreak = textTheme.wordBreak, fontWeight = textTheme.fontWeight, ignoreBuf = textTheme.ignoreBuf, heightLimit = 0, lineClamp } = this.attribute;
+            const lineHeight = (_a = calculateLineHeight(this.attribute.lineHeight, this.attribute.fontSize || textTheme.fontSize)) !== null && _a !== void 0 ? _a : (this.attribute.fontSize || textTheme.fontSize);
             const buf = ignoreBuf ? 0 : 2;
-            if (!this.shouldUpdateShape() && ((_a = this.cache) === null || _a === void 0 ? void 0 : _a.layoutData)) {
+            if (!this.shouldUpdateShape() && ((_b = this.cache) === null || _b === void 0 ? void 0 : _b.layoutData)) {
                 const bbox = this.cache.layoutData.bbox;
                 this._AABBBounds.set(bbox.xOffset, bbox.yOffset, bbox.xOffset + bbox.width, bbox.yOffset + bbox.height);
                 if (stroke) {
@@ -14726,8 +13742,8 @@
                         if (str !== '' && clip.str === '') {
                             if (ellipsis) {
                                 const clipEllipsis = layoutObj.textMeasure.clipTextWithSuffix(str, layoutObj.textOptions, maxLineWidth, ellipsis, false);
-                                clip.str = (_b = clipEllipsis.str) !== null && _b !== void 0 ? _b : '';
-                                clip.width = (_c = clipEllipsis.width) !== null && _c !== void 0 ? _c : 0;
+                                clip.str = (_c = clipEllipsis.str) !== null && _c !== void 0 ? _c : '';
+                                clip.width = (_d = clipEllipsis.width) !== null && _d !== void 0 ? _d : 0;
                             }
                             else {
                                 clip.str = '';
@@ -15569,6 +14585,13 @@
     builtinSymbols.forEach(symbol => {
         builtinSymbolsMap[symbol.type] = symbol;
     });
+    const 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'
+    };
 
     const _tempBounds$1 = new vutils.AABBBounds();
     const SYMBOL_UPDATE_TAG_KEY = ['symbolType', 'size', ...GRAPHIC_UPDATE_TAG_KEY];
@@ -15594,7 +14617,7 @@
         }
         doUpdateParsedPath() {
             const symbolTheme = getTheme(this).symbol;
-            const { symbolType = symbolTheme.symbolType } = this.attribute;
+            let { symbolType = symbolTheme.symbolType } = this.attribute;
             let path = builtinSymbolsMap[symbolType];
             if (path) {
                 this._parsedPath = path;
@@ -15605,6 +14628,8 @@
                 this._parsedPath = path;
                 return path;
             }
+            const _symbolType = builtInSymbolStrMap[symbolType];
+            symbolType = _symbolType || symbolType;
             const valid = isSvg(symbolType);
             if (valid === true) {
                 const parser = new XMLParser();
@@ -16354,8 +15379,9 @@
         constructor(text, newLine, character) {
             this.fontSize = character.fontSize || 16;
             this.textBaseline = character.textBaseline || 'alphabetic';
-            if (typeof character.lineHeight === 'number') {
-                this.lineHeight = character.lineHeight > this.fontSize ? character.lineHeight : this.fontSize;
+            const lineHeight = calculateLineHeight(character.lineHeight, this.fontSize);
+            if (typeof lineHeight === 'number') {
+                this.lineHeight = lineHeight > this.fontSize ? lineHeight : this.fontSize;
             }
             else {
                 this.lineHeight = Math.floor(1.2 * this.fontSize);
@@ -20671,19 +19697,55 @@
             }
             return !!ret;
         }
+        drawLinearLineHighPerformance(line, context, fill, stroke, fillOpacity, strokeOpacity, offsetX, offsetY, lineAttribute, drawContext, params, fillCb, strokeCb) {
+            var _a;
+            context.beginPath();
+            const z = (_a = this.z) !== null && _a !== void 0 ? _a : 0;
+            const { points } = line.attribute;
+            const startP = points[0];
+            context.moveTo(startP.x, startP.y, z);
+            for (let i = 1; i < points.length; i++) {
+                const p = points[i];
+                context.lineTo(p.x, p.y, z);
+            }
+            context.setShadowBlendStyle && context.setShadowBlendStyle(line, line.attribute, lineAttribute);
+            const { x: originX = 0, x: originY = 0 } = line.attribute;
+            if (fill !== false) {
+                if (fillCb) {
+                    fillCb(context, line.attribute, lineAttribute);
+                }
+                else if (fillOpacity) {
+                    context.setCommonStyle(line, line.attribute, originX - offsetX, originY - offsetY, lineAttribute);
+                    context.fill();
+                }
+            }
+            if (stroke !== false) {
+                if (strokeCb) {
+                    strokeCb(context, line.attribute, lineAttribute);
+                }
+                else if (strokeOpacity) {
+                    context.setStrokeStyle(line, line.attribute, originX - offsetX, originY - offsetY, lineAttribute);
+                    context.stroke();
+                }
+            }
+        }
         drawShape(line, context, x, y, drawContext, params, fillCb, strokeCb) {
             const lineAttribute = getTheme(line, params === null || params === void 0 ? void 0 : params.theme).line;
-            const { fill = lineAttribute.fill, stroke = lineAttribute.stroke, fillOpacity = lineAttribute.fillOpacity, strokeOpacity = lineAttribute.strokeOpacity } = line.attribute;
+            const { fill = lineAttribute.fill, stroke = lineAttribute.stroke, fillOpacity = lineAttribute.fillOpacity, strokeOpacity = lineAttribute.strokeOpacity, segments, points, closePath } = line.attribute;
             const data = this.valid(line, lineAttribute, fillCb, strokeCb);
             if (!data) {
                 return;
             }
+            let { curveType = lineAttribute.curveType } = line.attribute;
+            if (closePath && curveType === 'linear') {
+                curveType = 'linearClosed';
+            }
+            const { clipRange = lineAttribute.clipRange, clipRangeByDimension = lineAttribute.clipRangeByDimension } = line.attribute;
+            if (clipRange === 1 && !segments && !points.some(p => p.defined === false) && curveType === 'linear') {
+                return this.drawLinearLineHighPerformance(line, context, !!fill, !!stroke, fillOpacity, strokeOpacity, x, y, lineAttribute, drawContext, params, fillCb, strokeCb);
+            }
             if (line.shouldUpdateShape()) {
-                const { points, segments, closePath } = line.attribute;
-                let { curveType = lineAttribute.curveType } = line.attribute;
-                if (closePath && curveType === 'linear') {
-                    curveType = 'linearClosed';
-                }
+                const { points, segments } = line.attribute;
                 const _points = points;
                 if (segments && segments.length) {
                     let startPoint;
@@ -20747,7 +19809,6 @@
                 }
                 line.clearUpdateShapeTag();
             }
-            const { clipRange = lineAttribute.clipRange, clipRangeByDimension = lineAttribute.clipRangeByDimension } = line.attribute;
             if (Array.isArray(line.cache)) {
                 const segments = line.attribute.segments.filter(item => item.points.length);
                 if (segments[0].points.length === 1) {
@@ -21691,14 +20752,14 @@
         drawShape(text, context, x, y, drawContext, params, fillCb, strokeCb) {
             var _a, _b, _c;
             const textAttribute = getTheme(text, params === null || params === void 0 ? void 0 : params.theme).text;
-            const { text: str, fill = textAttribute.fill, stroke = textAttribute.stroke, fillOpacity = textAttribute.fillOpacity, strokeOpacity = textAttribute.strokeOpacity, opacity = textAttribute.opacity, lineWidth = textAttribute.lineWidth, visible = textAttribute.visible, underline = textAttribute.underline, lineThrough = textAttribute.lineThrough, keepDirIn3d = textAttribute.keepDirIn3d, direction = textAttribute.direction, fontSize = textAttribute.fontSize, verticalMode = textAttribute.verticalMode, x: originX = textAttribute.x, y: originY = textAttribute.y } = text.attribute;
+            const { text: str, underline = textAttribute.underline, lineThrough = textAttribute.lineThrough, keepDirIn3d = textAttribute.keepDirIn3d, direction = textAttribute.direction, fontSize = textAttribute.fontSize, verticalMode = textAttribute.verticalMode, x: originX = textAttribute.x, y: originY = textAttribute.y } = text.attribute;
             let { textAlign = textAttribute.textAlign, textBaseline = textAttribute.textBaseline } = text.attribute;
             if (!verticalMode && direction === 'vertical') {
                 const t = textAlign;
                 textAlign = (_a = text.getBaselineMapAlign()[textBaseline]) !== null && _a !== void 0 ? _a : 'left';
                 textBaseline = (_b = text.getAlignMapBaseline()[t]) !== null && _b !== void 0 ? _b : 'top';
             }
-            const lineHeight = (_c = text.attribute.lineHeight) !== null && _c !== void 0 ? _c : fontSize;
+            const lineHeight = (_c = calculateLineHeight(text.attribute.lineHeight, fontSize)) !== null && _c !== void 0 ? _c : fontSize;
             const data = this.valid(text, textAttribute, fillCb, strokeCb);
             if (!data) {
                 return;
@@ -21779,6 +20840,7 @@
                     }
                 }
                 else {
+                    text.tryUpdateAABBBounds();
                     const cache = text.cache;
                     const { verticalList } = cache;
                     context.textAlign = 'left';
@@ -21822,7 +20884,6 @@
                 }
             }
             else {
-                const cache = text.cache;
                 if (direction === 'horizontal') {
                     context.setTextStyle(text.attribute, textAttribute, z);
                     const t = text.clipedText;
@@ -21839,31 +20900,35 @@
                     }
                     drawText(t, 0, dy, 0);
                 }
-                else if (cache) {
-                    context.setTextStyleWithoutAlignBaseline(text.attribute, textAttribute, z);
-                    const { verticalList } = cache;
-                    let offsetY = 0;
-                    const totalW = verticalList[0].reduce((a, b) => a + (b.width || 0), 0);
-                    let offsetX = 0;
-                    if (textBaseline === 'bottom') {
-                        offsetX = -lineHeight;
-                    }
-                    else if (textBaseline === 'middle') {
-                        offsetX = -lineHeight / 2;
-                    }
-                    if (textAlign === 'center') {
-                        offsetY -= totalW / 2;
-                    }
-                    else if (textAlign === 'right') {
-                        offsetY -= totalW;
+                else {
+                    text.tryUpdateAABBBounds();
+                    const cache = text.cache;
+                    if (cache) {
+                        context.setTextStyleWithoutAlignBaseline(text.attribute, textAttribute, z);
+                        const { verticalList } = cache;
+                        let offsetY = 0;
+                        const totalW = verticalList[0].reduce((a, b) => a + (b.width || 0), 0);
+                        let offsetX = 0;
+                        if (textBaseline === 'bottom') {
+                            offsetX = -lineHeight;
+                        }
+                        else if (textBaseline === 'middle') {
+                            offsetX = -lineHeight / 2;
+                        }
+                        if (textAlign === 'center') {
+                            offsetY -= totalW / 2;
+                        }
+                        else if (textAlign === 'right') {
+                            offsetY -= totalW;
+                        }
+                        context.textAlign = 'left';
+                        context.textBaseline = 'top';
+                        verticalList[0].forEach(item => {
+                            const { text, width, direction } = item;
+                            drawText(text, offsetX, offsetY, direction);
+                            offsetY += width;
+                        });
                     }
-                    context.textAlign = 'left';
-                    context.textBaseline = 'top';
-                    verticalList[0].forEach(item => {
-                        const { text, width, direction } = item;
-                        drawText(text, offsetX, offsetY, direction);
-                        offsetY += width;
-                    });
                 }
             }
             transform3dMatrixToContextMatrix && this.restoreTransformUseContext2d(text, textAttribute, z, context);
@@ -23249,6 +22314,7 @@
             this.backupDirtyBounds = new vutils.Bounds();
             this.global = application.global;
             this.layerService = application.layerService;
+            this.init();
         }
         init() {
             this.contributions.forEach(item => {
@@ -23265,7 +22331,17 @@
                 .getContributions()
                 .sort((a, b) => a.order - b.order);
         }
+        prepareForDraw(renderService, drawContext) {
+            const count = renderService.renderTreeRoots.reduce((a, b) => a + b.count, 0);
+            if (count < this.global.optmizeSkipCheckBoundariesThreshold) {
+                this.useDirtyBounds = false;
+            }
+            else {
+                this.useDirtyBounds = true;
+            }
+        }
         draw(renderService, drawContext) {
+            this.prepareForDraw(renderService, drawContext);
             drawContext.drawContribution = this;
             this.currentRenderMap = this.styleRenderMap.get(drawContext.renderStyle) || this.defaultRenderMap;
             this.currentRenderService = renderService;
@@ -23338,13 +22414,17 @@
                 this._increaseRender(group, drawContext);
                 return;
             }
-            if (!vutils.isRectIntersect(group.AABBBounds, this.dirtyBounds, false)) {
+            if (this.useDirtyBounds && !vutils.isRectIntersect(group.AABBBounds, this.dirtyBounds, false)) {
                 return;
             }
-            const tempBounds = boundsAllocate.allocateByObj(this.dirtyBounds);
-            const gm = group.transMatrix;
-            const 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());
+            let nextM;
+            let tempBounds;
+            if (this.useDirtyBounds) {
+                tempBounds = boundsAllocate.allocateByObj(this.dirtyBounds);
+                const 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: () => {
                     var _a;
@@ -23373,9 +22453,11 @@
                         }, false, !!((_a = drawContext.context) === null || _a === void 0 ? void 0 : _a.camera));
                 }
             });
-            this.dirtyBounds.copy(tempBounds);
-            boundsAllocate.free(tempBounds);
-            matrixAllocate.free(nextM);
+            if (this.useDirtyBounds) {
+                this.dirtyBounds.copy(tempBounds);
+                boundsAllocate.free(tempBounds);
+                matrixAllocate.free(nextM);
+            }
         }
         _increaseRender(group, drawContext) {
             const { layer, stage } = drawContext;
@@ -23451,7 +22533,7 @@
                     this.dirtyBounds.translate(-scrollX, -scrollY);
                 }
             }
-            if (!(graphic.isContainer || vutils.isRectIntersect(graphic.AABBBounds, this.dirtyBounds, false))) {
+            if (this.useDirtyBounds && !(graphic.isContainer || vutils.isRectIntersect(graphic.AABBBounds, this.dirtyBounds, false))) {
                 retrans && this.dirtyBounds.copy(tempBounds);
                 return;
             }
@@ -23513,12 +22595,6 @@
             return;
         }
     };
-    __decorate([
-        postConstruct(),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
-    ], DefaultDrawContribution.prototype, "init", null);
     DefaultDrawContribution = __decorate([
         injectable(),
         __param(0, multiInject(GraphicRender)),
@@ -25677,6 +24753,10 @@
         get defaultLayer() {
             return this.at(0);
         }
+        get eventSystem() {
+            this.tryInitEventSystem();
+            return this._eventSystem;
+        }
         constructor(params) {
             var _a;
             super({});
@@ -25721,13 +24801,35 @@
             this.renderCount = 0;
             this._subView = !(this._viewBox.width() === this.width && this._viewBox.height() === this.height);
             this._background = (_a = params.background) !== null && _a !== void 0 ? _a : DefaultConfig$1.BACKGROUND;
-            this.appendChild(this.layerService.createLayer(this, params.canvas && vutils.isString(params.canvas) ? { main: true, canvasId: params.canvas } : { main: true }));
+            this.appendChild(this.layerService.createLayer(this, { main: true }));
             this.nextFrameRenderLayerSet = new Set();
             this.willNextFrameRender = false;
             this.stage = this;
             this.renderStyle = params.renderStyle;
-            if (this.global.supportEvent) {
-                this.eventSystem = new EventSystem({
+            if (params.autoRender) {
+                this.enableAutoRender();
+            }
+            if (params.disableDirtyBounds === false) {
+                this.enableDirtyBounds();
+            }
+            if (params.enableHtmlAttribute) {
+                this.enableHtmlAttribute(params.enableHtmlAttribute);
+            }
+            params.enableLayout && this.enableLayout();
+            this.hooks.beforeRender.tap('constructor', this.beforeRender);
+            this.hooks.afterRender.tap('constructor', this.afterRender);
+            this._beforeRender = params.beforeRender;
+            this._afterRender = params.afterRender;
+            this.ticker = params.ticker || defaultTicker;
+            this.supportInteractiveLayer = params.interactiveLayer !== false;
+            this.timeline = new DefaultTimeline();
+            this.ticker.addTimeline(this.timeline);
+            this.timeline.pause();
+            this.optmize(params.optimize);
+        }
+        tryInitEventSystem() {
+            if (this.global.supportEvent && !this._eventSystem) {
+                this._eventSystem = new EventSystem({
                     targetElement: this.window,
                     resolution: this.window.dpr || this.global.devicePixelRatio,
                     rootNode: this,
@@ -25749,39 +24851,32 @@
                     }
                 });
             }
-            if (params.autoRender) {
-                this.enableAutoRender();
-            }
-            if (params.disableDirtyBounds === false) {
-                this.enableDirtyBounds();
-            }
-            if (params.enableHtmlAttribute) {
-                this.enableHtmlAttribute(params.enableHtmlAttribute);
+        }
+        preventRender(prevent) {
+            if (prevent) {
+                this._skipRender = -Infinity;
             }
-            params.enableLayout && this.enableLayout();
-            this.hooks.beforeRender.tap('constructor', this.beforeRender);
-            this.hooks.afterRender.tap('constructor', this.afterRender);
-            this._beforeRender = params.beforeRender;
-            this._afterRender = params.afterRender;
-            this.ticker = params.ticker || defaultTicker;
-            this.supportInteractiveLayer = params.interactiveLayer !== false;
-            this.timeline = new DefaultTimeline();
-            this.ticker.addTimeline(this.timeline);
-            this.timeline.pause();
-            this.optmize(params.optimize);
-            if (this._background && vutils.isString(this._background)) {
-                this.setAttributes({ background: this._background });
+            else {
+                if (this.params && this.params.optimize && this.params.optimize.skipRenderWithOutRange !== false) {
+                    this._skipRender = this.window.isVisible() ? 0 : 1;
+                }
+                else {
+                    this._skipRender = 0;
+                }
             }
         }
         optmize(params) {
             this.optmizeRender(params === null || params === void 0 ? void 0 : params.skipRenderWithOutRange);
         }
-        optmizeRender(skipRenderWithOutRange = true) {
+        optmizeRender(skipRenderWithOutRange = false) {
             if (!skipRenderWithOutRange) {
                 return;
             }
-            this._skipRender = this.window.isVisible() ? 0 : 1;
+            this._skipRender = this._skipRender < 0 ? this._skipRender : this.window.isVisible() ? 0 : 1;
             this.window.onVisibleChange(visible => {
+                if (this._skipRender < 0) {
+                    return;
+                }
                 if (visible) {
                     if (this.dirtyBounds) {
                         this.dirtyBounds.setValue(0, 0, this._viewBox.width(), this._viewBox.height());
@@ -26073,13 +25168,13 @@
                 layer.render({
                     renderService: this.renderService,
                     background: layer === this.defaultLayer ? this.background : undefined,
-                    updateBounds: !!this.dirtyBounds
+                    updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty())
                 }, Object.assign({ renderStyle: this.renderStyle }, params));
             });
             if (this.interactiveLayer && !layerList.includes(this.interactiveLayer)) {
                 this.interactiveLayer.render({
                     renderService: this.renderService,
-                    updateBounds: !!this.dirtyBounds
+                    updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty())
                 }, Object.assign({ renderStyle: this.renderStyle }, params));
             }
         }
@@ -26183,7 +25278,7 @@
         }
         renderTo(window, params) {
             this.forEachChildren((layer, i) => {
-                layer.drawTo(window, Object.assign(Object.assign({}, params), { renderService: this.renderService, background: layer === this.defaultLayer ? this.background : undefined, clear: i === 0, updateBounds: !!this.dirtyBounds }));
+                layer.drawTo(window, Object.assign(Object.assign({}, params), { renderService: this.renderService, background: layer === this.defaultLayer ? this.background : undefined, clear: i === 0, updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty()) }));
             });
         }
         renderToNewWindow(fullImage = true, viewBox) {
@@ -27471,9 +26566,11 @@
     exports.bindContributionProvider = bindContributionProvider;
     exports.bindContributionProviderNoSingletonScope = bindContributionProviderNoSingletonScope;
     exports.boundStroke = boundStroke;
+    exports.builtInSymbolStrMap = builtInSymbolStrMap;
     exports.builtinSymbols = builtinSymbols;
     exports.builtinSymbolsMap = builtinSymbolsMap;
     exports.calcLineCache = calcLineCache$1;
+    exports.calculateLineHeight = calculateLineHeight;
     exports.canvasAllocate = canvasAllocate;
     exports.centroidOfSubpath = centroidOfSubpath;
     exports.circleBounds = circleBounds;
@@ -27617,7 +26714,6 @@
     exports.pointInterpolationHighPerformance = pointInterpolationHighPerformance;
     exports.pointsEqual = pointsEqual;
     exports.pointsInterpolation = pointsInterpolation;
-    exports.postConstruct = postConstruct;
     exports.rafBasedSto = rafBasedSto;
     exports.rectFillVisible = rectFillVisible;
     exports.rectStrokeVisible = rectStrokeVisible;