@visactor/vchart 2.1.5-alpha.0 → 2.1.6-alpha.0

package/build/index.js

@@ -9105,7 +9105,7 @@
       constructor() {
         super(), this._uid = Generator.GenAutoIncrementId(), this._firstChild = null, this._lastChild = null, this.parent = null, this._count = 1;
       }
-      onParentSharedStateTreeChanged(_stage, _layer, _inheritedSharedStateScope) {}
+      onParentSharedStateTreeChanged(_stage, _layer) {}
       forEachChildren(cb, reverse = !1) {
         if (reverse) {
           let child = this._lastChild,
@@ -13375,18 +13375,21 @@
       }
     }
 
-    function getScaledStroke(context, width, dpr) {
+    function getScaledStrokeWithMatrix(matrix, width, dpr) {
       let strokeWidth = width;
       const {
           a: a,
           b: b,
           c: c,
           d: d
-        } = context.currentMatrix,
+        } = matrix,
         scaleX = Math.sign(a) * Math.sqrt(a * a + b * b),
         scaleY = Math.sign(d) * Math.sqrt(c * c + d * d);
       return scaleX + scaleY === 0 ? 0 : (strokeWidth = strokeWidth / Math.abs(scaleX + scaleY) * 2 * dpr, strokeWidth);
     }
+    function getScaledStroke(context, width, dpr) {
+      return getScaledStrokeWithMatrix(context.currentMatrix, width, dpr);
+    }
     function createColor(context, c, params, offsetX = 0, offsetY = 0) {
       var _a, _b, _c, _d;
       if (!c || !0 === c) return "black";
@@ -14446,7 +14449,7 @@
     }
     class StateTransitionOrchestrator {
       analyzeTransition(targetAttrs, hasAnimation, options = {}) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const plan = {
           targetAttrs: Object.assign({}, targetAttrs),
           animateAttrs: {},
@@ -14455,10 +14458,17 @@
         if (!hasAnimation) return plan;
         const noWorkAnimateAttr = Object.assign(Object.assign({}, null !== (_a = options.noWorkAnimateAttr) && void 0 !== _a ? _a : {}), normalizeNoAnimateAttrConfig(null === (_b = options.animateConfig) || void 0 === _b ? void 0 : _b.noAnimateAttrs)),
           isClear = !0 === options.isClear,
-          readDefaultAttribute = options.getDefaultAttribute,
+          getDefaultAttribute = options.getDefaultAttribute,
+          readDefaultAttribute = getDefaultAttribute,
+          readStateTransitionDefaultAttribute = null !== (_c = options.getStateTransitionDefaultAttribute) && void 0 !== _c ? _c : getDefaultAttribute,
           shouldSkipDefaultAttribute = options.shouldSkipDefaultAttribute,
-          assignTransitionAttr = (key, value) => {
-            if (noWorkAnimateAttr[key]) plan.noAnimateAttrs[key] = value;else if (isClear && void 0 === value) {
+          stateTransitionTargetAttrs = null !== (_d = options.stateTransitionTargetAttrs) && void 0 !== _d ? _d : targetAttrs,
+          assignTransitionAttr = (key, value, isRemovedStateAttr = !1) => {
+            if (noWorkAnimateAttr[key]) plan.noAnimateAttrs[key] = value;else if (isRemovedStateAttr && void 0 === value) {
+              const defaultValue = null == readStateTransitionDefaultAttribute ? void 0 : readStateTransitionDefaultAttribute(key, stateTransitionTargetAttrs);
+              if (void 0 === defaultValue && (null == shouldSkipDefaultAttribute ? void 0 : shouldSkipDefaultAttribute(key, stateTransitionTargetAttrs))) return;
+              plan.animateAttrs[key] = defaultValue;
+            } else if (isClear && void 0 === value) {
               if (null == shouldSkipDefaultAttribute ? void 0 : shouldSkipDefaultAttribute(key, targetAttrs)) return;
               plan.animateAttrs[key] = readDefaultAttribute(key);
             } else plan.animateAttrs[key] = value;
@@ -14470,7 +14480,7 @@
         const extraAnimateAttrs = options.extraAnimateAttrs;
         if (extraAnimateAttrs) for (const key in extraAnimateAttrs) {
           const hasTargetAttr = Object.prototype.hasOwnProperty.call(targetAttrs, key);
-          !Object.prototype.hasOwnProperty.call(extraAnimateAttrs, key) || hasTargetAttr && void 0 !== targetAttrs[key] || assignTransitionAttr(key, extraAnimateAttrs[key]);
+          !Object.prototype.hasOwnProperty.call(extraAnimateAttrs, key) || hasTargetAttr && void 0 !== targetAttrs[key] || assignTransitionAttr(key, extraAnimateAttrs[key], !0);
         }
         return plan;
       }
@@ -14502,9 +14512,11 @@
           noWorkAnimateAttr: graphic.getNoWorkAnimateAttr(),
           isClear: !0,
           getDefaultAttribute: graphic.getDefaultAttribute.bind(graphic),
+          getStateTransitionDefaultAttribute: options.getStateTransitionDefaultAttribute,
           shouldSkipDefaultAttribute: null !== (_a = options.shouldSkipDefaultAttribute) && void 0 !== _a ? _a : graphic.shouldSkipStateTransitionDefaultAttribute.bind(graphic),
           animateConfig: options.animateConfig,
-          extraAnimateAttrs: options.extraAnimateAttrs
+          extraAnimateAttrs: options.extraAnimateAttrs,
+          stateTransitionTargetAttrs: options.stateTransitionTargetAttrs
         });
         return this.applyTransition(graphic, plan, hasAnimation, options);
       }
@@ -14719,17 +14731,14 @@
         }
         return null === (_a = this.stage) || void 0 === _a ? void 0 : _a.rootSharedStateScope;
       }
