tvcharts 0.6.60 → 0.6.62

package/dist/echarts.js

@@ -247,8 +247,8 @@ var platformApi = {
     let _cachedFont;
     return (text, font) => {
       if (!_ctx) {
-        const canvas = platformApi.createCanvas();
-        _ctx = canvas && canvas.getContext("2d");
+        const canvas2 = platformApi.createCanvas();
+        _ctx = canvas2 && canvas2.getContext("2d");
       }
       if (_ctx) {
         if (_cachedFont !== font) {
@@ -1250,7 +1250,7 @@ var Eventful = class {
     const eventProcessor = this._$eventProcessor;
     if (_h) {
       const argLen = args.length;
-      const ctx = args[argLen - 1];
+      const ctx2 = args[argLen - 1];
       const len2 = _h.length;
       for (let i = 0; i < len2; i++) {
         const hItem = _h[i];
@@ -1259,16 +1259,16 @@ var Eventful = class {
         }
         switch (argLen) {
           case 0:
-            hItem.h.call(ctx);
+            hItem.h.call(ctx2);
             break;
           case 1:
-            hItem.h.call(ctx, args[0]);
+            hItem.h.call(ctx2, args[0]);
             break;
           case 2:
-            hItem.h.call(ctx, args[0], args[1]);
+            hItem.h.call(ctx2, args[0], args[1]);
             break;
           default:
-            hItem.h.apply(ctx, args.slice(1, argLen - 1));
+            hItem.h.apply(ctx2, args.slice(1, argLen - 1));
             break;
         }
       }
@@ -9199,8 +9199,8 @@ var PathProxy2 = class {
   setDPR(dpr2) {
     this.dpr = dpr2;
   }
-  setContext(ctx) {
-    this._ctx = ctx;
+  setContext(ctx2) {
+    this._ctx = ctx2;
   }
   getContext() {
     return this._ctx;
@@ -9325,22 +9325,22 @@ var PathProxy2 = class {
   closePath() {
     this._drawPendingPt();
     this.addData(CMD.Z);
-    const ctx = this._ctx;
+    const ctx2 = this._ctx;
     const x0 = this._x0;
     const y0 = this._y0;
-    if (ctx) {
-      ctx.closePath();
+    if (ctx2) {
+      ctx2.closePath();
     }
     this._xi = x0;
     this._yi = y0;
     return this;
   }
-  fill(ctx) {
-    ctx && ctx.fill();
+  fill(ctx2) {
+    ctx2 && ctx2.fill();
     this.toStatic();
   }
-  stroke(ctx) {
-    ctx && ctx.stroke();
+  stroke(ctx2) {
+    ctx2 && ctx2.stroke();
     this.toStatic();
   }
   len() {
@@ -9615,7 +9615,7 @@ var PathProxy2 = class {
     this._pathLen = pathTotalLen;
     return pathTotalLen;
   }
-  rebuildPath(ctx, percent) {
+  rebuildPath(ctx2, percent) {
     const d = this.data;
     const ux = this._ux;
     const uy = this._uy;
@@ -9657,14 +9657,14 @@ var PathProxy2 = class {
           y0 = yi;
         }
         if (cmd !== CMD.L && pendingPtDist > 0) {
-          ctx.lineTo(pendingPtX, pendingPtY);
+          ctx2.lineTo(pendingPtX, pendingPtY);
           pendingPtDist = 0;
         }
         switch (cmd) {
           case CMD.M:
             x0 = xi = d[i++];
             y0 = yi = d[i++];
-            ctx.moveTo(xi, yi);
+            ctx2.moveTo(xi, yi);
             break;
           case CMD.L: {
             x = d[i++];
@@ -9676,12 +9676,12 @@ var PathProxy2 = class {
                 const l = pathSegLen[segCount++];
                 if (accumLength + l > displayedLength) {
                   const t = (displayedLength - accumLength) / l;
-                  ctx.lineTo(xi * (1 - t) + x * t, yi * (1 - t) + y * t);
+                  ctx2.lineTo(xi * (1 - t) + x * t, yi * (1 - t) + y * t);
                   break lo;
                 }
                 accumLength += l;
               }
-              ctx.lineTo(x, y);
+              ctx2.lineTo(x, y);
               xi = x;
               yi = y;
               pendingPtDist = 0;
@@ -9708,12 +9708,12 @@ var PathProxy2 = class {
                 const t = (displayedLength - accumLength) / l;
                 cubicSubdivide(xi, x1, x2, x3, t, tmpOutX);
                 cubicSubdivide(yi, y1, y2, y3, t, tmpOutY);
-                ctx.bezierCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2], tmpOutX[3], tmpOutY[3]);
+                ctx2.bezierCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2], tmpOutX[3], tmpOutY[3]);
                 break lo;
               }
               accumLength += l;
             }
-            ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+            ctx2.bezierCurveTo(x1, y1, x2, y2, x3, y3);
             xi = x3;
             yi = y3;
             break;
@@ -9729,12 +9729,12 @@ var PathProxy2 = class {
                 const t = (displayedLength - accumLength) / l;
                 quadraticSubdivide(xi, x1, x2, t, tmpOutX);
                 quadraticSubdivide(yi, y1, y2, t, tmpOutY);
-                ctx.quadraticCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2]);
+                ctx2.quadraticCurveTo(tmpOutX[1], tmpOutY[1], tmpOutX[2], tmpOutY[2]);
                 break lo;
               }
               accumLength += l;
             }
-            ctx.quadraticCurveTo(x1, y1, x2, y2);
+            ctx2.quadraticCurveTo(x1, y1, x2, y2);
             xi = x2;
             yi = y2;
             break;
@@ -9760,10 +9760,10 @@ var PathProxy2 = class {
               }
               accumLength += l;
             }
-            if (isEllipse && ctx.ellipse) {
-              ctx.ellipse(cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise);
+            if (isEllipse && ctx2.ellipse) {
+              ctx2.ellipse(cx, cy, rx, ry, psi, startAngle, endAngle, anticlockwise);
             } else {
-              ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
+              ctx2.arc(cx, cy, r, startAngle, endAngle, anticlockwise);
             }
             if (breakBuild) {
               break lo;
@@ -9786,33 +9786,33 @@ var PathProxy2 = class {
               const l = pathSegLen[segCount++];
               if (accumLength + l > displayedLength) {
                 let d2 = displayedLength - accumLength;
-                ctx.moveTo(x, y);
-                ctx.lineTo(x + mathMin3(d2, width), y);
+                ctx2.moveTo(x, y);
+                ctx2.lineTo(x + mathMin3(d2, width), y);
                 d2 -= width;
                 if (d2 > 0) {
-                  ctx.lineTo(x + width, y + mathMin3(d2, height));
+                  ctx2.lineTo(x + width, y + mathMin3(d2, height));
                 }
                 d2 -= height;
                 if (d2 > 0) {
-                  ctx.lineTo(x + mathMax3(width - d2, 0), y + height);
+                  ctx2.lineTo(x + mathMax3(width - d2, 0), y + height);
                 }
                 d2 -= width;
                 if (d2 > 0) {
-                  ctx.lineTo(x, y + mathMax3(height - d2, 0));
+                  ctx2.lineTo(x, y + mathMax3(height - d2, 0));
                 }
                 break lo;
               }
               accumLength += l;
             }
-            ctx.rect(x, y, width, height);
+            ctx2.rect(x, y, width, height);
             break;
           case CMD.F: {
             const r2 = d[i++];
             const g = d[i++];
             const b = d[i++];
             const a = d[i++];
-            ctx.fillStyle = `rgba(${r2},${g},${b},${a})`;
-            ctx.fill();
+            ctx2.fillStyle = `rgba(${r2},${g},${b},${a})`;
+            ctx2.fill();
             break;
           }
           case CMD.S: {
@@ -9820,24 +9820,24 @@ var PathProxy2 = class {
             const g = d[i++];
             const b = d[i++];
             const a = d[i++];
-            ctx.strokeStyle = `rgba(${r2},${g},${b},${a})`;
-            ctx.stroke();
+            ctx2.strokeStyle = `rgba(${r2},${g},${b},${a})`;
+            ctx2.stroke();
             break;
           }
           case CMD.B:
-            ctx.beginPath();
+            ctx2.beginPath();
             break;
           case CMD.Z:
             if (drawPart) {
               const l = pathSegLen[segCount++];
               if (accumLength + l > displayedLength) {
                 const t = (displayedLength - accumLength) / l;
-                ctx.lineTo(xi * (1 - t) + x0 * t, yi * (1 - t) + y0 * t);
+                ctx2.lineTo(xi * (1 - t) + x0 * t, yi * (1 - t) + y0 * t);
                 break lo;
               }
               accumLength += l;
             }
-            ctx.closePath();
+            ctx2.closePath();
             xi = x0;
             yi = y0;
         }
@@ -10299,8 +10299,8 @@ var Path2 = class extends Displayable_default {
     if (style.decal) {
       const decalEl = this._decalEl = this._decalEl || new Path2();
       if (decalEl.buildPath === Path2.prototype.buildPath) {
-        decalEl.buildPath = (ctx) => {
-          this.buildPath(ctx, this.shape);
+        decalEl.buildPath = (ctx2) => {
+          this.buildPath(ctx2, this.shape);
         };
       }
       decalEl.silent = true;
@@ -10388,7 +10388,7 @@ var Path2 = class extends Displayable_default {
       }
     }
   }
-  buildPath(ctx, shapeCfg, inBatch) {
+  buildPath(ctx2, shapeCfg, inBatch) {
   }
   pathUpdated() {
     this.__dirty &= ~SHAPE_CHANGED_BIT;
@@ -10750,7 +10750,7 @@ ZRImage.prototype.type = "image";
 var Image_default = ZRImage;
 
 // node_modules/tvrender/src/graphic/helper/roundRect.ts
-function buildPath(ctx, shape) {
+function buildPath(ctx2, shape) {
   let x = shape.x;
   let y = shape.y;
   let width = shape.width;
@@ -10810,15 +10810,15 @@ function buildPath(ctx, shape) {
     r1 *= height / total;
     r4 *= height / total;
   }
-  ctx.moveTo(x + r1, y);
-  ctx.lineTo(x + width - r2, y);
-  r2 !== 0 && ctx.arc(x + width - r2, y + r2, r2, -Math.PI / 2, 0);
-  ctx.lineTo(x + width, y + height - r3);
-  r3 !== 0 && ctx.arc(x + width - r3, y + height - r3, r3, 0, Math.PI / 2);
-  ctx.lineTo(x + r4, y + height);
-  r4 !== 0 && ctx.arc(x + r4, y + height - r4, r4, Math.PI / 2, Math.PI);
-  ctx.lineTo(x, y + r1);
-  r1 !== 0 && ctx.arc(x + r1, y + r1, r1, Math.PI, Math.PI * 1.5);
+  ctx2.moveTo(x + r1, y);
+  ctx2.lineTo(x + width - r2, y);
+  r2 !== 0 && ctx2.arc(x + width - r2, y + r2, r2, -Math.PI / 2, 0);
+  ctx2.lineTo(x + width, y + height - r3);
+  r3 !== 0 && ctx2.arc(x + width - r3, y + height - r3, r3, 0, Math.PI / 2);
+  ctx2.lineTo(x + r4, y + height);
+  r4 !== 0 && ctx2.arc(x + r4, y + height - r4, r4, Math.PI / 2, Math.PI);
+  ctx2.lineTo(x, y + r1);
+  r1 !== 0 && ctx2.arc(x + r1, y + r1, r1, Math.PI, Math.PI * 1.5);
 }
 
 // node_modules/tvrender/src/graphic/helper/subPixelOptimize.ts
@@ -10894,7 +10894,7 @@ var Rect = class extends Path_default {
   getDefaultShape() {
     return new RectShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     let x;
     let y;
     let width;
@@ -10914,9 +10914,9 @@ var Rect = class extends Path_default {
       height = shape.height;
     }
     if (!shape.r) {
-      ctx.rect(x, y, width, height);
+      ctx2.rect(x, y, width, height);
     } else {
-      buildPath(ctx, shape);
+      buildPath(ctx2, shape);
     }
   }
   isZeroArea() {
@@ -12494,13 +12494,13 @@ function createPathOptions(str, opts) {
   innerOpts.buildPath = function(path) {
     if (isPathProxy(path)) {
       path.setData(pathProxy.data);
-      const ctx = path.getContext();
-      if (ctx) {
-        path.rebuildPath(ctx, 1);
+      const ctx2 = path.getContext();
+      if (ctx2) {
+        path.rebuildPath(ctx2, 1);
       }
     } else {
-      const ctx = path;
-      pathProxy.rebuildPath(ctx, 1);
+      const ctx2 = path;
+      pathProxy.rebuildPath(ctx2, 1);
     }
   };
   innerOpts.applyTransform = function(m2) {
@@ -12535,9 +12535,9 @@ function mergePath(pathEls, opts) {
   pathBundle.buildPath = function(path) {
     if (isPathProxy(path)) {
       path.appendPath(pathList);
-      const ctx = path.getContext();
-      if (ctx) {
-        path.rebuildPath(ctx, 1);
+      const ctx2 = path.getContext();
+      if (ctx2) {
+        path.rebuildPath(ctx2, 1);
       }
     }
   };
@@ -12582,9 +12582,9 @@ var Circle = class extends Path_default {
   getDefaultShape() {
     return new CircleShape();
   }
-  buildPath(ctx, shape) {
-    ctx.moveTo(shape.cx + shape.r, shape.cy);
-    ctx.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);
+  buildPath(ctx2, shape) {
+    ctx2.moveTo(shape.cx + shape.r, shape.cy);
+    ctx2.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);
   }
 };
 Circle.prototype.type = "circle";
@@ -12606,7 +12606,7 @@ var Ellipse = class extends Path_default {
   getDefaultShape() {
     return new EllipseShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const k = 0.5522848;
     const x = shape.cx;
     const y = shape.cy;
@@ -12614,12 +12614,12 @@ var Ellipse = class extends Path_default {
     const b = shape.ry;
     const ox = a * k;
     const oy = b * k;
-    ctx.moveTo(x - a, y);
-    ctx.bezierCurveTo(x - a, y - oy, x - ox, y - b, x, y - b);
-    ctx.bezierCurveTo(x + ox, y - b, x + a, y - oy, x + a, y);
-    ctx.bezierCurveTo(x + a, y + oy, x + ox, y + b, x, y + b);
-    ctx.bezierCurveTo(x - ox, y + b, x - a, y + oy, x - a, y);
-    ctx.closePath();
+    ctx2.moveTo(x - a, y);
+    ctx2.bezierCurveTo(x - a, y - oy, x - ox, y - b, x, y - b);
+    ctx2.bezierCurveTo(x + ox, y - b, x + a, y - oy, x + a, y);
+    ctx2.bezierCurveTo(x + a, y + oy, x + ox, y + b, x, y + b);
+    ctx2.bezierCurveTo(x - ox, y + b, x - a, y + oy, x - a, y);
+    ctx2.closePath();
   }
 };
 Ellipse.prototype.type = "ellipse";
@@ -12709,7 +12709,7 @@ function normalizeCornerRadius(cr) {
   }
   return arr;
 }
-function buildPath2(ctx, shape) {
+function buildPath2(ctx2, shape) {
   let radius = mathMax4(shape.r, 0);
   let innerRadius = mathMax4(shape.r0 || 0, 0);
   const hasRadius = radius > 0;
@@ -12736,13 +12736,13 @@ function buildPath2(ctx, shape) {
   const mod = arc2 > PI26 && arc2 % PI26;
   mod > e && (arc2 = mod);
   if (!(radius > e)) {
-    ctx.moveTo(cx, cy);
+    ctx2.moveTo(cx, cy);
   } else if (arc2 > PI26 - e) {
-    ctx.moveTo(cx + radius * mathCos4(startAngle), cy + radius * mathSin4(startAngle));
-    ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise);
+    ctx2.moveTo(cx + radius * mathCos4(startAngle), cy + radius * mathSin4(startAngle));
+    ctx2.arc(cx, cy, radius, startAngle, endAngle, !clockwise);
     if (innerRadius > e) {
-      ctx.moveTo(cx + innerRadius * mathCos4(endAngle), cy + innerRadius * mathSin4(endAngle));
-      ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
+      ctx2.moveTo(cx + innerRadius * mathCos4(endAngle), cy + innerRadius * mathSin4(endAngle));
+      ctx2.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
     }
   } else {
     let icrStart;
@@ -12799,45 +12799,45 @@ function buildPath2(ctx, shape) {
       }
     }
     if (!hasArc) {
-      ctx.moveTo(cx + xrs, cy + yrs);
+      ctx2.moveTo(cx + xrs, cy + yrs);
     } else if (limitedOcrMax > e) {
       const crStart = mathMin4(ocrStart, limitedOcrMax);
       const crEnd = mathMin4(ocrEnd, limitedOcrMax);
       const ct0 = computeCornerTangents(xirs, yirs, xrs, yrs, radius, crStart, clockwise);
       const ct1 = computeCornerTangents(xre, yre, xire, yire, radius, crEnd, clockwise);
-      ctx.moveTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);
+      ctx2.moveTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);
       if (limitedOcrMax < ocrMax && crStart === crEnd) {
-        ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedOcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
+        ctx2.arc(cx + ct0.cx, cy + ct0.cy, limitedOcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
       } else {
-        crStart > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crStart, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
-        ctx.arc(cx, cy, radius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), !clockwise);
-        crEnd > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crEnd, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
+        crStart > 0 && ctx2.arc(cx + ct0.cx, cy + ct0.cy, crStart, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
+        ctx2.arc(cx, cy, radius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), !clockwise);
+        crEnd > 0 && ctx2.arc(cx + ct1.cx, cy + ct1.cy, crEnd, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
       }
     } else {
-      ctx.moveTo(cx + xrs, cy + yrs);
-      ctx.arc(cx, cy, radius, startAngle, endAngle, !clockwise);
+      ctx2.moveTo(cx + xrs, cy + yrs);
+      ctx2.arc(cx, cy, radius, startAngle, endAngle, !clockwise);
     }
     if (!(innerRadius > e) || !hasArc) {
-      ctx.lineTo(cx + xire, cy + yire);
+      ctx2.lineTo(cx + xire, cy + yire);
     } else if (limitedIcrMax > e) {
       const crStart = mathMin4(icrStart, limitedIcrMax);
       const crEnd = mathMin4(icrEnd, limitedIcrMax);
       const ct0 = computeCornerTangents(xire, yire, xre, yre, innerRadius, -crEnd, clockwise);
       const ct1 = computeCornerTangents(xrs, yrs, xirs, yirs, innerRadius, -crStart, clockwise);
-      ctx.lineTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);
+      ctx2.lineTo(cx + ct0.cx + ct0.x0, cy + ct0.cy + ct0.y0);
       if (limitedIcrMax < icrMax && crStart === crEnd) {
-        ctx.arc(cx + ct0.cx, cy + ct0.cy, limitedIcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
+        ctx2.arc(cx + ct0.cx, cy + ct0.cy, limitedIcrMax, mathATan2(ct0.y0, ct0.x0), mathATan2(ct1.y0, ct1.x0), !clockwise);
       } else {
-        crEnd > 0 && ctx.arc(cx + ct0.cx, cy + ct0.cy, crEnd, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
-        ctx.arc(cx, cy, innerRadius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), clockwise);
-        crStart > 0 && ctx.arc(cx + ct1.cx, cy + ct1.cy, crStart, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
+        crEnd > 0 && ctx2.arc(cx + ct0.cx, cy + ct0.cy, crEnd, mathATan2(ct0.y0, ct0.x0), mathATan2(ct0.y1, ct0.x1), !clockwise);
+        ctx2.arc(cx, cy, innerRadius, mathATan2(ct0.cy + ct0.y1, ct0.cx + ct0.x1), mathATan2(ct1.cy + ct1.y1, ct1.cx + ct1.x1), clockwise);
+        crStart > 0 && ctx2.arc(cx + ct1.cx, cy + ct1.cy, crStart, mathATan2(ct1.y1, ct1.x1), mathATan2(ct1.y0, ct1.x0), !clockwise);
       }
     } else {
-      ctx.lineTo(cx + xire, cy + yire);
-      ctx.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
+      ctx2.lineTo(cx + xire, cy + yire);
+      ctx2.arc(cx, cy, innerRadius, endAngle, startAngle, clockwise);
     }
   }
-  ctx.closePath();
+  ctx2.closePath();
 }
 
 // node_modules/tvrender/src/graphic/shape/Sector.ts
@@ -12860,8 +12860,8 @@ var Sector = class extends Path_default {
   getDefaultShape() {
     return new SectorShape();
   }
-  buildPath(ctx, shape) {
-    buildPath2(ctx, shape);
+  buildPath(ctx2, shape) {
+    buildPath2(ctx2, shape);
   }
   isZeroArea() {
     return this.shape.startAngle === this.shape.endAngle || this.shape.r === this.shape.r0;
@@ -12886,14 +12886,14 @@ var Ring = class extends Path_default {
   getDefaultShape() {
     return new RingShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const x = shape.cx;
     const y = shape.cy;
     const PI210 = Math.PI * 2;
-    ctx.moveTo(x + shape.r, y);
-    ctx.arc(x, y, shape.r, 0, PI210, false);
-    ctx.moveTo(x + shape.r0, y);
-    ctx.arc(x, y, shape.r0, 0, PI210, true);
+    ctx2.moveTo(x + shape.r, y);
+    ctx2.arc(x, y, shape.r, 0, PI210, false);
+    ctx2.moveTo(x + shape.r0, y);
+    ctx2.arc(x, y, shape.r0, 0, PI210, true);
   }
 };
 Ring.prototype.type = "ring";
@@ -12962,27 +12962,27 @@ function smoothBezier(points4, smooth, isLoop, constraint) {
 }
 
 // node_modules/tvrender/src/graphic/helper/poly.ts
-function buildPath3(ctx, shape, closePath) {
+function buildPath3(ctx2, shape, closePath) {
   const smooth = shape.smooth;
   let points4 = shape.points;
   if (points4 && points4.length >= 2) {
     if (smooth) {
       const controlPoints = smoothBezier(points4, smooth, closePath, shape.smoothConstraint);
-      ctx.moveTo(points4[0][0], points4[0][1]);
+      ctx2.moveTo(points4[0][0], points4[0][1]);
       const len2 = points4.length;
       for (let i = 0; i < (closePath ? len2 : len2 - 1); i++) {
         const cp1 = controlPoints[i * 2];
         const cp2 = controlPoints[i * 2 + 1];
         const p = points4[(i + 1) % len2];
-        ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]);
+        ctx2.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]);
       }
     } else {
-      ctx.moveTo(points4[0][0], points4[0][1]);
+      ctx2.moveTo(points4[0][0], points4[0][1]);
       for (let i = 1, l = points4.length; i < l; i++) {
-        ctx.lineTo(points4[i][0], points4[i][1]);
+        ctx2.lineTo(points4[i][0], points4[i][1]);
       }
     }
-    closePath && ctx.closePath();
+    closePath && ctx2.closePath();
   }
 }
 
@@ -13001,8 +13001,8 @@ var Polygon = class extends Path_default {
   getDefaultShape() {
     return new PolygonShape();
   }
-  buildPath(ctx, shape) {
-    buildPath3(ctx, shape, true);
+  buildPath(ctx2, shape) {
+    buildPath3(ctx2, shape, true);
   }
 };
 Polygon.prototype.type = "polygon";
@@ -13030,8 +13030,8 @@ var Polyline = class extends Path_default {
   getDefaultShape() {
     return new PolylineShape();
   }
-  buildPath(ctx, shape) {
-    buildPath3(ctx, shape, false);
+  buildPath(ctx2, shape) {
+    buildPath3(ctx2, shape, false);
   }
 };
 Polyline.prototype.type = "polyline";
@@ -13061,7 +13061,7 @@ var Line = class extends Path_default {
   getDefaultShape() {
     return new LineShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     let x1;
     let y1;
     let x2;
@@ -13082,12 +13082,12 @@ var Line = class extends Path_default {
     if (percent === 0) {
       return;
     }
-    ctx.moveTo(x1, y1);
+    ctx2.moveTo(x1, y1);
     if (percent < 1) {
       x2 = x1 * (1 - percent) + x2 * percent;
       y2 = y1 * (1 - percent) + y2 * percent;
     }
-    ctx.lineTo(x2, y2);
+    ctx2.lineTo(x2, y2);
   }
   pointAt(p) {
     const shape = this.shape;
@@ -13141,7 +13141,7 @@ var BezierCurve = class extends Path_default {
   getDefaultShape() {
     return new BezierCurveShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     let x1 = shape.x1;
     let y1 = shape.y1;
     let x2 = shape.x2;
@@ -13154,7 +13154,7 @@ var BezierCurve = class extends Path_default {
     if (percent === 0) {
       return;
     }
-    ctx.moveTo(x1, y1);
+    ctx2.moveTo(x1, y1);
     if (cpx2 == null || cpy2 == null) {
       if (percent < 1) {
         quadraticSubdivide(x1, cpx1, x2, percent, out);
@@ -13164,7 +13164,7 @@ var BezierCurve = class extends Path_default {
         cpy1 = out[1];
         y2 = out[2];
       }
-      ctx.quadraticCurveTo(cpx1, cpy1, x2, y2);
+      ctx2.quadraticCurveTo(cpx1, cpy1, x2, y2);
     } else {
       if (percent < 1) {
         cubicSubdivide(x1, cpx1, cpx2, x2, percent, out);
@@ -13176,7 +13176,7 @@ var BezierCurve = class extends Path_default {
         cpy2 = out[2];
         y2 = out[3];
       }
-      ctx.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2);
+      ctx2.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, x2, y2);
     }
   }
   pointAt(t) {
@@ -13214,7 +13214,7 @@ var Arc = class extends Path_default {
   getDefaultShape() {
     return new ArcShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const x = shape.cx;
     const y = shape.cy;
     const r = Math.max(shape.r, 0);
@@ -13223,8 +13223,8 @@ var Arc = class extends Path_default {
     const clockwise = shape.clockwise;
     const unitX = Math.cos(startAngle);
     const unitY = Math.sin(startAngle);
-    ctx.moveTo(unitX * r + x, unitY * r + y);
-    ctx.arc(x, y, r, startAngle, endAngle, !clockwise);
+    ctx2.moveTo(unitX * r + x, unitY * r + y);
+    ctx2.arc(x, y, r, startAngle, endAngle, !clockwise);
   }
 };
 Arc.prototype.type = "arc";
@@ -13257,10 +13257,10 @@ var CompoundPath = class extends Path_default {
       paths[i].path.setScale(scale4[0], scale4[1], paths[i].segmentIgnoreThreshold);
     }
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const paths = shape.paths || [];
     for (let i = 0; i < paths.length; i++) {
-      paths[i].buildPath(ctx, paths[i].shape, true);
+      paths[i].buildPath(ctx2, paths[i].shape, true);
     }
   }
   afterBrush() {
@@ -13561,15 +13561,15 @@ var CirculateLine = class extends Path_default {
   getDefaultShape() {
     return new CirculateLineShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4, count: count2, gap, lineWidth} = shape;
     const [start2, end2] = points4;
     const [startX, startY] = start2 || [];
     const [endX, endY] = end2 || [];
     for (let index = 0; index < count2; index++) {
       const xGap = index * gap;
-      ctx.moveTo(formatPoint(startX + xGap, lineWidth), startY);
-      ctx.lineTo(formatPoint(endX + xGap, lineWidth), endY);
+      ctx2.moveTo(formatPoint(startX + xGap, lineWidth), startY);
+      ctx2.lineTo(formatPoint(endX + xGap, lineWidth), endY);
     }
   }
 };
@@ -13589,14 +13589,14 @@ var Diagonal = class extends Path_default {
   getDefaultShape() {
     return new DiagonalShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4} = shape;
     for (let index = 0; index < points4.length; index++) {
       const [startPoint, endPoint] = points4[index];
       const [startX, startY] = startPoint;
       const [endX, endY] = endPoint;
-      ctx.moveTo(startX, startY);
-      ctx.lineTo(endX, endY);
+      ctx2.moveTo(startX, startY);
+      ctx2.lineTo(endX, endY);
     }
   }
 };
@@ -16278,6 +16278,7 @@ var BUILTIN_CHARTS_MAP = {
   strategy: "StrategyChart",
   mineLines: "MineLinesChart",
   lineFills: "LineFillsChart",
+  charPlot: "CharPlotChart",
   boxes: "BoxesChart",
   labels: "LabelsChart",
   hlines: "HLinesChart",
@@ -19823,14 +19824,14 @@ function getBlockGapLevel(frag) {
   }
   return 0;
 }
-function buildSection(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
+function buildSection(ctx2, fragment, topMarginForOuterGap, toolTipTextStyle) {
   const noHeader = fragment.noHeader;
   const gaps = getGap(getBlockGapLevel(fragment));
   const subMarkupTextList = [];
   let subBlocks = fragment.blocks || [];
   assert(!subBlocks || isArray(subBlocks));
   subBlocks = subBlocks || [];
-  const orderMode = ctx.orderMode;
+  const orderMode = ctx2.orderMode;
   if (fragment.sortBlocks && orderMode) {
     subBlocks = subBlocks.slice();
     const orderMap = {valueAsc: "asc", valueDesc: "desc"};
@@ -19843,57 +19844,57 @@ function buildSection(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
   }
   each(subBlocks, function(subBlock, idx) {
     const valueFormatter = fragment.valueFormatter;
-    const subMarkupText2 = getBuilder(subBlock)(valueFormatter ? extend(extend({}, ctx), {valueFormatter}) : ctx, subBlock, idx > 0 ? gaps.html : 0, toolTipTextStyle);
+    const subMarkupText2 = getBuilder(subBlock)(valueFormatter ? extend(extend({}, ctx2), {valueFormatter}) : ctx2, subBlock, idx > 0 ? gaps.html : 0, toolTipTextStyle);
     subMarkupText2 != null && subMarkupTextList.push(subMarkupText2);
   });
-  const subMarkupText = ctx.renderMode === "richText" ? subMarkupTextList.join(gaps.richText) : wrapBlockHTML(subMarkupTextList.join(""), noHeader ? topMarginForOuterGap : gaps.html);
+  const subMarkupText = ctx2.renderMode === "richText" ? subMarkupTextList.join(gaps.richText) : wrapBlockHTML(subMarkupTextList.join(""), noHeader ? topMarginForOuterGap : gaps.html);
   if (noHeader) {
     return subMarkupText;
   }
-  const displayableHeader = makeValueReadable(fragment.header, "ordinal", ctx.useUTC);
-  const {nameStyle} = getTooltipTextStyle(toolTipTextStyle, ctx.renderMode);
-  if (ctx.renderMode === "richText") {
-    return wrapInlineNameRichText(ctx, displayableHeader, nameStyle) + gaps.richText + subMarkupText;
+  const displayableHeader = makeValueReadable(fragment.header, "ordinal", ctx2.useUTC);
+  const {nameStyle} = getTooltipTextStyle(toolTipTextStyle, ctx2.renderMode);
+  if (ctx2.renderMode === "richText") {
+    return wrapInlineNameRichText(ctx2, displayableHeader, nameStyle) + gaps.richText + subMarkupText;
   } else {
     return wrapBlockHTML(`<div style="${nameStyle};${TOOLTIP_LINE_HEIGHT_CSS};">` + encodeHTML(displayableHeader) + "</div>" + subMarkupText, topMarginForOuterGap);
   }
 }
-function buildNameValue(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
-  const renderMode = ctx.renderMode;
+function buildNameValue(ctx2, fragment, topMarginForOuterGap, toolTipTextStyle) {
+  const renderMode = ctx2.renderMode;
   const noName = fragment.noName;
   const noValue = fragment.noValue;
   const noMarker = !fragment.markerType;
   const name = fragment.name;
-  const useUTC = ctx.useUTC;
-  const valueFormatter = fragment.valueFormatter || ctx.valueFormatter || ((value) => {
+  const useUTC = ctx2.useUTC;
+  const valueFormatter = fragment.valueFormatter || ctx2.valueFormatter || ((value) => {
     value = isArray(value) ? value : [value];
     return map(value, (val, idx) => makeValueReadable(val, isArray(valueTypeOption) ? valueTypeOption[idx] : valueTypeOption, useUTC));
   });
   if (noName && noValue) {
     return;
   }
-  const markerStr = noMarker ? "" : ctx.markupStyleCreator.makeTooltipMarker(fragment.markerType, fragment.markerColor || "#333", renderMode);
+  const markerStr = noMarker ? "" : ctx2.markupStyleCreator.makeTooltipMarker(fragment.markerType, fragment.markerColor || "#333", renderMode);
   const readableName = noName ? "" : makeValueReadable(name, "ordinal", useUTC);
   const valueTypeOption = fragment.valueType;
   const readableValueList = noValue ? [] : valueFormatter(fragment.value, fragment.dataIndex);
   const valueAlignRight = !noMarker || !noName;
   const valueCloseToMarker = !noMarker && noName;
   const {nameStyle, valueStyle} = getTooltipTextStyle(toolTipTextStyle, renderMode);
-  return renderMode === "richText" ? (noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameRichText(ctx, readableName, nameStyle)) + (noValue ? "" : wrapInlineValueRichText(ctx, readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)) : wrapBlockHTML((noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameHTML(readableName, !noMarker, nameStyle)) + (noValue ? "" : wrapInlineValueHTML(readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)), topMarginForOuterGap);
+  return renderMode === "richText" ? (noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameRichText(ctx2, readableName, nameStyle)) + (noValue ? "" : wrapInlineValueRichText(ctx2, readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)) : wrapBlockHTML((noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameHTML(readableName, !noMarker, nameStyle)) + (noValue ? "" : wrapInlineValueHTML(readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)), topMarginForOuterGap);
 }
 function buildTooltipMarkup(fragment, markupStyleCreator, renderMode, orderMode, useUTC, toolTipTextStyle) {
   if (!fragment) {
     return;
   }
   const builder = getBuilder(fragment);
-  const ctx = {
+  const ctx2 = {
     useUTC,
     renderMode,
     orderMode,
     markupStyleCreator,
     valueFormatter: fragment.valueFormatter
   };
-  return builder(ctx, fragment, 0, toolTipTextStyle);
+  return builder(ctx2, fragment, 0, toolTipTextStyle);
 }
 function getGap(gapLevel) {
   return {
@@ -19916,14 +19917,14 @@ function wrapInlineValueHTML(valueList, alignRight, valueCloseToMarker, style) {
   valueList = isArray(valueList) ? valueList : [valueList];
   return `<span style="${alignCSS};${style}">` + map(valueList, (value) => encodeHTML(value)).join("&nbsp;&nbsp;") + "</span>";
 }
-function wrapInlineNameRichText(ctx, name, style) {
-  return ctx.markupStyleCreator.wrapRichTextStyle(name, style);
+function wrapInlineNameRichText(ctx2, name, style) {
+  return ctx2.markupStyleCreator.wrapRichTextStyle(name, style);
 }
-function wrapInlineValueRichText(ctx, values, alignRight, valueCloseToMarker, style) {
+function wrapInlineValueRichText(ctx2, values, alignRight, valueCloseToMarker, style) {
   const styles = [style];
   const paddingLeft = valueCloseToMarker ? 10 : 20;
   alignRight && styles.push({padding: [0, 0, 0, paddingLeft], align: "right"});
-  return ctx.markupStyleCreator.wrapRichTextStyle(isArray(values) ? values.join("  ") : values, styles);
+  return ctx2.markupStyleCreator.wrapRichTextStyle(isArray(values) ? values.join("  ") : values, styles);
 }
 function retrieveVisualColorForTooltipMarker(series, dataIndex) {
   const style = series.getData().getItemVisual(dataIndex, "style");
@@ -21868,18 +21869,18 @@ var Arrow = Path_default.extend({
     width: 0,
     height: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const height = shape.height;
     const width = shape.width;
     const x = shape.x;
     const y = shape.y;
     const dx = width / 3 * 2;
-    ctx.moveTo(x, y);
-    ctx.lineTo(x + dx, y + height);
-    ctx.lineTo(x, y + height / 4 * 3);
-    ctx.lineTo(x - dx, y + height);
-    ctx.lineTo(x, y);
-    ctx.closePath();
+    ctx2.moveTo(x, y);
+    ctx2.lineTo(x + dx, y + height);
+    ctx2.lineTo(x, y + height / 4 * 3);
+    ctx2.lineTo(x - dx, y + height);
+    ctx2.lineTo(x, y);
+    ctx2.closePath();
   }
 });
 var Cross = Path_default.extend({
@@ -21890,27 +21891,27 @@ var Cross = Path_default.extend({
     width: 0,
     height: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const height = shape.height;
     const width = shape.width;
     const x = shape.x;
     const y = shape.y;
     const dx = width / 3;
     const dy = height / 3;
-    ctx.moveTo(x - dx * 0.5, y + dy * 1.5);
-    ctx.lineTo(x + dx * 0.5, y + dy * 1.5);
-    ctx.lineTo(x + dx * 0.5, y + dy * 0.5);
-    ctx.lineTo(x + dx * 1.5, y + dy * 0.5);
-    ctx.lineTo(x + dx * 1.5, y - dy * 0.5);
-    ctx.lineTo(x + dx * 0.5, y - dy * 0.5);
-    ctx.lineTo(x + dx * 0.5, y - dy * 1.5);
-    ctx.lineTo(x - dx * 0.5, y - dy * 1.5);
-    ctx.lineTo(x - dx * 0.5, y - dy * 0.5);
-    ctx.lineTo(x - dx * 1.5, y - dy * 0.5);
-    ctx.lineTo(x - dx * 1.5, y + dy * 0.5);
-    ctx.lineTo(x - dx * 0.5, y + dy * 0.5);
-    ctx.lineTo(x - dx * 0.5, y + dy * 1.5);
-    ctx.closePath();
+    ctx2.moveTo(x - dx * 0.5, y + dy * 1.5);
+    ctx2.lineTo(x + dx * 0.5, y + dy * 1.5);
+    ctx2.lineTo(x + dx * 0.5, y + dy * 0.5);
+    ctx2.lineTo(x + dx * 1.5, y + dy * 0.5);
+    ctx2.lineTo(x + dx * 1.5, y - dy * 0.5);
+    ctx2.lineTo(x + dx * 0.5, y - dy * 0.5);
+    ctx2.lineTo(x + dx * 0.5, y - dy * 1.5);
+    ctx2.lineTo(x - dx * 0.5, y - dy * 1.5);
+    ctx2.lineTo(x - dx * 0.5, y - dy * 0.5);
+    ctx2.lineTo(x - dx * 1.5, y - dy * 0.5);
+    ctx2.lineTo(x - dx * 1.5, y + dy * 0.5);
+    ctx2.lineTo(x - dx * 0.5, y + dy * 0.5);
+    ctx2.lineTo(x - dx * 0.5, y + dy * 1.5);
+    ctx2.closePath();
   }
 });
 var LabelDown = Path_default.extend({
@@ -21923,21 +21924,21 @@ var LabelDown = Path_default.extend({
     r: 0,
     triangleWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {x, y, width, height, r, triangleWidth} = shape;
     const triangleHeight = triangleWidth;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + width / 2 + triangleWidth, y + height);
-    ctx.lineTo(x + width / 2, y + height + triangleHeight);
-    ctx.lineTo(x + width / 2 - triangleWidth, y + height);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y + r);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + width / 2 + triangleWidth, y + height);
+    ctx2.lineTo(x + width / 2, y + height + triangleHeight);
+    ctx2.lineTo(x + width / 2 - triangleWidth, y + height);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y + r);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var LabelUp = Path_default.extend({
@@ -21950,21 +21951,21 @@ var LabelUp = Path_default.extend({
     r: 0,
     triangleWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {x, y, width, height, r, triangleWidth} = shape;
     const triangleHeight = triangleWidth;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width / 2 - triangleWidth, y);
-    ctx.lineTo(x + width / 2, y - triangleHeight);
-    ctx.lineTo(x + width / 2 + triangleWidth, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y + r);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width / 2 - triangleWidth, y);
+    ctx2.lineTo(x + width / 2, y - triangleHeight);
+    ctx2.lineTo(x + width / 2 + triangleWidth, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y + r);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var LabelLeft = Path_default.extend({
@@ -21977,21 +21978,21 @@ var LabelLeft = Path_default.extend({
     r: 0,
     triangleWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {x, y, width, height, r, triangleWidth} = shape;
     const triangleHeight = triangleWidth;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y + height / 2 + triangleWidth);
-    ctx.lineTo(x - triangleHeight, y + height / 2);
-    ctx.lineTo(x, y + height / 2 - triangleWidth);
-    ctx.lineTo(x, y + r);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y + height / 2 + triangleWidth);
+    ctx2.lineTo(x - triangleHeight, y + height / 2);
+    ctx2.lineTo(x, y + height / 2 - triangleWidth);
+    ctx2.lineTo(x, y + r);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var LabelRight = Path_default.extend({
@@ -22004,21 +22005,21 @@ var LabelRight = Path_default.extend({
     r: 0,
     triangleWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {x, y, width, height, r, triangleWidth} = shape;
     const triangleHeight = triangleWidth;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height / 2 - triangleWidth);
-    ctx.lineTo(x + width + triangleHeight, y + height / 2);
-    ctx.lineTo(x + width, y + height / 2 + triangleWidth);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y + r);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height / 2 - triangleWidth);
+    ctx2.lineTo(x + width + triangleHeight, y + height / 2);
+    ctx2.lineTo(x + width, y + height / 2 + triangleWidth);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y + r);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var LabelLowerLeft = Path_default.extend({
@@ -22033,7 +22034,7 @@ var LabelLowerLeft = Path_default.extend({
     offsetX: 0,
     offsetWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const height = shape.height;
     const width = shape.width;
     const x = shape.x;
@@ -22042,16 +22043,16 @@ var LabelLowerLeft = Path_default.extend({
     const offsetY = shape.offsetY;
     const offsetX = shape.offsetX;
     const offsetWidth = shape.offsetWidth;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + r, y + height);
-    ctx.lineTo(x - offsetWidth, y + height + offsetY);
-    ctx.lineTo(x, y + height - offsetX);
-    ctx.lineTo(x, y + r);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.lineTo(x - offsetWidth, y + height + offsetY);
+    ctx2.lineTo(x, y + height - offsetX);
+    ctx2.lineTo(x, y + r);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var LabelLowerRight = Path_default.extend({
@@ -22066,7 +22067,7 @@ var LabelLowerRight = Path_default.extend({
     offsetX: 0,
     offsetWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const offsetY = shape.offsetY;
     const offsetX = shape.offsetX;
     const offsetWidth = shape.offsetWidth;
@@ -22075,16 +22076,16 @@ var LabelLowerRight = Path_default.extend({
     const x = shape.x;
     const y = shape.y;
     const r = shape.r;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height - offsetWidth);
-    ctx.lineTo(x + width + offsetX, y + height + offsetY);
-    ctx.lineTo(x + width - r, y + height);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y + r);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height - offsetWidth);
+    ctx2.lineTo(x + width + offsetX, y + height + offsetY);
+    ctx2.lineTo(x + width - r, y + height);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y + r);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var LabelUpperLeft = Path_default.extend({
@@ -22099,7 +22100,7 @@ var LabelUpperLeft = Path_default.extend({
     offsetX: 0,
     offsetWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const height = shape.height;
     const width = shape.width;
     const x = shape.x;
@@ -22108,16 +22109,16 @@ var LabelUpperLeft = Path_default.extend({
     const offsetY = shape.offsetY;
     const offsetX = shape.offsetX;
     const offsetWidth = shape.offsetWidth;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y + offsetWidth);
-    ctx.lineTo(x - offsetX, y - offsetY);
-    ctx.lineTo(x + r, y);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y + offsetWidth);
+    ctx2.lineTo(x - offsetX, y - offsetY);
+    ctx2.lineTo(x + r, y);
   }
 });
 var LabelUpperRight = Path_default.extend({
@@ -22132,7 +22133,7 @@ var LabelUpperRight = Path_default.extend({
     offsetX: 0,
     offsetWidth: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const height = shape.height;
     const width = shape.width;
     const x = shape.x;
@@ -22141,16 +22142,16 @@ var LabelUpperRight = Path_default.extend({
     const offsetY = shape.offsetY;
     const offsetX = shape.offsetX;
     const offsetWidth = shape.offsetWidth;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.lineTo(x + width + offsetX, y - offsetY);
-    ctx.lineTo(x + width, y + offsetWidth);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.lineTo(x + width + offsetX, y - offsetY);
+    ctx2.lineTo(x + width, y + offsetWidth);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var LabelCenter = Path_default.extend({
@@ -22162,21 +22163,21 @@ var LabelCenter = Path_default.extend({
     height: 0,
     r: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const height = shape.height;
     const width = shape.width;
     const x = shape.x;
     const y = shape.y;
     const r = shape.r;
-    ctx.moveTo(x + r, y);
-    ctx.lineTo(x + width - r, y);
-    ctx.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
-    ctx.lineTo(x + width, y + height - r);
-    ctx.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
-    ctx.lineTo(x + r, y + height);
-    ctx.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
-    ctx.lineTo(x, y);
-    ctx.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
+    ctx2.moveTo(x + r, y);
+    ctx2.lineTo(x + width - r, y);
+    ctx2.arc(x + width - r, y + r, r, -Math.PI / 2, 0);
+    ctx2.lineTo(x + width, y + height - r);
+    ctx2.arc(x + width - r, y + height - r, r, 0, Math.PI / 2);
+    ctx2.lineTo(x + r, y + height);
+    ctx2.arc(x + r, y + height - r, r, Math.PI / 2, Math.PI);
+    ctx2.lineTo(x, y);
+    ctx2.arc(x + r, y + r, r, Math.PI, Math.PI * 1.5);
   }
 });
 var XCross = Path_default.extend({
@@ -22187,14 +22188,14 @@ var XCross = Path_default.extend({
     width: 0,
     height: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {x, y} = shape;
     const width = shape.width / 2;
     const height = shape.height / 2;
-    ctx.moveTo(x + width, y - height);
-    ctx.lineTo(x - width, y + height);
-    ctx.moveTo(x - width, y - height);
-    ctx.lineTo(x + width, y + height);
+    ctx2.moveTo(x + width, y - height);
+    ctx2.lineTo(x - width, y + height);
+    ctx2.moveTo(x - width, y - height);
+    ctx2.lineTo(x + width, y + height);
   }
 });
 var LCross = Path_default.extend({
@@ -22205,14 +22206,14 @@ var LCross = Path_default.extend({
     width: 0,
     height: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {x, y} = shape;
     const width = shape.width / 2;
     const height = shape.height / 2;
-    ctx.moveTo(x, y - height);
-    ctx.lineTo(x, y + height);
-    ctx.moveTo(x - width, y);
-    ctx.lineTo(x + width, y);
+    ctx2.moveTo(x, y - height);
+    ctx2.lineTo(x, y + height);
+    ctx2.moveTo(x - width, y);
+    ctx2.lineTo(x + width, y);
   }
 });
 var Flag = Path_default.extend({
@@ -22223,7 +22224,7 @@ var Flag = Path_default.extend({
     width: 0,
     height: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {x, y} = shape;
     const width = shape.width / 2;
     const height = shape.height / 2;
@@ -22234,14 +22235,14 @@ var Flag = Path_default.extend({
     const endX = x + width;
     const topY = y - height;
     const bottomY = y + height;
-    ctx.moveTo(x - width, topY);
-    ctx.lineTo(startX, topY);
-    ctx.bezierCurveTo(startX + 1 / 3 * shape.width, topY - range, startX + 2 / 3 * shape.width, topY + range, endX, topY);
-    ctx.lineTo(endX, topY + rangeHeight);
-    ctx.bezierCurveTo(startX + 2 / 3 * shape.width, topY + range + rangeHeight, startX + 1 / 3 * shape.width, topY - range + rangeHeight, startX, topY + rangeHeight);
-    ctx.lineTo(startX, bottomY);
-    ctx.lineTo(x - width, bottomY);
-    ctx.lineTo(x - width, topY);
+    ctx2.moveTo(x - width, topY);
+    ctx2.lineTo(startX, topY);
+    ctx2.bezierCurveTo(startX + 1 / 3 * shape.width, topY - range, startX + 2 / 3 * shape.width, topY + range, endX, topY);
+    ctx2.lineTo(endX, topY + rangeHeight);
+    ctx2.bezierCurveTo(startX + 2 / 3 * shape.width, topY + range + rangeHeight, startX + 1 / 3 * shape.width, topY - range + rangeHeight, startX, topY + rangeHeight);
+    ctx2.lineTo(startX, bottomY);
+    ctx2.lineTo(x - width, bottomY);
+    ctx2.lineTo(x - width, topY);
   }
 });
 var TriangleDown = Path_default.extend({
@@ -22311,19 +22312,19 @@ var ArrowUp = Path_default.extend({
     rectWidth: 0,
     triangleHeight: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {cx, cy, rectWidth, triangleHeight} = shape;
     const width = shape.width / 2;
     const height = shape.height / 2;
     const triangleY = cy - height + triangleHeight;
-    ctx.moveTo(cx, cy - height);
-    ctx.lineTo(cx + width, triangleY);
-    ctx.lineTo(cx + width - rectWidth, triangleY);
-    ctx.lineTo(cx + width - rectWidth, cy + height);
-    ctx.lineTo(cx - width + rectWidth, cy + height);
-    ctx.lineTo(cx - width + rectWidth, triangleY);
-    ctx.lineTo(cx - width, triangleY);
-    ctx.closePath();
+    ctx2.moveTo(cx, cy - height);
+    ctx2.lineTo(cx + width, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, cy + height);
+    ctx2.lineTo(cx - width + rectWidth, cy + height);
+    ctx2.lineTo(cx - width + rectWidth, triangleY);
+    ctx2.lineTo(cx - width, triangleY);
+    ctx2.closePath();
   }
 });
 var ArrowUpClose = Path_default.extend({
@@ -22336,21 +22337,21 @@ var ArrowUpClose = Path_default.extend({
     rectWidth: 0,
     triangleHeight: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {cx, cy, rectWidth, triangleHeight} = shape;
     const width = shape.width / 2;
     const height = shape.height / 2;
     const triangleY = cy - height + triangleHeight;
     const rectHeight = 3;
-    ctx.moveTo(cx, cy - height);
-    ctx.lineTo(cx + width, triangleY);
-    ctx.lineTo(cx + width - rectWidth, triangleY);
-    ctx.lineTo(cx + width - rectWidth, cy + height);
-    ctx.lineTo(cx - width + rectWidth, cy + height);
-    ctx.lineTo(cx - width + rectWidth, triangleY);
-    ctx.lineTo(cx - width, triangleY);
-    ctx.closePath();
-    ctx.rect(cx - width + 0.5, cy - height - 0.5 - rectHeight, shape.width - 0.5, rectHeight);
+    ctx2.moveTo(cx, cy - height);
+    ctx2.lineTo(cx + width, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, cy + height);
+    ctx2.lineTo(cx - width + rectWidth, cy + height);
+    ctx2.lineTo(cx - width + rectWidth, triangleY);
+    ctx2.lineTo(cx - width, triangleY);
+    ctx2.closePath();
+    ctx2.rect(cx - width + 0.5, cy - height - 0.5 - rectHeight, shape.width - 0.5, rectHeight);
   }
 });
 var ArrowDown = Path_default.extend({
@@ -22363,19 +22364,19 @@ var ArrowDown = Path_default.extend({
     rectWidth: 0,
     triangleHeight: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {cx, cy, rectWidth, triangleHeight} = shape;
     const width = shape.width / 2;
     const height = shape.height / 2;
     const triangleY = cy + height - triangleHeight;
-    ctx.moveTo(cx, cy + height);
-    ctx.lineTo(cx + width, triangleY);
-    ctx.lineTo(cx + width - rectWidth, triangleY);
-    ctx.lineTo(cx + width - rectWidth, cy - height);
-    ctx.lineTo(cx - width + rectWidth, cy - height);
-    ctx.lineTo(cx - width + rectWidth, triangleY);
-    ctx.lineTo(cx - width, triangleY);
-    ctx.closePath();
+    ctx2.moveTo(cx, cy + height);
+    ctx2.lineTo(cx + width, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, cy - height);
+    ctx2.lineTo(cx - width + rectWidth, cy - height);
+    ctx2.lineTo(cx - width + rectWidth, triangleY);
+    ctx2.lineTo(cx - width, triangleY);
+    ctx2.closePath();
   }
 });
 var ArrowDownClose = Path_default.extend({
@@ -22388,21 +22389,21 @@ var ArrowDownClose = Path_default.extend({
     rectWidth: 0,
     triangleHeight: 0
   },
-  buildPath: function(ctx, shape) {
+  buildPath: function(ctx2, shape) {
     const {cx, cy, rectWidth, triangleHeight} = shape;
     const width = shape.width / 2;
     const height = shape.height / 2;
     const triangleY = cy + height - triangleHeight;
     const rectHeight = 3;
-    ctx.moveTo(cx, cy + height);
-    ctx.lineTo(cx + width, triangleY);
-    ctx.lineTo(cx + width - rectWidth, triangleY);
-    ctx.lineTo(cx + width - rectWidth, cy - height);
-    ctx.lineTo(cx - width + rectWidth, cy - height);
-    ctx.lineTo(cx - width + rectWidth, triangleY);
-    ctx.lineTo(cx - width, triangleY);
-    ctx.closePath();
-    ctx.rect(cx - width + 0.5, cy + height + 0.5, shape.width - 0.5, rectHeight);
+    ctx2.moveTo(cx, cy + height);
+    ctx2.lineTo(cx + width, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, triangleY);
+    ctx2.lineTo(cx + width - rectWidth, cy - height);
+    ctx2.lineTo(cx - width + rectWidth, cy - height);
+    ctx2.lineTo(cx - width + rectWidth, triangleY);
+    ctx2.lineTo(cx - width, triangleY);
+    ctx2.closePath();
+    ctx2.rect(cx - width + 0.5, cy + height + 0.5, shape.width - 0.5, rectHeight);
   }
 });
 var symbolCtors = {
@@ -22690,7 +22691,7 @@ var SymbolClz = Path_default.extend({
     }
     return res;
   },
-  buildPath(ctx, shape, inBundle) {
+  buildPath(ctx2, shape, inBundle) {
     let symbolType = shape.symbolType;
     if (symbolType !== "none") {
       let proxySymbol = symbolBuildProxies[symbolType];
@@ -22699,7 +22700,7 @@ var SymbolClz = Path_default.extend({
         proxySymbol = symbolBuildProxies[symbolType];
       }
       symbolShapeMakers[symbolType](shape.x, shape.y, shape.width, shape.height, proxySymbol.shape, shape);
-      proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle);
+      proxySymbol.buildPath(ctx2, proxySymbol.shape, inBundle);
     }
   }
 });
@@ -22769,7 +22770,7 @@ function normalizeSymbolOffset(symbolOffset, symbolSize) {
 function isSafeNum(num) {
   return isFinite(num);
 }
-function createLinearGradient(ctx, obj, rect) {
+function createLinearGradient(ctx2, obj, rect) {
   let x = obj.x == null ? 0 : obj.x;
   let x2 = obj.x2 == null ? 1 : obj.x2;
   let y = obj.y == null ? 0 : obj.y;
@@ -22784,10 +22785,10 @@ function createLinearGradient(ctx, obj, rect) {
   x2 = isSafeNum(x2) ? x2 : 1;
   y = isSafeNum(y) ? y : 0;
   y2 = isSafeNum(y2) ? y2 : 0;
-  const canvasGradient = ctx.createLinearGradient(x, y, x2, y2);
+  const canvasGradient = ctx2.createLinearGradient(x, y, x2, y2);
   return canvasGradient;
 }
-function createRadialGradient(ctx, obj, rect) {
+function createRadialGradient(ctx2, obj, rect) {
   const width = rect.width;
   const height = rect.height;
   const min3 = Math.min(width, height);
@@ -22802,11 +22803,11 @@ function createRadialGradient(ctx, obj, rect) {
   x = isSafeNum(x) ? x : 0.5;
   y = isSafeNum(y) ? y : 0.5;
   r = r >= 0 && isSafeNum(r) ? r : 0.5;
-  const canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);
+  const canvasGradient = ctx2.createRadialGradient(x, y, 0, x, y, r);
   return canvasGradient;
 }
-function getCanvasGradient(ctx, obj, rect) {
-  const canvasGradient = obj.type === "radial" ? createRadialGradient(ctx, obj, rect) : createLinearGradient(ctx, obj, rect);
+function getCanvasGradient(ctx2, obj, rect) {
+  const canvasGradient = obj.type === "radial" ? createRadialGradient(ctx2, obj, rect) : createLinearGradient(ctx2, obj, rect);
   const colorStops = obj.colorStops;
   for (let i = 0; i < colorStops.length; i++) {
     canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);
@@ -22878,30 +22879,30 @@ function styleHasFill(style) {
   const fill = style.fill;
   return fill != null && fill !== "none";
 }
-function doFillPath(ctx, style) {
+function doFillPath(ctx2, style) {
   if (style.fillOpacity != null && style.fillOpacity !== 1) {
-    const originalGlobalAlpha = ctx.globalAlpha;
-    ctx.globalAlpha = style.fillOpacity * style.opacity;
-    ctx.fill();
-    ctx.globalAlpha = originalGlobalAlpha;
+    const originalGlobalAlpha = ctx2.globalAlpha;
+    ctx2.globalAlpha = style.fillOpacity * style.opacity;
+    ctx2.fill();
+    ctx2.globalAlpha = originalGlobalAlpha;
   } else {
-    ctx.fill();
+    ctx2.fill();
   }
 }
-function doStrokePath(ctx, style) {
+function doStrokePath(ctx2, style) {
   if (style.strokeOpacity != null && style.strokeOpacity !== 1) {
-    const originalGlobalAlpha = ctx.globalAlpha;
-    ctx.globalAlpha = style.strokeOpacity * style.opacity;
-    ctx.stroke();
-    ctx.globalAlpha = originalGlobalAlpha;
+    const originalGlobalAlpha = ctx2.globalAlpha;
+    ctx2.globalAlpha = style.strokeOpacity * style.opacity;
+    ctx2.stroke();
+    ctx2.globalAlpha = originalGlobalAlpha;
   } else {
-    ctx.stroke();
+    ctx2.stroke();
   }
 }
-function createCanvasPattern(ctx, pattern, el) {
+function createCanvasPattern(ctx2, pattern, el) {
   const image = createOrUpdateImage(pattern.image, pattern.__image, el);
   if (isImageReady(image)) {
-    const canvasPattern = ctx.createPattern(image, pattern.repeat || "repeat");
+    const canvasPattern = ctx2.createPattern(image, pattern.repeat || "repeat");
     if (typeof DOMMatrix === "function" && canvasPattern && canvasPattern.setTransform) {
       const matrix13 = new DOMMatrix();
       matrix13.translateSelf(pattern.x || 0, pattern.y || 0);
@@ -22912,7 +22913,7 @@ function createCanvasPattern(ctx, pattern, el) {
     return canvasPattern;
   }
 }
-function brushPath(ctx, el, style, inBatch) {
+function brushPath(ctx2, el, style, inBatch) {
   let hasStroke = styleHasStroke(style);
   let hasFill = styleHasFill(style);
   const strokePercent = style.strokePercent;
@@ -22939,35 +22940,35 @@ function brushPath(ctx, el, style, inBatch) {
       rect = el.getBoundingRect();
     }
     if (hasFillGradient) {
-      fillGradient = dirtyFlag ? getCanvasGradient(ctx, fill, rect) : el.__canvasFillGradient;
+      fillGradient = dirtyFlag ? getCanvasGradient(ctx2, fill, rect) : el.__canvasFillGradient;
       el.__canvasFillGradient = fillGradient;
     }
     if (hasStrokeGradient) {
-      strokeGradient = dirtyFlag ? getCanvasGradient(ctx, stroke, rect) : el.__canvasStrokeGradient;
+      strokeGradient = dirtyFlag ? getCanvasGradient(ctx2, stroke, rect) : el.__canvasStrokeGradient;
       el.__canvasStrokeGradient = strokeGradient;
     }
     if (hasFillPattern) {
-      fillPattern = dirtyFlag || !el.__canvasFillPattern ? createCanvasPattern(ctx, fill, el) : el.__canvasFillPattern;
+      fillPattern = dirtyFlag || !el.__canvasFillPattern ? createCanvasPattern(ctx2, fill, el) : el.__canvasFillPattern;
       el.__canvasFillPattern = fillPattern;
     }
     if (hasStrokePattern) {
-      strokePattern = dirtyFlag || !el.__canvasStrokePattern ? createCanvasPattern(ctx, stroke, el) : el.__canvasStrokePattern;
+      strokePattern = dirtyFlag || !el.__canvasStrokePattern ? createCanvasPattern(ctx2, stroke, el) : el.__canvasStrokePattern;
       el.__canvasStrokePattern = fillPattern;
     }
     if (hasFillGradient) {
-      ctx.fillStyle = fillGradient;
+      ctx2.fillStyle = fillGradient;
     } else if (hasFillPattern) {
       if (fillPattern) {
-        ctx.fillStyle = fillPattern;
+        ctx2.fillStyle = fillPattern;
       } else {
         hasFill = false;
       }
     }
     if (hasStrokeGradient) {
-      ctx.strokeStyle = strokeGradient;
+      ctx2.strokeStyle = strokeGradient;
     } else if (hasStrokePattern) {
       if (strokePattern) {
-        ctx.strokeStyle = strokePattern;
+        ctx2.strokeStyle = strokePattern;
       } else {
         hasStroke = false;
       }
@@ -22977,16 +22978,16 @@ function brushPath(ctx, el, style, inBatch) {
   path.setScale(scale4[0], scale4[1], el.segmentIgnoreThreshold);
   let lineDash;
   let lineDashOffset;
-  if (ctx.setLineDash && style.lineDash) {
+  if (ctx2.setLineDash && style.lineDash) {
     [lineDash, lineDashOffset] = getLineDash(el);
   }
   let needsRebuild = true;
   if (firstDraw || dirtyFlag & SHAPE_CHANGED_BIT) {
-    path.setDPR(ctx.dpr);
+    path.setDPR(ctx2.dpr);
     if (strokePart) {
       path.setContext(null);
     } else {
-      path.setContext(ctx);
+      path.setContext(ctx2);
       needsRebuild = false;
     }
     path.reset();
@@ -22995,34 +22996,34 @@ function brushPath(ctx, el, style, inBatch) {
     el.pathUpdated();
   }
   if (needsRebuild) {
-    path.rebuildPath(ctx, strokePart ? strokePercent : 1);
+    path.rebuildPath(ctx2, strokePart ? strokePercent : 1);
   }
   if (lineDash) {
-    ctx.setLineDash(lineDash);
-    ctx.lineDashOffset = lineDashOffset;
+    ctx2.setLineDash(lineDash);
+    ctx2.lineDashOffset = lineDashOffset;
   }
   if (!inBatch) {
     if (style.strokeFirst) {
       if (hasStroke) {
-        doStrokePath(ctx, style);
+        doStrokePath(ctx2, style);
       }
       if (hasFill) {
-        doFillPath(ctx, style);
+        doFillPath(ctx2, style);
       }
     } else {
       if (hasFill) {
-        doFillPath(ctx, style);
+        doFillPath(ctx2, style);
       }
       if (hasStroke) {
-        doStrokePath(ctx, style);
+        doStrokePath(ctx2, style);
       }
     }
   }
   if (lineDash) {
-    ctx.setLineDash([]);
+    ctx2.setLineDash([]);
   }
 }
-function brushImage(ctx, el, style) {
+function brushImage(ctx2, el, style) {
   const image = el.__image = createOrUpdateImage(style.image, el.__image, el, el.onload);
   if (!image || !isImageReady(image)) {
     return;
@@ -23043,50 +23044,50 @@ function brushImage(ctx, el, style) {
   if (style.sWidth && style.sHeight) {
     const sx = style.sx || 0;
     const sy = style.sy || 0;
-    ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height);
+    ctx2.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height);
   } else if (style.sx && style.sy) {
     const sx = style.sx;
     const sy = style.sy;
     const sWidth = width - sx;
     const sHeight = height - sy;
-    ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);
+    ctx2.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);
   } else {
-    ctx.drawImage(image, x, y, width, height);
+    ctx2.drawImage(image, x, y, width, height);
   }
 }
-function brushText(ctx, el, style) {
+function brushText(ctx2, el, style) {
   let text = style.text;
   text != null && (text += "");
   if (text) {
-    ctx.font = style.font || DEFAULT_FONT;
-    ctx.textAlign = style.textAlign;
-    ctx.textBaseline = style.textBaseline;
+    ctx2.font = style.font || DEFAULT_FONT;
+    ctx2.textAlign = style.textAlign;
+    ctx2.textBaseline = style.textBaseline;
     let lineDash;
     let lineDashOffset;
-    if (ctx.setLineDash && style.lineDash) {
+    if (ctx2.setLineDash && style.lineDash) {
       [lineDash, lineDashOffset] = getLineDash(el);
     }
     if (lineDash) {
-      ctx.setLineDash(lineDash);
-      ctx.lineDashOffset = lineDashOffset;
+      ctx2.setLineDash(lineDash);
+      ctx2.lineDashOffset = lineDashOffset;
     }
     if (style.strokeFirst) {
       if (styleHasStroke(style)) {
-        ctx.strokeText(text, style.x, style.y);
+        ctx2.strokeText(text, style.x, style.y);
       }
       if (styleHasFill(style)) {
-        ctx.fillText(text, style.x, style.y);
+        ctx2.fillText(text, style.x, style.y);
       }
     } else {
       if (styleHasFill(style)) {
-        ctx.fillText(text, style.x, style.y);
+        ctx2.fillText(text, style.x, style.y);
       }
       if (styleHasStroke(style)) {
-        ctx.strokeText(text, style.x, style.y);
+        ctx2.strokeText(text, style.x, style.y);
       }
     }
     if (lineDash) {
-      ctx.setLineDash([]);
+      ctx2.setLineDash([]);
     }
   }
 }
@@ -23096,7 +23097,7 @@ var STROKE_PROPS = [
   ["lineJoin", "miter"],
   ["miterLimit", 10]
 ];
-function bindCommonProps(ctx, style, prevStyle, forceSetAll, scope) {
+function bindCommonProps(ctx2, style, prevStyle, forceSetAll, scope) {
   let styleChanged = false;
   if (!forceSetAll) {
     prevStyle = prevStyle || {};
@@ -23105,74 +23106,74 @@ function bindCommonProps(ctx, style, prevStyle, forceSetAll, scope) {
     }
   }
   if (forceSetAll || style.opacity !== prevStyle.opacity) {
-    flushPathDrawn(ctx, scope);
+    flushPathDrawn(ctx2, scope);
     styleChanged = true;
     const opacity = Math.max(Math.min(style.opacity, 1), 0);
-    ctx.globalAlpha = isNaN(opacity) ? DEFAULT_COMMON_STYLE.opacity : opacity;
+    ctx2.globalAlpha = isNaN(opacity) ? DEFAULT_COMMON_STYLE.opacity : opacity;
   }
   if (forceSetAll || style.blend !== prevStyle.blend) {
     if (!styleChanged) {
-      flushPathDrawn(ctx, scope);
+      flushPathDrawn(ctx2, scope);
       styleChanged = true;
     }
-    ctx.globalCompositeOperation = style.blend || DEFAULT_COMMON_STYLE.blend;
+    ctx2.globalCompositeOperation = style.blend || DEFAULT_COMMON_STYLE.blend;
   }
   for (let i = 0; i < SHADOW_NUMBER_PROPS.length; i++) {
     const propName = SHADOW_NUMBER_PROPS[i];
     if (forceSetAll || style[propName] !== prevStyle[propName]) {
       if (!styleChanged) {
-        flushPathDrawn(ctx, scope);
+        flushPathDrawn(ctx2, scope);
         styleChanged = true;
       }
-      ctx[propName] = ctx.dpr * (style[propName] || 0);
+      ctx2[propName] = ctx2.dpr * (style[propName] || 0);
     }
   }
   if (forceSetAll || style.shadowColor !== prevStyle.shadowColor) {
     if (!styleChanged) {
-      flushPathDrawn(ctx, scope);
+      flushPathDrawn(ctx2, scope);
       styleChanged = true;
     }
-    ctx.shadowColor = style.shadowColor || DEFAULT_COMMON_STYLE.shadowColor;
+    ctx2.shadowColor = style.shadowColor || DEFAULT_COMMON_STYLE.shadowColor;
   }
   return styleChanged;
 }
-function bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetAll, scope) {
+function bindPathAndTextCommonStyle(ctx2, el, prevEl, forceSetAll, scope) {
   const style = getStyle(el, scope.inHover);
   const prevStyle = forceSetAll ? null : prevEl && getStyle(prevEl, scope.inHover) || {};
   if (style === prevStyle) {
     return false;
   }
-  let styleChanged = bindCommonProps(ctx, style, prevStyle, forceSetAll, scope);
+  let styleChanged = bindCommonProps(ctx2, style, prevStyle, forceSetAll, scope);
   if (forceSetAll || style.fill !== prevStyle.fill) {
     if (!styleChanged) {
-      flushPathDrawn(ctx, scope);
+      flushPathDrawn(ctx2, scope);
       styleChanged = true;
     }
-    isValidStrokeFillStyle(style.fill) && (ctx.fillStyle = style.fill);
+    isValidStrokeFillStyle(style.fill) && (ctx2.fillStyle = style.fill);
   }
   if (forceSetAll || style.stroke !== prevStyle.stroke) {
     if (!styleChanged) {
-      flushPathDrawn(ctx, scope);
+      flushPathDrawn(ctx2, scope);
       styleChanged = true;
     }
-    isValidStrokeFillStyle(style.stroke) && (ctx.strokeStyle = style.stroke);
+    isValidStrokeFillStyle(style.stroke) && (ctx2.strokeStyle = style.stroke);
   }
   if (forceSetAll || style.opacity !== prevStyle.opacity) {
     if (!styleChanged) {
-      flushPathDrawn(ctx, scope);
+      flushPathDrawn(ctx2, scope);
       styleChanged = true;
     }
-    ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;
+    ctx2.globalAlpha = style.opacity == null ? 1 : style.opacity;
   }
   if (el.hasStroke()) {
     const lineWidth = style.lineWidth;
     const newLineWidth = lineWidth / (style.strokeNoScale && el.getLineScale ? el.getLineScale() : 1);
-    if (ctx.lineWidth !== newLineWidth) {
+    if (ctx2.lineWidth !== newLineWidth) {
       if (!styleChanged) {
-        flushPathDrawn(ctx, scope);
+        flushPathDrawn(ctx2, scope);
         styleChanged = true;
       }
-      ctx.lineWidth = newLineWidth;
+      ctx2.lineWidth = newLineWidth;
     }
   }
   for (let i = 0; i < STROKE_PROPS.length; i++) {
@@ -23180,35 +23181,35 @@ function bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetAll, scope) {
     const propName = prop[0];
     if (forceSetAll || style[propName] !== prevStyle[propName]) {
       if (!styleChanged) {
-        flushPathDrawn(ctx, scope);
+        flushPathDrawn(ctx2, scope);
         styleChanged = true;
       }
-      ctx[propName] = style[propName] || prop[1];
+      ctx2[propName] = style[propName] || prop[1];
     }
   }
   return styleChanged;
 }
-function bindImageStyle(ctx, el, prevEl, forceSetAll, scope) {
-  return bindCommonProps(ctx, getStyle(el, scope.inHover), prevEl && getStyle(prevEl, scope.inHover), forceSetAll, scope);
+function bindImageStyle(ctx2, el, prevEl, forceSetAll, scope) {
+  return bindCommonProps(ctx2, getStyle(el, scope.inHover), prevEl && getStyle(prevEl, scope.inHover), forceSetAll, scope);
 }
-function setContextTransform(ctx, el) {
+function setContextTransform(ctx2, el) {
   const m2 = el.transform;
-  const dpr2 = ctx.dpr || 1;
+  const dpr2 = ctx2.dpr || 1;
   if (m2) {
-    ctx.setTransform(dpr2 * m2[0], dpr2 * m2[1], dpr2 * m2[2], dpr2 * m2[3], dpr2 * m2[4], dpr2 * m2[5]);
+    ctx2.setTransform(dpr2 * m2[0], dpr2 * m2[1], dpr2 * m2[2], dpr2 * m2[3], dpr2 * m2[4], dpr2 * m2[5]);
   } else {
-    ctx.setTransform(dpr2, 0, 0, dpr2, 0, 0);
+    ctx2.setTransform(dpr2, 0, 0, dpr2, 0, 0);
   }
 }
-function updateClipStatus(clipPaths, ctx, scope) {
+function updateClipStatus(clipPaths, ctx2, scope) {
   let allClipped = false;
   for (let i = 0; i < clipPaths.length; i++) {
     const clipPath = clipPaths[i];
     allClipped = allClipped || clipPath.isZeroArea();
-    setContextTransform(ctx, clipPath);
-    ctx.beginPath();
-    clipPath.buildPath(ctx, clipPath.shape);
-    ctx.clip();
+    setContextTransform(ctx2, clipPath);
+    ctx2.beginPath();
+    clipPath.buildPath(ctx2, clipPath.shape);
+    ctx2.clip();
   }
   scope.allClipped = allClipped;
 }
@@ -23229,19 +23230,19 @@ function canPathBatch(style) {
   const hasStroke = styleHasStroke(style);
   return !(style.lineDash || !(+hasFill ^ +hasStroke) || hasFill && typeof style.fill !== "string" || hasStroke && typeof style.stroke !== "string" || style.strokePercent < 1 || style.strokeOpacity < 1 || style.fillOpacity < 1);
 }
-function flushPathDrawn(ctx, scope) {
-  scope.batchFill && ctx.fill();
-  scope.batchStroke && ctx.stroke();
+function flushPathDrawn(ctx2, scope) {
+  scope.batchFill && ctx2.fill();
+  scope.batchStroke && ctx2.stroke();
   scope.batchFill = "";
   scope.batchStroke = "";
 }
 function getStyle(el, inHover) {
   return inHover ? el.__hoverStyle || el.style : el.style;
 }
-function brushSingle(ctx, el) {
-  brush(ctx, el, {inHover: false, viewWidth: 0, viewHeight: 0}, true);
+function brushSingle(ctx2, el) {
+  brush(ctx2, el, {inHover: false, viewWidth: 0, viewHeight: 0}, true);
 }
-function brush(ctx, el, scope, isLast) {
+function brush(ctx2, el, scope, isLast) {
   const m2 = el.transform;
   if (!el.shouldBePainted(scope.viewWidth, scope.viewHeight, false, false)) {
     el.__dirty &= ~REDRAW_BIT;
@@ -23254,17 +23255,17 @@ function brush(ctx, el, scope, isLast) {
   let forceSetStyle = false;
   if (!prevElClipPaths || isClipPathChanged(clipPaths, prevElClipPaths)) {
     if (prevElClipPaths && prevElClipPaths.length) {
-      flushPathDrawn(ctx, scope);
-      ctx.restore();
+      flushPathDrawn(ctx2, scope);
+      ctx2.restore();
       forceSetStyle = forceSetTransform = true;
       scope.prevElClipPaths = null;
       scope.allClipped = false;
       scope.prevEl = null;
     }
     if (clipPaths && clipPaths.length) {
-      flushPathDrawn(ctx, scope);
-      ctx.save();
-      updateClipStatus(clipPaths, ctx, scope);
+      flushPathDrawn(ctx2, scope);
+      ctx2.save();
+      updateClipStatus(clipPaths, ctx2, scope);
       forceSetTransform = true;
     }
     scope.prevElClipPaths = clipPaths;
@@ -23281,10 +23282,10 @@ function brush(ctx, el, scope, isLast) {
   }
   let canBatchPath = el instanceof Path_default && el.autoBatch && canPathBatch(el.style);
   if (forceSetTransform || isTransformChanged(m2, prevEl.transform)) {
-    flushPathDrawn(ctx, scope);
-    setContextTransform(ctx, el);
+    flushPathDrawn(ctx2, scope);
+    setContextTransform(ctx2, el);
   } else if (!canBatchPath) {
-    flushPathDrawn(ctx, scope);
+    flushPathDrawn(ctx2, scope);
   }
   const style = getStyle(el, scope.inHover);
   if (el instanceof Path_default) {
@@ -23292,11 +23293,11 @@ function brush(ctx, el, scope, isLast) {
       forceSetStyle = true;
       scope.lastDrawType = DRAW_TYPE_PATH;
     }
-    bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
+    bindPathAndTextCommonStyle(ctx2, el, prevEl, forceSetStyle, scope);
     if (!canBatchPath || !scope.batchFill && !scope.batchStroke) {
-      ctx.beginPath();
+      ctx2.beginPath();
     }
-    brushPath(ctx, el, style, canBatchPath);
+    brushPath(ctx2, el, style, canBatchPath);
     if (canBatchPath) {
       scope.batchFill = style.fill || "";
       scope.batchStroke = style.stroke || "";
@@ -23307,25 +23308,25 @@ function brush(ctx, el, scope, isLast) {
         forceSetStyle = true;
         scope.lastDrawType = DRAW_TYPE_TEXT;
       }
-      bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
-      brushText(ctx, el, style);
+      bindPathAndTextCommonStyle(ctx2, el, prevEl, forceSetStyle, scope);
+      brushText(ctx2, el, style);
     } else if (el instanceof Image_default) {
       if (scope.lastDrawType !== DRAW_TYPE_IMAGE) {
         forceSetStyle = true;
         scope.lastDrawType = DRAW_TYPE_IMAGE;
       }
-      bindImageStyle(ctx, el, prevEl, forceSetStyle, scope);
-      brushImage(ctx, el, style);
+      bindImageStyle(ctx2, el, prevEl, forceSetStyle, scope);
+      brushImage(ctx2, el, style);
     } else if (el.getTemporalDisplayables) {
       if (scope.lastDrawType !== DRAW_TYPE_INCREMENTAL) {
         forceSetStyle = true;
         scope.lastDrawType = DRAW_TYPE_INCREMENTAL;
       }
-      brushIncremental(ctx, el, scope);
+      brushIncremental(ctx2, el, scope);
     }
   }
   if (canBatchPath && isLast) {
-    flushPathDrawn(ctx, scope);
+    flushPathDrawn(ctx2, scope);
   }
   el.innerAfterBrush();
   el.afterBrush && el.afterBrush();
@@ -23333,10 +23334,10 @@ function brush(ctx, el, scope, isLast) {
   el.__dirty = 0;
   el.__isRendered = true;
 }
-function brushIncremental(ctx, el, scope) {
+function brushIncremental(ctx2, el, scope) {
   let displayables = el.getDisplayables();
   let temporalDisplayables = el.getTemporalDisplayables();
-  ctx.save();
+  ctx2.save();
   let innerScope = {
     prevElClipPaths: null,
     prevEl: null,
@@ -23351,7 +23352,7 @@ function brushIncremental(ctx, el, scope) {
     const displayable = displayables[i];
     displayable.beforeBrush && displayable.beforeBrush();
     displayable.innerBeforeBrush();
-    brush(ctx, displayable, innerScope, i === len2 - 1);
+    brush(ctx2, displayable, innerScope, i === len2 - 1);
     displayable.innerAfterBrush();
     displayable.afterBrush && displayable.afterBrush();
     innerScope.prevEl = displayable;
@@ -23360,14 +23361,14 @@ function brushIncremental(ctx, el, scope) {
     const displayable = temporalDisplayables[i2];
     displayable.beforeBrush && displayable.beforeBrush();
     displayable.innerBeforeBrush();
-    brush(ctx, displayable, innerScope, i2 === len3 - 1);
+    brush(ctx2, displayable, innerScope, i2 === len3 - 1);
     displayable.innerAfterBrush();
     displayable.afterBrush && displayable.afterBrush();
     innerScope.prevEl = displayable;
   }
   el.clearTemporalDisplayables();
   el.notClear = true;
-  ctx.restore();
+  ctx2.restore();
 }
 
 // src/util/decal.ts
@@ -23444,7 +23445,7 @@ function createOrUpdatePatternFromDecal(decalObject, api2) {
     const symbolArray = normalizeSymbolArray(decalOpt.symbol);
     const lineBlockLengthsX = getLineBlockLengthX(dashArrayX);
     const lineBlockLengthY = getLineBlockLengthY(dashArrayY);
-    const canvas = !isSVG && platformApi.createCanvas();
+    const canvas2 = !isSVG && platformApi.createCanvas();
     const svgRoot = isSVG && {
       tag: "g",
       attrs: {},
@@ -23452,17 +23453,17 @@ function createOrUpdatePatternFromDecal(decalObject, api2) {
       children: []
     };
     const pSize = getPatternSize();
-    let ctx;
-    if (canvas) {
-      canvas.width = pSize.width * dpr2;
-      canvas.height = pSize.height * dpr2;
-      ctx = canvas.getContext("2d");
+    let ctx2;
+    if (canvas2) {
+      canvas2.width = pSize.width * dpr2;
+      canvas2.height = pSize.height * dpr2;
+      ctx2 = canvas2.getContext("2d");
     }
     brushDecal();
     if (isValidKey) {
-      decalCache.put(cacheKey, canvas || svgRoot);
+      decalCache.put(cacheKey, canvas2 || svgRoot);
     }
-    pattern2.image = canvas;
+    pattern2.image = canvas2;
     pattern2.svgElement = svgRoot;
     pattern2.svgWidth = pSize.width;
     pattern2.svgHeight = pSize.height;
@@ -23494,11 +23495,11 @@ function createOrUpdatePatternFromDecal(decalObject, api2) {
       };
     }
     function brushDecal() {
-      if (ctx) {
-        ctx.clearRect(0, 0, canvas.width, canvas.height);
+      if (ctx2) {
+        ctx2.clearRect(0, 0, canvas2.width, canvas2.height);
         if (decalOpt.backgroundColor) {
-          ctx.fillStyle = decalOpt.backgroundColor;
-          ctx.fillRect(0, 0, canvas.width, canvas.height);
+          ctx2.fillStyle = decalOpt.backgroundColor;
+          ctx2.fillRect(0, 0, canvas2.width, canvas2.height);
         }
       }
       let ySum = 0;
@@ -23563,7 +23564,7 @@ function createOrUpdatePatternFromDecal(decalObject, api2) {
             svgRoot.children.push(symbolVNode);
           }
         } else {
-          brushSingle(ctx, symbol);
+          brushSingle(ctx2, symbol);
         }
       }
     }
@@ -24134,14 +24135,14 @@ var ECharts = class extends Eventful_default {
       const dpr2 = opts && opts.pixelRatio || this.getDevicePixelRatio();
       each(instances2, function(chart, id) {
         if (chart.group === groupId) {
-          const canvas = isSvg ? chart.getZr().painter.getSvgDom().innerHTML : chart.renderToCanvas(clone(opts));
+          const canvas2 = isSvg ? chart.getZr().painter.getSvgDom().innerHTML : chart.renderToCanvas(clone(opts));
           const boundingRect = chart.getDom().getBoundingClientRect();
           left = mathMin12(boundingRect.left, left);
           top = mathMin12(boundingRect.top, top);
           right = mathMax12(boundingRect.right, right);
           bottom = mathMax12(boundingRect.bottom, bottom);
           canvasList.push({
-            dom: canvas,
+            dom: canvas2,
             left: boundingRect.left,
             top: boundingRect.top
           });
@@ -25467,7 +25468,7 @@ ECharts.internalField = function() {
 var echartsProto = ECharts.prototype;
 echartsProto.on = createRegisterEventWithLowercaseECharts("on");
 echartsProto.off = createRegisterEventWithLowercaseECharts("off");
-echartsProto.one = function(eventName, cb, ctx) {
+echartsProto.one = function(eventName, cb, ctx2) {
   const self2 = this;
   deprecateLog("ECharts#one is deprecated.");
   function wrapped(...args2) {
@@ -25475,7 +25476,7 @@ echartsProto.one = function(eventName, cb, ctx) {
     self2.off(eventName, wrapped);
   }
   ;
-  this.on.call(this, eventName, wrapped, ctx);
+  this.on.call(this, eventName, wrapped, ctx2);
 };
 var MOUSE_EVENT_NAMES = [
   "click",
@@ -26537,25 +26538,25 @@ var SeriesData2 = class {
   indicesOfNearest(dim, value, maxDistance) {
     return this._store.indicesOfNearest(this._getStoreDimIndex(dim), value, maxDistance);
   }
-  each(dims, cb, ctx) {
+  each(dims, cb, ctx2) {
     "use strict";
     if (isFunction(dims)) {
-      ctx = cb;
+      ctx2 = cb;
       cb = dims;
       dims = [];
     }
-    const fCtx = ctx || this;
+    const fCtx = ctx2 || this;
     const dimIndices = map2(normalizeDimensions(dims), this._getStoreDimIndex, this);
     this._store.each(dimIndices, fCtx ? bind(cb, fCtx) : cb);
   }
-  filterSelf(dims, cb, ctx) {
+  filterSelf(dims, cb, ctx2) {
     "use strict";
     if (isFunction(dims)) {
-      ctx = cb;
+      ctx2 = cb;
       cb = dims;
       dims = [];
     }
-    const fCtx = ctx || this;
+    const fCtx = ctx2 || this;
     const dimIndices = map2(normalizeDimensions(dims), this._getStoreDimIndex, this);
     this._store = this._store.filter(dimIndices, fCtx ? bind(cb, fCtx) : cb);
     return this;
@@ -26573,30 +26574,30 @@ var SeriesData2 = class {
     this._store = this._store.selectRange(innerRange, contrastFn);
     return this;
   }
-  mapArray(dims, cb, ctx) {
+  mapArray(dims, cb, ctx2) {
     "use strict";
     if (isFunction(dims)) {
-      ctx = cb;
+      ctx2 = cb;
       cb = dims;
       dims = [];
     }
-    ctx = ctx || this;
+    ctx2 = ctx2 || this;
     const result = [];
     this.each(dims, function() {
       result.push(cb && cb.apply(this, arguments));
-    }, ctx);
+    }, ctx2);
     return result;
   }
-  map(dims, cb, ctx, ctxCompat) {
+  map(dims, cb, ctx2, ctxCompat) {
     "use strict";
-    const fCtx = ctx || ctxCompat || this;
+    const fCtx = ctx2 || ctxCompat || this;
     const dimIndices = map2(normalizeDimensions(dims), this._getStoreDimIndex, this);
     const list = cloneListForMapAndSample(this);
     list._store = this._store.map(dimIndices, fCtx ? bind(cb, fCtx) : cb);
     return list;
   }
-  modify(dims, cb, ctx, ctxCompat) {
-    const fCtx = ctx || ctxCompat || this;
+  modify(dims, cb, ctx2, ctxCompat) {
+    const fCtx = ctx2 || ctxCompat || this;
     if (true) {
       each(normalizeDimensions(dims), (dim) => {
         const dimInfo = this.getDimensionInfo(dim);
@@ -33000,7 +33001,7 @@ var Layer = class extends Eventful_default {
   }
   clear(clearAll, clearColor, repaintRects) {
     const dom = this.dom;
-    const ctx = this.ctx;
+    const ctx2 = this.ctx;
     const width = dom.width;
     const height = dom.height;
     clearColor = clearColor || this.clearColor;
@@ -33017,12 +33018,12 @@ var Layer = class extends Eventful_default {
     }
     const domBack = this.domBack;
     function doClear(x, y, width2, height2) {
-      ctx.clearRect(x, y, width2, height2);
+      ctx2.clearRect(x, y, width2, height2);
       if (clearColor && clearColor !== "transparent") {
         let clearColorGradientOrPattern;
         if (isGradientObject(clearColor)) {
           const shouldCache = clearColor.global || clearColor.__width === width2 && clearColor.__height === height2;
-          clearColorGradientOrPattern = shouldCache && clearColor.__canvasGradient || getCanvasGradient(ctx, clearColor, {
+          clearColorGradientOrPattern = shouldCache && clearColor.__canvasGradient || getCanvasGradient(ctx2, clearColor, {
             x: 0,
             y: 0,
             width: width2,
@@ -33034,23 +33035,23 @@ var Layer = class extends Eventful_default {
         } else if (isImagePatternObject(clearColor)) {
           clearColor.scaleX = clearColor.scaleX || dpr2;
           clearColor.scaleY = clearColor.scaleY || dpr2;
-          clearColorGradientOrPattern = createCanvasPattern(ctx, clearColor, {
+          clearColorGradientOrPattern = createCanvasPattern(ctx2, clearColor, {
             dirty() {
               self2.setUnpainted();
               self2.painter.refresh();
             }
           });
         }
-        ctx.save();
-        ctx.fillStyle = clearColorGradientOrPattern || clearColor;
-        ctx.fillRect(x, y, width2, height2);
-        ctx.restore();
+        ctx2.save();
+        ctx2.fillStyle = clearColorGradientOrPattern || clearColor;
+        ctx2.fillRect(x, y, width2, height2);
+        ctx2.restore();
       }
       if (haveMotionBLur) {
-        ctx.save();
-        ctx.globalAlpha = lastFrameAlpha;
-        ctx.drawImage(domBack, x, y, width2, height2);
-        ctx.restore();
+        ctx2.save();
+        ctx2.globalAlpha = lastFrameAlpha;
+        ctx2.drawImage(domBack, x, y, width2, height2);
+        ctx2.restore();
       }
     }
     ;
@@ -33198,29 +33199,29 @@ var CanvasPainter = class {
       viewWidth: this._width,
       viewHeight: this._height
     };
-    let ctx;
+    let ctx2;
     for (let i = 0; i < len2; i++) {
       const el = list[i];
       if (el.__inHover) {
         if (!hoverLayer) {
           hoverLayer = this._hoverlayer = this.getLayer(HOVER_LAYER_ZLEVEL);
         }
-        if (!ctx) {
-          ctx = hoverLayer.ctx;
-          ctx.save();
+        if (!ctx2) {
+          ctx2 = hoverLayer.ctx;
+          ctx2.save();
         }
-        brush(ctx, el, scope, i === len2 - 1);
+        brush(ctx2, el, scope, i === len2 - 1);
       }
     }
-    if (ctx) {
-      ctx.restore();
+    if (ctx2) {
+      ctx2.restore();
     }
   }
   getHoverLayer() {
     return this.getLayer(HOVER_LAYER_ZLEVEL);
   }
-  paintOne(ctx, el) {
-    brushSingle(ctx, el);
+  paintOne(ctx2, el) {
+    brushSingle(ctx2, el);
   }
   _paintList(list, prevList, paintAll, redrawId) {
     if (this._redrawId !== redrawId) {
@@ -33247,13 +33248,13 @@ var CanvasPainter = class {
     }
   }
   _compositeManually() {
-    const ctx = this.getLayer(CANVAS_ZLEVEL).ctx;
+    const ctx2 = this.getLayer(CANVAS_ZLEVEL).ctx;
     const width = this._domRoot.width;
     const height = this._domRoot.height;
-    ctx.clearRect(0, 0, width, height);
+    ctx2.clearRect(0, 0, width, height);
     this.eachBuiltinLayer(function(layer) {
       if (layer.virtual) {
-        ctx.drawImage(layer.dom, 0, 0, width, height);
+        ctx2.drawImage(layer.dom, 0, 0, width, height);
       }
     });
   }
@@ -33271,7 +33272,7 @@ var CanvasPainter = class {
     let needsRefreshHover = false;
     for (let k = 0; k < layerList.length; k++) {
       const layer = layerList[k];
-      const ctx = layer.ctx;
+      const ctx2 = layer.ctx;
       const repaintRects = useDirtyRect && layer.createRepaintRects(list, prevList, this._width, this._height);
       let start2 = paintAll ? layer.__startIndex : layer.__drawIndex;
       const useTimer = !paintAll && layer.incremental && Date.now;
@@ -33312,7 +33313,7 @@ var CanvasPainter = class {
           }
         }
         if (scope.prevElClipPaths) {
-          ctx.restore();
+          ctx2.restore();
         }
       };
       if (repaintRects) {
@@ -33322,18 +33323,18 @@ var CanvasPainter = class {
           const dpr2 = this.dpr;
           for (var r = 0; r < repaintRects.length; ++r) {
             const rect = repaintRects[r];
-            ctx.save();
-            ctx.beginPath();
-            ctx.rect(rect.x * dpr2, rect.y * dpr2, rect.width * dpr2, rect.height * dpr2);
-            ctx.clip();
+            ctx2.save();
+            ctx2.beginPath();
+            ctx2.rect(rect.x * dpr2, rect.y * dpr2, rect.width * dpr2, rect.height * dpr2);
+            ctx2.clip();
             repaint(rect);
-            ctx.restore();
+            ctx2.restore();
           }
         }
       } else {
-        ctx.save();
+        ctx2.save();
         repaint();
-        ctx.restore();
+        ctx2.restore();
       }
       layer.__drawIndex = i;
       if (layer.__drawIndex < layer.__endIndex) {
@@ -33353,15 +33354,15 @@ var CanvasPainter = class {
     };
   }
   _doPaintEl(el, currentLayer, useDirtyRect, repaintRect, scope, isLast) {
-    const ctx = currentLayer.ctx;
+    const ctx2 = currentLayer.ctx;
     if (useDirtyRect) {
       const paintRect = el.getPaintRect();
       if (!repaintRect || paintRect && paintRect.intersect(repaintRect)) {
-        brush(ctx, el, scope, isLast);
+        brush(ctx2, el, scope, isLast);
         el.setPrevPaintRect(paintRect);
       }
     } else {
-      brush(ctx, el, scope, isLast);
+      brush(ctx2, el, scope, isLast);
     }
   }
   getLayer(zlevel, virtual) {
@@ -33630,18 +33631,18 @@ var CanvasPainter = class {
     const imageLayer = new Layer_default("image", this, opts.pixelRatio || this.dpr);
     imageLayer.initContext();
     imageLayer.clear(false, opts.backgroundColor || this._backgroundColor);
-    const ctx = imageLayer.ctx;
+    const ctx2 = imageLayer.ctx;
     if (opts.pixelRatio <= this.dpr) {
       this.refresh();
       const width = imageLayer.dom.width;
       const height = imageLayer.dom.height;
       this.eachLayer(function(layer) {
         if (layer.__builtin__) {
-          ctx.drawImage(layer.dom, 0, 0, width, height);
+          ctx2.drawImage(layer.dom, 0, 0, width, height);
         } else if (layer.renderToCanvas) {
-          ctx.save();
-          layer.renderToCanvas(ctx);
-          ctx.restore();
+          ctx2.save();
+          layer.renderToCanvas(ctx2);
+          ctx2.restore();
         }
       });
     } else {
@@ -33653,7 +33654,7 @@ var CanvasPainter = class {
       const displayList = this.storage.getDisplayList(true);
       for (let i = 0, len2 = displayList.length; i < len2; i++) {
         const el = displayList[i];
-        brush(ctx, el, scope, i === len2 - 1);
+        brush(ctx2, el, scope, i === len2 - 1);
       }
     }
     return imageLayer.dom;
@@ -34386,7 +34387,7 @@ var mathMax6 = Math.max;
 function isPointNull(x, y) {
   return isNaN(x) || isNaN(y);
 }
-function drawSegment(ctx, points4, start2, segLen, allLen, dir3, smooth, smoothMonotone, connectNulls) {
+function drawSegment(ctx2, points4, start2, segLen, allLen, dir3, smooth, smoothMonotone, connectNulls) {
   let prevX;
   let prevY;
   let cpx0;
@@ -34409,7 +34410,7 @@ function drawSegment(ctx, points4, start2, segLen, allLen, dir3, smooth, smoothM
       break;
     }
     if (idx === start2) {
-      ctx[dir3 > 0 ? "moveTo" : "lineTo"](x, y);
+      ctx2[dir3 > 0 ? "moveTo" : "lineTo"](x, y);
       cpx0 = x;
       cpy0 = y;
     } else {
@@ -34502,11 +34503,11 @@ function drawSegment(ctx, points4, start2, segLen, allLen, dir3, smooth, smoothM
             nextCpy0 = y + vy * lenNextSeg / lenPrevSeg;
           }
         }
-        ctx.bezierCurveTo(cpx0, cpy0, cpx1, cpy1, x, y);
+        ctx2.bezierCurveTo(cpx0, cpy0, cpx1, cpy1, x, y);
         cpx0 = nextCpx0;
         cpy0 = nextCpy0;
       } else {
-        ctx.lineTo(x, y);
+        ctx2.lineTo(x, y);
       }
     }
     prevX = x;
@@ -34535,7 +34536,7 @@ var ECPolyline = class extends Path_default {
   getDefaultShape() {
     return new ECPolylineShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const points4 = shape.points;
     let i = 0;
     let len2 = points4.length / 2;
@@ -34552,7 +34553,7 @@ var ECPolyline = class extends Path_default {
       }
     }
     while (i < len2) {
-      i += drawSegment(ctx, points4, i, len2, len2, 1, shape.smooth, shape.smoothMonotone, shape.connectNulls) + 1;
+      i += drawSegment(ctx2, points4, i, len2, len2, 1, shape.smooth, shape.smoothMonotone, shape.connectNulls) + 1;
     }
   }
   getPointOn(xOrY, dim) {
@@ -34626,7 +34627,7 @@ var ECPolygon = class extends Path_default {
   getDefaultShape() {
     return new ECPolygonShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const points4 = shape.points;
     const stackedOnPoints = shape.stackedOnPoints;
     let i = 0;
@@ -34645,10 +34646,10 @@ var ECPolygon = class extends Path_default {
       }
     }
     while (i < len2) {
-      const k = drawSegment(ctx, points4, i, len2, len2, 1, shape.smooth, smoothMonotone, shape.connectNulls);
-      drawSegment(ctx, stackedOnPoints, i + k - 1, k, len2, -1, shape.stackedOnSmooth, smoothMonotone, shape.connectNulls);
+      const k = drawSegment(ctx2, points4, i, len2, len2, 1, shape.smooth, smoothMonotone, shape.connectNulls);
+      drawSegment(ctx2, stackedOnPoints, i + k - 1, k, len2, -1, shape.stackedOnSmooth, smoothMonotone, shape.connectNulls);
       i += k + 1;
-      ctx.closePath();
+      ctx2.closePath();
     }
   }
 };
@@ -36010,7 +36011,7 @@ var SausagePath = class extends Path_default {
   getDefaultShape() {
     return new SausageShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const cx = shape.cx;
     const cy = shape.cy;
     const r0 = Math.max(shape.r0 || 0, 0);
@@ -36030,15 +36031,15 @@ var SausagePath = class extends Path_default {
     const unitEndX = Math.cos(endAngle);
     const unitEndY = Math.sin(endAngle);
     if (lessThanCircle) {
-      ctx.moveTo(unitStartX * r0 + cx, unitStartY * r0 + cy);
-      ctx.arc(unitStartX * rCenter + cx, unitStartY * rCenter + cy, dr, -Math.PI + startAngle, startAngle, !clockwise);
+      ctx2.moveTo(unitStartX * r0 + cx, unitStartY * r0 + cy);
+      ctx2.arc(unitStartX * rCenter + cx, unitStartY * rCenter + cy, dr, -Math.PI + startAngle, startAngle, !clockwise);
     } else {
-      ctx.moveTo(unitStartX * r + cx, unitStartY * r + cy);
+      ctx2.moveTo(unitStartX * r + cx, unitStartY * r + cy);
     }
-    ctx.arc(cx, cy, r, startAngle, endAngle, !clockwise);
-    ctx.arc(unitEndX * rCenter + cx, unitEndY * rCenter + cy, dr, endAngle - Math.PI * 2, endAngle - Math.PI, !clockwise);
+    ctx2.arc(cx, cy, r, startAngle, endAngle, !clockwise);
+    ctx2.arc(unitEndX * rCenter + cx, unitEndY * rCenter + cy, dr, endAngle - Math.PI * 2, endAngle - Math.PI, !clockwise);
     if (r0 !== 0) {
-      ctx.arc(cx, cy, r0, endAngle, startAngle, clockwise);
+      ctx2.arc(cx, cy, r0, endAngle, startAngle, clockwise);
     }
   }
 };
@@ -36824,7 +36825,7 @@ var LargePath = class extends Path_default {
   getDefaultShape() {
     return new LagePathShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const points4 = shape.points;
     const baseDimIdx = this.baseDimIdx;
     const valueDimIdx = 1 - this.baseDimIdx;
@@ -36836,7 +36837,7 @@ var LargePath = class extends Path_default {
       size[valueDimIdx] = points4[i + 2];
       startPoint[baseDimIdx] = points4[i + baseDimIdx];
       startPoint[valueDimIdx] = points4[i + valueDimIdx];
-      ctx.rect(startPoint[0], startPoint[1], size[0], size[1]);
+      ctx2.rect(startPoint[0], startPoint[1], size[0], size[1]);
     }
   }
 };
@@ -37990,12 +37991,12 @@ var LargeSymbolPath = class extends Path_default {
     const size = shape.size;
     const symbolProxy = this.symbolProxy;
     const symbolProxyShape = symbolProxy.shape;
-    const ctx = path.getContext ? path.getContext() : path;
-    const canBoost = ctx && size[0] < BOOST_SIZE_THRESHOLD;
+    const ctx2 = path.getContext ? path.getContext() : path;
+    const canBoost = ctx2 && size[0] < BOOST_SIZE_THRESHOLD;
     const softClipShape = this.softClipShape;
     let i;
     if (canBoost) {
-      this._ctx = ctx;
+      this._ctx = ctx2;
       return;
     }
     this._ctx = null;
@@ -38023,10 +38024,10 @@ var LargeSymbolPath = class extends Path_default {
     const shape = this.shape;
     const points4 = shape.points;
     const size = shape.size;
-    const ctx = this._ctx;
+    const ctx2 = this._ctx;
     const softClipShape = this.softClipShape;
     let i;
-    if (!ctx) {
+    if (!ctx2) {
       return;
     }
     for (i = this._off; i < points4.length; ) {
@@ -38038,7 +38039,7 @@ var LargeSymbolPath = class extends Path_default {
       if (softClipShape && !softClipShape.contain(x, y)) {
         continue;
       }
-      ctx.fillRect(x - size[0] / 2, y - size[1] / 2, size[0], size[1]);
+      ctx2.fillRect(x - size[0] / 2, y - size[1] / 2, size[0], size[1]);
     }
     if (this.incremental) {
       this._off = i;
@@ -43980,15 +43981,15 @@ var TreePath = class extends Path_default {
   getDefaultShape() {
     return new TreeEdgeShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const childPoints = shape.childPoints;
     const childLen = childPoints.length;
     const parentPoint = shape.parentPoint;
     const firstChildPos = childPoints[0];
     const lastChildPos = childPoints[childLen - 1];
     if (childLen === 1) {
-      ctx.moveTo(parentPoint[0], parentPoint[1]);
-      ctx.lineTo(firstChildPos[0], firstChildPos[1]);
+      ctx2.moveTo(parentPoint[0], parentPoint[1]);
+      ctx2.lineTo(firstChildPos[0], firstChildPos[1]);
       return;
     }
     const orient = shape.orient;
@@ -43998,19 +43999,19 @@ var TreePath = class extends Path_default {
     const tmpPoint = [];
     tmpPoint[forkDim] = parentPoint[forkDim];
     tmpPoint[otherDim] = parentPoint[otherDim] + (lastChildPos[otherDim] - parentPoint[otherDim]) * forkPosition;
-    ctx.moveTo(parentPoint[0], parentPoint[1]);
-    ctx.lineTo(tmpPoint[0], tmpPoint[1]);
-    ctx.moveTo(firstChildPos[0], firstChildPos[1]);
+    ctx2.moveTo(parentPoint[0], parentPoint[1]);
+    ctx2.lineTo(tmpPoint[0], tmpPoint[1]);
+    ctx2.moveTo(firstChildPos[0], firstChildPos[1]);
     tmpPoint[forkDim] = firstChildPos[forkDim];
-    ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+    ctx2.lineTo(tmpPoint[0], tmpPoint[1]);
     tmpPoint[forkDim] = lastChildPos[forkDim];
-    ctx.lineTo(tmpPoint[0], tmpPoint[1]);
-    ctx.lineTo(lastChildPos[0], lastChildPos[1]);
+    ctx2.lineTo(tmpPoint[0], tmpPoint[1]);
+    ctx2.lineTo(lastChildPos[0], lastChildPos[1]);
     for (let i = 1; i < childLen - 1; i++) {
       const point = childPoints[i];
-      ctx.moveTo(point[0], point[1]);
+      ctx2.moveTo(point[0], point[1]);
       tmpPoint[forkDim] = point[forkDim];
-      ctx.lineTo(tmpPoint[0], tmpPoint[1]);
+      ctx2.lineTo(tmpPoint[0], tmpPoint[1]);
     }
   }
 };
@@ -47761,11 +47762,11 @@ var ECLinePath = class extends Path_default {
   getDefaultShape() {
     return new StraightLineShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     if (isStraightLine(shape)) {
-      straightLineProto.buildPath.call(this, ctx, shape);
+      straightLineProto.buildPath.call(this, ctx2, shape);
     } else {
-      bezierCurveProto.buildPath.call(this, ctx, shape);
+      bezierCurveProto.buildPath.call(this, ctx2, shape);
     }
   }
   pointAt(t) {
@@ -49188,7 +49189,7 @@ var PointerPath = class extends Path_default {
   getDefaultShape() {
     return new PointerShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const mathCos6 = Math.cos;
     const mathSin6 = Math.sin;
     const r = shape.r;
@@ -49197,11 +49198,11 @@ var PointerPath = class extends Path_default {
     const x = shape.x - mathCos6(angle) * width * (width >= r / 3 ? 1 : 2);
     const y = shape.y - mathSin6(angle) * width * (width >= r / 3 ? 1 : 2);
     angle = shape.angle - Math.PI / 2;
-    ctx.moveTo(x, y);
-    ctx.lineTo(shape.x + mathCos6(angle) * width, shape.y + mathSin6(angle) * width);
-    ctx.lineTo(shape.x + mathCos6(shape.angle) * r, shape.y + mathSin6(shape.angle) * r);
-    ctx.lineTo(shape.x - mathCos6(angle) * width, shape.y - mathSin6(angle) * width);
-    ctx.lineTo(x, y);
+    ctx2.moveTo(x, y);
+    ctx2.lineTo(shape.x + mathCos6(angle) * width, shape.y + mathSin6(angle) * width);
+    ctx2.lineTo(shape.x + mathCos6(shape.angle) * r, shape.y + mathSin6(shape.angle) * r);
+    ctx2.lineTo(shape.x - mathCos6(angle) * width, shape.y - mathSin6(angle) * width);
+    ctx2.lineTo(x, y);
   }
 };
 var PointerPath_default = PointerPath;
@@ -51984,18 +51985,18 @@ var SankeyPath = class extends Path_default {
   getDefaultShape() {
     return new SankeyPathShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const extent3 = shape.extent;
-    ctx.moveTo(shape.x1, shape.y1);
-    ctx.bezierCurveTo(shape.cpx1, shape.cpy1, shape.cpx2, shape.cpy2, shape.x2, shape.y2);
+    ctx2.moveTo(shape.x1, shape.y1);
+    ctx2.bezierCurveTo(shape.cpx1, shape.cpy1, shape.cpx2, shape.cpy2, shape.x2, shape.y2);
     if (shape.orient === "vertical") {
-      ctx.lineTo(shape.x2 + extent3, shape.y2);
-      ctx.bezierCurveTo(shape.cpx2 + extent3, shape.cpy2, shape.cpx1 + extent3, shape.cpy1, shape.x1 + extent3, shape.y1);
+      ctx2.lineTo(shape.x2 + extent3, shape.y2);
+      ctx2.bezierCurveTo(shape.cpx2 + extent3, shape.cpy2, shape.cpx1 + extent3, shape.cpy1, shape.x1 + extent3, shape.y1);
     } else {
-      ctx.lineTo(shape.x2, shape.y2 + extent3);
-      ctx.bezierCurveTo(shape.cpx2, shape.cpy2 + extent3, shape.cpx1, shape.cpy1 + extent3, shape.x1, shape.y1 + extent3);
+      ctx2.lineTo(shape.x2, shape.y2 + extent3);
+      ctx2.bezierCurveTo(shape.cpx2, shape.cpy2 + extent3, shape.cpx1, shape.cpy1 + extent3, shape.x1, shape.y1 + extent3);
     }
-    ctx.closePath();
+    ctx2.closePath();
   }
   highlight() {
     enterEmphasis(this);
@@ -52943,19 +52944,19 @@ var BoxPath = class extends Path_default {
   getDefaultShape() {
     return new BoxPathShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const ends = shape.points;
     let i = 0;
-    ctx.moveTo(ends[i][0], ends[i][1]);
+    ctx2.moveTo(ends[i][0], ends[i][1]);
     i++;
     for (; i < 4; i++) {
-      ctx.lineTo(ends[i][0], ends[i][1]);
+      ctx2.lineTo(ends[i][0], ends[i][1]);
     }
-    ctx.closePath();
+    ctx2.closePath();
     for (; i < ends.length; i++) {
-      ctx.moveTo(ends[i][0], ends[i][1]);
+      ctx2.moveTo(ends[i][0], ends[i][1]);
       i++;
-      ctx.lineTo(ends[i][0], ends[i][1]);
+      ctx2.lineTo(ends[i][0], ends[i][1]);
     }
   }
 };
@@ -53316,21 +53317,21 @@ var NormalBoxPath = class extends Path_default {
   getDefaultShape() {
     return new NormalBoxPathShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const ends = shape.points;
     if (this.__simpleBox) {
-      ctx.moveTo(ends[4][0], ends[4][1]);
-      ctx.lineTo(ends[6][0], ends[6][1]);
+      ctx2.moveTo(ends[4][0], ends[4][1]);
+      ctx2.lineTo(ends[6][0], ends[6][1]);
     } else {
-      ctx.moveTo(ends[0][0], ends[0][1]);
-      ctx.lineTo(ends[1][0], ends[1][1]);
-      ctx.lineTo(ends[2][0], ends[2][1]);
-      ctx.lineTo(ends[3][0], ends[3][1]);
-      ctx.closePath();
-      ctx.moveTo(ends[4][0], ends[4][1]);
-      ctx.lineTo(ends[5][0], ends[5][1]);
-      ctx.moveTo(ends[6][0], ends[6][1]);
-      ctx.lineTo(ends[7][0], ends[7][1]);
+      ctx2.moveTo(ends[0][0], ends[0][1]);
+      ctx2.lineTo(ends[1][0], ends[1][1]);
+      ctx2.lineTo(ends[2][0], ends[2][1]);
+      ctx2.lineTo(ends[3][0], ends[3][1]);
+      ctx2.closePath();
+      ctx2.moveTo(ends[4][0], ends[4][1]);
+      ctx2.lineTo(ends[5][0], ends[5][1]);
+      ctx2.moveTo(ends[6][0], ends[6][1]);
+      ctx2.lineTo(ends[7][0], ends[7][1]);
     }
   }
 };
@@ -53377,13 +53378,13 @@ var LargeBoxPath = class extends Path_default {
   getDefaultShape() {
     return new LargeBoxPathShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const points4 = shape.points;
     for (let i = 0; i < points4.length; ) {
       if (this.__sign === points4[i++]) {
         const x = points4[i++];
-        ctx.moveTo(x, points4[i++]);
-        ctx.lineTo(x, points4[i++]);
+        ctx2.moveTo(x, points4[i++]);
+        ctx2.lineTo(x, points4[i++]);
       } else {
         i += 3;
       }
@@ -54218,7 +54219,7 @@ var LargeLinesPath = class extends Path_default {
   getDefaultShape() {
     return new LargeLinesPathShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const segs = shape.segs;
     const curveness = shape.curveness;
     let i;
@@ -54226,9 +54227,9 @@ var LargeLinesPath = class extends Path_default {
       for (i = this._off; i < segs.length; ) {
         const count2 = segs[i++];
         if (count2 > 0) {
-          ctx.moveTo(segs[i++], segs[i++]);
+          ctx2.moveTo(segs[i++], segs[i++]);
           for (let k = 1; k < count2; k++) {
-            ctx.lineTo(segs[i++], segs[i++]);
+            ctx2.lineTo(segs[i++], segs[i++]);
           }
         }
       }
@@ -54238,13 +54239,13 @@ var LargeLinesPath = class extends Path_default {
         const y0 = segs[i++];
         const x1 = segs[i++];
         const y1 = segs[i++];
-        ctx.moveTo(x0, y0);
+        ctx2.moveTo(x0, y0);
         if (curveness > 0) {
           const x2 = (x0 + x1) / 2 - (y0 - y1) * curveness;
           const y2 = (y0 + y1) / 2 - (x1 - x0) * curveness;
-          ctx.quadraticCurveTo(x2, y2, x1, y1);
+          ctx2.quadraticCurveTo(x2, y2, x1, y1);
         } else {
-          ctx.lineTo(x1, y1);
+          ctx2.lineTo(x1, y1);
         }
       }
     }
@@ -54921,7 +54922,7 @@ var LinePlotPath = class extends Path_default {
   getDefaultShape() {
     return new LinePlotShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4} = shape;
     for (let index = 0; index < points4.length; index++) {
       const point = points4[index];
@@ -54934,11 +54935,11 @@ var LinePlotPath = class extends Path_default {
           continue;
         }
         const [x2, y2] = nextPoint;
-        ctx.moveTo(x2, y2);
+        ctx2.moveTo(x2, y2);
         continue;
       }
       const [x, y] = point;
-      ctx.lineTo(x, y);
+      ctx2.lineTo(x, y);
     }
   }
 };
@@ -54970,17 +54971,17 @@ var PolyPlotPath = class extends Path_default {
   getDefaultShape() {
     return new PolyPlotShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4, baseY} = shape;
     let startIndex = 0;
     for (let index = 0; index < points4.length; index++) {
       const point = points4[index];
       if (point === 0 || isPointNull4(point)) {
         if (startIndex) {
-          ctx.lineTo(points4[index - 1][0], baseY);
+          ctx2.lineTo(points4[index - 1][0], baseY);
           const startPoint = points4[startIndex];
-          ctx.lineTo(startPoint[0], baseY);
-          ctx.lineTo(startPoint[0], startPoint[1]);
+          ctx2.lineTo(startPoint[0], baseY);
+          ctx2.lineTo(startPoint[0], startPoint[1]);
         }
         let nextPoint = points4[++index];
         while ((nextPoint === 0 || isPointNull4(nextPoint)) && index < points4.length) {
@@ -54990,17 +54991,17 @@ var PolyPlotPath = class extends Path_default {
           continue;
         }
         const [x2, y2] = nextPoint;
-        ctx.moveTo(x2, y2);
+        ctx2.moveTo(x2, y2);
         startIndex = index;
         continue;
       }
       const [x, y] = point;
-      ctx.lineTo(x, y);
+      ctx2.lineTo(x, y);
       if (index === points4.length - 1) {
-        ctx.lineTo(points4[index][0], baseY);
+        ctx2.lineTo(points4[index][0], baseY);
         const startPoint = points4[startIndex];
-        ctx.lineTo(startPoint[0], baseY);
-        ctx.lineTo(startPoint[0], startPoint[1]);
+        ctx2.lineTo(startPoint[0], baseY);
+        ctx2.lineTo(startPoint[0], startPoint[1]);
       }
     }
   }
@@ -55034,7 +55035,7 @@ var HistogramPlotPath = class extends Path_default {
   getDefaultShape() {
     return new HistogramPlotShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4, baseY} = shape;
     for (let index = 0; index < points4.length; index++) {
       const point = points4[index];
@@ -55042,8 +55043,8 @@ var HistogramPlotPath = class extends Path_default {
         continue;
       }
       const [x, y] = point;
-      ctx.moveTo(x, y);
-      ctx.lineTo(x, baseY);
+      ctx2.moveTo(x, y);
+      ctx2.lineTo(x, baseY);
     }
   }
 };
@@ -55077,7 +55078,7 @@ var BarPlotPath = class extends Path_default {
   getDefaultShape() {
     return new BarPlotShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4, baseY, width} = shape;
     const offset = width / 2;
     for (let index = 0; index < points4.length; index++) {
@@ -55089,11 +55090,11 @@ var BarPlotPath = class extends Path_default {
       const leftX = Math.floor(x - offset);
       const rightX = Math.floor(x + offset);
       const dataY = Math.floor(y);
-      ctx.moveTo(leftX, dataY);
-      ctx.lineTo(rightX, dataY);
-      ctx.lineTo(rightX, baseY);
-      ctx.lineTo(leftX, baseY);
-      ctx.lineTo(leftX, dataY);
+      ctx2.moveTo(leftX, dataY);
+      ctx2.lineTo(rightX, dataY);
+      ctx2.lineTo(rightX, baseY);
+      ctx2.lineTo(leftX, baseY);
+      ctx2.lineTo(leftX, dataY);
     }
   }
 };
@@ -56741,7 +56742,7 @@ function getLineDashByLineStyle2(lineStyle) {
   if (lineStyle === "style_dashed") {
     return [8, 8];
   } else if (lineStyle === "style_dotted") {
-    return [4, 4];
+    return [2, 2];
   }
   return "solid";
 }
@@ -56795,6 +56796,36 @@ var BoxesView2 = class extends Chart_default {
       });
       linesGroup.add(el);
     });
+    const textList = data.getLayout("textList");
+    each(textList, function(item) {
+      const width = item.width - 8;
+      const textStyle = {
+        width,
+        text: item.text,
+        align: item.align,
+        fill: item.text_color ?? "#fff",
+        fontSize: item.text_size,
+        overflow: item.text_wrap === "wrap_auto" ? "breakAll" : "none"
+      };
+      const el = new Text_default({
+        style: {
+          ...textStyle
+        },
+        x: item.align === "center" ? item.x : item.x + 4,
+        y: item.y + 2
+      });
+      if (item.v_align === "middle") {
+        el.y = item.y - Math.min(el.getBoundingRect().height, item.height) / 2;
+      } else if (item.v_align === "bottom") {
+        el.y = item.y - Math.min(el.getBoundingRect().height, item.height) - 2;
+      }
+      if (item.text_wrap === "wrap_auto") {
+        el.useStyle({...textStyle, height: item.height, lineOverflow: "truncate", ellipsis: "..."});
+      } else {
+        el.useStyle({...textStyle, height: item.height});
+      }
+      linesGroup.add(el);
+    });
   }
   remove(ecModel, api2) {
     this._linesGroup && this._linesGroup.removeAll();
@@ -56874,14 +56905,69 @@ BoxesSeriesModel.defaultOption = {
 };
 var BoxesSeries_default = BoxesSeriesModel;
 
+// src/chart/boxes/util.ts
+var canvas = document.createElement("canvas");
+var ctx = canvas.getContext("2d");
+function findFontSize(text, maxWidth, font = "sans-serif", minSize = 2, maxSize = 50, tolerance = 8) {
+  let low = minSize;
+  let high = maxSize;
+  while (low <= high) {
+    const size = Math.floor((low + high) / 2);
+    ctx.font = `${size}px ${font}`;
+    const width = ctx.measureText(text).width;
+    if (Math.abs(width - maxWidth) <= tolerance) {
+      return size;
+    } else if (width < maxWidth) {
+      low = size + 1;
+    } else {
+      high = size - 1;
+    }
+  }
+  return high;
+}
+var boxFontSizeMapping = {
+  huge: 24,
+  large: 18,
+  normal: 14,
+  small: 10,
+  tiny: 6
+};
+function getFontSize(size, text, maxWidth, font) {
+  return boxFontSizeMapping[size] || findFontSize(text, maxWidth, font);
+}
+
 // src/chart/boxes/BoxesLayout.ts
 function optimizePoint3(point1, point2, lineWidth) {
-  const notOptimize = lineWidth % 2 === 0;
-  if (notOptimize) {
-    return;
-  }
-  point2[0] = point1[0] = Math.floor(point1[0]) + 0.5;
-  point2[1] = point1[1] = Math.floor(point1[1]) + 0.5;
+  if (lineWidth % 2 === 0) {
+    point1[1] = Math.floor(point1[1]);
+    point2[1] = Math.floor(point2[1]);
+  } else {
+    point1[0] = Math.floor(point1[0]) + 0.5;
+    point1[1] = Math.floor(point1[1]) + 0.5;
+    point2[0] = Math.floor(point2[0]) + 0.5;
+    point2[1] = Math.floor(point2[1]) + 0.5;
+  }
+}
+function getBoxPoint(startPoint, endPoint, text_halign, text_valign) {
+  let x = startPoint[0];
+  let y = startPoint[1];
+  let align = "left";
+  let v_align = "top";
+  if (text_halign === "align_center") {
+    x = (startPoint[0] + endPoint[0]) / 2;
+    align = "center";
+  } else if (text_halign === "align_right") {
+    x = endPoint[0];
+    align = "right";
+  }
+  if (text_valign === "align_center") {
+    y = (startPoint[1] + endPoint[1]) / 2;
+    v_align = "middle";
+  } else if (text_valign === "align_bottom") {
+    y = endPoint[1];
+    v_align = "bottom";
+  }
+  return {x, y, align, v_align};
 }
 var BoxesLayout = {
   seriesType: "boxes",
@@ -56921,10 +57007,13 @@ var BoxesLayout = {
       }
       return [left, right];
     }
+    const gTextStyleModel = ecModel && ecModel.getModel("textStyle");
+    const font = gTextStyleModel && gTextStyleModel.getShallow("fontFamily");
     return {
       progress(params, boxesData) {
         const store = boxesData.getStore();
         const linesPointById = {};
+        const textList = [];
         for (let i = params.start; i < params.end; i++) {
           const x1Val = store.get(x1DimI, i);
           const x2Val = store.get(x2DimI, i);
@@ -56933,7 +57022,19 @@ var BoxesLayout = {
           const startPoint = coordSys.dataToPoint([x1Val, y1Val]);
           const endPoint = coordSys.dataToPoint([x2Val, y2Val]);
           const itemModel = data.getItemModel(i);
-          const {border_width, border_color, style, extend: extend2, bgcolor} = itemModel.get("itemStyle");
+          const {
+            border_width,
+            border_color,
+            style,
+            extend: extend2,
+            bgcolor,
+            text,
+            text_color,
+            text_halign,
+            text_size,
+            text_valign,
+            text_wrap
+          } = itemModel.get("itemStyle");
           if (!border_color) {
             continue;
           }
@@ -56943,9 +57044,26 @@ var BoxesLayout = {
           const [left, right] = getHExtend(startPoint[0], endPoint[0], extend2);
           points4.push(left, right, startPoint[1], endPoint[1]);
           linesPointById[key] = points4;
+          if (text) {
+            const width2 = endPoint[0] - startPoint[0];
+            const {x, y, align, v_align} = getBoxPoint(startPoint, endPoint, text_halign, text_valign);
+            textList.push({
+              text,
+              text_color,
+              text_wrap,
+              text_size: getFontSize(text_size, text, width2 - 10, font),
+              align,
+              v_align,
+              width: width2,
+              height: Math.abs(endPoint[1] - startPoint[1]),
+              x,
+              y
+            });
+          }
         }
         data.setLayout({
-          linesPointById
+          linesPointById,
+          textList
         });
       }
     };
@@ -56960,6 +57078,244 @@ function install28(registers) {
   registers.registerLayout(BoxesLayout_default);
 }
 
+// src/chart/charPlot/CharPlotSeries.ts
+var CharPlotSeriesModel2 = class extends Series_default {
+  constructor() {
+    super(...arguments);
+    this.type = CharPlotSeriesModel2.type;
+  }
+  getInitialData(option, ecModel) {
+    return createSeriesData_default(null, this, {
+      useEncodeDefaulter: true
+    });
+  }
+  getProgressive() {
+    const progressive = this.option.progressive;
+    if (progressive == null) {
+      return this.option.large ? 5e3 : this.get("progressive");
+    }
+    return progressive;
+  }
+  getProgressiveThreshold() {
+    const progressiveThreshold = this.option.progressiveThreshold;
+    if (progressiveThreshold == null) {
+      return this.option.large ? 1e4 : this.get("progressiveThreshold");
+    }
+    return progressiveThreshold;
+  }
+  brushSelector(dataIndex, data, selectors) {
+    return selectors.point(data.getItemLayout(dataIndex));
+  }
+  getZLevelKey() {
+    return this.getData().count() > this.getProgressiveThreshold() ? this.id : "";
+  }
+};
+var CharPlotSeriesModel = CharPlotSeriesModel2;
+CharPlotSeriesModel.type = "series.charPlot";
+CharPlotSeriesModel.dependencies = ["grid", "polar"];
+CharPlotSeriesModel.defaultOption = {
+  coordinateSystem: "cartesian2d",
+  z: 2,
+  large: false,
+  largeThreshold: 2e3,
+  emphasis: {
+    scale: true
+  },
+  clip: true
+};
+var CharPlotSeries_default = CharPlotSeriesModel;
+
+// src/chart/charPlot/CharPlotView.ts
+var CharPlotView2 = class extends Chart_default {
+  constructor() {
+    super(...arguments);
+    this.type = CharPlotView2.type;
+  }
+  render(seriesModel, ecModel, api2) {
+    const data = seriesModel.getData();
+    this._renderText(data, seriesModel);
+    this._finished = true;
+  }
+  _renderText(data, seriesModel) {
+    if (!this._textGroup) {
+      this._textGroup = new Group_default();
+      this.group.add(this._textGroup);
+    } else {
+      this._textGroup.removeAll();
+    }
+    const textGroup = this._textGroup;
+    const charList = data.getLayout("charList");
+    const fontSize = data.getLayout("fontSize");
+    const textList = data.getLayout("textList");
+    const char = seriesModel.get("char");
+    const text = seriesModel.get("text");
+    each(charList, function(item) {
+      const el = new Text_default({
+        style: {
+          text: char,
+          verticalAlign: "middle",
+          align: "center",
+          fill: item.textColor,
+          fontSize
+        },
+        x: item.x,
+        y: item.y
+      });
+      textGroup.add(el);
+    });
+    const location = seriesModel.get("location");
+    let vAlign = "top";
+    if (["abovebar", "bottom", "absolute"].includes(location)) {
+      vAlign = "bottom";
+    } else if (location === "belowbar" || location === "top") {
+      return fontSize;
+    }
+    each(textList, function(item) {
+      const el = new Text_default({
+        style: {
+          text,
+          verticalAlign: vAlign,
+          align: "center",
+          fill: item.textColor,
+          fontSize: 12
+        },
+        x: item.x,
+        y: item.y
+      });
+      textGroup.add(el);
+    });
+  }
+  _getClipShape(seriesModel) {
+    if (!seriesModel.get("clip", true)) {
+      return;
+    }
+    const coordSys = seriesModel.coordinateSystem;
+    return coordSys && coordSys.getArea && coordSys.getArea(0.1);
+  }
+  remove(ecModel, api2) {
+    this._textGroup && this._textGroup.removeAll();
+    this._textGroup = null;
+  }
+  dispose() {
+  }
+};
+var CharPlotView = CharPlotView2;
+CharPlotView.type = "charPlot";
+var CharPlotView_default = CharPlotView;
+
+// src/chart/charPlot/util.ts
+var charFontSizeMapping = {
+  huge: 100,
+  large: 74,
+  normal: 49,
+  small: 30,
+  tiny: 14
+};
+function getFontSizeByBarWidth(barWidth) {
+  return Math.round(barWidth);
+}
+function getFontSize2(size, barWidth) {
+  return charFontSizeMapping[size] || getFontSizeByBarWidth(barWidth);
+}
+function getDistance(location, fontSize) {
+  if (location === "abovebar" || location === "bottom" || location === "absolute") {
+    return -fontSize;
+  } else {
+    return fontSize;
+  }
+}
+
+// src/chart/charPlot/CharPlotLayout.ts
+function getYByLocation(seriesModel) {
+  const location = seriesModel.get("location");
+  if (!["bottom", "top"].includes(location)) {
+    return null;
+  }
+  const yAxis = seriesModel.coordinateSystem.getAxis("y");
+  const scale4 = yAxis.scale;
+  const [, end2] = yAxis.getExtent();
+  const [boundaryGapX, boundaryGapY] = scale4.rawExtentInfo.getBoundaryGapInner();
+  return Math.floor(location === "top" ? end2 * boundaryGapX + 30 : end2 * (1 - boundaryGapY) + 30);
+}
+var CharPlotLayout = {
+  seriesType: "charPlot",
+  plan: createRenderPlanner(),
+  reset: function(seriesModel) {
+    const data = seriesModel.getData();
+    const coordSys = seriesModel.coordinateSystem;
+    if (!coordSys) {
+      return;
+    }
+    const bandWidth = coordSys.getAxesByScale("ordinal")[0].scale.barSpace;
+    const location = seriesModel.get("location");
+    const size = seriesModel.get("size");
+    const fontSize = getFontSize2(size, bandWidth);
+    const distance2 = getDistance(location, fontSize);
+    const dims = map(coordSys.dimensions, function(dim) {
+      return data.mapDimension(dim);
+    }).slice(0, 2);
+    const store = data.getStore();
+    const dimIdx0 = data.getDimensionIndex(dims[0]);
+    const dimIdx1 = data.getDimensionIndex(dims[1]);
+    const xOffset = seriesModel.get("offset") || 0;
+    const char = seriesModel.get("char");
+    const text = seriesModel.get("text");
+    const price = getYByLocation(seriesModel);
+    const showLast = seriesModel.get("showLast");
+    return {
+      progress(params, charPlotData) {
+        const charList = [];
+        const textList = [];
+        const lastIndex = data.count(true) - 1;
+        const tmpIn = [];
+        for (let i = params.start; i < params.end; i++) {
+          if (showLast && lastIndex - data.getRawIndex(i) >= showLast) {
+            continue;
+          }
+          tmpIn[0] = store.get(dimIdx0, i) + xOffset;
+          tmpIn[1] = store.get(dimIdx1, i);
+          if (isNaN(tmpIn[1])) {
+            continue;
+          }
+          const itemModel = data.getItemModel(i);
+          const {color: color2, text_color} = itemModel.get("itemStyle");
+          const point = coordSys.dataToPoint(tmpIn);
+          const x = point[0];
+          const y = price ?? point[1] + distance2;
+          if (char && color2) {
+            charList.push({
+              x,
+              y,
+              textColor: color2
+            });
+          }
+          const textColor = text_color || color2;
+          if (text && textColor) {
+            textList.push({
+              x,
+              y: y + distance2,
+              textColor
+            });
+          }
+        }
+        charPlotData.setLayout({
+          charList,
+          fontSize,
+          textList
+        });
+      }
+    };
+  }
+};
+var CharPlotLayout_default = CharPlotLayout;
+
+// src/chart/charPlot/install.ts
+function install29(registers) {
+  registers.registerSeriesModel(CharPlotSeries_default);
+  registers.registerChartView(CharPlotView_default);
+  registers.registerLayout(CharPlotLayout_default);
+}
+
 // src/chart/labels/LabelsSeries.ts
 var LabelsSeriesModel2 = class extends Series_default {
   constructor() {
@@ -57405,7 +57761,7 @@ function getSymbolLabelFontSize(size, width) {
 }
 
 // src/chart/labels/labelsLayout.ts
-function getYByLocation(seriesModel) {
+function getYByLocation2(seriesModel) {
   const location = seriesModel.get("location");
   if (!["bottom", "top"].includes(location)) {
     return null;
@@ -57474,7 +57830,7 @@ var labelsLayout = {
     const dimIdx0 = data.getDimensionIndex(dims[0]);
     const dimIdx1 = data.getDimensionIndex(dims[1]);
     const xOffset = seriesModel.get("offset") || 0;
-    const price = getYByLocation(seriesModel);
+    const price = getYByLocation2(seriesModel);
     const showLast = seriesModel.get("showLast");
     return {
       progress(params, labelsData) {
@@ -57592,7 +57948,7 @@ var labelsLayout = {
 var labelsLayout_default = labelsLayout;
 
 // src/chart/labels/install.ts
-function install29(registers) {
+function install30(registers) {
   registers.registerSeriesModel(LabelsSeries_default);
   registers.registerChartView(LabelsView_default);
   registers.registerLayout(labelsLayout_default);
@@ -57727,7 +58083,7 @@ var hLinesLayout = {
 var hLinesLayout_default = hLinesLayout;
 
 // src/chart/hlines/install.ts
-function install30(registers) {
+function install31(registers) {
   registers.registerChartView(HLinesView_default);
   registers.registerSeriesModel(HLinesSeries_default);
   registers.registerLayout(hLinesLayout_default);
@@ -57799,20 +58155,20 @@ var FillPolyPath = class extends Path_default {
   getDefaultShape() {
     return new FillPolyShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4} = shape;
     for (let index = 0; index < points4.length; index++) {
       const polyPoints = points4[index];
       for (let i = 0; i < polyPoints.length; i++) {
         const [x, y] = polyPoints[i];
         if (i === 0) {
-          ctx.moveTo(x, y);
+          ctx2.moveTo(x, y);
           continue;
         }
-        ctx.lineTo(x, y);
+        ctx2.lineTo(x, y);
         if (i + 1 === polyPoints.length) {
           const [fx, fy] = polyPoints[0];
-          ctx.lineTo(fx, fy);
+          ctx2.lineTo(fx, fy);
         }
       }
     }
@@ -58010,7 +58366,7 @@ var fillsLayout = {
 var fillsLayout_default = fillsLayout;
 
 // src/chart/fills/install.ts
-function install31(registers) {
+function install32(registers) {
   registers.registerChartView(FillsView_default);
   registers.registerSeriesModel(FillsSeries_default);
   registers.registerLayout(fillsLayout_default);
@@ -58074,20 +58430,20 @@ var BgColorPath = class extends Path_default {
   getDefaultShape() {
     return new BgColorShape();
   }
-  buildPath(ctx, shape) {
+  buildPath(ctx2, shape) {
     const {points: points4, isLine} = shape;
     if (isLine) {
       for (let index = 0; index < points4.length; index++) {
         const point = points4[index];
         const {x, y, height} = point;
-        ctx.moveTo(x, y);
-        ctx.lineTo(x, y + height);
+        ctx2.moveTo(x, y);
+        ctx2.lineTo(x, y + height);
       }
     } else {
       for (let index = 0; index < points4.length; index++) {
         const point = points4[index];
         const {x, y, width, height} = point;
-        ctx.rect(x, y, width, height);
+        ctx2.rect(x, y, width, height);
       }
     }
   }
@@ -58214,7 +58570,7 @@ var bgColorLayout = {
 var BgColorLayout_default = bgColorLayout;
 
 // src/chart/bgColor/install.ts
-function install32(registers) {
+function install33(registers) {
   registers.registerChartView(BgColorView_default);
   registers.registerSeriesModel(BgColorSeries_default);
   registers.registerLayout(BgColorLayout_default);
@@ -58232,32 +58588,32 @@ var HeatmapLayer = class {
       inRange: null,
       outOfRange: null
     };
-    const canvas = platformApi.createCanvas();
-    this.canvas = canvas;
+    const canvas2 = platformApi.createCanvas();
+    this.canvas = canvas2;
   }
   update(data, width, height, normalize5, colorFunc, isInRange) {
     const brush3 = this._getBrush();
     const gradientInRange = this._getGradient(colorFunc, "inRange");
     const gradientOutOfRange = this._getGradient(colorFunc, "outOfRange");
     const r = this.pointSize + this.blurSize;
-    const canvas = this.canvas;
-    const ctx = canvas.getContext("2d");
+    const canvas2 = this.canvas;
+    const ctx2 = canvas2.getContext("2d");
     const len2 = data.length;
-    canvas.width = width;
-    canvas.height = height;
+    canvas2.width = width;
+    canvas2.height = height;
     for (let i = 0; i < len2; ++i) {
       const p = data[i];
       const x = p[0];
       const y = p[1];
       const value = p[2];
       const alpha = normalize5(value);
-      ctx.globalAlpha = alpha;
-      ctx.drawImage(brush3, x - r, y - r);
+      ctx2.globalAlpha = alpha;
+      ctx2.drawImage(brush3, x - r, y - r);
     }
-    if (!canvas.width || !canvas.height) {
-      return canvas;
+    if (!canvas2.width || !canvas2.height) {
+      return canvas2;
     }
-    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const imageData = ctx2.getImageData(0, 0, canvas2.width, canvas2.height);
     const pixels = imageData.data;
     let offset = 0;
     const pixelLen = pixels.length;
@@ -58278,8 +58634,8 @@ var HeatmapLayer = class {
         offset += 4;
       }
     }
-    ctx.putImageData(imageData, 0, 0);
-    return canvas;
+    ctx2.putImageData(imageData, 0, 0);
+    return canvas2;
   }
   _getBrush() {
     const brushCanvas = this._brushCanvas || (this._brushCanvas = platformApi.createCanvas());
@@ -58287,15 +58643,15 @@ var HeatmapLayer = class {
     const d = r * 2;
     brushCanvas.width = d;
     brushCanvas.height = d;
-    const ctx = brushCanvas.getContext("2d");
-    ctx.clearRect(0, 0, d, d);
-    ctx.shadowOffsetX = d;
-    ctx.shadowBlur = this.blurSize;
-    ctx.shadowColor = "#000";
-    ctx.beginPath();
-    ctx.arc(-r, r, this.pointSize, 0, Math.PI * 2, true);
-    ctx.closePath();
-    ctx.fill();
+    const ctx2 = brushCanvas.getContext("2d");
+    ctx2.clearRect(0, 0, d, d);
+    ctx2.shadowOffsetX = d;
+    ctx2.shadowBlur = this.blurSize;
+    ctx2.shadowColor = "#000";
+    ctx2.beginPath();
+    ctx2.arc(-r, r, this.pointSize, 0, Math.PI * 2, true);
+    ctx2.closePath();
+    ctx2.fill();
     return brushCanvas;
   }
   _getGradient(colorFunc, state) {
@@ -58612,7 +58968,7 @@ HeatmapSeriesModel.defaultOption = {
 var HeatmapSeries_default = HeatmapSeriesModel;
 
 // src/chart/heatmap/install.ts
-function install33(registers) {
+function install34(registers) {
   registers.registerChartView(HeatmapView_default);
   registers.registerSeriesModel(HeatmapSeries_default);
 }
@@ -59175,7 +59531,7 @@ PictorialBarSeriesModel.defaultOption = inheritDefaultOption(BaseBarSeries_defau
 var PictorialBarSeries_default = PictorialBarSeriesModel;
 
 // src/chart/bar/installPictorialBar.ts
-function install34(registers) {
+function install35(registers) {
   registers.registerChartView(PictorialBarView_default);
   registers.registerSeriesModel(PictorialBarSeries_default);
   registers.registerLayout(registers.PRIORITY.VISUAL.LAYOUT, curry(layout2, "pictorialBar"));
@@ -59576,7 +59932,7 @@ function computeBaseline(data) {
 }
 
 // src/chart/themeRiver/install.ts
-function install35(registers) {
+function install36(registers) {
   registers.registerChartView(ThemeRiverView_default);
   registers.registerSeriesModel(ThemeRiverSeries_default);
   registers.registerLayout(themeRiverLayout);
@@ -60214,7 +60570,7 @@ function sunburstVisual(ecModel) {
 }
 
 // src/chart/sunburst/install.ts
-function install36(registers) {
+function install37(registers) {
   registers.registerChartView(SunburstView_default);
   registers.registerSeriesModel(SunburstSeries_default);
   registers.registerLayout(curry(sunburstLayout, "sunburst"));
@@ -61662,7 +62018,7 @@ function hasOwnPathData(shape) {
 }
 
 // src/chart/custom/install.ts
-function install37(registers) {
+function install38(registers) {
   registers.registerChartView(CustomView_default);
   registers.registerSeriesModel(CustomSeries_default);
 }
@@ -62883,7 +63239,7 @@ function illegalPoint(point) {
 }
 
 // src/component/axisPointer/install.ts
-function install38(registers) {
+function install39(registers) {
   AxisView_default.registerAxisPointerClass("CartesianAxisPointer", CartesianAxisPointer_default);
   registers.registerComponentModel(AxisPointerModel_default);
   registers.registerComponentView(AxisPointerView_default);
@@ -62912,9 +63268,9 @@ function install38(registers) {
 }
 
 // src/component/grid/install.ts
-function install39(registers) {
+function install40(registers) {
   use(install6);
-  use(install38);
+  use(install39);
 }
 
 // src/component/axisPointer/PolarAxisPointer.ts
@@ -63968,8 +64324,8 @@ var PolarView2 = class extends Component_default2 {
 };
 var PolarView = PolarView2;
 PolarView.type = "polar";
-function install40(registers) {
-  use(install38);
+function install41(registers) {
+  use(install39);
   AxisView_default.registerAxisPointerClass("PolarAxisPointer", PolarAxisPointer_default);
   registers.registerCoordinateSystem("polar", polarCreator_default);
   registers.registerComponentModel(PolarModel_default);
@@ -64432,8 +64788,8 @@ var SingleView2 = class extends Component_default2 {
 };
 var SingleView = SingleView2;
 SingleView.type = "single";
-function install41(registers) {
-  use(install38);
+function install42(registers) {
+  use(install39);
   AxisView_default.registerAxisPointerClass("SingleAxisPointer", SingleAxisPointer_default);
   registers.registerComponentView(SingleView);
   registers.registerComponentView(SingleAxisView_default);
@@ -65123,7 +65479,7 @@ function getCoordSys5(finder) {
 var Calendar_default = Calendar;
 
 // src/component/calendar/install.ts
-function install42(registers) {
+function install43(registers) {
   registers.registerComponentModel(CalendarModel_default);
   registers.registerComponentView(CalendarView_default);
   registers.registerCoordinateSystem("calendar", Calendar_default);
@@ -65512,7 +65868,7 @@ function setEventData(el, graphicModel, elOption) {
 }
 
 // src/component/graphic/install.ts
-function install43(registers) {
+function install44(registers) {
   registers.registerComponentModel(GraphicComponentModel);
   registers.registerComponentView(GraphicComponentView);
   registers.registerPreprocessor(function(option) {
@@ -65668,6 +66024,9 @@ var DataZoomModel2 = class extends Component_default {
     this.settledOption = inputRawOption;
     this.mergeDefaultAndTheme(option, ecModel);
     this._doInit(inputRawOption);
+    if (option.barSpace && option.lastBarRightSideDiffBarCount !== void 0) {
+      this.setDistanceRange([option.barSpace, option.lastBarRightSideDiffBarCount]);
+    }
   }
   mergeOption(newOption) {
     const inputRawOption = retrieveRawOption(newOption);
@@ -66392,7 +66751,7 @@ function installCommon(registers) {
 }
 
 // src/component/dataZoom/installDataZoomSelect.ts
-function install44(registers) {
+function install45(registers) {
   registers.registerComponentModel(SelectZoomModel_default);
   registers.registerComponentView(SelectZoomView_default);
   installCommon(registers);
@@ -67792,7 +68151,7 @@ registerInternalOptionCreator("dataZoom", function(ecModel) {
 var DataZoom_default = DataZoomFeature;
 
 // src/component/toolbox/install.ts
-function install45(registers) {
+function install46(registers) {
   registers.registerComponentModel(ToolboxModel_default);
   registers.registerComponentView(ToolboxView_default);
   registerFeature("saveAsImage", SaveAsImage_default);
@@ -67800,7 +68159,7 @@ function install45(registers) {
   registerFeature("dataView", DataView_default);
   registerFeature("dataZoom", DataZoom_default);
   registerFeature("restore", Restore_default);
-  use(install44);
+  use(install45);
 }
 
 // src/component/tooltip/TooltipModel.ts
@@ -68968,8 +69327,8 @@ function findComponentReference(payload, ecModel, api2) {
 var TooltipView_default = TooltipView;
 
 // src/component/tooltip/install.ts
-function install46(registers) {
-  use(install38);
+function install47(registers) {
+  use(install39);
   registers.registerComponentModel(TooltipModel_default);
   registers.registerComponentView(TooltipView_default);
   registers.registerAction({
@@ -69585,7 +69944,7 @@ var BrushFeature = class extends ToolboxFeature {
 var Brush_default = BrushFeature;
 
 // src/component/brush/install.ts
-function install47(registers) {
+function install48(registers) {
   registers.registerComponentView(BrushView_default);
   registers.registerComponentModel(BrushModel_default);
   registers.registerPreprocessor(brushPreprocessor);
@@ -69732,7 +70091,7 @@ var TitleView2 = class extends Component_default2 {
 };
 var TitleView = TitleView2;
 TitleView.type = "title";
-function install48(registers) {
+function install49(registers) {
   registers.registerComponentModel(TitleModel);
   registers.registerComponentView(TitleView);
 }
@@ -70097,7 +70456,7 @@ TableView.type = "table";
 var TableView_default = TableView;
 
 // src/component/table/install.ts
-function install49(registers) {
+function install50(registers) {
   registers.registerComponentModel(TableModel_default);
   registers.registerComponentView(TableView_default);
 }
@@ -70951,7 +71310,7 @@ function has(obj, attr) {
 }
 
 // src/component/timeline/install.ts
-function install50(registers) {
+function install51(registers) {
   registers.registerComponentModel(SliderTimelineModel_default);
   registers.registerComponentView(SliderTimelineView_default);
   registers.registerSubTypeDefaulter("timeline", function() {
@@ -71392,7 +71751,7 @@ function createData(coordSys, seriesModel, mpModel) {
 var MarkPointView_default = MarkPointView;
 
 // src/component/marker/installMarkPoint.ts
-function install51(registers) {
+function install52(registers) {
   registers.registerComponentModel(MarkPointModel_default);
   registers.registerComponentView(MarkPointView_default);
   registers.registerPreprocessor(function(opt) {
@@ -71710,7 +72069,7 @@ function createList2(coordSys, seriesModel, mlModel) {
 var MarkLineView_default = MarkLineView;
 
 // src/component/marker/installMarkLine.ts
-function install52(registers) {
+function install53(registers) {
   registers.registerComponentModel(MarkLineModel_default);
   registers.registerComponentView(MarkLineView_default);
   registers.registerPreprocessor(function(opt) {
@@ -72024,7 +72383,7 @@ function createList3(coordSys, seriesModel, maModel) {
 var MarkAreaView_default = MarkAreaView;
 
 // src/component/marker/installMarkArea.ts
-function install53(registers) {
+function install54(registers) {
   registers.registerComponentModel(MarkAreaModel_default);
   registers.registerComponentView(MarkAreaView_default);
   registers.registerPreprocessor(function(opt) {
@@ -72667,7 +73026,7 @@ function updateLabel({x, y, labelData, markerModel, gridRect, position: position
 var MarkLabelView_default = MarkLabelView;
 
 // src/component/marker/installMarkLabel.ts
-function install54(registers) {
+function install55(registers) {
   registers.registerComponentModel(MarkLabelModal_default);
   registers.registerComponentView(MarkLabelView_default);
   registers.registerPreprocessor(function(opt) {
@@ -73349,7 +73708,7 @@ function installLegendAction(registers) {
 }
 
 // src/component/legend/installLegendPlain.ts
-function install55(registers) {
+function install56(registers) {
   registers.registerComponentModel(LegendModel_default);
   registers.registerComponentView(LegendView_default);
   registers.registerProcessor(registers.PRIORITY.PROCESSOR.SERIES_FILTER, legendFilter);
@@ -73679,17 +74038,17 @@ function installScrollableLegendAction(registers) {
 }
 
 // src/component/legend/installLegendScroll.ts
-function install56(registers) {
-  use(install55);
+function install57(registers) {
+  use(install56);
   registers.registerComponentModel(ScrollableLegendModel_default);
   registers.registerComponentView(ScrollableLegendView_default);
   installScrollableLegendAction(registers);
 }
 
 // src/component/legend/install.ts
-function install57(registers) {
-  use(install55);
+function install58(registers) {
   use(install56);
+  use(install57);
 }
 
 // src/component/dataZoom/InsideZoomModel.ts
@@ -74116,7 +74475,7 @@ var getDirectionInfo = {
 var InsideZoomView_default = InsideZoomView;
 
 // src/component/dataZoom/installDataZoomInside.ts
-function install58(registers) {
+function install59(registers) {
   installCommon(registers);
   registers.registerComponentModel(InsideZoomModel_default);
   registers.registerComponentView(InsideZoomView_default);
@@ -74872,16 +75231,16 @@ function getCursor(orient) {
 var SliderZoomView_default = SliderZoomView;
 
 // src/component/dataZoom/installDataZoomSlider.ts
-function install59(registers) {
+function install60(registers) {
   registers.registerComponentModel(SliderZoomModel_default);
   registers.registerComponentView(SliderZoomView_default);
   installCommon(registers);
 }
 
 // src/component/dataZoom/install.ts
-function install60(registers) {
-  use(install58);
+function install61(registers) {
   use(install59);
+  use(install60);
 }
 
 // src/visual/visualDefault.ts
@@ -76146,7 +76505,7 @@ function installCommon2(registers) {
 }
 
 // src/component/visualMap/installVisualMapContinuous.ts
-function install61(registers) {
+function install62(registers) {
   registers.registerComponentModel(ContinuousModel_default);
   registers.registerComponentView(ContinuousView_default);
   installCommon2(registers);
@@ -76586,16 +76945,16 @@ PiecewiseVisualMapView.type = "visualMap.piecewise";
 var PiecewiseView_default = PiecewiseVisualMapView;
 
 // src/component/visualMap/installVisualMapPiecewise.ts
-function install62(registers) {
+function install63(registers) {
   registers.registerComponentModel(PiecewiseModel_default);
   registers.registerComponentView(PiecewiseView_default);
   installCommon2(registers);
 }
 
 // src/component/visualMap/install.ts
-function install63(registers) {
-  use(install61);
+function install64(registers) {
   use(install62);
+  use(install63);
 }
 
 // src/visual/aria.ts
@@ -76791,7 +77150,7 @@ function ariaPreprocessor(option) {
 }
 
 // src/component/aria/install.ts
-function install64(registers) {
+function install65(registers) {
   registers.registerPreprocessor(ariaPreprocessor);
   registers.registerVisual(registers.PRIORITY.VISUAL.ARIA, ariaVisual);
 }
@@ -77129,7 +77488,7 @@ var sortTransform = {
 };
 
 // src/component/transform/install.ts
-function install65(registers) {
+function install66(registers) {
   registers.registerTransform(filterTransform);
   registers.registerTransform(sortTransform);
 }
@@ -77167,7 +77526,7 @@ var DatasetView = class extends Component_default2 {
   }
 };
 DatasetView.type = "dataset";
-function install66(registers) {
+function install67(registers) {
   registers.registerComponentModel(DatasetModel);
   registers.registerComponentView(DatasetView);
 }
@@ -78885,6 +79244,7 @@ use([
   install18,
   install19,
   install20,
+  install29,
   install21,
   install22,
   install23,
@@ -78893,27 +79253,26 @@ use([
   install26,
   install27,
   install28,
-  install29,
   install30,
-  install32,
   install31,
   install33,
+  install32,
   install34,
   install35,
   install36,
-  install37
+  install37,
+  install38
 ]);
-use(install39);
 use(install40);
-use(install10);
 use(install41);
-use(install17);
+use(install10);
 use(install42);
+use(install17);
 use(install43);
-use(install45);
+use(install44);
 use(install46);
-use(install38);
 use(install47);
+use(install39);
 use(install48);
 use(install49);
 use(install50);
@@ -78921,16 +79280,17 @@ use(install51);
 use(install52);
 use(install53);
 use(install54);
-use(install57);
-use(install60);
+use(install55);
 use(install58);
-use(install59);
-use(install63);
 use(install61);
-use(install62);
+use(install59);
+use(install60);
 use(install64);
+use(install62);
+use(install63);
 use(install65);
 use(install66);
+use(install67);
 use(installUniversalTransition);
 use(installLabelLayout);