@visactor/vrender-core 1.1.5 → 1.1.6

package/dist/index.es.js

@@ -7639,9 +7639,9 @@ class GradientParser {
     }
 }
 
-function getScaledStroke(context, width, dpr) {
+function getScaledStrokeWithMatrix(matrix, width, dpr) {
     let strokeWidth = width;
-    const { a, b, c, d } = context.currentMatrix;
+    const { a, b, c, d } = matrix;
     const scaleX = Math.sign(a) * Math.sqrt(a * a + b * b);
     const scaleY = Math.sign(d) * Math.sqrt(c * c + d * d);
     if (scaleX + scaleY === 0) {
@@ -7650,6 +7650,9 @@ function getScaledStroke(context, width, dpr) {
     strokeWidth = (strokeWidth / Math.abs(scaleX + scaleY)) * 2 * dpr;
     return 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 || c === true) {
@@ -9530,7 +9533,7 @@ function normalizeNoAnimateAttrConfig(config) {
 }
 class StateTransitionOrchestrator {
     analyzeTransition(targetAttrs, hasAnimation, options = {}) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const plan = {
             targetAttrs: Object.assign({}, targetAttrs),
             animateAttrs: {},
@@ -9543,12 +9546,22 @@ class StateTransitionOrchestrator {
         const isClear = options.isClear === true;
         const getDefaultAttribute = options.getDefaultAttribute;
         const readDefaultAttribute = getDefaultAttribute;
+        const readStateTransitionDefaultAttribute = ((_c = options.getStateTransitionDefaultAttribute) !== null && _c !== void 0 ? _c : getDefaultAttribute);
         const shouldSkipDefaultAttribute = options.shouldSkipDefaultAttribute;
-        const assignTransitionAttr = (key, value) => {
+        const stateTransitionTargetAttrs = (_d = options.stateTransitionTargetAttrs) !== null && _d !== void 0 ? _d : targetAttrs;
+        const assignTransitionAttr = (key, value, isRemovedStateAttr = false) => {
             if (noWorkAnimateAttr[key]) {
                 plan.noAnimateAttrs[key] = value;
                 return;
             }
+            if (isRemovedStateAttr && value === undefined) {
+                const defaultValue = readStateTransitionDefaultAttribute === null || readStateTransitionDefaultAttribute === void 0 ? void 0 : readStateTransitionDefaultAttribute(key, stateTransitionTargetAttrs);
+                if (defaultValue === undefined && (shouldSkipDefaultAttribute === null || shouldSkipDefaultAttribute === void 0 ? void 0 : shouldSkipDefaultAttribute(key, stateTransitionTargetAttrs))) {
+                    return;
+                }
+                plan.animateAttrs[key] = defaultValue;
+                return;
+            }
             if (isClear && value === undefined) {
                 if (shouldSkipDefaultAttribute === null || shouldSkipDefaultAttribute === void 0 ? void 0 : shouldSkipDefaultAttribute(key, targetAttrs)) {
                     return;
@@ -9573,7 +9586,7 @@ class StateTransitionOrchestrator {
                     (hasTargetAttr && targetAttrs[key] !== undefined)) {
                     continue;
                 }
-                assignTransitionAttr(key, extraAnimateAttrs[key]);
+                assignTransitionAttr(key, extraAnimateAttrs[key], true);
             }
         }
         return plan;
@@ -9613,9 +9626,11 @@ class StateTransitionOrchestrator {
             noWorkAnimateAttr: graphic.getNoWorkAnimateAttr(),
             isClear: true,
             getDefaultAttribute: graphic.getDefaultAttribute.bind(graphic),
+            getStateTransitionDefaultAttribute: options.getStateTransitionDefaultAttribute,
             shouldSkipDefaultAttribute: (_a = options.shouldSkipDefaultAttribute) !== null && _a !== void 0 ? _a : graphic.shouldSkipStateTransitionDefaultAttribute.bind(graphic),
             animateConfig: options.animateConfig,
-            extraAnimateAttrs: options.extraAnimateAttrs
+            extraAnimateAttrs: options.extraAnimateAttrs,
+            stateTransitionTargetAttrs: options.stateTransitionTargetAttrs
         });
         return this.applyTransition(graphic, plan, hasAnimation, options);
     }
@@ -10124,35 +10139,33 @@ class GraphicImpl extends Node {
         return snapshot;
     }
     buildRemovedStateAnimationAttrs(targetStateAttrs, previousResolvedStatePatch) {
-        const extraAttrs = {};
         if (!previousResolvedStatePatch) {
-            return extraAttrs;
+            return;
         }
         const snapshot = this.buildStaticAttributeSnapshot();
-        const staticTargetAttrs = snapshot;
+        const extraAttrs = {};
         Object.keys(previousResolvedStatePatch).forEach(key => {
             const hasTargetAttr = Object.prototype.hasOwnProperty.call(targetStateAttrs, key);
             if (hasTargetAttr && targetStateAttrs[key] !== undefined) {
                 return;
             }
             const assignFallbackAttr = (value) => {
-                if (value === undefined && this.shouldSkipStateTransitionDefaultAttribute(key, staticTargetAttrs)) {
-                    return;
-                }
                 extraAttrs[key] = value === undefined ? value : cloneAttributeValue(value);
             };
             if (hasTargetAttr) {
-                assignFallbackAttr(this.getStateTransitionDefaultAttribute(key, staticTargetAttrs));
+                assignFallbackAttr(targetStateAttrs[key]);
                 return;
             }
             if (Object.prototype.hasOwnProperty.call(snapshot, key)) {
-                const snapshotValue = snapshot[key];
-                assignFallbackAttr(snapshotValue === undefined ? this.getStateTransitionDefaultAttribute(key, staticTargetAttrs) : snapshotValue);
+                assignFallbackAttr(snapshot[key]);
                 return;
             }
-            assignFallbackAttr(this.getStateTransitionDefaultAttribute(key, staticTargetAttrs));
+            assignFallbackAttr(undefined);
         });
-        return extraAttrs;
+        return {
+            extraAttrs: extraAttrs,
+            stateTransitionTargetAttrs: snapshot
+        };
     }
     syncObjectToSnapshot(target, snapshot, excludedKeys) {
         const delta = new Map();
@@ -11386,7 +11399,8 @@ class GraphicImpl extends Node {
         }
         if (hasAnimation && animateSameStatePatchChange) {
             this._syncFinalAttributeFromStaticTruth();
-            this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
+            const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+            this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, removedStateAnimationAttrs === null || removedStateAnimationAttrs === void 0 ? void 0 : removedStateAnimationAttrs.extraAttrs, removedStateAnimationAttrs === null || removedStateAnimationAttrs === void 0 ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
         }
         else {
             this.stopStateAnimates();
@@ -11405,13 +11419,15 @@ class GraphicImpl extends Node {
         var _a, _b, _c;
         return (_c = (_a = animateConfig !== null && animateConfig !== void 0 ? animateConfig : this.stateAnimateConfig) !== null && _a !== void 0 ? _a : (_b = this.context) === null || _b === void 0 ? void 0 : _b.stateAnimateConfig) !== null && _c !== void 0 ? _c : DefaultStateAnimateConfig;
     }
-    applyStateAttrs(attrs, stateNames, hasAnimation, isClear, animateConfig, extraAnimateAttrs) {
+    applyStateAttrs(attrs, stateNames, hasAnimation, isClear, animateConfig, extraAnimateAttrs, stateTransitionTargetAttrs) {
         const resolvedAnimateConfig = hasAnimation ? this.resolveStateAnimateConfig(animateConfig) : undefined;
         const transitionOptions = resolvedAnimateConfig
             ? {
                 animateConfig: resolvedAnimateConfig,
                 extraAnimateAttrs: extraAnimateAttrs,
-                shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this)
+                getStateTransitionDefaultAttribute: this.getStateTransitionDefaultAttribute.bind(this),
+                shouldSkipDefaultAttribute: this.shouldSkipStateTransitionDefaultAttribute.bind(this),
+                stateTransitionTargetAttrs: stateTransitionTargetAttrs
             }
             : undefined;
         if (isClear) {
@@ -11422,7 +11438,9 @@ class GraphicImpl extends Node {
             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);
     }
@@ -11478,7 +11496,8 @@ class GraphicImpl extends Node {
         this.clearSharedStateActiveRegistrations();
         if (hasAnimation) {
             this._syncFinalAttributeFromStaticTruth();
-            this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, true, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
+            const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+            this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, true, undefined, removedStateAnimationAttrs === null || removedStateAnimationAttrs === void 0 ? void 0 : removedStateAnimationAttrs.extraAttrs, removedStateAnimationAttrs === null || removedStateAnimationAttrs === void 0 ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
         }
         else {
             this.stopStateAnimates();
@@ -11561,7 +11580,8 @@ class GraphicImpl extends Node {
         this.syncSharedStateActiveRegistrations();
         if (hasAnimation) {
             this._syncFinalAttributeFromStaticTruth();
-            this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch));
+            const removedStateAnimationAttrs = this.buildRemovedStateAnimationAttrs(resolvedStateAttrs, previousResolvedStatePatch);
+            this.applyStateAttrs(resolvedStateAttrs, transition.states, hasAnimation, false, undefined, removedStateAnimationAttrs === null || removedStateAnimationAttrs === void 0 ? void 0 : removedStateAnimationAttrs.extraAttrs, removedStateAnimationAttrs === null || removedStateAnimationAttrs === void 0 ? void 0 : removedStateAnimationAttrs.stateTransitionTargetAttrs);
         }
         else {
             this.stopStateAnimates();
@@ -12730,13 +12750,14 @@ class Text extends Graphic {
         if (!this.obbText) {
             this.obbText = new Text({});
         }
-        this.obbText.setAttributes(Object.assign(Object.assign({}, attribute), { angle: 0 }));
+        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;
         const { x, y } = attribute;
         const boundsCenter = { x: (bounds1.x1 + bounds1.x2) / 2, y: (bounds1.y1 + bounds1.y2) / 2 };
         const center = rotatePoint(boundsCenter, angle, { x, y });
         this._OBBBounds.copy(bounds1);
-        this._OBBBounds.translate(center.x - boundsCenter.x, center.y - boundsCenter.y);
+        this._OBBBounds.translate(center.x - boundsCenter.x + dx, center.y - boundsCenter.y + dy);
         this._OBBBounds.angle = angle;
         return this._OBBBounds;
     }
@@ -16669,7 +16690,262 @@ function createGroup(attributes) {
     return new Group(attributes);
 }
 
-const POLYGON_UPDATE_TAG_KEY = ['points', 'cornerRadius', ...GRAPHIC_UPDATE_TAG_KEY];
+function drawPolygon(path, points, x, y) {
+    if (!points || !points.length) {
+        return;
+    }
+    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 = true) {
+    var _a;
+    const normalized = normalizePolygonPoints(points, cornerRadius, closePath);
+    if (normalized) {
+        drawRoundedPolygon(path, normalized.points, x, y, normalized.cornerRadius, closePath);
+        return;
+    }
+    if (points.length < 3) {
+        drawPolygon(path, points, x, y);
+        return;
+    }
+    let startI = 0;
+    let endI = points.length - 1;
+    if (!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[i === 0 ? endI : (i - 1) % points.length];
+        const angularPoint = points[i % points.length];
+        const p2 = points[(i + 1) % points.length];
+        const dx1 = angularPoint.x - p1.x;
+        const dy1 = angularPoint.y - p1.y;
+        const dx2 = angularPoint.x - p2.x;
+        const dy2 = angularPoint.y - p2.y;
+        const angle = (Math.atan2(dy1, dx1) - Math.atan2(dy2, dx2)) / 2;
+        const tan = Math.abs(Math.tan(angle));
+        let radius = Array.isArray(cornerRadius) ? (_a = cornerRadius[i % points.length]) !== null && _a !== void 0 ? _a : 0 : cornerRadius;
+        let segment = radius / tan;
+        const length1 = getLength(dx1, dy1);
+        const length2 = getLength(dx2, dy2);
+        const length = Math.min(length1, length2);
+        if (segment > length) {
+            segment = length;
+            radius = length * tan;
+        }
+        const p1Cross = getProportionPoint(angularPoint, segment, length1, dx1, dy1);
+        const p2Cross = getProportionPoint(angularPoint, segment, length2, dx2, dy2);
+        const dx = angularPoint.x * 2 - p1Cross.x - p2Cross.x;
+        const dy = angularPoint.y * 2 - p1Cross.y - p2Cross.y;
+        const L = getLength(dx, dy);
+        const d = getLength(segment, radius);
+        const circlePoint = getProportionPoint(angularPoint, d, 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;
+        if (sweepAngle < 0) {
+            startAngle = endAngle;
+            sweepAngle = -sweepAngle;
+        }
+        if (sweepAngle > Math.PI) {
+            sweepAngle = sweepAngle - Math.PI;
+        }
+        if (i === 0) {
+            path.moveTo(p1Cross.x + x, p1Cross.y + y);
+        }
+        else {
+            path.lineTo(p1Cross.x + x, p1Cross.y + y);
+        }
+        if (sweepAngle) {
+            path.arcTo(angularPoint.x + x, angularPoint.y + y, p2Cross.x + x, p2Cross.y + y, radius);
+        }
+        path.lineTo(p2Cross.x + x, p2Cross.y + y);
+    }
+    if (!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 = true) {
+    var _a;
+    let hasDuplicate = false;
+    for (let i = 1; i < points.length; i++) {
+        if (isSamePoint(points[i - 1], points[i])) {
+            hasDuplicate = true;
+            break;
+        }
+    }
+    if (!hasDuplicate && closePath && points.length > 1 && isSamePoint(points[0], points[points.length - 1])) {
+        hasDuplicate = true;
+    }
+    if (!hasDuplicate) {
+        return null;
+    }
+    const normalizedPoints = [];
+    const normalizedCornerRadius = Array.isArray(cornerRadius) ? [] : null;
+    for (let i = 0; i < points.length; i++) {
+        if (normalizedPoints.length && isSamePoint(normalizedPoints[normalizedPoints.length - 1], points[i])) {
+            continue;
+        }
+        normalizedPoints.push(points[i]);
+        normalizedCornerRadius === null || normalizedCornerRadius === void 0 ? void 0 : normalizedCornerRadius.push((_a = cornerRadius[i]) !== null && _a !== void 0 ? _a : 0);
+    }
+    if (closePath &&
+        normalizedPoints.length > 1 &&
+        isSamePoint(normalizedPoints[0], normalizedPoints[normalizedPoints.length - 1])) {
+        normalizedPoints.pop();
+        normalizedCornerRadius === null || normalizedCornerRadius === void 0 ? void 0 : normalizedCornerRadius.pop();
+    }
+    return {
+        points: normalizedPoints,
+        cornerRadius: normalizedCornerRadius !== null && normalizedCornerRadius !== void 0 ? 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];
+        const 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 = true) {
+    var _a;
+    const n = (_a = points === null || points === void 0 ? void 0 : points.length) !== null && _a !== void 0 ? _a : 0;
+    if (n < 2 || (closePath && n < 3) || !distance) {
+        return points;
+    }
+    const sign = getPolygonWinding(points);
+    const edgeCount = closePath ? n : n - 1;
+    const lines = [];
+    for (let i = 0; i < edgeCount; i++) {
+        const cur = points[i];
+        const next = points[(i + 1) % n];
+        const dx = next.x - cur.x;
+        const dy = next.y - cur.y;
+        const len = Math.sqrt(dx * dx + dy * dy);
+        if (!len) {
+            lines.push(null);
+            continue;
+        }
+        const offsetX = (sign * dy * distance) / len;
+        const offsetY = (-sign * dx * distance) / len;
+        lines.push({ x: cur.x + offsetX, y: cur.y + offsetY, dx, dy, len, offsetX, 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;
+        if (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--) {
+        if (i < edgeCount && lines[i]) {
+            nextLine = lines[i];
+        }
+        nextLines[i] = nextLine;
+    }
+    const offsetPointByLine = (point, line) => ({
+        x: point.x + line.offsetX,
+        y: point.y + line.offsetY
+    });
+    const result = [];
+    for (let i = 0; i < n; i++) {
+        const prev = prevLines[i];
+        const cur = nextLines[i];
+        const 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;
+        const 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;
+    const viewBoxMatrix = (_a = polygon.stage) === null || _a === void 0 ? void 0 : _a.window.getViewBoxTransform();
+    if (!viewBoxMatrix) {
+        return globalMatrix;
+    }
+    return {
+        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
+    };
+};
+const getPolygonBoundsScale = (polygon) => getScaledStrokeWithMatrix(getBoundsScaleMatrix(polygon), 1, 1);
+const updateBoundsOfPolygonOuterBorder = (attribute, polygonTheme, aabbBounds, polygon) => {
+    const { outerBorder, points = polygonTheme.points, closePath = polygonTheme.closePath, shadowBlur = polygonTheme.shadowBlur, keepStrokeScale = polygonTheme.keepStrokeScale } = attribute;
+    if (outerBorder && outerBorder.visible !== false) {
+        const defaultOuterBorder = polygonTheme.outerBorder;
+        const { distance = defaultOuterBorder.distance, lineWidth = defaultOuterBorder.lineWidth, lineJoin = defaultOuterBorder.lineJoin, strokeBoundsBuffer = defaultOuterBorder.strokeBoundsBuffer } = outerBorder;
+        const boundsScale = getPolygonBoundsScale(polygon);
+        let scaledDistance = distance;
+        if (!keepStrokeScale) {
+            scaledDistance *= boundsScale;
+        }
+        offsetPolygonPoints(points, scaledDistance, closePath).forEach(point => {
+            aabbBounds.add(point.x, point.y);
+        });
+        const scaledLineWidth = lineWidth * (keepStrokeScale ? 1 : boundsScale);
+        const scaledShadowBlur = shadowBlur * boundsScale;
+        boundStroke(aabbBounds, (scaledShadowBlur + scaledLineWidth) / 2, lineJoin === 'miter', strokeBoundsBuffer);
+    }
+    return aabbBounds;
+};
+
+const POLYGON_UPDATE_TAG_KEY = ['points', 'cornerRadius', 'outerBorder', 'keepStrokeScale', ...GRAPHIC_UPDATE_TAG_KEY];
 class Polygon extends Graphic {
     constructor(params) {
         super(params);
@@ -16686,6 +16962,20 @@ class Polygon extends Graphic {
     getGraphicTheme() {
         return getTheme(this).polygon;
     }
+    tryUpdateAABBBounds() {
+        const { outerBorder } = this.attribute;
+        if (outerBorder && outerBorder.visible !== false) {
+            const boundsScale = getPolygonBoundsScale(this);
+            if (boundsScale !== this._outerBorderBoundsScale) {
+                this._outerBorderBoundsScale = boundsScale;
+                this.addUpdateBoundTag();
+            }
+        }
+        else {
+            this._outerBorderBoundsScale = undefined;
+        }
+        return super.tryUpdateAABBBounds();
+    }
     updateAABBBounds(attribute, polygonTheme, aabbBounds) {
         if (!this.updatePathProxyAABBBounds(aabbBounds)) {
             this.updatePolygonAABBBoundsImprecise(attribute, polygonTheme, aabbBounds);
@@ -16702,6 +16992,7 @@ class Polygon extends Graphic {
         points.forEach(p => {
             aabbBounds.add(p.x, p.y);
         });
+        updateBoundsOfPolygonOuterBorder(attribute, polygonTheme, aabbBounds, this);
         return aabbBounds;
     }
     _interpolate(key, ratio, lastStepVal, nextStepVal, nextAttributes) {
@@ -22358,23 +22649,27 @@ class DefaultRectRenderContribution {
         }
         const { cornerRadius = rectAttribute.cornerRadius, cornerType = rectAttribute.cornerType, opacity = rectAttribute.opacity, x: originX = rectAttribute.x, y: originY = rectAttribute.y, scaleX = rectAttribute.scaleX, scaleY = rectAttribute.scaleY, x1, y1, keepStrokeScale = rectAttribute.keepStrokeScale } = rect.attribute;
         let { width, height } = rect.attribute;
-        width = (width !== null && width !== void 0 ? width : x1 - x) || 0;
-        height = (height !== null && height !== void 0 ? height : y1 - y) || 0;
+        width = (width !== null && width !== void 0 ? width : x1 - originX) || 0;
+        height = (height !== null && height !== void 0 ? height : y1 - originY) || 0;
+        const borderX = width < 0 ? x + width : x;
+        const borderY = height < 0 ? y + height : y;
+        const borderWidth = width < 0 ? -width : width;
+        const borderHeight = height < 0 ? -height : height;
         const renderBorder = (borderStyle, key) => {
             const doStroke = !!(borderStyle && borderStyle.stroke);
             const sign = key === 'outerBorder' ? -1 : 1;
             const { distance = rectAttribute[key].distance } = borderStyle;
             const d = keepStrokeScale ? distance : getScaledStroke(context, distance, context.dpr);
-            const nextX = x + sign * d;
-            const nextY = y + sign * d;
+            const nextX = borderX + sign * d;
+            const nextY = borderY + sign * d;
             const dw = d * 2;
             if (cornerRadius === 0 || (isArray(cornerRadius) && cornerRadius.every(num => num === 0))) {
                 context.beginPath();
-                context.rect(nextX, nextY, width - sign * dw, height - sign * dw);
+                context.rect(nextX, nextY, borderWidth - sign * dw, borderHeight - sign * dw);
             }
             else {
                 context.beginPath();
-                createRectPath(context, nextX, nextY, width - sign * dw, height - sign * dw, cornerRadius, cornerType !== 'bevel');
+                createRectPath(context, nextX, nextY, borderWidth - sign * dw, borderHeight - sign * dw, cornerRadius, cornerType !== 'bevel');
             }
             context.setShadowBlendStyle && context.setShadowBlendStyle(rect, rect.attribute, rectAttribute);
             if (strokeCb) {
@@ -25848,99 +26143,94 @@ class DefaultCanvasTextRender extends BaseRender {
 class AbstractGraphicRender {
 }
 
-function drawPolygon(path, points, x, y) {
-    if (!points || !points.length) {
-        return;
-    }
-    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 = true) {
-    var _a;
-    if (points.length < 3) {
-        drawPolygon(path, points, x, y);
-        return;
-    }
-    let startI = 0;
-    let endI = points.length - 1;
-    if (!closePath) {
-        startI += 1;
-        endI -= 1;
-        path.moveTo(points[0].x + x, points[0].y + y);
+const defaultPolygonTextureRenderContribution = defaultBaseTextureRenderContribution;
+const defaultPolygonBackgroundRenderContribution = defaultBaseBackgroundRenderContribution;
+class DefaultPolygonRenderContribution {
+    constructor() {
+        this.time = BaseRenderContributionTime.afterFillStroke;
+        this.useStyle = true;
+        this.order = 0;
     }
-    for (let i = startI; i <= endI; i++) {
-        const p1 = points[i === 0 ? endI : (i - 1) % points.length];
-        const angularPoint = points[i % points.length];
-        const p2 = points[(i + 1) % points.length];
-        const dx1 = angularPoint.x - p1.x;
-        const dy1 = angularPoint.y - p1.y;
-        const dx2 = angularPoint.x - p2.x;
-        const dy2 = angularPoint.y - p2.y;
-        const angle = (Math.atan2(dy1, dx1) - Math.atan2(dy2, dx2)) / 2;
-        const tan = Math.abs(Math.tan(angle));
-        let radius = Array.isArray(cornerRadius) ? ((_a = cornerRadius[i % points.length]) !== null && _a !== void 0 ? _a : 0) : cornerRadius;
-        let segment = radius / tan;
-        const length1 = getLength(dx1, dy1);
-        const length2 = getLength(dx2, dy2);
-        const length = Math.min(length1, length2);
-        if (segment > length) {
-            segment = length;
-            radius = length * tan;
-        }
-        const p1Cross = getProportionPoint(angularPoint, segment, length1, dx1, dy1);
-        const p2Cross = getProportionPoint(angularPoint, segment, length2, dx2, dy2);
-        const dx = angularPoint.x * 2 - p1Cross.x - p2Cross.x;
-        const dy = angularPoint.y * 2 - p1Cross.y - p2Cross.y;
-        const L = getLength(dx, dy);
-        const d = getLength(segment, radius);
-        const circlePoint = getProportionPoint(angularPoint, d, 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;
-        if (sweepAngle < 0) {
-            startAngle = endAngle;
-            sweepAngle = -sweepAngle;
-        }
-        if (sweepAngle > Math.PI) {
-            sweepAngle = sweepAngle - Math.PI;
-        }
-        if (i === 0) {
-            path.moveTo(p1Cross.x + x, p1Cross.y + y);
-        }
-        else {
-            path.lineTo(p1Cross.x + x, p1Cross.y + y);
-        }
-        if (sweepAngle) {
-            path.arcTo(angularPoint.x + x, angularPoint.y + y, p2Cross.x + x, p2Cross.y + y, radius);
+    drawShape(polygon, context, x, y, doFill, doStroke, fVisible, sVisible, polygonAttribute, drawContext, fillCb, strokeCb) {
+        const { outerBorder, innerBorder } = polygon.attribute;
+        const doOuterBorder = outerBorder && outerBorder.visible !== false;
+        const doInnerBorder = innerBorder && innerBorder.visible !== false;
+        if (!(doOuterBorder || doInnerBorder)) {
+            return;
         }
-        path.lineTo(p2Cross.x + x, p2Cross.y + y);
-    }
-    if (!closePath) {
-        path.lineTo(points[endI + 1].x + x, points[endI + 1].y + y);
+        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;
+        const renderBorder = (borderStyle, key) => {
+            var _a, _b;
+            const doBorderStroke = !!borderStyle.stroke;
+            const distanceDirection = key === 'outerBorder' ? 1 : -1;
+            const { distance = polygonAttribute[key].distance } = borderStyle;
+            const borderDistance = distanceDirection *
+                (keepStrokeScale ? distance : getScaledStroke(context, distance, context.dpr));
+            const normalized = normalizePolygonPoints(points, cornerRadius, closePath);
+            const normalizedPoints = (_a = normalized === null || normalized === void 0 ? void 0 : normalized.points) !== null && _a !== void 0 ? _a : points;
+            const normalizedCornerRadius = (_b = normalized === null || normalized === void 0 ? void 0 : normalized.cornerRadius) !== null && _b !== void 0 ? _b : cornerRadius;
+            const borderPoints = offsetPolygonPoints(normalizedPoints, borderDistance, closePath);
+            const winding = getPolygonWinding(normalizedPoints);
+            const borderCornerRadius = normalizedPoints.map((point, i) => {
+                var _a;
+                const radius = isArray(normalizedCornerRadius)
+                    ? (_a = normalizedCornerRadius[i]) !== null && _a !== void 0 ? _a : 0
+                    : normalizedCornerRadius || 0;
+                if ((!closePath && (i === 0 || i === normalizedPoints.length - 1)) || normalizedPoints.length < 3) {
+                    return radius;
+                }
+                const prev = normalizedPoints[(i - 1 + normalizedPoints.length) % normalizedPoints.length];
+                const next = normalizedPoints[(i + 1) % normalizedPoints.length];
+                const cross = (point.x - prev.x) * (next.y - point.y) - (point.y - prev.y) * (next.x - point.x);
+                const cornerDirection = cross * winding < 0 ? -1 : 1;
+                return Math.max(0, radius + borderDistance * cornerDirection);
+            });
+            const noCorner = borderCornerRadius.length === 0 || borderCornerRadius.every(r => r === 0);
+            context.beginPath();
+            if (noCorner) {
+                drawPolygon(context.camera ? context : context.nativeContext, borderPoints, x, y);
+            }
+            else {
+                drawRoundedPolygon(context.camera ? context : context.nativeContext, borderPoints, x, y, borderCornerRadius, closePath);
+            }
+            closePath && context.closePath();
+            context.setShadowBlendStyle && context.setShadowBlendStyle(polygon, polygon.attribute, polygonAttribute);
+            if (strokeCb) {
+                strokeCb(context, borderStyle, polygonAttribute[key]);
+            }
+            else if (doBorderStroke) {
+                const lastOpacity = polygonAttribute[key].opacity;
+                const borderStyleWithStrokeScale = borderStyle;
+                const 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;
+                if (lastKeepStrokeScale === undefined) {
+                    delete borderStyleWithStrokeScale.keepStrokeScale;
+                }
+                else {
+                    borderStyleWithStrokeScale.keepStrokeScale = lastKeepStrokeScale;
+                }
+                context.stroke();
+            }
+        };
+        doOuterBorder && renderBorder(outerBorder, 'outerBorder');
+        doInnerBorder && renderBorder(innerBorder, 'innerBorder');
     }
 }
-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.builtinContributions = [
+            defaultPolygonRenderContribution,
+            defaultPolygonBackgroundRenderContribution,
+            defaultPolygonTextureRenderContribution
+        ];
         this.init(graphicRenderContributions);
     }
     drawShape(polygon, context, x, y, drawContext, params, fillCb, strokeCb) {
@@ -30834,4 +31124,4 @@ const registerFlexLayoutPlugin = () => {
     Factory.registerPlugin('FlexLayoutPlugin', FlexLayoutPlugin);
 };
 
-export { APPLICATION_STATE_SYMBOL, ARC3D_NUMBER_TYPE, ARC_NUMBER_TYPE, AREA_NUMBER_TYPE, AbstractGraphicRender, AnimateMode, AnimateStatus, AnimateStepType, AppContext, Application, Arc, Arc3d, Arc3dRender, ArcRender, ArcRenderContribution, Area, AreaRender, AreaRenderContribution, AttributeUpdateType, AutoEnablePlugins, Base3dRender, BaseCanvas, BaseEnvContribution, BaseRender, BaseRenderContributionTime, BaseWindowHandlerContribution, Basis, BeforeRenderConstribution, BoundsContext, BoundsPicker, BrowserEntry, CIRCLE_NUMBER_TYPE, CONTRIBUTION_STORE_STATE_SYMBOL, Canvas3DDrawItemInterceptor, Canvas3DPickItemInterceptor, CanvasFactory, CanvasTextLayout, Circle, CircleRender, CircleRenderContribution, ColorInterpolate, ColorStore, ColorType, CommonDrawItemInterceptorContribution, CommonRenderContribution, Context2dFactory, ContributionProvider, ContributionRegistry, ContributionStore, CubicBezierCurve, CurveContext, CurveTypeEnum, CustomEvent, CustomPath2D, CustomSymbolClass, DEFAULT_TEXT_FONT_FAMILY, DebugDrawItemInterceptorContribution, DefaultArcAllocate, DefaultArcAttribute, DefaultArcRenderContribution, DefaultAreaAllocate, DefaultAreaAttribute, DefaultAreaTextureRenderContribution, DefaultAttribute, DefaultBaseBackgroundRenderContribution, DefaultBaseClipRenderAfterContribution, DefaultBaseClipRenderBeforeContribution, DefaultBaseInteractiveRenderContribution, DefaultBaseTextureRenderContribution, DefaultCanvasAllocate, DefaultCanvasArc3DRender, DefaultCanvasArcRender, DefaultCanvasAreaRender, DefaultCanvasCircleRender, DefaultCanvasGroupRender, DefaultCanvasImageRender, DefaultCanvasLineRender, DefaultCanvasPathRender, DefaultCanvasPolygonRender, DefaultCanvasPyramid3dRender, DefaultCanvasRect3dRender, DefaultCanvasRectRender, DefaultCanvasSymbolRender, DefaultCanvasTextRender, DefaultCircleAllocate, DefaultCircleAttribute, DefaultCircleRenderContribution, DefaultConnectAttribute, DefaultDebugAttribute, DefaultFillStyle, DefaultGlobal, DefaultGlobalPickerService, DefaultGlyphAttribute, DefaultGraphicAllocate, DefaultGraphicMemoryManager, DefaultGraphicService, DefaultGraphicUtil, DefaultGroupAttribute, DefaultGroupBackgroundRenderContribution, DefaultImageAttribute, DefaultImageRenderContribution, DefaultLayerService, DefaultLayout, DefaultLineAllocate, DefaultLineAttribute, DefaultMat4Allocate, DefaultMatrixAllocate, DefaultPathAllocate, DefaultPathAttribute, DefaultPickService, DefaultPickStyle, DefaultPolygonAttribute, DefaultRect3dAttribute, DefaultRectAllocate, DefaultRectAttribute, DefaultRectRenderContribution, DefaultRenderService, DefaultRichTextAttribute, DefaultRichTextIconAttribute, DefaultStarAttribute, DefaultStrokeStyle, DefaultStyle, DefaultSymbolAllocate, DefaultSymbolAttribute, DefaultSymbolClipRangeStrokeRenderContribution, DefaultSymbolRenderContribution, DefaultTextAllocate, DefaultTextAttribute, DefaultTextMeasureContribution, DefaultTextStyle, DefaultTransform, DefaultTransformUtil, DefaultWindow, Direction, DirectionalLight, DrawContribution, DrawItemInterceptor, DynamicLayerHandlerContribution, Edge, EditModule, EmptyContext2d, EnvContribution, EventManager, EventSystem, EventTarget, FACTORY_STATE_SYMBOL, FORMAT_ALL_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, FORMAT_TEXT_COMMAND, Factory, FederatedEvent, FederatedMouseEvent, FederatedPointerEvent, FederatedWheelEvent, FlexLayoutPlugin, GLYPH_NUMBER_TYPE, GRAPHIC_CLASS_SYMBOL, GRAPHIC_REGISTRY_SYMBOL, GRAPHIC_UPDATE_TAG_KEY, GROUP_NUMBER_TYPE, Generator, GlobalPickerService, Glyph, GlyphRender, GradientParser, Graphic, GraphicCreator$1 as GraphicCreator, GraphicFactory, GraphicPicker, GraphicRender, GraphicService, GraphicUtil, Group, GroupRender, GroupRenderContribution, GroupUpdateAABBBoundsMode, HtmlAttributePlugin, IContainPointMode, IMAGE_NUMBER_TYPE, Image, ImageRender, ImageRenderContribution, IncrementalDrawContribution, InteractiveDrawItemInterceptorContribution, InteractivePickItemInterceptorContribution, InteractiveSubRenderContribution, LINE_NUMBER_TYPE, Layer, LayerFactory, LayerService, Line$1 as Line, LineRender, Linear, LinearClosed, Mat4Allocate, MatrixAllocate, MeasureModeEnum, MiniappEntry, MonotoneX, MonotoneY, NOWORK_ANIMATE_ATTR, Node, NodeEntry, OrthoCamera, PATH_NUMBER_TYPE, POLYGON_NUMBER_TYPE, PURE_STYLE_KEY, PYRAMID3D_NUMBER_TYPE, Path, PathRender, PathRenderContribution, PerformanceRAF, PickItemInterceptor, PickServiceInterceptor, PickerRegistry, PickerService, PluginRegistry, PluginService, Polygon, PolygonRender, PolygonRenderContribution, Pyramid3d, Pyramid3dRender, RECT3D_NUMBER_TYPE, RECT_NUMBER_TYPE, RICHTEXT_NUMBER_TYPE, RUNTIME_INSTALLER_STATE_SYMBOL, RafBasedSTO, ReactAttributePlugin, Rect, Rect3DRender, Rect3d, RectRender, RectRenderContribution, ReflectSegContext, RenderSelector, RenderService, RendererRegistry, ResourceLoader, RichText, RichTextEditPlugin, RichTextRender, STAR_NUMBER_TYPE, STATUS$1 as STATUS, SVG_ATTRIBUTE_MAP, SVG_ATTRIBUTE_MAP_KEYS, SVG_PARSE_ATTRIBUTE_MAP, SVG_PARSE_ATTRIBUTE_MAP_KEYS, SYMBOL_NUMBER_TYPE, SegContext, ShadowPickServiceInterceptorContribution, ShadowRoot, ShadowRootDrawItemInterceptorContribution, ShadowRootPickItemInterceptorContribution, SplitRectAfterRenderContribution, SplitRectBeforeRenderContribution, Stage, StageFactory, Star, StarRender, StarRenderContribution, StateDefinitionCompiler, StateEngine, StaticLayerHandlerContribution, Step, StepClosed, Symbol$1 as Symbol, SymbolRender, SymbolRenderContribution, TEXT_NUMBER_TYPE, Text, TextDirection, TextMeasureContribution, TextRender, TextRenderContribution, Theme, TransformUtil, UpdateTag, VGlobal, VWindow, ViewTransform3dPlugin, VirtualLayerHandlerContribution, WILDCARD, WindowHandlerContribution, WrapText, XMLParser, _calculateLineHeight, _interpolateColor, addArcToBezierPath, addAttributeToPrototype, alignBezierCurves, alignSubpath, application, applyTransformOnBezierCurves, arc3dModule, arcModule, areaModule, bezier, bezierCurversToPath, binarySplitPolygon, bindArc3dRenderModule, bindArcRenderModule, bindAreaRenderModule, bindCircleRenderModule, bindContributionProvider, bindContributionProviderNoSingletonScope, bindGlyphRenderModule, bindImageRenderModule, bindLineRenderModule, bindPathRenderModule, bindPolygonRenderModule, bindPyramid3dRenderModule, bindRect3dRenderModule, bindRectRenderModule, bindRichtextRenderModule, bindStarRenderModule, bindSymbolRenderModule, bindTextRenderModule, boundStroke, builtInSymbolStrMap, builtinSymbols, builtinSymbolsMap, calcLineCache, calculateArcCornerRadius, calculateLineHeight, canvasAllocate, centroidOfSubpath, circleBounds, circleModule, clock, colorEqual, colorStringInterpolationToStr, configureRuntimeApplicationForApp, container, cornerTangents, createBrowserApp as createApp, createArc, createArc3d, createArea, createBrowserApp, createCanvasEventTransformer, createCircle, createColor, createConicalGradient, createContributionProvider, createEventTransformer, createGlyph, createGraphic, createGroup, createImage, createLine, createMat4, createMiniappApp, createNodeApp, createPath, createPolygon, createPyramid3d, createRect, createRect3d, createRectPath, createRichText, createShadowRoot, createStage, createStar, createSymbol, createText, createWrapText, cubicCalc, cubicLength, cubicPointAt, cubicSubdivide, defaultArcAllocate, defaultArcBackgroundRenderContribution, defaultArcRenderContribution, defaultArcTextureRenderContribution, defaultAreaAllocate, defaultBaseBackgroundRenderContribution, defaultBaseClipRenderAfterContribution, defaultBaseClipRenderBeforeContribution, defaultBaseTextureRenderContribution, defaultCircleAllocate, defaultCircleBackgroundRenderContribution, defaultCircleRenderContribution, defaultCircleTextureRenderContribution, defaultGraphicMemoryManager, defaultGroupBackgroundRenderContribution, defaultImageBackgroundRenderContribution, defaultImageRenderContribution, defaultLineAllocate, defaultPathAllocate, defaultRectAllocate, defaultRectBackgroundRenderContribution, defaultRectRenderContribution, defaultRectTextureRenderContribution, defaultStarBackgroundRenderContribution, defaultStarTextureRenderContribution, defaultSymbolAllocate, defaultSymbolBackgroundRenderContribution, defaultSymbolClipRangeStrokeRenderContribution, defaultSymbolRenderContribution, defaultSymbolTextureRenderContribution, defaultTextAllocate, diff, divideCubic, drawArc, drawArcPath$1 as drawArcPath, drawAreaSegments, drawBackgroundImage, drawImageWithLayout, drawIncrementalAreaSegments, drawIncrementalSegments, drawSegments, enumCommandMap, fillVisible, findBestMorphingRotation, findConfigIndexByCursorIdx, findCursorIdxByConfigIndex, findNextGraphic, flatten_simplify, foreach, foreachAsync, genBasisSegments, genBasisTypeSegments, genLinearClosedSegments, genLinearClosedTypeSegments, genLinearSegments, genLinearTypeSegments, genMonotoneXSegments, genMonotoneXTypeSegments, genMonotoneYSegments, genMonotoneYTypeSegments, genNumberType, genStepClosedSegments, genStepSegments, genStepTypeSegments, getApplicationState, getAttributeFromDefaultAttrList, getBackgroundImage, getConicGradientAt, getContributionStoreState, getCurrentEnv, getDefaultCharacterConfig, getExtraModelMatrix, getFactoryState, getGraphicClassState, getGraphicRegistryState, getLegacyBindingContext, getModelMatrix, getRichTextBounds, getRuntimeInstallerBindingContext, getRuntimeInstallerGlobal, getRuntimeInstallerState, getScaledStroke, getTextBounds, getTheme, getThemeFromGroup, globalTheme, glyphModule, graphicCreator, graphicService, graphicUtil, identityMat4, imageModule, incrementalAddTo, installRuntimeContributionModule, installRuntimeDrawContributionsToApp, installRuntimeGraphicRenderersToApp, installRuntimePickersToApp, interpolateColor, interpolateGradientConicalColor, interpolateGradientLinearColor, interpolateGradientRadialColor, interpolatePureColorArray, interpolatePureColorArrayToStr, intersect, isBrowserEnv, isNoRepeatSizingMode, isNodeEnv, isSvg, isXML, layerService, lineModule, lookAt, mapToCanvasPointForCanvas, mat3Tomat4, mat4Allocate, matrixAllocate, multiplyMat4Mat3, multiplyMat4Mat4, newThemeObj, ortho, parsePadding, parseStroke, parseSvgPath, pathModule, pathToBezierCurves, point$3 as point, pointEqual, pointInterpolation, pointInterpolationHighPerformance, pointsEqual, pointsInterpolation, polygonModule, preLoadAllModule, pyramid3dModule, quadCalc, quadLength, quadPointAt, rafBasedSto, rect3dModule, rectFillVisible, rectModule, rectStrokeVisible, recursiveCallBinarySplit, refreshRuntimeInstallerContributions, registerArc3dGraphic, registerArcGraphic, registerAreaGraphic, registerCircleGraphic, registerDirectionalLight, registerFlexLayoutPlugin, registerGlobalEventTransformer, registerGlyphGraphic, registerGraphic, registerGroupGraphic, registerHtmlAttributePlugin, registerImageGraphic, registerLineGraphic, registerOrthoCamera, registerPathGraphic, registerPolygonGraphic, registerPyramid3dGraphic, registerReactAttributePlugin, registerRect3dGraphic, registerRectGraphic, registerRichtextGraphic, registerShadowRootGraphic, registerStarGraphic, registerSymbolGraphic, registerTextGraphic, registerViewTransform3dPlugin, registerWindowEventTransformer, registerWrapTextGraphic, renderCommandList, resolveBackgroundDrawMode, resolveBackgroundParamsByImageSizing, resolveBackgroundPosition, resolveBackgroundSizing, resolveContainerBinding, resolveImageMode, resolveImageRepeatMode, resolveRenderableImageSize, rewriteProto, richtextModule, rotateX, rotateY, rotateZ, runFill, runStroke, scaleMat4, segments, shouldClipImageByLayout, shouldUseMat4, snapLength, splitArc, splitArea, splitCircle, splitLine, splitPath, splitPolygon, splitRect, splitToGrids, starModule, strCommandMap, strokeVisible, symbolModule, textAttributesToStyle, textDrawOffsetX, textDrawOffsetY, textLayoutOffsetY, textModule, transformMat4, transformPointForCanvas, transformUtil, translate, verticalLayout, vglobal, waitForAllSubLayers, wrapCanvas, wrapContext, xul };
+export { APPLICATION_STATE_SYMBOL, ARC3D_NUMBER_TYPE, ARC_NUMBER_TYPE, AREA_NUMBER_TYPE, AbstractGraphicRender, AnimateMode, AnimateStatus, AnimateStepType, AppContext, Application, Arc, Arc3d, Arc3dRender, ArcRender, ArcRenderContribution, Area, AreaRender, AreaRenderContribution, AttributeUpdateType, AutoEnablePlugins, Base3dRender, BaseCanvas, BaseEnvContribution, BaseRender, BaseRenderContributionTime, BaseWindowHandlerContribution, Basis, BeforeRenderConstribution, BoundsContext, BoundsPicker, BrowserEntry, CIRCLE_NUMBER_TYPE, CONTRIBUTION_STORE_STATE_SYMBOL, Canvas3DDrawItemInterceptor, Canvas3DPickItemInterceptor, CanvasFactory, CanvasTextLayout, Circle, CircleRender, CircleRenderContribution, ColorInterpolate, ColorStore, ColorType, CommonDrawItemInterceptorContribution, CommonRenderContribution, Context2dFactory, ContributionProvider, ContributionRegistry, ContributionStore, CubicBezierCurve, CurveContext, CurveTypeEnum, CustomEvent, CustomPath2D, CustomSymbolClass, DEFAULT_TEXT_FONT_FAMILY, DebugDrawItemInterceptorContribution, DefaultArcAllocate, DefaultArcAttribute, DefaultArcRenderContribution, DefaultAreaAllocate, DefaultAreaAttribute, DefaultAreaTextureRenderContribution, DefaultAttribute, DefaultBaseBackgroundRenderContribution, DefaultBaseClipRenderAfterContribution, DefaultBaseClipRenderBeforeContribution, DefaultBaseInteractiveRenderContribution, DefaultBaseTextureRenderContribution, DefaultCanvasAllocate, DefaultCanvasArc3DRender, DefaultCanvasArcRender, DefaultCanvasAreaRender, DefaultCanvasCircleRender, DefaultCanvasGroupRender, DefaultCanvasImageRender, DefaultCanvasLineRender, DefaultCanvasPathRender, DefaultCanvasPolygonRender, DefaultCanvasPyramid3dRender, DefaultCanvasRect3dRender, DefaultCanvasRectRender, DefaultCanvasSymbolRender, DefaultCanvasTextRender, DefaultCircleAllocate, DefaultCircleAttribute, DefaultCircleRenderContribution, DefaultConnectAttribute, DefaultDebugAttribute, DefaultFillStyle, DefaultGlobal, DefaultGlobalPickerService, DefaultGlyphAttribute, DefaultGraphicAllocate, DefaultGraphicMemoryManager, DefaultGraphicService, DefaultGraphicUtil, DefaultGroupAttribute, DefaultGroupBackgroundRenderContribution, DefaultImageAttribute, DefaultImageRenderContribution, DefaultLayerService, DefaultLayout, DefaultLineAllocate, DefaultLineAttribute, DefaultMat4Allocate, DefaultMatrixAllocate, DefaultPathAllocate, DefaultPathAttribute, DefaultPickService, DefaultPickStyle, DefaultPolygonAttribute, DefaultRect3dAttribute, DefaultRectAllocate, DefaultRectAttribute, DefaultRectRenderContribution, DefaultRenderService, DefaultRichTextAttribute, DefaultRichTextIconAttribute, DefaultStarAttribute, DefaultStrokeStyle, DefaultStyle, DefaultSymbolAllocate, DefaultSymbolAttribute, DefaultSymbolClipRangeStrokeRenderContribution, DefaultSymbolRenderContribution, DefaultTextAllocate, DefaultTextAttribute, DefaultTextMeasureContribution, DefaultTextStyle, DefaultTransform, DefaultTransformUtil, DefaultWindow, Direction, DirectionalLight, DrawContribution, DrawItemInterceptor, DynamicLayerHandlerContribution, Edge, EditModule, EmptyContext2d, EnvContribution, EventManager, EventSystem, EventTarget, FACTORY_STATE_SYMBOL, FORMAT_ALL_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, FORMAT_TEXT_COMMAND, Factory, FederatedEvent, FederatedMouseEvent, FederatedPointerEvent, FederatedWheelEvent, FlexLayoutPlugin, GLYPH_NUMBER_TYPE, GRAPHIC_CLASS_SYMBOL, GRAPHIC_REGISTRY_SYMBOL, GRAPHIC_UPDATE_TAG_KEY, GROUP_NUMBER_TYPE, Generator, GlobalPickerService, Glyph, GlyphRender, GradientParser, Graphic, GraphicCreator$1 as GraphicCreator, GraphicFactory, GraphicPicker, GraphicRender, GraphicService, GraphicUtil, Group, GroupRender, GroupRenderContribution, GroupUpdateAABBBoundsMode, HtmlAttributePlugin, IContainPointMode, IMAGE_NUMBER_TYPE, Image, ImageRender, ImageRenderContribution, IncrementalDrawContribution, InteractiveDrawItemInterceptorContribution, InteractivePickItemInterceptorContribution, InteractiveSubRenderContribution, LINE_NUMBER_TYPE, Layer, LayerFactory, LayerService, Line$1 as Line, LineRender, Linear, LinearClosed, Mat4Allocate, MatrixAllocate, MeasureModeEnum, MiniappEntry, MonotoneX, MonotoneY, NOWORK_ANIMATE_ATTR, Node, NodeEntry, OrthoCamera, PATH_NUMBER_TYPE, POLYGON_NUMBER_TYPE, PURE_STYLE_KEY, PYRAMID3D_NUMBER_TYPE, Path, PathRender, PathRenderContribution, PerformanceRAF, PickItemInterceptor, PickServiceInterceptor, PickerRegistry, PickerService, PluginRegistry, PluginService, Polygon, PolygonRender, PolygonRenderContribution, Pyramid3d, Pyramid3dRender, RECT3D_NUMBER_TYPE, RECT_NUMBER_TYPE, RICHTEXT_NUMBER_TYPE, RUNTIME_INSTALLER_STATE_SYMBOL, RafBasedSTO, ReactAttributePlugin, Rect, Rect3DRender, Rect3d, RectRender, RectRenderContribution, ReflectSegContext, RenderSelector, RenderService, RendererRegistry, ResourceLoader, RichText, RichTextEditPlugin, RichTextRender, STAR_NUMBER_TYPE, STATUS$1 as STATUS, SVG_ATTRIBUTE_MAP, SVG_ATTRIBUTE_MAP_KEYS, SVG_PARSE_ATTRIBUTE_MAP, SVG_PARSE_ATTRIBUTE_MAP_KEYS, SYMBOL_NUMBER_TYPE, SegContext, ShadowPickServiceInterceptorContribution, ShadowRoot, ShadowRootDrawItemInterceptorContribution, ShadowRootPickItemInterceptorContribution, SplitRectAfterRenderContribution, SplitRectBeforeRenderContribution, Stage, StageFactory, Star, StarRender, StarRenderContribution, StateDefinitionCompiler, StateEngine, StaticLayerHandlerContribution, Step, StepClosed, Symbol$1 as Symbol, SymbolRender, SymbolRenderContribution, TEXT_NUMBER_TYPE, Text, TextDirection, TextMeasureContribution, TextRender, TextRenderContribution, Theme, TransformUtil, UpdateTag, VGlobal, VWindow, ViewTransform3dPlugin, VirtualLayerHandlerContribution, WILDCARD, WindowHandlerContribution, WrapText, XMLParser, _calculateLineHeight, _interpolateColor, addArcToBezierPath, addAttributeToPrototype, alignBezierCurves, alignSubpath, application, applyTransformOnBezierCurves, arc3dModule, arcModule, areaModule, bezier, bezierCurversToPath, binarySplitPolygon, bindArc3dRenderModule, bindArcRenderModule, bindAreaRenderModule, bindCircleRenderModule, bindContributionProvider, bindContributionProviderNoSingletonScope, bindGlyphRenderModule, bindImageRenderModule, bindLineRenderModule, bindPathRenderModule, bindPolygonRenderModule, bindPyramid3dRenderModule, bindRect3dRenderModule, bindRectRenderModule, bindRichtextRenderModule, bindStarRenderModule, bindSymbolRenderModule, bindTextRenderModule, boundStroke, builtInSymbolStrMap, builtinSymbols, builtinSymbolsMap, calcLineCache, calculateArcCornerRadius, calculateLineHeight, canvasAllocate, centroidOfSubpath, circleBounds, circleModule, clock, colorEqual, colorStringInterpolationToStr, configureRuntimeApplicationForApp, container, cornerTangents, createBrowserApp as createApp, createArc, createArc3d, createArea, createBrowserApp, createCanvasEventTransformer, createCircle, createColor, createConicalGradient, createContributionProvider, createEventTransformer, createGlyph, createGraphic, createGroup, createImage, createLine, createMat4, createMiniappApp, createNodeApp, createPath, createPolygon, createPyramid3d, createRect, createRect3d, createRectPath, createRichText, createShadowRoot, createStage, createStar, createSymbol, createText, createWrapText, cubicCalc, cubicLength, cubicPointAt, cubicSubdivide, defaultArcAllocate, defaultArcBackgroundRenderContribution, defaultArcRenderContribution, defaultArcTextureRenderContribution, defaultAreaAllocate, defaultBaseBackgroundRenderContribution, defaultBaseClipRenderAfterContribution, defaultBaseClipRenderBeforeContribution, defaultBaseTextureRenderContribution, defaultCircleAllocate, defaultCircleBackgroundRenderContribution, defaultCircleRenderContribution, defaultCircleTextureRenderContribution, defaultGraphicMemoryManager, defaultGroupBackgroundRenderContribution, defaultImageBackgroundRenderContribution, defaultImageRenderContribution, defaultLineAllocate, defaultPathAllocate, defaultRectAllocate, defaultRectBackgroundRenderContribution, defaultRectRenderContribution, defaultRectTextureRenderContribution, defaultStarBackgroundRenderContribution, defaultStarTextureRenderContribution, defaultSymbolAllocate, defaultSymbolBackgroundRenderContribution, defaultSymbolClipRangeStrokeRenderContribution, defaultSymbolRenderContribution, defaultSymbolTextureRenderContribution, defaultTextAllocate, diff, divideCubic, drawArc, drawArcPath$1 as drawArcPath, drawAreaSegments, drawBackgroundImage, drawImageWithLayout, drawIncrementalAreaSegments, drawIncrementalSegments, drawSegments, enumCommandMap, fillVisible, findBestMorphingRotation, findConfigIndexByCursorIdx, findCursorIdxByConfigIndex, findNextGraphic, flatten_simplify, foreach, foreachAsync, genBasisSegments, genBasisTypeSegments, genLinearClosedSegments, genLinearClosedTypeSegments, genLinearSegments, genLinearTypeSegments, genMonotoneXSegments, genMonotoneXTypeSegments, genMonotoneYSegments, genMonotoneYTypeSegments, genNumberType, genStepClosedSegments, genStepSegments, genStepTypeSegments, getApplicationState, getAttributeFromDefaultAttrList, getBackgroundImage, getConicGradientAt, getContributionStoreState, getCurrentEnv, getDefaultCharacterConfig, getExtraModelMatrix, getFactoryState, getGraphicClassState, getGraphicRegistryState, getLegacyBindingContext, getModelMatrix, getRichTextBounds, getRuntimeInstallerBindingContext, getRuntimeInstallerGlobal, getRuntimeInstallerState, getScaledStroke, getScaledStrokeWithMatrix, getTextBounds, getTheme, getThemeFromGroup, globalTheme, glyphModule, graphicCreator, graphicService, graphicUtil, identityMat4, imageModule, incrementalAddTo, installRuntimeContributionModule, installRuntimeDrawContributionsToApp, installRuntimeGraphicRenderersToApp, installRuntimePickersToApp, interpolateColor, interpolateGradientConicalColor, interpolateGradientLinearColor, interpolateGradientRadialColor, interpolatePureColorArray, interpolatePureColorArrayToStr, intersect, isBrowserEnv, isNoRepeatSizingMode, isNodeEnv, isSvg, isXML, layerService, lineModule, lookAt, mapToCanvasPointForCanvas, mat3Tomat4, mat4Allocate, matrixAllocate, multiplyMat4Mat3, multiplyMat4Mat4, newThemeObj, ortho, parsePadding, parseStroke, parseSvgPath, pathModule, pathToBezierCurves, point$3 as point, pointEqual, pointInterpolation, pointInterpolationHighPerformance, pointsEqual, pointsInterpolation, polygonModule, preLoadAllModule, pyramid3dModule, quadCalc, quadLength, quadPointAt, rafBasedSto, rect3dModule, rectFillVisible, rectModule, rectStrokeVisible, recursiveCallBinarySplit, refreshRuntimeInstallerContributions, registerArc3dGraphic, registerArcGraphic, registerAreaGraphic, registerCircleGraphic, registerDirectionalLight, registerFlexLayoutPlugin, registerGlobalEventTransformer, registerGlyphGraphic, registerGraphic, registerGroupGraphic, registerHtmlAttributePlugin, registerImageGraphic, registerLineGraphic, registerOrthoCamera, registerPathGraphic, registerPolygonGraphic, registerPyramid3dGraphic, registerReactAttributePlugin, registerRect3dGraphic, registerRectGraphic, registerRichtextGraphic, registerShadowRootGraphic, registerStarGraphic, registerSymbolGraphic, registerTextGraphic, registerViewTransform3dPlugin, registerWindowEventTransformer, registerWrapTextGraphic, renderCommandList, resolveBackgroundDrawMode, resolveBackgroundParamsByImageSizing, resolveBackgroundPosition, resolveBackgroundSizing, resolveContainerBinding, resolveImageMode, resolveImageRepeatMode, resolveRenderableImageSize, rewriteProto, richtextModule, rotateX, rotateY, rotateZ, runFill, runStroke, scaleMat4, segments, shouldClipImageByLayout, shouldUseMat4, snapLength, splitArc, splitArea, splitCircle, splitLine, splitPath, splitPolygon, splitRect, splitToGrids, starModule, strCommandMap, strokeVisible, symbolModule, textAttributesToStyle, textDrawOffsetX, textDrawOffsetY, textLayoutOffsetY, textModule, transformMat4, transformPointForCanvas, transformUtil, translate, verticalLayout, vglobal, waitForAllSubLayers, wrapCanvas, wrapContext, xul };