-      syncSharedStateScopeBinding(nextScope, markDirty = !0) {
+      syncSharedStateScopeBindingFromTree(markDirty = !0) {
         var _a;
+        const nextScope = this.resolveBoundSharedStateScope();
         return this.boundSharedStateScope === nextScope ? (this.syncSharedStateActiveRegistrations(), !1) : (this.boundSharedStateScope = nextScope, this.boundSharedStateRevision = void 0, this.compiledStateDefinitions = void 0, this.compiledStateDefinitionsCacheKey = void 0, this.stateEngine = void 0, this.stateEngineCompiledDefinitions = void 0, this.syncSharedStateActiveRegistrations(), markDirty && (null === (_a = this.currentStates) || void 0 === _a ? void 0 : _a.length) && this.markSharedStateDirty(), !0);
       }
-      syncSharedStateScopeBindingFromTree(markDirty = !0, inheritedSharedStateScope) {
-        const nextScope = void 0 === inheritedSharedStateScope ? this.resolveBoundSharedStateScope() : null != inheritedSharedStateScope ? inheritedSharedStateScope : void 0;
-        return this.syncSharedStateScopeBinding(nextScope, markDirty);
-      }
-      syncSharedStateScopeBindingOnTreeChange(markDirty = !0, inheritedSharedStateScope) {
+      syncSharedStateScopeBindingOnTreeChange(markDirty = !0) {
         var _a, _b;
-        return !!((null === (_a = this.currentStates) || void 0 === _a ? void 0 : _a.length) || this.boundSharedStateScope || (null === (_b = this.registeredActiveScopes) || void 0 === _b ? void 0 : _b.size) || this.sharedStateDirty) && this.syncSharedStateScopeBindingFromTree(markDirty, inheritedSharedStateScope);
+        return !!((null === (_a = this.currentStates) || void 0 === _a ? void 0 : _a.length) || this.boundSharedStateScope || (null === (_b = this.registeredActiveScopes) || void 0 === _b ? void 0 : _b.size) || this.sharedStateDirty) && this.syncSharedStateScopeBindingFromTree(markDirty);
       }
       syncSharedStateActiveRegistrations() {
         var _a;
@@ -14737,7 +14746,6 @@
         if (!(null === (_a = this.currentStates) || void 0 === _a ? void 0 : _a.length) || !this.boundSharedStateScope) return (null == previousScopes ? void 0 : previousScopes.size) && (previousScopes.forEach(scope => {
           scope.subtreeActiveDescendants.delete(this);
         }), previousScopes.clear()), void (this.registeredActiveScopes = void 0);
-        if ((null == previousScopes ? void 0 : previousScopes.size) && this.isSharedStateScopeChainRegistered(previousScopes)) return;
         const nextScopes = new Set(collectSharedStateScopeChain(this.boundSharedStateScope));
         null == previousScopes || previousScopes.forEach(scope => {
           nextScopes.has(scope) || scope.subtreeActiveDescendants.delete(this);
@@ -14745,15 +14753,6 @@
           scope.subtreeActiveDescendants.add(this);
         }), this.registeredActiveScopes = nextScopes;
       }
-      isSharedStateScopeChainRegistered(previousScopes) {
-        let scope = this.boundSharedStateScope,
-          scopeCount = 0;
-        for (; scope;) {
-          if (!previousScopes.has(scope)) return !1;
-          scopeCount += 1, scope = scope.parentScope;
-        }
-        return scopeCount === previousScopes.size;
-      }
       clearSharedStateActiveRegistrations() {
         const previousScopes = this.registeredActiveScopes;
         previousScopes && (previousScopes.forEach(scope => {
@@ -14763,8 +14762,8 @@
       markSharedStateDirty() {
         this.sharedStateDirty = !0, enqueueGraphicSharedStateRefresh(this.stage, this), scheduleStageSharedStateRefresh(this.stage);
       }
-      onParentSharedStateTreeChanged(stage, layer, inheritedSharedStateScope) {
-        this.stage === stage && this.layer === layer ? this.syncSharedStateScopeBindingOnTreeChange(!0, inheritedSharedStateScope) : this.setStage(stage, layer, inheritedSharedStateScope);
+      onParentSharedStateTreeChanged(stage, layer) {
+        this.stage === stage && this.layer === layer ? this.syncSharedStateScopeBindingOnTreeChange() : this.setStage(stage, layer);
       }
       refreshSharedStateBeforeRender() {
         var _a;
@@ -14814,21 +14813,20 @@
         }), snapshot) : snapshot;
       }
       buildRemovedStateAnimationAttrs(targetStateAttrs, previousResolvedStatePatch) {
-        const extraAttrs = {};
-        if (!previousResolvedStatePatch) return extraAttrs;
+        if (!previousResolvedStatePatch) return;
         const snapshot = this.buildStaticAttributeSnapshot(),
-          staticTargetAttrs = snapshot;
+          extraAttrs = {};
         return Object.keys(previousResolvedStatePatch).forEach(key => {
           const hasTargetAttr = Object.prototype.hasOwnProperty.call(targetStateAttrs, key);
           if (hasTargetAttr && void 0 !== targetStateAttrs[key]) return;
           const assignFallbackAttr = value => {
-            void 0 === value && this.shouldSkipStateTransitionDefaultAttribute(key, staticTargetAttrs) || (extraAttrs[key] = void 0 === value ? value : cloneAttributeValue(value));
+            extraAttrs[key] = void 0 === value ? value : cloneAttributeValue(value);
           };
-          if (hasTargetAttr) assignFallbackAttr(this.getStateTransitionDefaultAttribute(key, staticTargetAttrs));else if (Object.prototype.hasOwnProperty.call(snapshot, key)) {
-            const snapshotValue = snapshot[key];
-            assignFallbackAttr(void 0 === snapshotValue ? this.getStateTransitionDefaultAttribute(key, staticTargetAttrs) : snapshotValue);
-          } else assignFallbackAttr(this.getStateTransitionDefaultAttribute(key, staticTargetAttrs));
-        }), extraAttrs;
+          hasTargetAttr ? assignFallbackAttr(targetStateAttrs[key]) : Object.prototype.hasOwnProperty.call(snapshot, key) ? assignFallbackAttr(snapshot[key]) : assignFallbackAttr(void 0);
+        }), {
+          extraAttrs: extraAttrs,
+          stateTransitionTargetAttrs: snapshot
+        };
       }
       syncObjectToSnapshot(target, snapshot, excludedKeys) {
         const delta = new Map();
@@ -15415,10 +15413,6 @@
         var _a;
         return null === (_a = this.states) || void 0 === _a ? void 0 : _a[stateName];
       }
-      setStateDefinitionsWithCompiled(definitions, compiledDefinitions) {
-        var _a;
-        this.states = definitions, this.localStateDefinitionsSource !== definitions && (this.localStateDefinitionsSource = definitions, this.localStateDefinitionsVersion = (null !== (_a = this.localStateDefinitionsVersion) && void 0 !== _a ? _a : 0) + 1), this.compiledStateDefinitions = compiledDefinitions, this.compiledStateDefinitionsCacheKey = `local:${this.localStateDefinitionsVersion}`;
-      }
       getStateResolveBaseAttrs() {
         var _a;
         return null !== (_a = this.baseAttributes) && void 0 !== _a ? _a : this.attribute;
@@ -15548,29 +15542,37 @@
             resolvedStateAttrs: resolvedStateAttrs
           } = this.resolveGraphicStateTransition(states, !0),
           patchChanged = !this.sameStatePatches(previousResolvedStatePatch, resolvedStateAttrs);
-        patchChanged && !this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1) || (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), patchChanged && (hasAnimation && animateSameStatePatchChange ? (this._syncFinalAttributeFromStaticTruth(), this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch))) : (this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
+        if ((!patchChanged || this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1)) && (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), patchChanged)) if (hasAnimation && animateSameStatePatchChange) {
+          this._syncFinalAttributeFromStaticTruth();
+          const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+          this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.extraAttrs, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
+        } else this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
           type: AttributeUpdateType.STATE
         }) : this.restoreAttributeFromStatePatchDelta(previousResolvedStatePatch, this.resolvedStatePatch, {
           type: AttributeUpdateType.STATE
-        }), this.emitStateUpdateEvent())));
+        }), this.emitStateUpdateEvent();
       }
       resolveStateAnimateConfig(animateConfig) {
         var _a, _b, _c;
         return null !== (_c = null !== (_a = null != animateConfig ? animateConfig : this.stateAnimateConfig) && void 0 !== _a ? _a : null === (_b = this.context) || void 0 === _b ? void 0 : _b.stateAnimateConfig) && void 0 !== _c ? _c : DefaultStateAnimateConfig;
       }
-      applyStateAttrs(attrs, stateNames, hasAnimation, isClear, animateConfig, extraAnimateAttrs) {
+      applyStateAttrs(attrs, stateNames, hasAnimation, isClear, animateConfig, extraAnimateAttrs, stateTransitionTargetAttrs) {
         const resolvedAnimateConfig = hasAnimation ? this.resolveStateAnimateConfig(animateConfig) : void 0,
           transitionOptions = resolvedAnimateConfig ? {
             animateConfig: resolvedAnimateConfig,
             extraAnimateAttrs: extraAnimateAttrs,
-            shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this)
+            getStateTransitionDefaultAttribute: this.getStateTransitionDefaultAttribute.bind(this),
+            shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this),
+            stateTransitionTargetAttrs: stateTransitionTargetAttrs
           } : void 0;
         if (isClear) return void this.getStateTransitionOrchestrator().applyClearTransition(this, attrs, hasAnimation, transitionOptions);
         const plan = this.getStateTransitionOrchestrator().analyzeTransition(attrs, hasAnimation, {
           noWorkAnimateAttr: this.getNoWorkAnimateAttr(),
           animateConfig: resolvedAnimateConfig,
           extraAnimateAttrs: extraAnimateAttrs,
-          shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this)
+          getStateTransitionDefaultAttribute: this.getStateTransitionDefaultAttribute.bind(this),
+          shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this),
+          stateTransitionTargetAttrs: stateTransitionTargetAttrs
         });
         this.getStateTransitionOrchestrator().applyTransition(this, plan, hasAnimation, transitionOptions);
       }
@@ -15597,11 +15599,15 @@
           transition = this.resolveClearStatesTransition();
         if (!transition.changed && 0 === previousStates.length) return this.currentStates = [], this.effectiveStates = [], this.resolvedStatePatch = void 0, this.sharedStateDirty = !1, void this.clearSharedStateActiveRegistrations();
         const resolvedStateAttrs = hasAnimation || this.hasCustomEvent("beforeStateUpdate") ? cloneAttributeValue(null !== (_b = this.baseAttributes) && void 0 !== _b ? _b : {}) : null !== (_c = this.baseAttributes) && void 0 !== _c ? _c : {};
-        transition.changed && !this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !0) || (this.currentStates = transition.states, this.effectiveStates = [], this.resolvedStatePatch = void 0, this.sharedStateDirty = !1, this.clearSharedStateActiveRegistrations(), hasAnimation ? (this._syncFinalAttributeFromStaticTruth(), this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !0, void 0, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch))) : (this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
+        if (!transition.changed || this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !0)) if (this.currentStates = transition.states, this.effectiveStates = [], this.resolvedStatePatch = void 0, this.sharedStateDirty = !1, this.clearSharedStateActiveRegistrations(), hasAnimation) {
+          this._syncFinalAttributeFromStaticTruth();
+          const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+          this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !0, void 0, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.extraAttrs, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
+        } else this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
           type: AttributeUpdateType.STATE
         }) : this.restoreAttributeFromStatePatchDelta(previousResolvedStatePatch, void 0, {
           type: AttributeUpdateType.STATE
-        }), this.emitStateUpdateEvent()));
+        }), this.emitStateUpdateEvent();
       }
       removeState(stateName, hasAnimation) {
         const transition = this.resolveRemoveStateTransition(stateName);
@@ -15642,11 +15648,15 @@
             effectiveStates: effectiveStates,
             resolvedStateAttrs: resolvedStateAttrs
           } = this.resolveGraphicStateTransition(states);
-        !transition.changed && this.sameStateNames(previousStates, transition.states) || this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1) && (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), hasAnimation ? (this._syncFinalAttributeFromStaticTruth(), this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch))) : (this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
+        if ((transition.changed || !this.sameStateNames(previousStates, transition.states)) && this.beforeStateUpdate(resolvedStateAttrs, previousStates, transition.states, hasAnimation, !1)) if (this.currentStates = transition.states, this.effectiveStates = [...effectiveStates], this.resolvedStatePatch = resolvedStateAttrs, this.sharedStateDirty = !1, this.syncSharedStateActiveRegistrations(), hasAnimation) {
+          this._syncFinalAttributeFromStaticTruth();
+          const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+          this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, !1, void 0, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.extraAttrs, null == removedStateAnimationAttrs ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
+        } else this.stopStateAnimates(), this.attributeMayContainTransientAttrs ? this._restoreAttributeFromStaticTruth({
           type: AttributeUpdateType.STATE
         }) : this.restoreAttributeFromStatePatchDelta(previousResolvedStatePatch, this.resolvedStatePatch, {
           type: AttributeUpdateType.STATE
-        }), this.emitStateUpdateEvent()));
+        }), this.emitStateUpdateEvent();
       }
       invalidateResolver() {
         var _a, _b;
@@ -15766,12 +15776,12 @@
           this._globalTransMatrix.translate(scrollX, scrollY);
         }
       }
