@visactor/vrender-components 0.20.15 → 0.20.17

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { tau, halfPi as halfPi$1, AABBBounds, degreeToRadian, Point, PointService, abs, max, min, atan2, epsilon, Matrix, pi2, Logger, isNumberClose, TextMeasure, EventEmitter, isBoolean, isObject, isFunction, isString, cos, sin, pi, isArray, pointAt, isNumber, getDecimalPlaces, isNil, Color, OBBBounds, has, normalTransform, isValidUrl, isBase64, acos, sqrt, transformBoundsWithMatrix, arrayEqual, getContextFont, rotatePoint, clampAngleByRadian, asin, Bounds, getRectIntersect, isRectIntersect, isPlainObject, merge, clamp, clampRange, normalizePadding, debounce, throttle, hexToRgb, crossProduct, isValid, isEmpty, rectInsideAnotherRect, radianToDegree, getAngleByPoint, polarToCartesian, array, isValidNumber, calculateAnchorOfBounds, computeQuadrant, isGreater, isLess, normalizeAngle, flattenArray, cloneDeep, get, last, isRotateAABBIntersect, mixin, isEqual, interpolateString, minInArray, maxInArray, binaryFuzzySearchInNumberRange, polygonContainPoint } from '@visactor/vutils';
+import { tau, halfPi as halfPi$1, AABBBounds, degreeToRadian, Point, PointService, abs, max, min, atan2, epsilon, Matrix, pi2, Logger, pi, isArray, isNumberClose, TextMeasure, EventEmitter, isBoolean, isObject, isFunction, isString, cos, sin, pointAt, isNumber, getDecimalPlaces, isNil, Color, OBBBounds, has, normalTransform, isValidUrl, isBase64, acos, sqrt, transformBoundsWithMatrix, arrayEqual, getContextFont, rotatePoint, clampAngleByRadian, asin, Bounds, getRectIntersect, isRectIntersect, isPlainObject, merge, clamp, clampRange, normalizePadding, debounce, throttle, hexToRgb, crossProduct, isValid, isEmpty, rectInsideAnotherRect, radianToDegree, getAngleByPoint, polarToCartesian, array, isValidNumber, calculateAnchorOfBounds, computeQuadrant, isGreater, isLess, normalizeAngle, flattenArray, cloneDeep, get, last, isRotateAABBIntersect, mixin, isEqual, interpolateString, minInArray, maxInArray, binaryFuzzySearchInNumberRange, polygonContainPoint } from '@visactor/vutils';
 import { isContinuous, isDiscrete, LinearScale } from '@visactor/vscale';
 
 class Generator {
@@ -2231,6 +2231,292 @@ const DefaultRichTextIconAttribute = Object.assign(Object.assign({}, DefaultImag
 class Application {}
 const application = new Application();
 
+const parse = function () {
+  const tokens = {
+    linearGradient: /^(linear\-gradient)/i,
+    radialGradient: /^(radial\-gradient)/i,
+    conicGradient: /^(conic\-gradient)/i,
+    sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
+    extentKeywords: /^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,
+    positionKeywords: /^(left|center|right|top|bottom)/i,
+    pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
+    percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,
+    emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
+    angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
+    fromAngleValue: /^from\s*(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
+    startCall: /^\(/,
+    endCall: /^\)/,
+    comma: /^,/,
+    hexColor: /(^\#[0-9a-fA-F]+)/,
+    literalColor: /^([a-zA-Z]+)/,
+    rgbColor: /^(rgb\(\d{1,3},\s*\d{1,3},\s*\d{1,3}\))/i,
+    rgbaColor: /^(rgba\(\d{1,3},\s*\d{1,3},\s*\d{1,3},\s*((\d\.\d+)|\d{1,3})\))/i,
+    number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/
+  };
+  let input = "";
+  function error(msg) {
+    const err = new Error(input + ": " + msg);
+    throw err.source = input, err;
+  }
+  function getAST() {
+    const ast = matchListing(matchDefinition);
+    return input.length > 0 && error("Invalid input not EOF"), ast;
+  }
+  function matchDefinition() {
+    return matchGradient("linear", tokens.linearGradient, matchLinearOrientation) || matchGradient("radial", tokens.radialGradient, matchListRadialOrientations) || matchGradient("conic", tokens.conicGradient, matchConicalOrientation);
+  }
+  function matchGradient(gradientType, pattern, orientationMatcher) {
+    return function (pattern, callback) {
+      const captures = scan(pattern);
+      if (captures) {
+        scan(tokens.startCall) || error("Missing (");
+        const result = callback(captures);
+        return scan(tokens.endCall) || error("Missing )"), result;
+      }
+    }(pattern, function (captures) {
+      const orientation = orientationMatcher();
+      return orientation && (scan(tokens.comma) || error("Missing comma before color stops")), {
+        type: gradientType,
+        orientation: orientation,
+        colorStops: matchListing(matchColorStop)
+      };
+    });
+  }
+  function matchLinearOrientation() {
+    return match("directional", tokens.sideOrCorner, 1) || match("angular", tokens.angleValue, 1);
+  }
+  function matchConicalOrientation() {
+    return match("angular", tokens.fromAngleValue, 1);
+  }
+  function matchListRadialOrientations() {
+    let radialOrientations,
+      lookaheadCache,
+      radialOrientation = matchRadialOrientation();
+    return radialOrientation && (radialOrientations = [], radialOrientations.push(radialOrientation), lookaheadCache = input, scan(tokens.comma) && (radialOrientation = matchRadialOrientation(), radialOrientation ? radialOrientations.push(radialOrientation) : input = lookaheadCache)), radialOrientations;
+  }
+  function matchRadialOrientation() {
+    let radialType = function () {
+      const circle = match("shape", /^(circle)/i, 0);
+      circle && (circle.style = matchLength() || matchExtentKeyword());
+      return circle;
+    }() || function () {
+      const ellipse = match("shape", /^(ellipse)/i, 0);
+      ellipse && (ellipse.style = matchDistance() || matchExtentKeyword());
+      return ellipse;
+    }();
+    if (radialType) radialType.at = matchAtPosition();else {
+      const extent = matchExtentKeyword();
+      if (extent) {
+        radialType = extent;
+        const positionAt = matchAtPosition();
+        positionAt && (radialType.at = positionAt);
+      } else {
+        const defaultPosition = matchPositioning();
+        defaultPosition && (radialType = {
+          type: "default-radial",
+          at: defaultPosition
+        });
+      }
+    }
+    return radialType;
+  }
+  function matchExtentKeyword() {
+    return match("extent-keyword", tokens.extentKeywords, 1);
+  }
+  function matchAtPosition() {
+    if (match("position", /^at/, 0)) {
+      const positioning = matchPositioning();
+      return positioning || error("Missing positioning value"), positioning;
+    }
+  }
+  function matchPositioning() {
+    const location = {
+      x: matchDistance(),
+      y: matchDistance()
+    };
+    if (location.x || location.y) return {
+      type: "position",
+      value: location
+    };
+  }
+  function matchListing(matcher) {
+    let captures = matcher();
+    const result = [];
+    if (captures) for (result.push(captures); scan(tokens.comma);) captures = matcher(), captures ? result.push(captures) : error("One extra comma");
+    return result;
+  }
+  function matchColorStop() {
+    const color = match("hex", tokens.hexColor, 1) || match("rgba", tokens.rgbaColor, 1) || match("rgb", tokens.rgbColor, 1) || match("literal", tokens.literalColor, 0);
+    return color || error("Expected color definition"), color.length = matchDistance(), color;
+  }
+  function matchDistance() {
+    return match("%", tokens.percentageValue, 1) || match("position-keyword", tokens.positionKeywords, 1) || matchLength();
+  }
+  function matchLength() {
+    return match("px", tokens.pixelValue, 1) || match("em", tokens.emValue, 1);
+  }
+  function match(type, pattern, captureIndex) {
+    const captures = scan(pattern);
+    if (captures) return {
+      type: type,
+      value: captures[captureIndex]
+    };
+  }
+  function scan(regexp) {
+    const blankCaptures = /^[\n\r\t\s]+/.exec(input);
+    blankCaptures && consume(blankCaptures[0].length);
+    const captures = regexp.exec(input);
+    return captures && consume(captures[0].length), captures;
+  }
+  function consume(size) {
+    input = input.substr(size);
+  }
+  return function (code) {
+    return input = code.toString(), getAST();
+  };
+}();
+class GradientParser {
+  static IsGradient(c) {
+    return !("string" == typeof c && !c.includes("gradient"));
+  }
+  static IsGradientStr(c) {
+    return "string" == typeof c && c.includes("gradient");
+  }
+  static Parse(c) {
+    if (GradientParser.IsGradientStr(c)) try {
+      const datum = parse(c)[0];
+      if (datum) {
+        if ("linear" === datum.type) return GradientParser.ParseLinear(datum);
+        if ("radial" === datum.type) return GradientParser.ParseRadial(datum);
+        if ("conic" === datum.type) return GradientParser.ParseConic(datum);
+      }
+    } catch (err) {
+      return c;
+    }
+    return c;
+  }
+  static ParseConic(datum) {
+    const {
+        orientation: orientation,
+        colorStops = []
+      } = datum,
+      halfPi = pi / 2,
+      sa = parseFloat(orientation.value) / 180 * pi - halfPi;
+    return {
+      gradient: "conical",
+      x: .5,
+      y: .5,
+      startAngle: sa,
+      endAngle: sa + pi2,
+      stops: colorStops.map(item => ({
+        color: item.value,
+        offset: parseFloat(item.length.value) / 100
+      }))
+    };
+  }
+  static ParseRadial(datum) {
+    const {
+      colorStops = []
+    } = datum;
+    return {
+      gradient: "radial",
+      x0: .5,
+      y0: .5,
+      x1: .5,
+      y1: .5,
+      r0: 0,
+      r1: 1,
+      stops: colorStops.map(item => ({
+        color: item.value,
+        offset: parseFloat(item.length.value) / 100
+      }))
+    };
+  }
+  static ParseLinear(datum) {
+    const {
+        orientation: orientation,
+        colorStops = []
+      } = datum,
+      halfPi = pi / 2;
+    let angle = "angular" === orientation.type ? parseFloat(orientation.value) / 180 * pi : 0;
+    for (; angle < 0;) angle += pi2;
+    for (; angle >= pi2;) angle -= pi2;
+    let x0 = 0,
+      y0 = 0,
+      x1 = 0,
+      y1 = 0;
+    return angle < halfPi ? (x0 = 0, y0 = 1, x1 = Math.sin(angle), y1 = y0 - Math.cos(angle)) : angle < pi ? (x0 = 0, y0 = 0, x1 = Math.cos(angle - halfPi), y1 = Math.sin(angle - halfPi)) : angle < pi + halfPi ? (x0 = 1, y0 = 0, x1 = x0 - Math.sin(angle - pi), y1 = Math.cos(angle - pi)) : (x0 = 1, x1 = x0 - Math.cos(angle - halfPi - pi), y1 -= Math.sin(angle - halfPi - pi)), {
+      gradient: "linear",
+      x0: x0,
+      y0: y0,
+      x1: x1,
+      y1: y1,
+      stops: colorStops.map(item => ({
+        color: item.value,
+        offset: parseFloat(item.length.value) / 100
+      }))
+    };
+  }
+}
+
+function getScaledStroke(context, width, dpr) {
+  let strokeWidth = width;
+  const {
+      a: a,
+      b: b,
+      c: c,
+      d: d
+    } = context.currentMatrix,
+    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 createColor(context, c, params) {
+  let offsetX = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  let offsetY = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  if (!c || !0 === c) return "black";
+  let result, color;
+  if (isArray(c)) for (let i = 0; i < c.length && (color = c[i], !color); i++);else color = c;
+  if (color = GradientParser.Parse(color), "string" == typeof color) return color;
+  if (params.AABBBounds && (!params.attribute || 0 !== params.attribute.scaleX || 0 !== params.attribute.scaleY)) {
+    const bounds = params.AABBBounds;
+    let w = bounds.x2 - bounds.x1,
+      h = bounds.y2 - bounds.y1,
+      x = bounds.x1 - offsetX,
+      y = bounds.y1 - offsetY;
+    if (params.attribute) {
+      const {
+        scaleX = 1,
+        scaleY = 1
+      } = params.attribute;
+      w /= scaleX, h /= scaleY, x /= scaleX, y /= scaleY;
+    }
+    "linear" === color.gradient ? result = createLinearGradient(context, color, x, y, w, h) : "conical" === color.gradient ? result = createConicGradient(context, color, x, y, w, h) : "radial" === color.gradient && (result = createRadialGradient(context, color, x, y, w, h));
+  }
+  return result || "orange";
+}
+function createLinearGradient(context, color, x, y, w, h) {
+  var _a, _b, _c, _d;
+  const canvasGradient = context.createLinearGradient(x + (null !== (_a = color.x0) && void 0 !== _a ? _a : 0) * w, y + (null !== (_b = color.y0) && void 0 !== _b ? _b : 0) * h, x + (null !== (_c = color.x1) && void 0 !== _c ? _c : 1) * w, y + (null !== (_d = color.y1) && void 0 !== _d ? _d : 0) * h);
+  return color.stops.forEach(stop => {
+    canvasGradient.addColorStop(stop.offset, stop.color);
+  }), canvasGradient;
+}
+function createRadialGradient(context, color, x, y, w, h) {
+  var _a, _b, _c, _d, _e, _f;
+  const canvasGradient = context.createRadialGradient(x + (null !== (_a = color.x0) && void 0 !== _a ? _a : .5) * w, y + (null !== (_b = color.y0) && void 0 !== _b ? _b : .5) * h, Math.max(w, h) * (null !== (_c = color.r0) && void 0 !== _c ? _c : 0), x + (null !== (_d = color.x1) && void 0 !== _d ? _d : .5) * w, y + (null !== (_e = color.y1) && void 0 !== _e ? _e : .5) * h, Math.max(w, h) * (null !== (_f = color.r1) && void 0 !== _f ? _f : .5));
+  return color.stops.forEach(stop => {
+    canvasGradient.addColorStop(stop.offset, stop.color);
+  }), canvasGradient;
+}
+function createConicGradient(context, color, x, y, w, h) {
+  var _a, _b;
+  const canvasGradient = context.createConicGradient(x + (null !== (_a = color.x) && void 0 !== _a ? _a : 0) * w, y + (null !== (_b = color.y) && void 0 !== _b ? _b : 0) * h, color.startAngle, color.endAngle);
+  return color.stops.forEach(stop => {
+    canvasGradient.addColorStop(stop.offset, stop.color);
+  }), canvasGradient.GetPattern(w + x, h + y, undefined);
+}
+
 const DIRECTION_KEY = {
   horizontal: {
     width: "width",
@@ -2282,14 +2568,16 @@ const setTextStyle = (ctx, character) => {
     fontFamily: character.fontFamily || "sans-serif"
   });
 };
-function applyFillStyle(ctx, character) {
+function applyFillStyle(ctx, character, b) {
   const fillStyle = character && character.fill || defaultFormatting.fill;
   if (!fillStyle) return void (ctx.globalAlpha = 0);
   const {
     fillOpacity = 1,
     opacity = 1
   } = character;
-  ctx.globalAlpha = fillOpacity * opacity, ctx.fillStyle = fillStyle, setTextStyle(ctx, character);
+  ctx.globalAlpha = fillOpacity * opacity, ctx.fillStyle = b ? createColor(ctx, fillStyle, {
+    AABBBounds: b
+  }) : fillStyle, setTextStyle(ctx, character);
 }
 function applyStrokeStyle(ctx, character) {
   const strokeStyle = character && character.stroke || defaultFormatting.stroke;
@@ -6455,350 +6743,64 @@ class BaseRender {
     } else context.transformFromMatrix(graphic.transMatrix, !0), result.x = 0, result.y = 0, result.z = 0;
     return result;
   }
-  transformUseContext2d(graphic, graphicAttribute, z, context) {
-    const camera = context.camera;
-    if (this.camera = camera, camera) {
-      const bounds = graphic.AABBBounds,
-        width = bounds.x2 - bounds.x1,
-        height = bounds.y2 - bounds.y1,
-        p1 = context.project(0, 0, z),
-        p2 = context.project(width, 0, z),
-        p3 = context.project(width, height, z),
-        _p1 = {
-          x: 0,
-          y: 0
-        },
-        _p2 = {
-          x: width,
-          y: 0
-        },
-        _p3 = {
-          x: width,
-          y: height
-        };
-      context.camera = null;
-      const denom = 1 / (_p1.x * (_p3.y - _p2.y) - _p2.x * _p3.y + _p3.x * _p2.y + (_p2.x - _p3.x) * _p1.y),
-        m11 = -(_p1.y * (p3.x - p2.x) - _p2.y * p3.x + _p3.y * p2.x + (_p2.y - _p3.y) * p1.x) * denom,
-        m12 = (_p2.y * p3.y + _p1.y * (p2.y - p3.y) - _p3.y * p2.y + (_p3.y - _p2.y) * p1.y) * denom,
-        m21 = (_p1.x * (p3.x - p2.x) - _p2.x * p3.x + _p3.x * p2.x + (_p2.x - _p3.x) * p1.x) * denom,
-        m22 = -(_p2.x * p3.y + _p1.x * (p2.y - p3.y) - _p3.x * p2.y + (_p3.x - _p2.x) * p1.y) * denom,
-        dx = (_p1.x * (_p3.y * p2.x - _p2.y * p3.x) + _p1.y * (_p2.x * p3.x - _p3.x * p2.x) + (_p3.x * _p2.y - _p2.x * _p3.y) * p1.x) * denom,
-        dy = (_p1.x * (_p3.y * p2.y - _p2.y * p3.y) + _p1.y * (_p2.x * p3.y - _p3.x * p2.y) + (_p3.x * _p2.y - _p2.x * _p3.y) * p1.y) * denom;
-      context.setTransform(m11, m12, m21, m22, dx, dy, !0);
-    }
-  }
-  restoreTransformUseContext2d(graphic, graphicAttribute, z, context) {
-    this.camera && (context.camera = this.camera);
-  }
-  transformWithoutTranslate(context, x, y, z, scaleX, scaleY, angle) {
-    const p = context.project(x, y, z);
-    context.translate(p.x, p.y, !1), context.scale(scaleX, scaleY, !1), context.rotate(angle, !1), context.translate(-p.x, -p.y, !1), context.setTransformForCurrent();
-  }
-  _draw(graphic, defaultAttr, computed3dMatrix, drawContext, params) {
-    const {
-      context: context
-    } = drawContext;
-    if (!context) return;
-    const {
-      renderable: renderable
-    } = graphic.attribute;
-    if (!1 === renderable) return;
-    context.highPerformanceSave();
-    const data = this.transform(graphic, defaultAttr, context, computed3dMatrix),
-      {
-        x: x,
-        y: y,
-        z: z,
-        lastModelMatrix: lastModelMatrix
-      } = data;
-    this.z = z, drawPathProxy(graphic, context, x, y, drawContext, params) || (this.drawShape(graphic, context, x, y, drawContext, params), this.z = 0, context.modelMatrix !== lastModelMatrix && mat4Allocate.free(context.modelMatrix), context.modelMatrix = lastModelMatrix), context.highPerformanceRestore();
-  }
-}
-
-const parse = function () {
-  const tokens = {
-    linearGradient: /^(linear\-gradient)/i,
-    radialGradient: /^(radial\-gradient)/i,
-    conicGradient: /^(conic\-gradient)/i,
-    sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
-    extentKeywords: /^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,
-    positionKeywords: /^(left|center|right|top|bottom)/i,
-    pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
-    percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,
-    emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
-    angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
-    fromAngleValue: /^from\s*(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
-    startCall: /^\(/,
-    endCall: /^\)/,
-    comma: /^,/,
-    hexColor: /(^\#[0-9a-fA-F]+)/,
-    literalColor: /^([a-zA-Z]+)/,
-    rgbColor: /^(rgb\(\d{1,3},\s*\d{1,3},\s*\d{1,3}\))/i,
-    rgbaColor: /^(rgba\(\d{1,3},\s*\d{1,3},\s*\d{1,3},\s*((\d\.\d+)|\d{1,3})\))/i,
-    number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/
-  };
-  let input = "";
-  function error(msg) {
-    const err = new Error(input + ": " + msg);
-    throw err.source = input, err;
-  }
-  function getAST() {
-    const ast = matchListing(matchDefinition);
-    return input.length > 0 && error("Invalid input not EOF"), ast;
-  }
-  function matchDefinition() {
-    return matchGradient("linear", tokens.linearGradient, matchLinearOrientation) || matchGradient("radial", tokens.radialGradient, matchListRadialOrientations) || matchGradient("conic", tokens.conicGradient, matchConicalOrientation);
-  }
-  function matchGradient(gradientType, pattern, orientationMatcher) {
-    return function (pattern, callback) {
-      const captures = scan(pattern);
-      if (captures) {
-        scan(tokens.startCall) || error("Missing (");
-        const result = callback(captures);
-        return scan(tokens.endCall) || error("Missing )"), result;
-      }
-    }(pattern, function (captures) {
-      const orientation = orientationMatcher();
-      return orientation && (scan(tokens.comma) || error("Missing comma before color stops")), {
-        type: gradientType,
-        orientation: orientation,
-        colorStops: matchListing(matchColorStop)
-      };
-    });
-  }
-  function matchLinearOrientation() {
-    return match("directional", tokens.sideOrCorner, 1) || match("angular", tokens.angleValue, 1);
-  }
-  function matchConicalOrientation() {
-    return match("angular", tokens.fromAngleValue, 1);
-  }
-  function matchListRadialOrientations() {
-    let radialOrientations,
-      lookaheadCache,
-      radialOrientation = matchRadialOrientation();
-    return radialOrientation && (radialOrientations = [], radialOrientations.push(radialOrientation), lookaheadCache = input, scan(tokens.comma) && (radialOrientation = matchRadialOrientation(), radialOrientation ? radialOrientations.push(radialOrientation) : input = lookaheadCache)), radialOrientations;
-  }
-  function matchRadialOrientation() {
-    let radialType = function () {
-      const circle = match("shape", /^(circle)/i, 0);
-      circle && (circle.style = matchLength() || matchExtentKeyword());
-      return circle;
-    }() || function () {
-      const ellipse = match("shape", /^(ellipse)/i, 0);
-      ellipse && (ellipse.style = matchDistance() || matchExtentKeyword());
-      return ellipse;
-    }();
-    if (radialType) radialType.at = matchAtPosition();else {
-      const extent = matchExtentKeyword();
-      if (extent) {
-        radialType = extent;
-        const positionAt = matchAtPosition();
-        positionAt && (radialType.at = positionAt);
-      } else {
-        const defaultPosition = matchPositioning();
-        defaultPosition && (radialType = {
-          type: "default-radial",
-          at: defaultPosition
-        });
-      }
-    }
-    return radialType;
-  }
-  function matchExtentKeyword() {
-    return match("extent-keyword", tokens.extentKeywords, 1);
-  }
-  function matchAtPosition() {
-    if (match("position", /^at/, 0)) {
-      const positioning = matchPositioning();
-      return positioning || error("Missing positioning value"), positioning;
-    }
-  }
-  function matchPositioning() {
-    const location = {
-      x: matchDistance(),
-      y: matchDistance()
-    };
-    if (location.x || location.y) return {
-      type: "position",
-      value: location
-    };
-  }
-  function matchListing(matcher) {
-    let captures = matcher();
-    const result = [];
-    if (captures) for (result.push(captures); scan(tokens.comma);) captures = matcher(), captures ? result.push(captures) : error("One extra comma");
-    return result;
-  }
-  function matchColorStop() {
-    const color = match("hex", tokens.hexColor, 1) || match("rgba", tokens.rgbaColor, 1) || match("rgb", tokens.rgbColor, 1) || match("literal", tokens.literalColor, 0);
-    return color || error("Expected color definition"), color.length = matchDistance(), color;
-  }
-  function matchDistance() {
-    return match("%", tokens.percentageValue, 1) || match("position-keyword", tokens.positionKeywords, 1) || matchLength();
-  }
-  function matchLength() {
-    return match("px", tokens.pixelValue, 1) || match("em", tokens.emValue, 1);
-  }
-  function match(type, pattern, captureIndex) {
-    const captures = scan(pattern);
-    if (captures) return {
-      type: type,
-      value: captures[captureIndex]
-    };
-  }
-  function scan(regexp) {
-    const blankCaptures = /^[\n\r\t\s]+/.exec(input);
-    blankCaptures && consume(blankCaptures[0].length);
-    const captures = regexp.exec(input);
-    return captures && consume(captures[0].length), captures;
-  }
-  function consume(size) {
-    input = input.substr(size);
-  }
-  return function (code) {
-    return input = code.toString(), getAST();
-  };
-}();
-class GradientParser {
-  static IsGradient(c) {
-    return !("string" == typeof c && !c.includes("gradient"));
-  }
-  static IsGradientStr(c) {
-    return "string" == typeof c && c.includes("gradient");
-  }
-  static Parse(c) {
-    if (GradientParser.IsGradientStr(c)) try {
-      const datum = parse(c)[0];
-      if (datum) {
-        if ("linear" === datum.type) return GradientParser.ParseLinear(datum);
-        if ("radial" === datum.type) return GradientParser.ParseRadial(datum);
-        if ("conic" === datum.type) return GradientParser.ParseConic(datum);
-      }
-    } catch (err) {
-      return c;
+  transformUseContext2d(graphic, graphicAttribute, z, context) {
+    const camera = context.camera;
+    if (this.camera = camera, camera) {
+      const bounds = graphic.AABBBounds,
+        width = bounds.x2 - bounds.x1,
+        height = bounds.y2 - bounds.y1,
+        p1 = context.project(0, 0, z),
+        p2 = context.project(width, 0, z),
+        p3 = context.project(width, height, z),
+        _p1 = {
+          x: 0,
+          y: 0
+        },
+        _p2 = {
+          x: width,
+          y: 0
+        },
+        _p3 = {
+          x: width,
+          y: height
+        };
+      context.camera = null;
+      const denom = 1 / (_p1.x * (_p3.y - _p2.y) - _p2.x * _p3.y + _p3.x * _p2.y + (_p2.x - _p3.x) * _p1.y),
+        m11 = -(_p1.y * (p3.x - p2.x) - _p2.y * p3.x + _p3.y * p2.x + (_p2.y - _p3.y) * p1.x) * denom,
+        m12 = (_p2.y * p3.y + _p1.y * (p2.y - p3.y) - _p3.y * p2.y + (_p3.y - _p2.y) * p1.y) * denom,
+        m21 = (_p1.x * (p3.x - p2.x) - _p2.x * p3.x + _p3.x * p2.x + (_p2.x - _p3.x) * p1.x) * denom,
+        m22 = -(_p2.x * p3.y + _p1.x * (p2.y - p3.y) - _p3.x * p2.y + (_p3.x - _p2.x) * p1.y) * denom,
+        dx = (_p1.x * (_p3.y * p2.x - _p2.y * p3.x) + _p1.y * (_p2.x * p3.x - _p3.x * p2.x) + (_p3.x * _p2.y - _p2.x * _p3.y) * p1.x) * denom,
+        dy = (_p1.x * (_p3.y * p2.y - _p2.y * p3.y) + _p1.y * (_p2.x * p3.y - _p3.x * p2.y) + (_p3.x * _p2.y - _p2.x * _p3.y) * p1.y) * denom;
+      context.setTransform(m11, m12, m21, m22, dx, dy, !0);
     }
-    return c;
   }
-  static ParseConic(datum) {
-    const {
-        orientation: orientation,
-        colorStops = []
-      } = datum,
-      halfPi = pi / 2,
-      sa = parseFloat(orientation.value) / 180 * pi - halfPi;
-    return {
-      gradient: "conical",
-      x: .5,
-      y: .5,
-      startAngle: sa,
-      endAngle: sa + pi2,
-      stops: colorStops.map(item => ({
-        color: item.value,
-        offset: parseFloat(item.length.value) / 100
-      }))
-    };
+  restoreTransformUseContext2d(graphic, graphicAttribute, z, context) {
+    this.camera && (context.camera = this.camera);
   }
-  static ParseRadial(datum) {
-    const {
-      colorStops = []
-    } = datum;
-    return {
-      gradient: "radial",
-      x0: .5,
-      y0: .5,
-      x1: .5,
-      y1: .5,
-      r0: 0,
-      r1: 1,
-      stops: colorStops.map(item => ({
-        color: item.value,
-        offset: parseFloat(item.length.value) / 100
-      }))
-    };
+  transformWithoutTranslate(context, x, y, z, scaleX, scaleY, angle) {
+    const p = context.project(x, y, z);
+    context.translate(p.x, p.y, !1), context.scale(scaleX, scaleY, !1), context.rotate(angle, !1), context.translate(-p.x, -p.y, !1), context.setTransformForCurrent();
   }
-  static ParseLinear(datum) {
+  _draw(graphic, defaultAttr, computed3dMatrix, drawContext, params) {
     const {
-        orientation: orientation,
-        colorStops = []
-      } = datum,
-      halfPi = pi / 2;
-    let angle = "angular" === orientation.type ? parseFloat(orientation.value) / 180 * pi : 0;
-    for (; angle < 0;) angle += pi2;
-    for (; angle > pi2;) angle -= pi2;
-    let x0 = 0,
-      y0 = 0,
-      x1 = 0,
-      y1 = 0;
-    return angle < halfPi ? (x0 = 0, y0 = 1, x1 = Math.sin(angle), y1 = Math.cos(angle)) : angle < pi ? (x0 = 0, y0 = 0, x1 = Math.cos(angle - halfPi), y1 = Math.sin(angle - halfPi)) : angle < pi + halfPi ? (x0 = 1, y0 = 0, x1 = x0 - Math.sin(angle - pi), y1 = Math.cos(angle - pi)) : (x0 = 1, x1 = x0 - Math.cos(angle - halfPi - pi), y1 -= Math.sin(angle - halfPi - pi)), {
-      gradient: "linear",
-      x0: x0,
-      y0: y0,
-      x1: x1,
-      y1: y1,
-      stops: colorStops.map(item => ({
-        color: item.value,
-        offset: parseFloat(item.length.value) / 100
-      }))
-    };
-  }
-}
-
-function getScaledStroke(context, width, dpr) {
-  let strokeWidth = width;
-  const {
-      a: a,
-      b: b,
-      c: c,
-      d: d
-    } = context.currentMatrix,
-    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 createColor(context, c, params) {
-  let offsetX = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-  let offsetY = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
-  if (!c || !0 === c) return "black";
-  let result, color;
-  if (isArray(c)) for (let i = 0; i < c.length && (color = c[i], !color); i++);else color = c;
-  if (color = GradientParser.Parse(color), "string" == typeof color) return color;
-  if (params.AABBBounds && (!params.attribute || 0 !== params.attribute.scaleX || 0 !== params.attribute.scaleY)) {
-    const bounds = params.AABBBounds;
-    let w = bounds.x2 - bounds.x1,
-      h = bounds.y2 - bounds.y1,
-      x = bounds.x1 - offsetX,
-      y = bounds.y1 - offsetY;
-    if (params.attribute) {
-      const {
-        scaleX = 1,
-        scaleY = 1
-      } = params.attribute;
-      w /= scaleX, h /= scaleY, x /= scaleX, y /= scaleY;
-    }
-    "linear" === color.gradient ? result = createLinearGradient(context, color, x, y, w, h) : "conical" === color.gradient ? result = createConicGradient(context, color, x, y, w, h) : "radial" === color.gradient && (result = createRadialGradient(context, color, x, y, w, h));
+      context: context
+    } = drawContext;
+    if (!context) return;
+    const {
+      renderable: renderable
+    } = graphic.attribute;
+    if (!1 === renderable) return;
+    context.highPerformanceSave();
+    const data = this.transform(graphic, defaultAttr, context, computed3dMatrix),
+      {
+        x: x,
+        y: y,
+        z: z,
+        lastModelMatrix: lastModelMatrix
+      } = data;
+    this.z = z, drawPathProxy(graphic, context, x, y, drawContext, params) || (this.drawShape(graphic, context, x, y, drawContext, params), this.z = 0, context.modelMatrix !== lastModelMatrix && mat4Allocate.free(context.modelMatrix), context.modelMatrix = lastModelMatrix), context.highPerformanceRestore();
   }
-  return result || "orange";
-}
-function createLinearGradient(context, color, x, y, w, h) {
-  var _a, _b, _c, _d;
-  const canvasGradient = context.createLinearGradient(x + (null !== (_a = color.x0) && void 0 !== _a ? _a : 0) * w, y + (null !== (_b = color.y0) && void 0 !== _b ? _b : 0) * h, x + (null !== (_c = color.x1) && void 0 !== _c ? _c : 1) * w, y + (null !== (_d = color.y1) && void 0 !== _d ? _d : 0) * h);
-  return color.stops.forEach(stop => {
-    canvasGradient.addColorStop(stop.offset, stop.color);
-  }), canvasGradient;
-}
-function createRadialGradient(context, color, x, y, w, h) {
-  var _a, _b, _c, _d, _e, _f;
-  const canvasGradient = context.createRadialGradient(x + (null !== (_a = color.x0) && void 0 !== _a ? _a : .5) * w, y + (null !== (_b = color.y0) && void 0 !== _b ? _b : .5) * h, Math.max(w, h) * (null !== (_c = color.r0) && void 0 !== _c ? _c : 0), x + (null !== (_d = color.x1) && void 0 !== _d ? _d : .5) * w, y + (null !== (_e = color.y1) && void 0 !== _e ? _e : .5) * h, Math.max(w, h) * (null !== (_f = color.r1) && void 0 !== _f ? _f : .5));
-  return color.stops.forEach(stop => {
-    canvasGradient.addColorStop(stop.offset, stop.color);
-  }), canvasGradient;
-}
-function createConicGradient(context, color, x, y, w, h) {
-  var _a, _b;
-  const canvasGradient = context.createConicGradient(x + (null !== (_a = color.x) && void 0 !== _a ? _a : 0) * w, y + (null !== (_b = color.y) && void 0 !== _b ? _b : 0) * h, color.startAngle, color.endAngle);
-  return color.stops.forEach(stop => {
-    canvasGradient.addColorStop(stop.offset, stop.color);
-  }), canvasGradient.GetPattern(w + x, h + y, undefined);
 }
 
 var __decorate$I = undefined && undefined.__decorate || function (decorators, target, key, desc) {
@@ -7679,7 +7681,7 @@ function drawEachCurve(path, curve, lastCurve, defined0, offsetX, offsetY, offse
       originP2: originP2
     } = curve;
     let validP;
-    if (originP1 && !1 !== originP1.defined ? validP = p0 : originP1 && !1 !== originP2.defined && (validP = null !== (_a = curve.p3) && void 0 !== _a ? _a : curve.p1), defined0) {
+    if (originP1 && !1 !== originP1.defined && !lastCurve ? validP = p0 : originP1 && !1 !== originP2.defined && (validP = null !== (_a = curve.p3) && void 0 !== _a ? _a : curve.p1), defined0) {
       newDefined0 = !defined0;
       const x = validP ? validP.x : curve.p0.x,
         y = validP ? validP.y : curve.p0.y;
@@ -9197,7 +9199,10 @@ class ShadowRootDrawItemInterceptorContribution {
     const {
       context: context
     } = drawContext;
-    if (context.highPerformanceSave(), context.transformFromMatrix(graphic.transMatrix, !0), drawContribution.dirtyBounds && drawContribution.backupDirtyBounds) {
+    context.highPerformanceSave();
+    const t1 = graphic.parent.globalTransMatrix,
+      t2 = graphic.stage.window.getViewBoxTransform().clone().multiply(t1.a, t1.b, t1.c, t1.d, t1.e, t1.f);
+    if (graphic.parent && context.setTransformFromMatrix(t2, !0), drawContribution.dirtyBounds && drawContribution.backupDirtyBounds) {
       tempDirtyBounds.copy(drawContribution.dirtyBounds), tempBackupDirtyBounds.copy(drawContribution.backupDirtyBounds);
       const m = graphic.globalTransMatrix.getInverse();
       drawContribution.dirtyBounds.copy(drawContribution.backupDirtyBounds).transformWithMatrix(m), drawContribution.backupDirtyBounds.copy(drawContribution.dirtyBounds);
@@ -10217,6 +10222,9 @@ class BaseSymbol {
       bounds.x1 = -halfS, bounds.x2 = halfS, bounds.y1 = -halfS, bounds.y2 = halfS;
     } else bounds.x1 = -size[0] / 2, bounds.x2 = size[0] / 2, bounds.y1 = -size[1] / 2, bounds.y2 = size[1] / 2;
   }
+  parseSize(size) {
+    return isNumber(size) ? size : Math.min(size[0], size[1]);
+  }
 }
 
 function circle(ctx, r, x, y, z) {
@@ -10227,13 +10235,13 @@ class CircleSymbol extends BaseSymbol {
     super(...arguments), this.type = "circle", this.pathStr = "M0.5,0A0.5,0.5,0,1,1,-0.5,0A0.5,0.5,0,1,1,0.5,0";
   }
   draw(ctx, size, x, y, z) {
-    return circle(ctx, size / 2, x, y, z);
+    return circle(ctx, this.parseSize(size) / 2, x, y, z);
   }
   drawOffset(ctx, size, x, y, offset, z) {
-    return circle(ctx, size / 2 + offset, x, y, z);
+    return circle(ctx, this.parseSize(size) / 2 + offset, x, y, z);
   }
   drawToSvgPath(size, x, y, z) {
-    const r = size / 2;
+    const r = this.parseSize(size) / 2;
     return `M ${x - r}, ${y} a ${r},${r} 0 1,0 ${2 * r},0 a ${r},${r} 0 1,0 -${2 * r},0`;
   }
 }
@@ -10250,10 +10258,10 @@ class CrossSymbol extends BaseSymbol {
     super(...arguments), this.type = "cross", this.pathStr = "M-0.5,-0.2L-0.5,0.2L-0.2,0.2L-0.2,0.5L0.2,0.5L0.2,0.2L0.5,0.2L0.5,-0.2L0.2,-0.2L0.2,-0.5L-0.2,-0.5L-0.2,-0.2Z";
   }
   draw(ctx, size, x, y, z) {
-    return cross(ctx, size / 6, x, y, z);
+    return cross(ctx, this.parseSize(size) / 6, x, y, z);
   }
   drawOffset(ctx, size, x, y, offset, z) {
-    return crossOffset(ctx, size / 6, x, y, offset, z);
+    return crossOffset(ctx, this.parseSize(size) / 6, x, y, offset, z);
   }
 }
 var cross$1 = new CrossSymbol();
@@ -10266,13 +10274,13 @@ class DiamondSymbol extends BaseSymbol {
     super(...arguments), this.type = "diamond", this.pathStr = "M-0.5,0L0,-0.5L0.5,0L0,0.5Z";
   }
   draw(ctx, size, x, y, z) {
-    return diamond(ctx, size / 2, x, y, z);
+    return diamond(ctx, this.parseSize(size) / 2, x, y, z);
   }
   drawFitDir(ctx, size, x, y, z) {
-    return diamond(ctx, size / 2, x, y, z);
+    return diamond(ctx, this.parseSize(size) / 2, x, y, z);
   }
   drawOffset(ctx, size, x, y, offset, z) {
-    return diamond(ctx, size / 2 + offset, x, y, z);
+    return diamond(ctx, this.parseSize(size) / 2 + offset, x, y, z);
   }
 }
 var diamond$1 = new DiamondSymbol();
@@ -10286,10 +10294,10 @@ class SquareSymbol extends BaseSymbol {
     super(...arguments), this.type = "square", this.pathStr = "M-0.5,-0.5h1v1h-1Z";
   }
   draw(ctx, size, x, y) {
-    return square(ctx, size / 2, x, y);
+    return square(ctx, this.parseSize(size) / 2, x, y);
   }
   drawOffset(ctx, size, x, y, offset) {
-    return square(ctx, size / 2 + offset, x, y);
+    return square(ctx, this.parseSize(size) / 2 + offset, x, y);
   }
 }
 var square$1 = new SquareSymbol();
@@ -10303,10 +10311,10 @@ class TriangleUpSymbol extends BaseSymbol {
     super(...arguments), this.type = "triangleUp", this.pathStr = "M0.5,0.5 L-0.5,0.5 L0,-0.5 Z";
   }
   draw(ctx, size, x, y) {
-    return trianglUpOffset(ctx, size / 2, x, y);
+    return trianglUpOffset(ctx, this.parseSize(size) / 2, x, y);
   }
   drawOffset(ctx, size, x, y, offset) {
-    return trianglUpOffset(ctx, size / 2, x, y, offset);
+    return trianglUpOffset(ctx, this.parseSize(size) / 2, x, y, offset);
   }
 }
 var triangleUp = new TriangleUpSymbol();
@@ -10338,10 +10346,10 @@ class StarSymbol extends BaseSymbol {
     super(...arguments), this.type = "star", this.pathStr = "M0 -1L0.22451398828979266 -0.3090169943749474L0.9510565162951535 -0.30901699437494745L0.3632712640026804 0.1180339887498948L0.5877852522924732 0.8090169943749473L8.326672684688674e-17 0.3819660112501051L-0.587785252292473 0.8090169943749476L-0.3632712640026804 0.11803398874989487L-0.9510565162951536 -0.30901699437494723L-0.22451398828979274 -0.30901699437494734Z";
   }
   draw(ctx, size, transX, transY) {
-    return star(ctx, size / 2, transX, transY);
+    return star(ctx, this.parseSize(size) / 2, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return star(ctx, size / 2 + offset, transX, transY);
+    return star(ctx, this.parseSize(size) / 2 + offset, transX, transY);
   }
 }
 var star$1 = new StarSymbol();
@@ -10359,10 +10367,10 @@ class ArrowSymbol extends BaseSymbol {
     super(...arguments), this.type = "arrow", this.pathStr = "M-0.07142857142857142,0.5L0.07142857142857142,0.5L0.07142857142857142,-0.0625L0.2,-0.0625L0,-0.5L-0.2,-0.0625L-0.07142857142857142,-0.0625Z";
   }
   draw(ctx, size, transX, transY) {
-    return arrow(ctx, size / 2, transX, transY);
+    return arrow(ctx, this.parseSize(size) / 2, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return arrow(ctx, size / 2 + offset, transX, transY);
+    return arrow(ctx, this.parseSize(size) / 2 + offset, transX, transY);
   }
 }
 var arrow$1 = new ArrowSymbol();
@@ -10376,10 +10384,10 @@ class WedgeSymbol extends BaseSymbol {
     super(...arguments), this.type = "wedge", this.pathStr = "M0,-0.5773502691896257L-0.125,0.28867513459481287L0.125,0.28867513459481287Z";
   }
   draw(ctx, size, transX, transY) {
-    return wedge(ctx, size / 2, transX, transY);
+    return wedge(ctx, this.parseSize(size) / 2, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return wedge(ctx, size / 2 + offset, transX, transY);
+    return wedge(ctx, this.parseSize(size) / 2 + offset, transX, transY);
   }
 }
 var wedge$1 = new WedgeSymbol();
@@ -10392,10 +10400,10 @@ class StrokeSymbol extends BaseSymbol {
     super(...arguments), this.type = "stroke", this.pathStr = "";
   }
   draw(ctx, size, transX, transY) {
-    return stroke(ctx, size / 2, transX, transY);
+    return stroke(ctx, this.parseSize(size) / 2, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return stroke(ctx, size / 2 + offset, transX, transY);
+    return stroke(ctx, this.parseSize(size) / 2 + offset, transX, transY);
   }
 }
 var stroke$1 = new StrokeSymbol();
@@ -10417,10 +10425,10 @@ class WyeSymbol extends BaseSymbol {
     super(...arguments), this.type = "wye", this.pathStr = "M0.25 0.14433756729740646L0.25 0.6443375672974064L-0.25 0.6443375672974064L-0.25 0.14433756729740643L-0.6830127018922193 -0.10566243270259357L-0.4330127018922193 -0.5386751345948129L0 -0.28867513459481287L0.4330127018922193 -0.5386751345948129L0.6830127018922193 -0.10566243270259357Z";
   }
   draw(ctx, size, transX, transY) {
-    return wye(ctx, size / 2, transX, transY);
+    return wye(ctx, this.parseSize(size) / 2, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return wye(ctx, size / 2 + offset, transX, transY);
+    return wye(ctx, this.parseSize(size) / 2 + offset, transX, transY);
   }
 }
 var wye$1 = new WyeSymbol();
@@ -10433,10 +10441,10 @@ class TriangleLeftSymbol extends BaseSymbol {
     super(...arguments), this.type = "triangleLeft", this.pathStr = "M-0.5,0 L0.5,0.5 L0.5,-0.5 Z";
   }
   draw(ctx, size, x, y) {
-    return trianglLeftOffset(ctx, size / 2, x, y, 0);
+    return trianglLeftOffset(ctx, this.parseSize(size) / 2, x, y, 0);
   }
   drawOffset(ctx, size, x, y, offset) {
-    return trianglLeftOffset(ctx, size / 2, x, y, offset);
+    return trianglLeftOffset(ctx, this.parseSize(size) / 2, x, y, offset);
   }
 }
 var triangleLeft = new TriangleLeftSymbol();
@@ -10450,10 +10458,10 @@ class TriangleRightSymbol extends BaseSymbol {
     super(...arguments), this.type = "triangleRight", this.pathStr = "M-0.5,0.5 L0.5,0 L-0.5,-0.5 Z";
   }
   draw(ctx, size, x, y) {
-    return trianglRightOffset(ctx, size / 2, x, y);
+    return trianglRightOffset(ctx, this.parseSize(size) / 2, x, y);
   }
   drawOffset(ctx, size, x, y, offset) {
-    return trianglRightOffset(ctx, size / 2, x, y, offset);
+    return trianglRightOffset(ctx, this.parseSize(size) / 2, x, y, offset);
   }
 }
 var triangleRight = new TriangleRightSymbol();
@@ -10467,10 +10475,10 @@ class TriangleDownSymbol extends BaseSymbol {
     super(...arguments), this.type = "triangleDown", this.pathStr = "M-0.5,-0.5 L0.5,-0.5 L0,0.5 Z";
   }
   draw(ctx, size, x, y) {
-    return trianglDownOffset(ctx, size / 2, x, y);
+    return trianglDownOffset(ctx, this.parseSize(size) / 2, x, y);
   }
   drawOffset(ctx, size, x, y, offset) {
-    return trianglDownOffset(ctx, size / 2, x, y, offset);
+    return trianglDownOffset(ctx, this.parseSize(size) / 2, x, y, offset);
   }
 }
 var triangleDown = new TriangleDownSymbol();
@@ -10485,10 +10493,10 @@ class ThinTriangleSymbol extends BaseSymbol {
     super(...arguments), this.type = "thinTriangle", this.pathStr = "M0,-0.5773502691896257L-0.5,0.28867513459481287L0.5,0.28867513459481287Z";
   }
   draw(ctx, size, x, y) {
-    return thinTriangle(ctx, size / 2 / sqrt3, x, y);
+    return thinTriangle(ctx, this.parseSize(size) / 2 / sqrt3, x, y);
   }
   drawOffset(ctx, size, x, y, offset) {
-    return thinTriangle(ctx, size / 2 / sqrt3 + offset, x, y);
+    return thinTriangle(ctx, this.parseSize(size) / 2 / sqrt3 + offset, x, y);
   }
 }
 var thinTriangle$1 = new ThinTriangleSymbol();
@@ -10502,10 +10510,10 @@ class Arrow2LeftSymbol extends BaseSymbol {
     super(...arguments), this.type = "arrow2Left", this.pathStr = "M 0.25 -0.5 L -0.25 0 l 0.25 0.5";
   }
   draw(ctx, size, transX, transY) {
-    return arrow2Left(ctx, size / 4, transX, transY);
+    return arrow2Left(ctx, this.parseSize(size) / 4, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return arrow2Left(ctx, size / 4 + offset, transX, transY);
+    return arrow2Left(ctx, this.parseSize(size) / 4 + offset, transX, transY);
   }
 }
 var arrow2Left$1 = new Arrow2LeftSymbol();
@@ -10519,10 +10527,10 @@ class Arrow2RightSymbol extends BaseSymbol {
     super(...arguments), this.type = "arrow2Right", this.pathStr = "M -0.25 -0.5 l 0.25 0 l -0.25 0.5";
   }
   draw(ctx, size, transX, transY) {
-    return arrow2Right(ctx, size / 4, transX, transY);
+    return arrow2Right(ctx, this.parseSize(size) / 4, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return arrow2Right(ctx, size / 4 + offset, transX, transY);
+    return arrow2Right(ctx, this.parseSize(size) / 4 + offset, transX, transY);
   }
 }
 var arrow2Right$1 = new Arrow2RightSymbol();
@@ -10536,10 +10544,10 @@ class Arrow2UpSymbol extends BaseSymbol {
     super(...arguments), this.type = "arrow2Up", this.pathStr = "M -0.5 0.25 L 0 -0.25 l 0.5 0.25";
   }
   draw(ctx, size, transX, transY) {
-    return arrow2Up(ctx, size / 4, transX, transY);
+    return arrow2Up(ctx, this.parseSize(size) / 4, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return arrow2Up(ctx, size / 4 + offset, transX, transY);
+    return arrow2Up(ctx, this.parseSize(size) / 4 + offset, transX, transY);
   }
 }
 var arrow2Up$1 = new Arrow2UpSymbol();
@@ -10553,10 +10561,10 @@ class Arrow2DownSymbol extends BaseSymbol {
     super(...arguments), this.type = "arrow2Down", this.pathStr = "M -0.5 -0.25 L 0 0.25 l 0.5 -0.25";
   }
   draw(ctx, size, transX, transY) {
-    return arrow2Down(ctx, size / 4, transX, transY);
+    return arrow2Down(ctx, this.parseSize(size) / 4, transX, transY);
   }
   drawOffset(ctx, size, transX, transY, offset) {
-    return arrow2Down(ctx, size / 4 + offset, transX, transY);
+    return arrow2Down(ctx, this.parseSize(size) / 4 + offset, transX, transY);
   }
 }
 var arrow2Down$1 = new Arrow2DownSymbol();
@@ -10569,13 +10577,13 @@ class LineVSymbol extends BaseSymbol {
     super(...arguments), this.type = "lineV", this.pathStr = "M0,-0.5L0,0.5";
   }
   draw(ctx, size, x, y, z) {
-    return lineV(ctx, size / 2, x, y);
+    return lineV(ctx, this.parseSize(size) / 2, x, y);
   }
   drawOffset(ctx, size, x, y, offset, z) {
-    return lineV(ctx, size / 2 + offset, x, y);
+    return lineV(ctx, this.parseSize(size) / 2 + offset, x, y);
   }
   drawToSvgPath(size, x, y, z) {
-    const r = size / 2;
+    const r = this.parseSize(size) / 2;
     return `M ${x}, ${y - r} L ${x},${y + r}`;
   }
 }
@@ -10589,13 +10597,13 @@ class LineHSymbol extends BaseSymbol {
     super(...arguments), this.type = "lineH", this.pathStr = "M-0.5,0L0.5,0";
   }
   draw(ctx, size, x, y, z) {
-    return lineH(ctx, size / 2, x, y);
+    return lineH(ctx, this.parseSize(size) / 2, x, y);
   }
   drawOffset(ctx, size, x, y, offset, z) {
-    return lineH(ctx, size / 2 + offset, x, y);
+    return lineH(ctx, this.parseSize(size) / 2 + offset, x, y);
   }
   drawToSvgPath(size, x, y, z) {
-    const r = size / 2;
+    const r = this.parseSize(size) / 2;
     return `M ${x - r}, ${y} L ${x + r},${y}`;
   }
 }
@@ -10609,13 +10617,13 @@ class CloseSymbol extends BaseSymbol {
     super(...arguments), this.type = "close", this.pathStr = "M-0.5,-0.5L0.5,0.5,M0.5,-0.5L-0.5,0.5";
   }
   draw(ctx, size, x, y, z) {
-    return close(ctx, size / 2, x, y);
+    return close(ctx, this.parseSize(size) / 2, x, y);
   }
   drawOffset(ctx, size, x, y, offset, z) {
-    return close(ctx, size / 2 + offset, x, y);
+    return close(ctx, this.parseSize(size) / 2 + offset, x, y);
   }
   drawToSvgPath(size, x, y, z) {
-    const r = size / 2;
+    const r = this.parseSize(size) / 2;
     return `M ${x - r}, ${y - r} L ${x + r},${y + r} M ${x + r}, ${y - r} L ${x - r},${y + r}`;
   }
 }
@@ -10649,15 +10657,18 @@ class CustomSymbolClass {
     this.pathStr = "", this.type = type, isArray(path) ? this.svgCache = path : this.path = path, this.isSvg = isSvg;
   }
   drawOffset(ctx, size, x, y, offset, z, cb) {
-    return this.isSvg ? !!this.svgCache && (this.svgCache.forEach(item => {
+    return size = this.parseSize(size), this.isSvg ? !!this.svgCache && (this.svgCache.forEach(item => {
       ctx.beginPath(), renderCommandList(item.path.commandList, ctx, x, y, size, size), cb && cb(item.path, item.attribute);
     }), !1) : (renderCommandList(this.path.commandList, ctx, x, y, size + offset, size + offset), !1);
   }
   draw(ctx, size, x, y, z, cb) {
-    return this.drawOffset(ctx, size, x, y, 0, z, cb);
+    return size = this.parseSize(size), this.drawOffset(ctx, size, x, y, 0, z, cb);
+  }
+  parseSize(size) {
+    return isNumber(size) ? size : Math.min(size[0], size[1]);
   }
   bounds(size, bounds) {
-    if (this.isSvg) {
+    if (size = this.parseSize(size), this.isSvg) {
       if (!this.svgCache) return;
       return bounds.clear(), void this.svgCache.forEach(_ref => {
         let {
@@ -11161,7 +11172,11 @@ class Paragraph {
       case "sub":
         baseline += this.descent / 2;
     }
-    "vertical" === direction && (ctx.save(), ctx.rotateAbout(Math.PI / 2, left, baseline), ctx.translate(-this.heightOrigin || -this.lineHeight / 2, -this.descent / 2), ctx.translate(left, baseline), left = 0, baseline = 0), this.character.stroke && (applyStrokeStyle(ctx, this.character), ctx.strokeText(text, left, baseline)), applyFillStyle(ctx, this.character), this.character.fill && ctx.fillText(text, left, baseline), this.character.fill && ("boolean" == typeof this.character.lineThrough || "boolean" == typeof this.character.underline ? (this.character.underline && ctx.fillRect(left, 1 + baseline, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1), this.character.lineThrough && ctx.fillRect(left, 1 + baseline - this.ascent / 2, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1)) : "underline" === this.character.textDecoration ? ctx.fillRect(left, 1 + baseline, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1) : "line-through" === this.character.textDecoration && ctx.fillRect(left, 1 + baseline - this.ascent / 2, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1)), "vertical" === direction && ctx.restore();
+    "vertical" === direction && (ctx.save(), ctx.rotateAbout(Math.PI / 2, left, baseline), ctx.translate(-this.heightOrigin || -this.lineHeight / 2, -this.descent / 2), ctx.translate(left, baseline), left = 0, baseline = 0);
+    const {
+      lineWidth = 1
+    } = this.character;
+    this.character.stroke && lineWidth && ctx.strokeText(text, left, baseline), this.character.fill && ctx.fillText(text, left, baseline), this.character.fill && ("boolean" == typeof this.character.lineThrough || "boolean" == typeof this.character.underline ? (this.character.underline && ctx.fillRect(left, 1 + baseline, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1), this.character.lineThrough && ctx.fillRect(left, 1 + baseline - this.ascent / 2, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1)) : "underline" === this.character.textDecoration ? ctx.fillRect(left, 1 + baseline, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1) : "line-through" === this.character.textDecoration && ctx.fillRect(left, 1 + baseline - this.ascent / 2, this.widthOrigin || this.width, this.character.fontSize ? Math.max(1, Math.floor(this.character.fontSize / 10)) : 1)), "vertical" === direction && ctx.restore();
   }
   getWidthWithEllips(direction) {
     let text = this.text;
@@ -11384,12 +11399,18 @@ class Line {
         paragraph.ellipsis = "hide", otherParagraphWidth += paragraph.width;
       }
     }
-    this.paragraphs.map((paragraph, index) => {
+    this.paragraphs.forEach((paragraph, index) => {
       if (paragraph instanceof RichTextIcon) return paragraph.setAttributes({
         x: x + paragraph._x,
         y: y + paragraph._y
       }), void drawIcon(paragraph, ctx, x + paragraph._x, y + paragraph._y, this.ascent);
-      paragraph.draw(ctx, y + this.ascent, x, 0 === index, this.textAlign);
+      const b = {
+        x1: this.left,
+        y1: this.top,
+        x2: this.left + this.actualWidth,
+        y2: this.top + this.height
+      };
+      applyStrokeStyle(ctx, paragraph.character), applyFillStyle(ctx, paragraph.character, b), paragraph.draw(ctx, y + this.ascent, x, 0 === index, this.textAlign);
     });
   }
   getWidthWithEllips(ellipsis) {
@@ -11412,7 +11433,7 @@ class Line {
       paragraph.ellipsis = "hide", otherParagraphWidth += paragraph.width;
     }
     let width = 0;
-    return this.paragraphs.map((paragraph, index) => {
+    return this.paragraphs.forEach((paragraph, index) => {
       width += paragraph instanceof RichTextIcon ? paragraph.width : paragraph.getWidthWithEllips(this.direction);
     }), width;
   }
@@ -11452,7 +11473,7 @@ class Wrapper {
   }
 }
 
-const RICHTEXT_UPDATE_TAG_KEY = ["width", "height", "ellipsis", "wordBreak", "verticalDirection", "maxHeight", "maxWidth", "textAlign", "textBaseline", "textConfig", "layoutDirection", "fill", "stroke", "fontSize", ...GRAPHIC_UPDATE_TAG_KEY];
+const RICHTEXT_UPDATE_TAG_KEY = ["width", "height", "ellipsis", "wordBreak", "verticalDirection", "maxHeight", "maxWidth", "textAlign", "textBaseline", "textConfig", "layoutDirection", "fill", "stroke", "fontSize", "fontFamily", "fontStyle", "fontWeight", "lineWidth", "opacity", "fillOpacity", "strokeOpacity", ...GRAPHIC_UPDATE_TAG_KEY];
 class RichText extends Graphic {
   constructor(params) {
     super(params), this.type = "richtext", this._currentHoverIcon = null, this.numberType = RICHTEXT_NUMBER_TYPE, this.onBeforeAttributeUpdate = (val, attributes, key) => {
@@ -15996,24 +16017,29 @@ function defaultLabelPosition(type) {
             return DefaultPositions;
     }
 }
-function clampText(text, width, height) {
+function clampText(text, width, height, padding = {}) {
     const { x1, x2, y1, y2 } = text.AABBBounds;
+    const { top = 0, left = 0, right = 0, bottom = 0 } = padding;
     const minX = Math.min(x1, x2);
     const maxX = Math.max(x1, x2);
     const minY = Math.min(y1, y2);
     const maxY = Math.max(y1, y2);
+    const minXWithPadding = 0 - left;
+    const maxXWithPadding = width + right;
+    const minYWithPadding = 0 - top;
+    const maxYWithPadding = height + bottom;
     let dx = 0;
     let dy = 0;
-    if (minX < 0 && maxX - minX <= width) {
+    if (minX < minXWithPadding && maxX - minX <= width) {
         dx = -minX;
     }
-    else if (maxX > width && minX - (maxX - width) >= 0) {
+    else if (maxX > maxXWithPadding && minX - (maxX - width) >= minXWithPadding) {
         dx = width - maxX;
     }
-    if (minY < 0 && maxY - minY <= height) {
+    if (minY < minYWithPadding && maxY - minY <= height) {
         dy = -minY;
     }
-    else if (maxY > height && minY - (maxY - height) >= 0) {
+    else if (maxY > maxYWithPadding && minY - (maxY - height) >= minYWithPadding) {
         dy = height - maxY;
     }
     return { dx, dy };
@@ -16313,69 +16339,177 @@ function loadLabelComponent() {
     registerLine();
 }
 
-function shiftY(texts, option = {}) {
-    const { maxIterations = 10, maxError = 0.1, padding = 1, maxY = Number.MAX_VALUE } = option;
+const isIntersect = (top, bottom) => {
+    return Math.ceil(top) > Math.floor(bottom);
+};
+const isXIntersect = ([a, b], [c, d]) => {
+    return d > a && b > c;
+};
+function getIntersectionLength(range1, range2) {
+    const [start1, end1] = range1;
+    const [start2, end2] = range2;
+    const start = Math.max(start1, start2);
+    const end = Math.min(end1, end2);
+    return Math.max(0, end - start);
+}
+function shiftY(texts, option) {
+    const { maxY = Number.MAX_VALUE, labelling, globalShiftY = { enable: true, maxIterations: 10, maxError: 0.1, padding: 1 } } = option;
     const n = texts.length;
     if (n <= 1) {
         return texts;
     }
-    const isIntersect = ([a, b], [c, d]) => {
-        return d > a && b > c;
-    };
+    const xMap = new Map();
     const textInformation = new Map();
-    const getY0 = (text) => textInformation.get(text).y0;
-    const getY = (text) => textInformation.get(text).y;
+    const getY1Initial = (text) => textInformation.get(text).y1Initial;
     const getHeight = (text) => textInformation.get(text).height;
+    const getY1 = (text) => textInformation.get(text).y1;
+    const getY = (text) => textInformation.get(text).y;
+    const getX = (text) => textInformation.get(text).x;
     const getX1 = (text) => textInformation.get(text).x1;
     const getX2 = (text) => textInformation.get(text).x2;
-    const setY = (text, y) => {
-        textInformation.get(text).y = y;
+    const getAdjustAttempts = (text) => textInformation.get(text).attempts;
+    const setY1 = (text, y) => {
+        textInformation.get(text).y1 = y;
     };
+    const setAdjustAttempts = (text, attempts) => {
+        textInformation.get(text).attempts = attempts;
+    };
+    function adjustPositionInOneGroup(texts) {
+        if (texts.length === 1) {
+            return;
+        }
+        for (let i = texts.length - 1; i > 0; i--) {
+            const curText = texts[i];
+            const upperText = texts[i - 1];
+            const lowerText = texts[i + 1];
+            if (isIntersect(getY1(upperText) + getHeight(upperText), getY1(curText))) {
+                const { y } = labelling(curText);
+                if (!lowerText || !isIntersect(y + getHeight(curText) / 2, getY1(lowerText))) {
+                    if (y + getHeight(curText) / 2 <= maxY) {
+                        setY1(curText, getY1(curText) + y - getY(curText));
+                    }
+                }
+            }
+        }
+    }
+    texts.sort((a, b) => a.attribute.x - b.attribute.x);
     for (const text of texts) {
         const { y1, y2, x1, x2 } = text.AABBBounds;
-        textInformation.set(text, { y0: y1, y: y1, height: y2 - y1, x1, x2 });
+        const { x, y } = text.attribute;
+        textInformation.set(text, { y1Initial: y1, y1, y2, y, height: y2 - y1, x1, x2, x, attempts: 0 });
+        let hasRange = false;
+        for (const [range, xGroupTexts] of xMap) {
+            const { start, end } = range;
+            if (x1 >= start && x2 <= end) {
+                xGroupTexts.push(text);
+                hasRange = true;
+            }
+            else if (isNumberClose(x, getX(xGroupTexts[0]), undefined, 5)) {
+                const newRange = { start: Math.min(start, x1), end: Math.max(end, x2) };
+                xGroupTexts.push(text);
+                xMap.set(newRange, xGroupTexts);
+                xMap.delete(range);
+                hasRange = true;
+            }
+            else if (getIntersectionLength([start, end], [x1, x2]) / (end - start) > 0.5) {
+                const newRange = { start: Math.min(start, x1), end: Math.max(end, x2) };
+                xGroupTexts.push(text);
+                xMap.set(newRange, xGroupTexts);
+                xMap.delete(range);
+                hasRange = true;
+            }
+            if (hasRange) {
+                break;
+            }
+        }
+        if (!hasRange) {
+            xMap.set({ start: x1, end: x2 }, [text]);
+        }
     }
-    for (let iter = 0; iter < maxIterations; iter++) {
-        texts.sort((a, b) => getY(a) - getY(b));
-        let error = 0;
-        for (let i = 0; i < n - 1; i++) {
-            const curText = texts[i];
-            let j = i + 1;
-            let nextText;
-            while ((nextText = texts[j]) &&
-                !isIntersect([getX1(curText), getX2(curText)], [getX1(nextText), getX2(nextText)])) {
-                j += 1;
-            }
-            if (nextText) {
-                const y0 = getY(curText);
-                const h0 = getHeight(curText);
-                const y1 = getY(nextText);
-                const delta = y1 - (y0 + h0);
-                if (delta < padding) {
-                    const newDelta = (padding - delta) / 2;
-                    error = Math.max(error, newDelta);
-                    if (y1 + newDelta + getHeight(nextText) > maxY) {
-                        setY(curText, y0 - (padding - delta));
-                    }
-                    else if (y0 - newDelta < 0) {
-                        setY(nextText, y1 + (padding - delta));
-                    }
-                    else {
-                        setY(curText, y0 - newDelta);
-                        setY(nextText, y1 + newDelta);
+    for (const xTexts of xMap.values()) {
+        xTexts.sort((a, b) => getY1Initial(a) - getY1Initial(b));
+        adjustPositionInOneGroup(xTexts);
+    }
+    if (globalShiftY.enable !== false) {
+        const { maxIterations = 10, maxError = 0.1, padding = 1, maxAttempts = 1000, deltaYTolerance = Number.MAX_VALUE } = globalShiftY;
+        for (let iter = 0; iter < maxIterations; iter++) {
+            texts.sort((a, b) => getY1(a) - getY1(b));
+            let error = 0;
+            for (let i = 0; i < n - 1; i++) {
+                const curText = texts[i];
+                if (getAdjustAttempts(curText) >= maxAttempts) {
+                    continue;
+                }
+                let j = i + 1;
+                let nextText;
+                while ((nextText = texts[j]) &&
+                    !isXIntersect([getX1(curText), getX2(curText)], [getX1(nextText), getX2(nextText)])) {
+                    j += 1;
+                }
+                if (nextText) {
+                    const y1 = getY1(curText);
+                    const h0 = getHeight(curText);
+                    const nextY1 = getY1(nextText);
+                    const delta = nextY1 - (y1 + h0);
+                    if (delta < padding) {
+                        const newDelta = (padding - delta) / 2;
+                        error = Math.max(error, newDelta);
+                        if (y1 + newDelta + getHeight(nextText) > maxY) {
+                            const newY1 = y1 - (padding - delta);
+                            const curTextDelta = getY1Initial(curText) - newY1;
+                            if (Math.abs(curTextDelta) <= deltaYTolerance) {
+                                setY1(curText, newY1);
+                                setAdjustAttempts(curText, getAdjustAttempts(curText) + 1);
+                            }
+                        }
+                        else if (y1 - newDelta < 0) {
+                            const newY1 = nextY1 + (padding - delta);
+                            const nextTextDelta = getY1Initial(nextText) - newY1;
+                            if (Math.abs(nextTextDelta) <= deltaYTolerance) {
+                                setY1(nextText, newY1);
+                                setAdjustAttempts(nextText, getAdjustAttempts(nextText) + 1);
+                            }
+                        }
+                        else {
+                            const newCurY1 = y1 - newDelta;
+                            const curTextDelta = getY1Initial(curText) - newCurY1;
+                            const newNextY1 = nextY1 + newDelta;
+                            const nextTextDelta = getY1Initial(nextText) - newNextY1;
+                            if (Math.abs(curTextDelta) <= deltaYTolerance && Math.abs(nextTextDelta) <= deltaYTolerance) {
+                                setY1(curText, newCurY1);
+                                setY1(nextText, newNextY1);
+                                setAdjustAttempts(curText, getAdjustAttempts(curText) + 1);
+                                setAdjustAttempts(nextText, getAdjustAttempts(nextText) + 1);
+                            }
+                        }
                     }
                 }
             }
-        }
-        if (error < maxError) {
-            break;
+            if (error < maxError) {
+                break;
+            }
         }
     }
     for (const text of texts) {
-        const finalY = text.attribute.y + getY(text) - getY0(text);
+        const finalY = text.attribute.y + getY1(text) - getY1Initial(text);
         text.setAttribute('y', finalY);
     }
-    return texts;
+    const result = [];
+    texts.sort((a, b) => a.attribute.x - b.attribute.x);
+    let start = 0;
+    let end = texts.length - 1;
+    while (start <= end) {
+        if (start === end) {
+            result.push(texts[start]);
+        }
+        else {
+            result.push(texts[start]);
+            result.push(texts[end]);
+        }
+        start++;
+        end--;
+    }
+    return result;
 }
 
 loadLabelComponent();
@@ -16721,18 +16855,25 @@ class LabelBase extends AbstractComponent {
         if (clampForce) {
             for (let i = 0; i < result.length; i++) {
                 const text = labels[i];
-                const { dx = 0, dy = 0 } = clampText(text, bmpTool.width, bmpTool.height);
+                const { dx = 0, dy = 0 } = clampText(text, bmpTool.width, bmpTool.height, bmpTool.padding);
                 if (dx !== 0 || dy !== 0) {
                     text.setAttributes({ x: text.attribute.x + dx, y: text.attribute.y + dy });
+                    text._isClamped = true;
                 }
             }
         }
-        result = shiftY(result, Object.assign({ maxY: bmpTool.height }, strategy));
+        result = shiftY(result, Object.assign(Object.assign({ maxY: bmpTool.height }, strategy), { labelling: (text) => {
+                const baseMark = this.getRelatedGraphic(text.attribute);
+                const graphicBound = this._isCollectionBase
+                    ? this.getGraphicBounds(null, this._idToPoint.get(text.attribute.id))
+                    : this.getGraphicBounds(baseMark, text);
+                return this.labeling(text.AABBBounds, graphicBound, 'bottom', this.attribute.offset);
+            } }));
         for (let i = 0; i < result.length; i++) {
             const text = result[i];
             const bounds = text.AABBBounds;
             const range = boundToRange(bmpTool, bounds, true);
-            if (canPlace(bmpTool, bitmap, bounds, clampForce, overlapPadding)) {
+            if (canPlace(bmpTool, bitmap, bounds, clampForce, text._isClamped ? 0 : overlapPadding)) {
                 bitmap.setRange(range);
             }
             else {
@@ -16805,7 +16946,7 @@ class LabelBase extends AbstractComponent {
                 }
             }
             if (!hasPlace && clampForce) {
-                const { dx = 0, dy = 0 } = clampText(text, bmpTool.width, bmpTool.height);
+                const { dx = 0, dy = 0 } = clampText(text, bmpTool.width, bmpTool.height, bmpTool.padding);
                 if (dx === 0 && dy === 0) {
                     if (canPlace(bmpTool, bitmap, text.AABBBounds)) {
                         bitmap.setRange(boundToRange(bmpTool, text.AABBBounds, true));
@@ -22366,11 +22507,19 @@ var IMarkAreaLabelPosition;
     IMarkAreaLabelPosition["right"] = "right";
     IMarkAreaLabelPosition["top"] = "top";
     IMarkAreaLabelPosition["bottom"] = "bottom";
+    IMarkAreaLabelPosition["topLeft"] = "topLeft";
+    IMarkAreaLabelPosition["topRight"] = "topRight";
+    IMarkAreaLabelPosition["bottomLeft"] = "bottomLeft";
+    IMarkAreaLabelPosition["bottomRight"] = "bottomRight";
     IMarkAreaLabelPosition["middle"] = "middle";
     IMarkAreaLabelPosition["insideLeft"] = "insideLeft";
     IMarkAreaLabelPosition["insideRight"] = "insideRight";
     IMarkAreaLabelPosition["insideTop"] = "insideTop";
     IMarkAreaLabelPosition["insideBottom"] = "insideBottom";
+    IMarkAreaLabelPosition["insideTopLeft"] = "insideTopLeft";
+    IMarkAreaLabelPosition["insideTopRight"] = "insideTopRight";
+    IMarkAreaLabelPosition["insideBottomLeft"] = "insideBottomLeft";
+    IMarkAreaLabelPosition["insideBottomRight"] = "insideBottomRight";
 })(IMarkAreaLabelPosition || (IMarkAreaLabelPosition = {}));
 var IMarkCommonArcLabelPosition;
 (function (IMarkCommonArcLabelPosition) {
@@ -23200,6 +23349,38 @@ const DEFAULT_CARTESIAN_MARK_AREA_TEXT_STYLE_MAP = {
     middle: {
         textAlign: 'center',
         textBaseline: 'middle'
+    },
+    topLeft: {
+        textAlign: 'right',
+        textBaseline: 'top'
+    },
+    insideTopLeft: {
+        textAlign: 'left',
+        textBaseline: 'top'
+    },
+    topRight: {
+        textAlign: 'left',
+        textBaseline: 'top'
+    },
+    insideTopRight: {
+        textAlign: 'right',
+        textBaseline: 'top'
+    },
+    bottomLeft: {
+        textAlign: 'right',
+        textBaseline: 'bottom'
+    },
+    insideBottomLeft: {
+        textAlign: 'left',
+        textBaseline: 'bottom'
+    },
+    bottomRight: {
+        textAlign: 'left',
+        textBaseline: 'bottom'
+    },
+    insideBottomRight: {
+        textAlign: 'right',
+        textBaseline: 'bottom'
     }
 };
 const DEFAULT_MARK_POINT_THEME = {
@@ -23931,7 +24112,7 @@ class MarkPoint extends Marker {
         this._isStraightLine =
             fuzzyEqualNumber(itemOffsetX, 0, FUZZY_EQUAL_DELTA) || fuzzyEqualNumber(itemOffsetY, 0, FUZZY_EQUAL_DELTA);
         if (this._isArcLine) {
-            const { x: x1, y: y1 } = newPosition;
+            const { x: x1, y: y1 } = this.attribute.position;
             const { x: x2, y: y2 } = newItemPosition;
             const x0 = (x1 + x2) / 2;
             const y0 = (y1 + y2) / 2;
@@ -23944,6 +24125,10 @@ class MarkPoint extends Marker {
             startAngle = deltaXYToAngle(y1 - centerY, x1 - centerX);
             endAngle = deltaXYToAngle(y2 - centerY, x2 - centerX);
             center = { x: centerX, y: centerY };
+            const R = Math.sqrt((centerX - x1) * (centerX - x1) + (centerY - y1) * (centerY - y1));
+            const r = this.attribute.targetSymbol.style.size / 2;
+            const deltaAngle = Math.acos(Math.sqrt(1 - (r * r) / (4 * R * R))) * 2;
+            startAngle = startAngle + deltaAngle;
             if (arcRatio > 0) {
                 if (endAngle < startAngle) {
                     endAngle += Math.PI * 2;
@@ -24094,11 +24279,23 @@ class MarkPoint extends Marker {
     }
     computeNewPositionAfterTargetItem(position) {
         var _a, _b;
-        const { itemContent = {}, targetSymbol } = this.attribute;
+        const { itemContent = {}, targetSymbol, itemLine } = this.attribute;
         const { offsetX: itemContentOffsetX = 0, offsetY: itemContentOffsetY = 0 } = itemContent;
         const { offset: targetSymbolOffset = 0, style: targetSymbolStyle, visible: targetItemvisible = false, size: targetSymbolSize } = targetSymbol;
         const targetSize = targetItemvisible ? (_b = (_a = targetSymbolStyle.size) !== null && _a !== void 0 ? _a : targetSymbolSize) !== null && _b !== void 0 ? _b : 20 : 0;
-        const targetOffsetAngle = deltaXYToAngle(itemContentOffsetY, itemContentOffsetX);
+        let targetOffsetAngle;
+        if (itemLine.type === 'type-do') {
+            targetOffsetAngle = deltaXYToAngle(itemContentOffsetY, itemContentOffsetX / 2);
+        }
+        else if (itemLine.type === 'type-po') {
+            targetOffsetAngle = deltaXYToAngle(0, itemContentOffsetX);
+        }
+        else if (itemLine.type === 'type-op') {
+            targetOffsetAngle = deltaXYToAngle(itemContentOffsetY, 0);
+        }
+        else {
+            targetOffsetAngle = deltaXYToAngle(itemContentOffsetY, itemContentOffsetX);
+        }
         const newPosition = {
             x: position.x + (targetSize / 2 + targetSymbolOffset) * Math.cos(targetOffsetAngle),
             y: position.y + (targetSize / 2 + targetSymbolOffset) * Math.sin(targetOffsetAngle)
@@ -29555,6 +29752,6 @@ EmptyTip.defaultAttributes = {
     }
 };
 
-const version = "0.20.15";
+const version = "0.20.17";
 
 export { AXIS_ELEMENT_NAME, AbstractComponent, ArcInfo, ArcLabel, ArcSegment, AxisStateValue, BasePlayer, Brush, CheckBox, CircleAxis, CircleAxisGrid, CircleCrosshair, ColorContinuousLegend, ContinuousPlayer, DEFAULT_ITEM_SPACE_COL, DEFAULT_ITEM_SPACE_ROW, DEFAULT_LABEL_SPACE, DEFAULT_PAGER_SPACE, DEFAULT_SHAPE_SIZE, DEFAULT_SHAPE_SPACE, DEFAULT_STATES$1 as DEFAULT_STATES, DEFAULT_TITLE_SPACE, DEFAULT_VALUE_SPACE, DataLabel, DataZoom, DataZoomActiveTag, DirectionEnum, DiscreteLegend, DiscretePlayer, EmptyTip, GroupTransition, IMarkAreaLabelPosition, IMarkCommonArcLabelPosition, IMarkLineLabelPosition, IMarkPointItemPosition, IOperateType, Indicator, LEGEND_ELEMENT_NAME, LabelBase, LegendEvent, LegendStateValue, LineAxis, LineAxisGrid, LineCrosshair, LineLabel, LinkPath, MarkArcArea, MarkArcLine, MarkArea, MarkLine, MarkPoint, Pager, PlayerEventEnum, PolygonCrosshair, PopTip, Radio, RectCrosshair, RectLabel, SLIDER_ELEMENT_NAME, ScrollBar, SectorCrosshair, Segment, SizeContinuousLegend, Slider, SymbolLabel, Tag, Timeline, Title, Tooltip, TopZIndex, VTag, alignTextInLine, angle, angleLabelOrientAttribute, angleTo, cartesianTicks, clampRadian, computeOffsetForlimit, continuousTicks, contrastAccessibilityChecker, convertDomainToTickData, createTextGraphicByType, deltaXYToAngle, fuzzyEqualNumber, getAxisBreakSymbolAttrs, getCircleLabelPosition, getCirclePoints, getCircleVerticalVector, getElMap, getHorizontalPath, getMarksByName, getNoneGroupMarksByName, getPolarAngleLabelPosition, getPolygonPath, getSizeHandlerPath, getTextAlignAttrOfVerticalDir, getTextType, getVerticalCoord, getVerticalPath, hasOverlap, htmlAttributeTransform, initTextMeasure, isInRange, isPostiveXAxis, isRichText, isVisible, labelSmartInvert, length, limitShapeInBounds, linearDiscreteTicks, loadPoptip, measureTextSize, normalize, polarAngleAxisDiscreteTicks, polarTicks, reactAttributeTransform, registerArcDataLabel, registerLineDataLabel, registerMarkArcAreaAnimate, registerMarkArcLineAnimate, registerMarkAreaAnimate, registerMarkLineAnimate, registerMarkPointAnimate, registerRectDataLabel, registerSymbolDataLabel, removeRepeatPoint, richTextAttributeTransform, scale, setPoptipTheme, smartInvertStrategy, tan2AngleToAngle, textIntersect, ticks, traverseGroup, version };