-      setStage(stage, layer, inheritedSharedStateScope) {
+      setStage(stage, layer) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const graphicService = null !== (_c = null !== (_a = null == stage ? void 0 : stage.graphicService) && void 0 !== _a ? _a : null === (_b = this.stage) || void 0 === _b ? void 0 : _b.graphicService) && void 0 !== _c ? _c : application.graphicService,
           previousStage = this.stage;
         if (this.stage !== stage || this.layer !== layer) {
-          if (this.stage = stage, this.layer = layer, ((null === (_d = this.currentStates) || void 0 === _d ? void 0 : _d.length) || this.boundSharedStateScope || (null === (_e = this.registeredActiveScopes) || void 0 === _e ? void 0 : _e.size) || this.sharedStateDirty) && this.syncSharedStateScopeBindingOnTreeChange(!0, inheritedSharedStateScope), this.setStageToShadowRoot(stage, layer), this.mayHaveTrackedAnimates() && this.hasAnyTrackedAnimate()) {
+          if (this.stage = stage, this.layer = layer, ((null === (_d = this.currentStates) || void 0 === _d ? void 0 : _d.length) || this.boundSharedStateScope || (null === (_e = this.registeredActiveScopes) || void 0 === _e ? void 0 : _e.size) || this.sharedStateDirty) && this.syncSharedStateScopeBindingOnTreeChange(!0), this.setStageToShadowRoot(stage, layer), this.mayHaveTrackedAnimates() && this.hasAnyTrackedAnimate()) {
             const previousTimeline = null === (_f = null == previousStage ? void 0 : previousStage.getTimeline) || void 0 === _f ? void 0 : _f.call(previousStage),
               nextTimeline = null === (_g = null == stage ? void 0 : stage.getTimeline) || void 0 === _g ? void 0 : _g.call(stage),
               detachedStageAnimates = [];
@@ -15788,7 +15798,7 @@
           }
           return this._onSetStage && this._onSetStage(this, stage, layer), void (null === (_h = null == graphicService ? void 0 : graphicService.onSetStage) || void 0 === _h || _h.call(graphicService, this, stage));
         }
-        ((null === (_j = this.currentStates) || void 0 === _j ? void 0 : _j.length) || this.boundSharedStateScope || (null === (_k = this.registeredActiveScopes) || void 0 === _k ? void 0 : _k.size) || this.sharedStateDirty) && this.syncSharedStateScopeBindingOnTreeChange(!0, inheritedSharedStateScope);
+        ((null === (_j = this.currentStates) || void 0 === _j ? void 0 : _j.length) || this.boundSharedStateScope || (null === (_k = this.registeredActiveScopes) || void 0 === _k ? void 0 : _k.size) || this.sharedStateDirty) && this.syncSharedStateScopeBindingOnTreeChange(!0);
       }
       detachStageForRelease() {
         var _a, _b, _c;
@@ -16729,13 +16739,13 @@
           child.setStage(null, null);
         }), this.addUpdateBoundTag();
       }
-      setStage(stage, layer, inheritedSharedStateScope) {
+      setStage(stage, layer) {
         var _a, _b, _c, _d, _e, _f;
         const graphicService = null !== (_c = null !== (_a = null == stage ? void 0 : stage.graphicService) && void 0 !== _a ? _a : null === (_b = this.stage) || void 0 === _b ? void 0 : _b.graphicService) && void 0 !== _c ? _c : application.graphicService,
           needsSharedStateTreeSync = this.hasSharedStateDefinitions() || this.sharedStateScope || (null === (_d = this.currentStates) || void 0 === _d ? void 0 : _d.length) || this.boundSharedStateScope || (null === (_e = this.registeredActiveScopes) || void 0 === _e ? void 0 : _e.size) || this.sharedStateDirty;
-        if (this.stage !== stage) return this.stage = stage, this.layer = layer, needsSharedStateTreeSync && (this.ensureSharedStateScopeBound(), this.syncSharedStateScopeBindingOnTreeChange(!0, inheritedSharedStateScope)), this.setStageToShadowRoot(stage, layer), this._onSetStage && this._onSetStage(this, stage, layer), null === (_f = null == graphicService ? void 0 : graphicService.onSetStage) || void 0 === _f || _f.call(graphicService, this, stage), void this.notifyChildrenSharedStateTreeChanged(inheritedSharedStateScope);
+        if (this.stage !== stage) return this.stage = stage, this.layer = layer, needsSharedStateTreeSync && (this.ensureSharedStateScopeBound(), this.syncSharedStateScopeBindingOnTreeChange(!0)), this.setStageToShadowRoot(stage, layer), this._onSetStage && this._onSetStage(this, stage, layer), null === (_f = null == graphicService ? void 0 : graphicService.onSetStage) || void 0 === _f || _f.call(graphicService, this, stage), void this.notifyChildrenSharedStateTreeChanged();
         const layerChanged = this.layer !== layer;
-        layerChanged && (this.layer = layer), needsSharedStateTreeSync ? (this.ensureSharedStateScopeBound(), this.syncSharedStateScopeBindingOnTreeChange(!0, inheritedSharedStateScope), this.notifyChildrenSharedStateTreeChanged(inheritedSharedStateScope)) : layerChanged && this.notifyChildrenSharedStateTreeChanged(inheritedSharedStateScope);
+        layerChanged && (this.layer = layer), needsSharedStateTreeSync ? (this.ensureSharedStateScopeBound(), this.syncSharedStateScopeBindingOnTreeChange(!0), this.notifyChildrenSharedStateTreeChanged()) : layerChanged && this.notifyChildrenSharedStateTreeChanged();
       }
       addUpdatePositionTag() {
         super.addUpdatePositionTag(), this.forEachChildren(g => {
@@ -16794,26 +16804,17 @@
       hasSharedStateDefinitions() {
         return !!this._sharedStateDefinitions && Object.keys(this._sharedStateDefinitions).length > 0;
       }
-      resolveChildSharedStateScope(inheritedSharedStateScope) {
-        var _a;
-        return this.sharedStateScope ? this.sharedStateScope : void 0 !== inheritedSharedStateScope ? inheritedSharedStateScope : null !== (_a = this.resolveBoundSharedStateScope()) && void 0 !== _a ? _a : null;
-      }
-      notifyChildrenSharedStateTreeChanged(inheritedSharedStateScope) {
-        const childSharedStateScope = this.resolveChildSharedStateScope(inheritedSharedStateScope);
+      notifyChildrenSharedStateTreeChanged() {
         this.forEachChildren(item => {
-          this.setStageToChild(item, childSharedStateScope);
+          this.syncChildSharedStateTreeBinding(item);
         });
       }
-      setStageToChild(child, inheritedSharedStateScope) {
-        const graphic = child;
-        "function" != typeof graphic.setStage || child.onParentSharedStateTreeChanged !== Graphic.prototype.onParentSharedStateTreeChanged && child.onParentSharedStateTreeChanged !== Group.prototype.onParentSharedStateTreeChanged || graphic.stage === this.stage && graphic.layer === this.layer ? child.onParentSharedStateTreeChanged(this.stage, this.layer, inheritedSharedStateScope) : graphic.setStage(this.stage, this.layer, inheritedSharedStateScope);
+      syncChildSharedStateTreeBinding(child) {
+        child.onParentSharedStateTreeChanged(this.stage, this.layer);
       }
-      syncChildSharedStateTreeBinding(child, inheritedSharedStateScope) {
-        void 0 === inheritedSharedStateScope && (inheritedSharedStateScope = this.resolveChildSharedStateScope()), this.setStageToChild(child, inheritedSharedStateScope);
-      }
-      onParentSharedStateTreeChanged(stage, layer, inheritedSharedStateScope) {
+      onParentSharedStateTreeChanged(stage, layer) {
         var _a;
-        this.stage === stage && this.layer === layer ? (this.ensureSharedStateScopeBound(), this.syncSharedStateScopeBindingOnTreeChange(!!(null === (_a = this.currentStates) || void 0 === _a ? void 0 : _a.length), inheritedSharedStateScope), this.notifyChildrenSharedStateTreeChanged(inheritedSharedStateScope)) : this.setStage(stage, layer, inheritedSharedStateScope);
+        this.stage === stage && this.layer === layer ? (this.ensureSharedStateScopeBound(), this.syncSharedStateScopeBindingOnTreeChange(!!(null === (_a = this.currentStates) || void 0 === _a ? void 0 : _a.length)), this.notifyChildrenSharedStateTreeChanged()) : this.setStage(stage, layer);
       }
     };
     Group$1.NOWORK_ANIMATE_ATTR = NOWORK_ANIMATE_ATTR;
@@ -17096,7 +17097,204 @@
       return new Path(attributes);
     }
 
-    const POLYGON_UPDATE_TAG_KEY = ["points", "cornerRadius", ...GRAPHIC_UPDATE_TAG_KEY];
+    function drawPolygon(path, points, x, y) {
+      if (points && points.length) {
+        path.moveTo(points[0].x + x, points[0].y + y);
+        for (let i = 1; i < points.length; i++) path.lineTo(points[i].x + x, points[i].y + y);
+      }
+    }
+    function drawRoundedPolygon(path, points, x, y, cornerRadius, closePath = !0) {
+      var _a;
+      const normalized = normalizePolygonPoints(points, cornerRadius, closePath);
+      if (normalized) return void drawRoundedPolygon(path, normalized.points, x, y, normalized.cornerRadius, closePath);
+      if (points.length < 3) return void drawPolygon(path, points, x, y);
+      let startI = 0,
+        endI = points.length - 1;
+      closePath || (startI += 1, endI -= 1, path.moveTo(points[0].x + x, points[0].y + y));
+      for (let i = startI; i <= endI; i++) {
+        const p1 = points[0 === i ? endI : (i - 1) % points.length],
+          angularPoint = points[i % points.length],
+          p2 = points[(i + 1) % points.length],
+          dx1 = angularPoint.x - p1.x,
+          dy1 = angularPoint.y - p1.y,
+          dx2 = angularPoint.x - p2.x,
+          dy2 = angularPoint.y - p2.y,
+          angle = (Math.atan2(dy1, dx1) - Math.atan2(dy2, dx2)) / 2,
+          tan = Math.abs(Math.tan(angle));
+        let radius = Array.isArray(cornerRadius) ? null !== (_a = cornerRadius[i % points.length]) && void 0 !== _a ? _a : 0 : cornerRadius,
+          segment = radius / tan;
+        const length1 = getLength(dx1, dy1),
+          length2 = getLength(dx2, dy2),
+          length = Math.min(length1, length2);
+        segment > length && (segment = length, radius = length * tan);
+        const p1Cross = getProportionPoint(angularPoint, segment, length1, dx1, dy1),
+          p2Cross = getProportionPoint(angularPoint, segment, length2, dx2, dy2),
+          dx = 2 * angularPoint.x - p1Cross.x - p2Cross.x,
+          dy = 2 * angularPoint.y - p1Cross.y - p2Cross.y,
+          L = getLength(dx, dy),
+          circlePoint = getProportionPoint(angularPoint, getLength(segment, radius), L, dx, dy);
+        let startAngle = Math.atan2(p1Cross.y - circlePoint.y, p1Cross.x - circlePoint.x);
+        const endAngle = Math.atan2(p2Cross.y - circlePoint.y, p2Cross.x - circlePoint.x);
+        let sweepAngle = endAngle - startAngle;
+        sweepAngle < 0 && (startAngle = endAngle, sweepAngle = -sweepAngle), sweepAngle > Math.PI && (sweepAngle -= Math.PI), 0 === i ? path.moveTo(p1Cross.x + x, p1Cross.y + y) : path.lineTo(p1Cross.x + x, p1Cross.y + y), sweepAngle && path.arcTo(angularPoint.x + x, angularPoint.y + y, p2Cross.x + x, p2Cross.y + y, radius), path.lineTo(p2Cross.x + x, p2Cross.y + y);
+      }
+      closePath || path.lineTo(points[endI + 1].x + x, points[endI + 1].y + y);
+    }
+    function getLength(dx, dy) {
+      return Math.sqrt(dx * dx + dy * dy);
+    }
+    function getProportionPoint(point, segment, length, dx, dy) {
+      const factor = segment / length;
+      return {
+        x: point.x - dx * factor,
+        y: point.y - dy * factor
+      };
+    }
+    function normalizePolygonPoints(points, cornerRadius, closePath = !0) {
+      var _a;
+      let hasDuplicate = !1;
+      for (let i = 1; i < points.length; i++) if (isSamePoint(points[i - 1], points[i])) {
+        hasDuplicate = !0;
+        break;
+      }
+      if (!hasDuplicate && closePath && points.length > 1 && isSamePoint(points[0], points[points.length - 1]) && (hasDuplicate = !0), !hasDuplicate) return null;
+      const normalizedPoints = [],
+        normalizedCornerRadius = Array.isArray(cornerRadius) ? [] : null;
+      for (let i = 0; i < points.length; i++) normalizedPoints.length && isSamePoint(normalizedPoints[normalizedPoints.length - 1], points[i]) || (normalizedPoints.push(points[i]), null == normalizedCornerRadius || normalizedCornerRadius.push(null !== (_a = cornerRadius[i]) && void 0 !== _a ? _a : 0));
+      return closePath && normalizedPoints.length > 1 && isSamePoint(normalizedPoints[0], normalizedPoints[normalizedPoints.length - 1]) && (normalizedPoints.pop(), null == normalizedCornerRadius || normalizedCornerRadius.pop()), {
+        points: normalizedPoints,
+        cornerRadius: null != normalizedCornerRadius ? normalizedCornerRadius : cornerRadius
+      };
+    }
+    function isSamePoint(a, b) {
+      return a.x === b.x && a.y === b.y;
+    }
+    function getPolygonWinding(points) {
+      let signedArea = 0;
+      for (let i = 0; i < points.length; i++) {
+        const current = points[i],
+          next = points[(i + 1) % points.length];
+        signedArea += current.x * next.y - next.x * current.y;
+      }
+      return signedArea > 0 ? 1 : -1;
+    }
+    function offsetPolygonPoints(points, distance, closePath = !0) {
+      var _a;
+      const n = null !== (_a = null == points ? void 0 : points.length) && void 0 !== _a ? _a : 0;
+      if (n < 2 || closePath && n < 3 || !distance) return points;
+      const sign = getPolygonWinding(points),
+        edgeCount = closePath ? n : n - 1,
+        lines = [];
+      for (let i = 0; i < edgeCount; i++) {
+        const cur = points[i],
+          next = points[(i + 1) % n],
+          dx = next.x - cur.x,
+          dy = next.y - cur.y,
+          len = Math.sqrt(dx * dx + dy * dy);
+        if (!len) {
+          lines.push(null);
+          continue;
+        }
+        const offsetX = sign * dy * distance / len,
+          offsetY = -sign * dx * distance / len;
+        lines.push({
+          x: cur.x + offsetX,
+          y: cur.y + offsetY,
+          dx: dx,
+          dy: dy,
+          len: len,
+          offsetX: offsetX,
+          offsetY: offsetY
+        });
+      }
+      const prevLines = new Array(n);
+      let prevLine = null;
+      if (closePath) for (let i = edgeCount - 1; i >= 0; i--) if (lines[i]) {
+        prevLine = lines[i];
+        break;
+      }
+      for (let i = 0; i < n; i++) prevLines[i] = prevLine, i < edgeCount && lines[i] && (prevLine = lines[i]);
+      const nextLines = new Array(n);
+      let nextLine = null;
+      if (closePath) for (let count = 0; count < edgeCount; count++) {
+        const line = lines[(n - 1 + count) % edgeCount];
+        if (line) {
+          nextLine = line;
+          break;
+        }
+      }
+      for (let i = n - 1; i >= 0; i--) i < edgeCount && lines[i] && (nextLine = lines[i]), nextLines[i] = nextLine;
+      const offsetPointByLine = (point, line) => ({
+          x: point.x + line.offsetX,
+          y: point.y + line.offsetY
+        }),
+        result = [];
+      for (let i = 0; i < n; i++) {
+        const prev = prevLines[i],
+          cur = nextLines[i],
+          line = prev || cur;
+        if (!line) {
+          result.push(points[i]);
+          continue;
+        }
+        if (!prev || !cur) {
+          result.push(offsetPointByLine(points[i], line));
+          continue;
+        }
+        const denominator = prev.dx * cur.dy - prev.dy * cur.dx;
+        if (Math.abs(denominator) <= 1e-12 * prev.len * cur.len) {
+          result.push(offsetPointByLine(points[i], cur));
+          continue;
+        }
+        const t = ((cur.x - prev.x) * cur.dy - (cur.y - prev.y) * cur.dx) / denominator,
+          point = {
+            x: prev.x + prev.dx * t,
+            y: prev.y + prev.dy * t
+          };
+        result.push(Number.isFinite(point.x) && Number.isFinite(point.y) ? point : offsetPointByLine(points[i], cur));
+      }
+      return result;
+    }
+
+    const getBoundsScaleMatrix = polygon => {
+      var _a;
+      const globalMatrix = polygon.globalTransMatrix,
+        viewBoxMatrix = null === (_a = polygon.stage) || void 0 === _a ? void 0 : _a.window.getViewBoxTransform();
+      return viewBoxMatrix ? {
+        a: viewBoxMatrix.a * globalMatrix.a + viewBoxMatrix.c * globalMatrix.b,
+        b: viewBoxMatrix.b * globalMatrix.a + viewBoxMatrix.d * globalMatrix.b,
+        c: viewBoxMatrix.a * globalMatrix.c + viewBoxMatrix.c * globalMatrix.d,
+        d: viewBoxMatrix.b * globalMatrix.c + viewBoxMatrix.d * globalMatrix.d
+      } : globalMatrix;
+    };
+    const getPolygonBoundsScale = polygon => getScaledStrokeWithMatrix(getBoundsScaleMatrix(polygon), 1, 1);
+    const updateBoundsOfPolygonOuterBorder = (attribute, polygonTheme, aabbBounds, polygon) => {
+      const {
+        outerBorder: outerBorder,
+        points = polygonTheme.points,
+        closePath = polygonTheme.closePath,
+        shadowBlur = polygonTheme.shadowBlur,
+        keepStrokeScale = polygonTheme.keepStrokeScale
+      } = attribute;
+      if (outerBorder && !1 !== outerBorder.visible) {
+        const defaultOuterBorder = polygonTheme.outerBorder,
+          {
+            distance = defaultOuterBorder.distance,
+            lineWidth = defaultOuterBorder.lineWidth,
+            lineJoin = defaultOuterBorder.lineJoin,
+            strokeBoundsBuffer = defaultOuterBorder.strokeBoundsBuffer
+          } = outerBorder,
+          boundsScale = getPolygonBoundsScale(polygon);
+        let scaledDistance = distance;
+        keepStrokeScale || (scaledDistance *= boundsScale), offsetPolygonPoints(points, scaledDistance, closePath).forEach(point => {
+          aabbBounds.add(point.x, point.y);
+        });
+        boundStroke(aabbBounds, (shadowBlur * boundsScale + lineWidth * (keepStrokeScale ? 1 : boundsScale)) / 2, "miter" === lineJoin, strokeBoundsBuffer);
+      }
+      return aabbBounds;
+    };
+
+    const POLYGON_UPDATE_TAG_KEY = ["points", "cornerRadius", "outerBorder", "keepStrokeScale", ...GRAPHIC_UPDATE_TAG_KEY];
     class Polygon extends Graphic {
       constructor(params) {
         super(params), this.type = "polygon", this.numberType = POLYGON_NUMBER_TYPE;
@@ -17113,6 +17311,16 @@
       getGraphicTheme() {
         return getTheme$1(this).polygon;
       }
+      tryUpdateAABBBounds() {
+        const {
+          outerBorder: outerBorder
+        } = this.attribute;
+        if (outerBorder && !1 !== outerBorder.visible) {
+          const boundsScale = getPolygonBoundsScale(this);
+          boundsScale !== this._outerBorderBoundsScale && (this._outerBorderBoundsScale = boundsScale, this.addUpdateBoundTag());
+        } else this._outerBorderBoundsScale = void 0;
+        return super.tryUpdateAABBBounds();
+      }
       updateAABBBounds(attribute, polygonTheme, aabbBounds) {
         this.updatePathProxyAABBBounds(aabbBounds) || this.updatePolygonAABBBoundsImprecise(attribute, polygonTheme, aabbBounds), application.graphicService.updateTempAABBBounds(aabbBounds), this.widthWithoutTransform = aabbBounds.x2 - aabbBounds.x1, this.heightWithoutTransform = aabbBounds.y2 - aabbBounds.y1;
         const {
@@ -17126,7 +17334,7 @@
         } = attribute;
         return points.forEach(p => {
           aabbBounds.add(p.x, p.y);
-        }), aabbBounds;
+        }), updateBoundsOfPolygonOuterBorder(attribute, polygonTheme, aabbBounds, this), aabbBounds;
       }
       _interpolate(key, ratio, lastStepVal, nextStepVal, nextAttributes) {
         "points" === key && (nextAttributes.points = pointsInterpolation(lastStepVal, nextStepVal, ratio));
@@ -18180,8 +18388,8 @@
       clone() {
         return new RichText(Object.assign({}, this.attribute));
       }
-      setStage(stage, layer, inheritedSharedStateScope) {
-        super.setStage(stage, layer, inheritedSharedStateScope);
+      setStage(stage, layer) {
+        super.setStage(stage, layer);
         this.getFrameCache().icons.forEach(icon => {
           icon.setStage(stage, layer);
         });
@@ -18569,8 +18777,15 @@
           const b = this.AABBBounds;
           return this._OBBBounds.setValue(b.x1, b.y1, b.x2, b.y2), this._OBBBounds;
         }
-        this.obbText || (this.obbText = new Text({})), this.obbText.setAttributes(Object.assign(Object.assign({}, attribute), {
-          angle: 0
+        this.obbText || (this.obbText = new Text({}));
+        const {
+          dx = 0,
+          dy = 0
+        } = attribute;
+        this.obbText.setAttributes(Object.assign(Object.assign({}, attribute), {
+          angle: 0,
+          dx: 0,
+          dy: 0
         }));
         const bounds1 = this.obbText.AABBBounds,
           {
@@ -18585,7 +18800,7 @@
             x: x,
             y: y
           });
-        return this._OBBBounds.copy(bounds1), this._OBBBounds.translate(center.x - boundsCenter.x, center.y - boundsCenter.y), this._OBBBounds.angle = angle, this._OBBBounds;
+        return this._OBBBounds.copy(bounds1), this._OBBBounds.translate(center.x - boundsCenter.x + dx, center.y - boundsCenter.y + dy), this._OBBBounds.angle = angle, this._OBBBounds;
       }
       updateAABBBounds(attribute, textTheme, aabbBounds) {
         const {
@@ -23453,22 +23668,26 @@
           width: width,
           height: height
         } = rect.attribute;
-        width = (null != width ? width : x1 - x) || 0, height = (null != height ? height : y1 - y) || 0;
-        const renderBorder = (borderStyle, key) => {
-          const doStroke = !(!borderStyle || !borderStyle.stroke),
-            sign = "outerBorder" === key ? -1 : 1,
-            {
-              distance = rectAttribute[key].distance
-            } = borderStyle,
-            d = keepStrokeScale ? distance : getScaledStroke(context, distance, context.dpr),
-            nextX = x + sign * d,
-            nextY = y + sign * d,
-            dw = 2 * d;
-          if (0 === cornerRadius || isArray$1(cornerRadius) && cornerRadius.every(num => 0 === num) ? (context.beginPath(), context.rect(nextX, nextY, width - sign * dw, height - sign * dw)) : (context.beginPath(), createRectPath(context, nextX, nextY, width - sign * dw, height - sign * dw, cornerRadius, "bevel" !== cornerType)), context.setShadowBlendStyle && context.setShadowBlendStyle(rect, rect.attribute, rectAttribute), strokeCb) strokeCb(context, borderStyle, rectAttribute[key]);else if (doStroke) {
-            const lastOpacity = rectAttribute[key].opacity;
-            rectAttribute[key].opacity = opacity, context.setStrokeStyle(rect, borderStyle, (originX - x) / scaleX, (originY - y) / scaleY, rectAttribute[key]), rectAttribute[key].opacity = lastOpacity, context.stroke();
-          }
-        };
+        width = (null != width ? width : x1 - originX) || 0, height = (null != height ? height : y1 - originY) || 0;
+        const borderX = width < 0 ? x + width : x,
+          borderY = height < 0 ? y + height : y,
+          borderWidth = width < 0 ? -width : width,
+          borderHeight = height < 0 ? -height : height,
+          renderBorder = (borderStyle, key) => {
+            const doStroke = !(!borderStyle || !borderStyle.stroke),
+              sign = "outerBorder" === key ? -1 : 1,
+              {
+                distance = rectAttribute[key].distance
+              } = borderStyle,
+              d = keepStrokeScale ? distance : getScaledStroke(context, distance, context.dpr),
+              nextX = borderX + sign * d,
+              nextY = borderY + sign * d,
+              dw = 2 * d;
+            if (0 === cornerRadius || isArray$1(cornerRadius) && cornerRadius.every(num => 0 === num) ? (context.beginPath(), context.rect(nextX, nextY, borderWidth - sign * dw, borderHeight - sign * dw)) : (context.beginPath(), createRectPath(context, nextX, nextY, borderWidth - sign * dw, borderHeight - sign * dw, cornerRadius, "bevel" !== cornerType)), context.setShadowBlendStyle && context.setShadowBlendStyle(rect, rect.attribute, rectAttribute), strokeCb) strokeCb(context, borderStyle, rectAttribute[key]);else if (doStroke) {
+              const lastOpacity = rectAttribute[key].opacity;
+              rectAttribute[key].opacity = opacity, context.setStrokeStyle(rect, borderStyle, (originX - x) / scaleX, (originY - y) / scaleY, rectAttribute[key]), rectAttribute[key].opacity = lastOpacity, context.stroke();
+            }
+          };
         doOuterBorder && renderBorder(outerBorder, "outerBorder"), doInnerBorder && renderBorder(innerBorder, "innerBorder");
       }
     }
@@ -23906,7 +24125,8 @@
     const StarRender = Symbol.for("StarRender");
 
     const DrawItemInterceptor = Symbol.for("DrawItemInterceptor");
-    const tempDirtyBounds = new AABBBounds(),
+    const INTERACTIVE_POST_MATRIX = "_interactivePostMatrix",
+      tempDirtyBounds = new AABBBounds(),
       tempBackupDirtyBounds = new AABBBounds();
     class ShadowRootDrawItemInterceptorContribution {
       constructor() {
@@ -23970,12 +24190,23 @@
       beforeDrawItem(graphic, renderService, drawContext, drawContribution, params) {
         return !this.processing && (graphic.baseGraphic ? this.beforeDrawInteractive(graphic, renderService, drawContext, drawContribution, params) : this.beforeSetInteractive(graphic, renderService, drawContext, drawContribution, params));
       }
+      resolveInteractivePostMatrix(graphic, interactiveGraphic) {
+        const parent = graphic.parent;
+        if (!parent) return graphic.attribute.postMatrix;
+        let matrix = interactiveGraphic[INTERACTIVE_POST_MATRIX];
+        matrix || (matrix = new Matrix(), interactiveGraphic[INTERACTIVE_POST_MATRIX] = matrix);
+        const ancestorMatrix = parent.globalTransMatrix;
+        matrix.setValue(ancestorMatrix.a, ancestorMatrix.b, ancestorMatrix.c, ancestorMatrix.d, ancestorMatrix.e, ancestorMatrix.f);
+        const ownPostMatrix = graphic.attribute.postMatrix;
+        return ownPostMatrix && matrix.multiply(ownPostMatrix.a, ownPostMatrix.b, ownPostMatrix.c, ownPostMatrix.d, ownPostMatrix.e, ownPostMatrix.f), matrix;
+      }
       beforeSetInteractive(graphic, renderService, drawContext, drawContribution, params) {
         let interactiveGraphic = graphic.interactiveGraphic;
         if (graphic.attribute.globalZIndex) {
           interactiveGraphic || (interactiveGraphic = graphic.clone(), graphic.interactiveGraphic = interactiveGraphic, interactiveGraphic.baseGraphic = graphic), interactiveGraphic.setAttributes({
             globalZIndex: 0,
-            zIndex: graphic.attribute.globalZIndex
+            zIndex: graphic.attribute.globalZIndex,
+            postMatrix: this.resolveInteractivePostMatrix(graphic, interactiveGraphic)
           }, !1, {
             skipUpdateCallback: !0
           }), drawContext.stage.tryInitInteractiveLayer();
@@ -27718,64 +27949,69 @@
     }
     const pathModule = bindPathRenderModule;
 
-    function drawPolygon(path, points, x, y) {
-      if (points && points.length) {
-        path.moveTo(points[0].x + x, points[0].y + y);
-        for (let i = 1; i < points.length; i++) path.lineTo(points[i].x + x, points[i].y + y);
+    const defaultPolygonTextureRenderContribution = defaultBaseTextureRenderContribution;
+    const defaultPolygonBackgroundRenderContribution = defaultBaseBackgroundRenderContribution;
+    class DefaultPolygonRenderContribution {
+      constructor() {
+        this.time = BaseRenderContributionTime.afterFillStroke, this.useStyle = !0, this.order = 0;
       }
-    }
-    function drawRoundedPolygon(path, points, x, y, cornerRadius, closePath = !0) {
-      var _a;
-      if (points.length < 3) return void drawPolygon(path, points, x, y);
-      let startI = 0,
-        endI = points.length - 1;
-      closePath || (startI += 1, endI -= 1, path.moveTo(points[0].x + x, points[0].y + y));
-      for (let i = startI; i <= endI; i++) {
-        const p1 = points[0 === i ? endI : (i - 1) % points.length],
-          angularPoint = points[i % points.length],
-          p2 = points[(i + 1) % points.length],
-          dx1 = angularPoint.x - p1.x,
-          dy1 = angularPoint.y - p1.y,
-          dx2 = angularPoint.x - p2.x,
-          dy2 = angularPoint.y - p2.y,
-          angle = (Math.atan2(dy1, dx1) - Math.atan2(dy2, dx2)) / 2,
-          tan = Math.abs(Math.tan(angle));
-        let radius = Array.isArray(cornerRadius) ? null !== (_a = cornerRadius[i % points.length]) && void 0 !== _a ? _a : 0 : cornerRadius,
-          segment = radius / tan;
-        const length1 = getLength(dx1, dy1),
-          length2 = getLength(dx2, dy2),
-          length = Math.min(length1, length2);
-        segment > length && (segment = length, radius = length * tan);
-        const p1Cross = getProportionPoint(angularPoint, segment, length1, dx1, dy1),
-          p2Cross = getProportionPoint(angularPoint, segment, length2, dx2, dy2),
-          dx = 2 * angularPoint.x - p1Cross.x - p2Cross.x,
-          dy = 2 * angularPoint.y - p1Cross.y - p2Cross.y,
-          L = getLength(dx, dy),
-          circlePoint = getProportionPoint(angularPoint, getLength(segment, radius), L, dx, dy);
-        let startAngle = Math.atan2(p1Cross.y - circlePoint.y, p1Cross.x - circlePoint.x);
-        const endAngle = Math.atan2(p2Cross.y - circlePoint.y, p2Cross.x - circlePoint.x);
-        let sweepAngle = endAngle - startAngle;
-        sweepAngle < 0 && (startAngle = endAngle, sweepAngle = -sweepAngle), sweepAngle > Math.PI && (sweepAngle -= Math.PI), 0 === i ? path.moveTo(p1Cross.x + x, p1Cross.y + y) : path.lineTo(p1Cross.x + x, p1Cross.y + y), sweepAngle && path.arcTo(angularPoint.x + x, angularPoint.y + y, p2Cross.x + x, p2Cross.y + y, radius), path.lineTo(p2Cross.x + x, p2Cross.y + y);
+      drawShape(polygon, context, x, y, doFill, doStroke, fVisible, sVisible, polygonAttribute, drawContext, fillCb, strokeCb) {
+        const {
+            outerBorder: outerBorder,
+            innerBorder: innerBorder
+          } = polygon.attribute,
+          doOuterBorder = outerBorder && !1 !== outerBorder.visible,
+          doInnerBorder = innerBorder && !1 !== innerBorder.visible;
+        if (!doOuterBorder && !doInnerBorder) return;
+        const {
+            points = polygonAttribute.points,
+            cornerRadius = polygonAttribute.cornerRadius,
+            opacity = polygonAttribute.opacity,
+            x: originX = polygonAttribute.x,
+            y: originY = polygonAttribute.y,
+            scaleX = polygonAttribute.scaleX,
+            scaleY = polygonAttribute.scaleY,
+            keepStrokeScale = polygonAttribute.keepStrokeScale,
+            closePath = polygonAttribute.closePath
+          } = polygon.attribute,
+          renderBorder = (borderStyle, key) => {
+            var _a, _b;
+            const doBorderStroke = !!borderStyle.stroke,
+              distanceDirection = "outerBorder" === key ? 1 : -1,
+              {
+                distance = polygonAttribute[key].distance
+              } = borderStyle,
+              borderDistance = distanceDirection * (keepStrokeScale ? distance : getScaledStroke(context, distance, context.dpr)),
+              normalized = normalizePolygonPoints(points, cornerRadius, closePath),
+              normalizedPoints = null !== (_a = null == normalized ? void 0 : normalized.points) && void 0 !== _a ? _a : points,
+              normalizedCornerRadius = null !== (_b = null == normalized ? void 0 : normalized.cornerRadius) && void 0 !== _b ? _b : cornerRadius,
+              borderPoints = offsetPolygonPoints(normalizedPoints, borderDistance, closePath),
+              winding = getPolygonWinding(normalizedPoints),
+              borderCornerRadius = normalizedPoints.map((point, i) => {
+                var _a;
+                const radius = isArray$1(normalizedCornerRadius) ? null !== (_a = normalizedCornerRadius[i]) && void 0 !== _a ? _a : 0 : normalizedCornerRadius || 0;
+                if (!closePath && (0 === i || i === normalizedPoints.length - 1) || normalizedPoints.length < 3) return radius;
+                const prev = normalizedPoints[(i - 1 + normalizedPoints.length) % normalizedPoints.length],
+                  next = normalizedPoints[(i + 1) % normalizedPoints.length],
+                  cornerDirection = ((point.x - prev.x) * (next.y - point.y) - (point.y - prev.y) * (next.x - point.x)) * winding < 0 ? -1 : 1;
+                return Math.max(0, radius + borderDistance * cornerDirection);
+              }),
+              noCorner = 0 === borderCornerRadius.length || borderCornerRadius.every(r => 0 === r);
+            if (context.beginPath(), noCorner ? drawPolygon(context.camera ? context : context.nativeContext, borderPoints, x, y) : drawRoundedPolygon(context.camera ? context : context.nativeContext, borderPoints, x, y, borderCornerRadius, closePath), closePath && context.closePath(), context.setShadowBlendStyle && context.setShadowBlendStyle(polygon, polygon.attribute, polygonAttribute), strokeCb) strokeCb(context, borderStyle, polygonAttribute[key]);else if (doBorderStroke) {
+              const lastOpacity = polygonAttribute[key].opacity,
+                borderStyleWithStrokeScale = borderStyle,
+                lastKeepStrokeScale = borderStyleWithStrokeScale.keepStrokeScale;
+              polygonAttribute[key].opacity = opacity, borderStyleWithStrokeScale.keepStrokeScale = keepStrokeScale, context.setStrokeStyle(polygon, borderStyleWithStrokeScale, (originX - x) / scaleX, (originY - y) / scaleY, polygonAttribute[key]), polygonAttribute[key].opacity = lastOpacity, void 0 === lastKeepStrokeScale ? delete borderStyleWithStrokeScale.keepStrokeScale : borderStyleWithStrokeScale.keepStrokeScale = lastKeepStrokeScale, context.stroke();
+            }
+          };
+        doOuterBorder && renderBorder(outerBorder, "outerBorder"), doInnerBorder && renderBorder(innerBorder, "innerBorder");
       }
-      closePath || path.lineTo(points[endI + 1].x + x, points[endI + 1].y + y);
     }
-    function getLength(dx, dy) {
-      return Math.sqrt(dx * dx + dy * dy);
-    }
-    function getProportionPoint(point, segment, length, dx, dy) {
-      const factor = segment / length;
-      return {
-        x: point.x - dx * factor,
-        y: point.y - dy * factor
-      };
-    }
-
-    const defaultPolygonTextureRenderContribution = defaultBaseTextureRenderContribution;
-    const defaultPolygonBackgroundRenderContribution = defaultBaseBackgroundRenderContribution;
+    const defaultPolygonRenderContribution = new DefaultPolygonRenderContribution();
 
     class DefaultCanvasPolygonRender extends BaseRender {
       constructor(graphicRenderContributions) {
-        super(), this.graphicRenderContributions = graphicRenderContributions, this.numberType = POLYGON_NUMBER_TYPE, this.builtinContributions = [defaultPolygonBackgroundRenderContribution, defaultPolygonTextureRenderContribution], this.init(graphicRenderContributions);
+        super(), this.graphicRenderContributions = graphicRenderContributions, this.numberType = POLYGON_NUMBER_TYPE, this.builtinContributions = [defaultPolygonRenderContribution, defaultPolygonBackgroundRenderContribution, defaultPolygonTextureRenderContribution], this.init(graphicRenderContributions);
       }
       drawShape(polygon, context, x, y, drawContext, params, fillCb, strokeCb) {
         const polygonAttribute = getTheme$1(polygon, null == params ? void 0 : params.theme).polygon,
@@ -43255,6 +43491,8 @@
       var _a, _b;
       return null !== (_b = null !== (_a = null == params ? void 0 : params.lynx) && void 0 !== _a ? _a : null == params ? void 0 : params.runtime) && void 0 !== _b ? _b : getGlobalLynxRuntime();
     }
+    const requestAnimationFrameBasedSTO = callback => rafBasedSto.call(callback),
+      cancelAnimationFrameBasedSTO = handle => rafBasedSto.clear(handle);
     function getLynxPixelRatio(params, runtime) {
       var _a, _b, _c, _d, _e;
       return null !== (_e = null !== (_d = null !== (_a = null == params ? void 0 : params.pixelRatio) && void 0 !== _a ? _a : null === (_c = null === (_b = null == runtime ? void 0 : runtime.getSystemInfoSync) || void 0 === _b ? void 0 : _b.call(runtime)) || void 0 === _c ? void 0 : _c.pixelRatio) && void 0 !== _d ? _d : getGlobalSystemPixelRatio()) && void 0 !== _e ? _e : 1;
@@ -43326,7 +43564,7 @@
     }
     class LynxEnvContribution extends BaseEnvContribution {
       constructor() {
-        super(), this.type = "lynx", this.supportEvent = !0, this.canvasMap = new Map(), this.freeCanvasList = [], this.canvasIdx = 0, this.supportsTouchEvents = !0;
+        super(), this.type = "lynx", this.supportEvent = !0, this.canvasMap = new Map(), this.freeCanvasList = [], this.canvasIdx = 0, this.requestAnimationFrame = requestAnimationFrameBasedSTO, this.cancelAnimationFrame = cancelAnimationFrameBasedSTO, this.supportsTouchEvents = !0;
         try {
           this.supportsPointerEvents = !!globalThis.PointerEvent, this.supportsMouseEvents = !!globalThis.MouseEvent;
         } catch (err) {
@@ -43335,7 +43573,8 @@
         this.applyStyles = !0;
       }
       configure(service, params = {}) {
-        service.env === this.type && (service.setActiveEnvContribution(this), this.lynxEnvParams = params, this.lynxRuntime = getLynxRuntime(params));
+        var _a, _b;
+        service.env === this.type && (service.setActiveEnvContribution(this), this.lynxEnvParams = params, this.lynxRuntime = getLynxRuntime(params), "function" == typeof (null === (_a = this.lynxRuntime) || void 0 === _a ? void 0 : _a.requestAnimationFrame) && "function" == typeof (null === (_b = this.lynxRuntime) || void 0 === _b ? void 0 : _b.cancelAnimationFrame) ? (this.requestAnimationFrame = this.lynxRuntime.requestAnimationFrame.bind(this.lynxRuntime), this.cancelAnimationFrame = this.lynxRuntime.cancelAnimationFrame.bind(this.lynxRuntime)) : (this.requestAnimationFrame = requestAnimationFrameBasedSTO, this.cancelAnimationFrame = cancelAnimationFrameBasedSTO));
       }
       getDynamicCanvasCount() {
         return this.freeCanvasList.length;
@@ -43387,14 +43626,10 @@
         return getLynxPixelRatio(void 0, this.lynxRuntime);
       }
       getRequestAnimationFrame() {
-        return function (callback) {
-          return rafBasedSto.call(callback);
-        };
+        return this.requestAnimationFrame;
       }
       getCancelAnimationFrame() {
-        return h => {
-          rafBasedSto.clear(h);
-        };
+        return this.cancelAnimationFrame;
       }
       mapToCanvasPoint(event) {
         var _a;
@@ -48117,7 +48352,6 @@
         }
         _reCompile(updateResult, morphConfig) {
             var _a, _b, _c, _d, _e, _f, _g;
-            const shouldRestoreUserEvents = updateResult.reMake && !!this._chart;
             if (updateResult.reMake) {
                 this._releaseData();
                 this._initDataSet();
@@ -48137,9 +48371,6 @@
             if (updateResult.reMake) {
                 const cacheGrammarForMorph = this.isAnimationEnable() && (morphConfig === null || morphConfig === void 0 ? void 0 : morphConfig.morph) !== false;
                 (_c = this._compiler) === null || _c === void 0 ? void 0 : _c.releaseGrammar(!cacheGrammarForMorph);
-                if (shouldRestoreUserEvents) {
-                    this._userEvents.forEach(e => { var _a; return (_a = this._event) === null || _a === void 0 ? void 0 : _a.on(e.eType, e.query, e.handler); });
-                }
             }
             else if (updateResult.reCompile) {
                 (_d = this._compiler) === null || _d === void 0 ? void 0 : _d.clear({ chart: this._chart, vChart: this });
@@ -62854,6 +63085,7 @@
                     m.beforeRelease();
                 });
             }
+            this._event.release();
             super.release();
             this.clear();
             [...this._components, ...this._regions, ...this._series].forEach(m => {
@@ -70395,7 +70627,7 @@
     loadDiscreteLegendComponent();
     let DiscreteLegend$1 = class DiscreteLegend extends LegendBase {
       constructor(attributes, options) {
-        super((null == options ? void 0 : options.skipDefault) ? attributes : merge$1({}, DiscreteLegend.defaultAttributes, attributes)), this.name = "discreteLegend", this._itemsContainer = null, this._itemHeightByUser = void 0, this._itemHeight = 0, this._itemMaxWidth = 0, this._contentMaxHeight = 0, this._stateDefinitionsCache = new WeakMap(), this._onHover = e => {
+        super((null == options ? void 0 : options.skipDefault) ? attributes : merge$1({}, DiscreteLegend.defaultAttributes, attributes)), this.name = "discreteLegend", this._itemsContainer = null, this._itemHeightByUser = void 0, this._itemHeight = 0, this._itemMaxWidth = 0, this._contentMaxHeight = 0, this._onHover = e => {
           const target = e.target;
           if (target && target.name && target.name.startsWith(LEGEND_ELEMENT_NAME.item)) {
             const legendItem = target.delegate;
@@ -70443,7 +70675,7 @@
         };
       }
       render() {
-        this._stateDefinitionsCache = new WeakMap(), super.render(), this._lastActiveItem = null;
+        super.render(), this._lastActiveItem = null;
       }
       setSelected(selectedData) {
         var _a;
@@ -70623,7 +70855,7 @@
         }), this._appendDataToShape(itemGroup, LEGEND_ELEMENT_NAME.item, item, itemGroup)) : (itemGroup = graphicCreator.group(Object.assign({
           x: 0,
           y: 0
-        }, backgroundStyle.style)), this._appendDataToShape(itemGroup, LEGEND_ELEMENT_NAME.item, item, itemGroup, backgroundStyle.state, backgroundStyle.reuseStateDefinitions)), itemGroup.id = `${null != id ? id : label}-${index}`, itemGroup.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected);
+        }, backgroundStyle.style)), this._appendDataToShape(itemGroup, LEGEND_ELEMENT_NAME.item, item, itemGroup, backgroundStyle.state)), itemGroup.id = `${null != id ? id : label}-${index}`, itemGroup.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected);
         const innerGroup = graphicCreator.group({
           x: 0,
           y: 0,
@@ -70646,7 +70878,7 @@
           Object.keys(shapeStyle.state || {}).forEach(key => {
             const color = shapeStyle.state[key].fill || shapeStyle.state[key].stroke;
             shape.fill && isNil$1(shapeStyle.state[key].fill) && color && (shapeStyle.state[key].fill = color), shape.stroke && isNil$1(shapeStyle.state[key].stroke) && color && (shapeStyle.state[key].stroke = color);
-          }), this._appendDataToShape(itemShape, LEGEND_ELEMENT_NAME.itemShape, item, itemGroup, shapeStyle.state, !1), itemShape.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected), innerGroup.add(itemShape);
+          }), this._appendDataToShape(itemShape, LEGEND_ELEMENT_NAME.itemShape, item, itemGroup, shapeStyle.state), itemShape.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected), innerGroup.add(itemShape);
         }
         let focusSpace = 0;
         if (focus) {
@@ -70673,7 +70905,7 @@
             _originText: labelAttr.formatMethod ? label : void 0
           }),
           labelShape = createTextGraphicByType(labelAttributes);
-        this._appendDataToShape(labelShape, LEGEND_ELEMENT_NAME.itemLabel, item, itemGroup, labelStyle.state, labelStyle.reuseStateDefinitions), labelShape.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected), innerGroup.add(labelShape);
+        this._appendDataToShape(labelShape, LEGEND_ELEMENT_NAME.itemLabel, item, itemGroup, labelStyle.state), labelShape.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected), innerGroup.add(labelShape);
         const labelSpace = get$1(labelAttr, "space", DEFAULT_LABEL_SPACE);
         if (isValid$1(value)) {
           const valueSpace = get$1(valueAttr, "space", focus ? DEFAULT_VALUE_SPACE : 0),
@@ -70689,7 +70921,7 @@
               _originText: valueAttr.formatMethod ? value : void 0
             }),
             valueShape = createTextGraphicByType(valueAttributes);
-          if (this._appendDataToShape(valueShape, LEGEND_ELEMENT_NAME.itemValue, item, itemGroup, valueStyle.state, valueStyle.reuseStateDefinitions), valueShape.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected), this._itemWidthByUser) {
+          if (this._appendDataToShape(valueShape, LEGEND_ELEMENT_NAME.itemValue, item, itemGroup, valueStyle.state), valueShape.addState(isSelected ? LegendStateValue.selected : LegendStateValue.unSelected), this._itemWidthByUser) {
             const layoutWidth = this._itemWidthByUser - parsedPadding[1] - parsedPadding[3] - shapeSize - shapeSpace - labelSpace - focusSpace - valueSpace;
             this._autoEllipsis(autoEllipsisStrategy, layoutWidth, labelShape, valueShape), valueAttr.alignRight ? valueShape.setAttributes({
               textAlign: "right",
@@ -71119,17 +71351,8 @@
           item.hasState(LegendStateValue.selected) && selectedData.push(item.data);
         }), selectedData;
       }
-      _appendDataToShape(shape, name, data, delegateShape, states, reuseStateDefinitions = !0) {
-        if (shape.name = name, shape.data = data, shape.delegate = delegateShape, !reuseStateDefinitions) return void (shape.states = merge$1({}, DEFAULT_STATES, states));
-        const source = null != states ? states : DEFAULT_STATES,
-          cached = this._stateDefinitionsCache.get(source);
-        if (cached) return shape.states = cached.definitions, void shape.setStateDefinitionsWithCompiled(cached.definitions, cached.compiledDefinitions);
-        const definitions = states ? merge$1({}, DEFAULT_STATES, states) : DEFAULT_STATES,
-          entry = {
-            definitions: definitions,
-            compiledDefinitions: new StateDefinitionCompiler().compile(definitions)
-          };
-        this._stateDefinitionsCache.set(source, entry), shape.states = entry.definitions, shape.setStateDefinitionsWithCompiled(entry.definitions, entry.compiledDefinitions);
+      _appendDataToShape(shape, name, data, delegateShape, states = {}) {
+        shape.name = name, shape.data = data, shape.delegate = delegateShape, shape.states = merge$1({}, DEFAULT_STATES, states);
       }
       _dispatchLegendEvent(eventName, legendItem, event) {
         const currentSelectedItems = this._getSelectedLegends();
@@ -71146,17 +71369,12 @@
       }
       _handleStyle(config, item, isSelected, index, items) {
         const newConfig = {};
-        if (config.style && (isFunction$1(config.style) ? newConfig.style = config.style(item, isSelected, index, items) : newConfig.style = config.style), config.state) {
-          const stateKeys = Object.keys(config.state),
-            hasStateFunction = stateKeys.some(key => isFunction$1(config.state[key]));
-          newConfig.reuseStateDefinitions = !hasStateFunction, hasStateFunction ? (newConfig.state = {}, stateKeys.forEach(key => {
-            config.state[key] && (newConfig.state[key] = isFunction$1(config.state[key]) ? config.state[key](item, isSelected, index, items) : config.state[key]);
-          })) : newConfig.state = config.state;
-        }
-        return newConfig;
+        return config.style && (isFunction$1(config.style) ? newConfig.style = config.style(item, isSelected, index, items) : newConfig.style = config.style), config.state && (newConfig.state = {}, Object.keys(config.state).forEach(key => {
+          config.state[key] && (isFunction$1(config.state[key]) ? newConfig.state[key] = config.state[key](item, isSelected, index, items) : newConfig.state[key] = config.state[key]);
+        })), newConfig;
       }
       release() {
-        this._stateDefinitionsCache = new WeakMap(), super.release(), this.removeAllEventListeners();
+        super.release(), this.removeAllEventListeners();
       }
     };
     DiscreteLegend$1.defaultAttributes = {
@@ -96978,7 +97196,9 @@
         pager = cloneDeep(pager);
         background = cloneDeep(background);
         const attrs = restSpec;
-        if (isFunction$1(attrs.maxRow) || isFunction$1(attrs.maxCol)) {
+        const pagerLayout = pager.layout;
+        const pagerPosition = pager.position;
+        if (isFunction$1(attrs.maxRow) || isFunction$1(attrs.maxCol) || isFunction$1(pagerLayout) || isFunction$1(pagerPosition)) {
             const resolvedOrient = isValidOrient(layoutOrient) ? layoutOrient : isValidOrient(orient) ? orient : 'left';
             if (isFunction$1(attrs.maxRow)) {
                 attrs.maxRow = attrs.maxRow({ rect, orient: resolvedOrient, id });
@@ -96986,6 +97206,20 @@
             if (isFunction$1(attrs.maxCol)) {
                 attrs.maxCol = attrs.maxCol({ rect, orient: resolvedOrient, id });
             }
+            const isArrowPager = pager.type !== 'scrollbar';
+            const pagerContext = {
+                rect,
+                orient: resolvedOrient,
+                id,
+                maxRow: attrs.maxRow,
+                maxCol: attrs.maxCol
+            };
+            if (isArrowPager && isFunction$1(pagerLayout)) {
+                pager.layout = pagerLayout(pagerContext);
+            }
+            if (isArrowPager && isFunction$1(pagerPosition)) {
+                pager.position = pagerPosition(pagerContext);
+            }
         }
         if (title.visible) {
             attrs.title = transformLegendTitleAttributes(title);
@@ -105672,6 +105906,50 @@ C0.3-1.4,0.3-1.4,0.3-1.4z;`;
             super(...arguments);
             this.specKey = 'markPoint';
             this.layoutZIndex = exports.LayoutZIndex.MarkPoint;
+            this._handleDimensionHover = (params) => {
+                var _a, _b;
+                const targetSymbol = this._getTargetSymbolGraphic();
+                if (!targetSymbol) {
+                    return;
+                }
+                switch (params.action) {
+                    case 'enter': {
+                        targetSymbol.removeState(exports.STATE_VALUE_ENUM.STATE_DIMENSION_HOVER);
+                        targetSymbol.removeState(exports.STATE_VALUE_ENUM.STATE_DIMENSION_HOVER_REVERSE);
+                        if (this._isDimensionHoverTarget(params)) {
+                            targetSymbol.addState(exports.STATE_VALUE_ENUM.STATE_DIMENSION_HOVER, true);
+                        }
+                        else if ((_b = (_a = this._spec.targetSymbol) === null || _a === void 0 ? void 0 : _a.state) === null || _b === void 0 ? void 0 : _b.dimension_hover_reverse) {
+                            targetSymbol.addState(exports.STATE_VALUE_ENUM.STATE_DIMENSION_HOVER_REVERSE, true);
+                        }
+                        break;
+                    }
+                    case 'leave':
+                        targetSymbol.removeState(exports.STATE_VALUE_ENUM.STATE_DIMENSION_HOVER);
+                        targetSymbol.removeState(exports.STATE_VALUE_ENUM.STATE_DIMENSION_HOVER_REVERSE);
+                        break;
+                }
+            };
+        }
+        initEvent() {
+            var _a;
+            super.initEvent();
+            const targetSymbolState = (_a = this._spec.targetSymbol) === null || _a === void 0 ? void 0 : _a.state;
+            if (this.coordinateType === 'cartesian' &&
+                ((targetSymbolState === null || targetSymbolState === void 0 ? void 0 : targetSymbolState.dimension_hover) || (targetSymbolState === null || targetSymbolState === void 0 ? void 0 : targetSymbolState.dimension_hover_reverse))) {
+                this.event.on(exports.DimensionEventEnum.dimensionHover, this._handleDimensionHover);
+            }
+        }
+        _getTargetSymbolGraphic() {
+            var _a;
+            return (_a = this._markerComponent) === null || _a === void 0 ? void 0 : _a.find(node => node.name === 'mark-point-targetItem', true);
+        }
+        _isDimensionHoverTarget(params) {
+            var _a, _b, _c, _d;
+            const latestData = (_a = this._markerData) === null || _a === void 0 ? void 0 : _a.latestData;
+            const markerData = (_c = (_b = latestData === null || latestData === void 0 ? void 0 : latestData[0]) === null || _b === void 0 ? void 0 : _b.latestData) !== null && _c !== void 0 ? _c : latestData;
+            const markerXValues = array((_d = markerData === null || markerData === void 0 ? void 0 : markerData[0]) === null || _d === void 0 ? void 0 : _d.x).filter(isValid$1);
+            return markerXValues.some(value => params.dimensionInfo.some(dimension => dimension.value === value));
         }
         static _getMarkerCoordinateType(markerSpec) {
             const { doPolarProcess, doGeoProcess } = getMarkPointProcessInfo(markerSpec);