@ai-table/grid 0.0.11 → 0.0.13

package/esm2022/renderer/drawers/drawer.mjs

@@ -0,0 +1,936 @@
+import GraphemeSplitter from 'grapheme-splitter';
+import { AI_TABLE_OFFSET, AI_TABLE_TAG_FONT_SIZE, AI_TABLE_TAG_PADDING, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FONT_WEIGHT, DEFAULT_TEXT_ALIGN_CENTER, DEFAULT_TEXT_ALIGN_LEFT, DEFAULT_TEXT_DECORATION, DEFAULT_TEXT_VERTICAL_ALIGN_MIDDLE, DEFAULT_TEXT_VERTICAL_ALIGN_TOP, DEFAULT_WRAP_TEXT_MAX_ROW, FONT_SIZE_SM, WebOutlinedPath } from '../../constants';
+import { AITable } from '../../core';
+import { AITableAvatarSize, AITableAvatarType } from '../../types';
+import { getTextWidth, imageCache, textDataCache, TextMeasure } from '../../utils';
+// 用于正确地分割字符串，包括表情符号
+export const graphemeSplitter = new GraphemeSplitter();
+/**
+ * 用于在 Canvas 上进行的各种绘图操作，包含了文本绘制、矩形绘制、路径绘制以及一些几何计算等功能
+ */
+export class Drawer {
+    constructor() {
+        this.ctx = TextMeasure().context;
+        this.needDraw = false;
+        this.colors = AITable.getColors();
+    }
+    initCtx(ctx) {
+        this.needDraw = Boolean(ctx);
+        this.ctx = ctx || TextMeasure().context;
+        /**
+         * textBaseline 指定为 middle，兼容浏览器差异
+         */
+        this.ctx.textBaseline = DEFAULT_TEXT_VERTICAL_ALIGN_MIDDLE;
+    }
+    // 设置样式
+    setStyle(options) {
+        const { fontSize, fontWeight, fillStyle, strokeStyle } = options;
+        if (fontSize || fontWeight) {
+            this.ctx.font = `${fontWeight || DEFAULT_FONT_WEIGHT} ${fontSize || DEFAULT_FONT_SIZE}px ${DEFAULT_FONT_FAMILY}`;
+        }
+        if (fillStyle) {
+            this.ctx.fillStyle = fillStyle;
+        }
+        if (strokeStyle) {
+            this.ctx.strokeStyle = strokeStyle;
+        }
+    }
+    // 文本省略
+    textEllipsis(options) {
+        const { text, maxWidth, fontSize = DEFAULT_FONT_SIZE, fontWeight = DEFAULT_FONT_WEIGHT } = options;
+        if (text == null)
+            return {
+                text: '',
+                textWidth: 0,
+                isEllipsis: false
+            };
+        const fontStyle = `${fontWeight} ${fontSize}px ${DEFAULT_FONT_FAMILY}`;
+        if (!maxWidth) {
+            return {
+                text,
+                textWidth: getTextWidth(this.ctx, text, fontStyle),
+                isEllipsis: false
+            };
+        }
+        const ellipsis = '…';
+        const textSize = text.length;
+        // 预先确定传入文本的阈值宽度
+        let guessSize = Math.ceil(maxWidth / fontSize);
+        let guessText = text.substr(0, guessSize);
+        let guessWidth = getTextWidth(this.ctx, guessText, fontStyle);
+        while (guessWidth <= maxWidth) {
+            if (textSize <= guessSize) {
+                return {
+                    text,
+                    textWidth: guessWidth,
+                    isEllipsis: false
+                };
+            }
+            guessSize++;
+            guessText = text.substr(0, guessSize);
+            guessWidth = getTextWidth(this.ctx, guessText, fontStyle);
+        }
+        const ellipsisWidth = getTextWidth(this.ctx, ellipsis, fontStyle);
+        while (guessSize >= 0 && guessWidth + ellipsisWidth > maxWidth) {
+            guessSize--;
+            guessText = text.substr(0, guessSize);
+            guessWidth = getTextWidth(this.ctx, guessText, fontStyle);
+        }
+        return {
+            text: `${guessText || text[0]}${ellipsis}`,
+            textWidth: maxWidth,
+            isEllipsis: true
+        };
+    }
+    // 绘制线段
+    line(options) {
+        const { x, y, points, stroke, closed = false } = options;
+        const length = points.length;
+        this.ctx.save();
+        this.ctx.beginPath();
+        if (stroke)
+            this.ctx.strokeStyle = stroke;
+        this.ctx.lineWidth = 1;
+        this.ctx.translate(x, y);
+        this.ctx.moveTo(points[0], points[1]);
+        for (let n = 2; n < length; n += 2) {
+            this.ctx.lineTo(points[n], points[n + 1]);
+        }
+        if (closed) {
+            this.ctx.closePath();
+        }
+        this.ctx.stroke();
+        this.ctx.restore();
+    }
+    // 绘制圆
+    arc(options) {
+        const { x, y, stroke, fill, radius } = options;
+        this.ctx.beginPath();
+        if (fill)
+            this.setStyle({ fillStyle: fill });
+        if (stroke)
+            this.setStyle({ strokeStyle: stroke });
+        this.ctx.arc(x, y, radius, 0, 2 * Math.PI, false);
+        if (fill) {
+            this.ctx.fill();
+        }
+        if (stroke) {
+            this.ctx.stroke();
+        }
+    }
+    // 绘制矩形
+    rect(options) {
+        const { x, y, width, height, radius, fill, stroke } = options;
+        this.ctx.beginPath();
+        if (fill)
+            this.setStyle({ fillStyle: fill });
+        if (stroke)
+            this.setStyle({ strokeStyle: stroke });
+        if (!radius) {
+            this.ctx.rect(x, y, width, height);
+        }
+        else {
+            let topLeft = 0;
+            let topRight = 0;
+            let bottomLeft = 0;
+            let bottomRight = 0;
+            if (typeof radius === 'number') {
+                topLeft = topRight = bottomLeft = bottomRight = Math.min(radius, width / 2, height / 2);
+            }
+            else {
+                topLeft = Math.min(radius[0] || 0, width / 2, height / 2);
+                topRight = Math.min(radius[1] || 0, width / 2, height / 2);
+                bottomRight = Math.min(radius[2] || 0, width / 2, height / 2);
+                bottomLeft = Math.min(radius[3] || 0, width / 2, height / 2);
+            }
+            this.ctx.moveTo(x + topLeft, y);
+            this.ctx.lineTo(x + width - topRight, y);
+            this.ctx.arc(x + width - topRight, y + topRight, topRight, (Math.PI * 3) / 2, 0, false);
+            this.ctx.lineTo(x + width, y + height - bottomRight);
+            this.ctx.arc(x + width - bottomRight, y + height - bottomRight, bottomRight, 0, Math.PI / 2, false);
+            this.ctx.lineTo(x + bottomLeft, y + height);
+            this.ctx.arc(x + bottomLeft, y + height - bottomLeft, bottomLeft, Math.PI / 2, Math.PI, false);
+            this.ctx.lineTo(x, y + topLeft);
+            this.ctx.arc(x + topLeft, y + topLeft, topLeft, Math.PI, (Math.PI * 3) / 2, false);
+        }
+        this.ctx.closePath();
+        if (fill) {
+            this.ctx.fill();
+        }
+        if (stroke) {
+            this.ctx.stroke();
+        }
+    }
+    customRect(options) {
+        const { x, y, width, height, fill, strokes } = options;
+        if (fill)
+            this.setStyle({ fillStyle: fill });
+        this.ctx.fillRect(x, y, width, height);
+        if (strokes) {
+            const { top, right, bottom, left } = strokes;
+            // 上边框
+            this.ctx.beginPath();
+            this.setStyle({ strokeStyle: top ?? this.colors.transparent });
+            this.ctx.moveTo(x, y);
+            this.ctx.lineTo(x + width, y);
+            this.ctx.stroke();
+            // 右边框
+            this.ctx.beginPath();
+            this.setStyle({ strokeStyle: right ?? this.colors.transparent });
+            this.ctx.moveTo(x + width, y);
+            this.ctx.lineTo(x + width, y + height);
+            this.ctx.stroke();
+            // 下边框
+            this.ctx.beginPath();
+            this.setStyle({ strokeStyle: bottom ?? this.colors.transparent });
+            this.ctx.moveTo(x, y + height);
+            this.ctx.lineTo(x + width, y + height);
+            this.ctx.stroke();
+            // 左边框
+            this.ctx.beginPath();
+            this.setStyle({ strokeStyle: left ?? this.colors.transparent });
+            this.ctx.moveTo(x, y);
+            this.ctx.lineTo(x, y + height);
+            this.ctx.stroke();
+        }
+    }
+    // 换行文本绘制
+    wrapText(options) {
+        const { x, y, text, maxWidth, lineHeight, maxRow = DEFAULT_WRAP_TEXT_MAX_ROW, fontSize = DEFAULT_FONT_SIZE, fillStyle = this.colors.gray800, textAlign = DEFAULT_TEXT_ALIGN_LEFT, verticalAlign = DEFAULT_TEXT_VERTICAL_ALIGN_TOP, fontWeight = DEFAULT_FONT_WEIGHT, textDecoration = DEFAULT_TEXT_DECORATION, fieldType, needDraw = false } = options;
+        let offsetX = 0;
+        let offsetY = 0;
+        const baselineOffset = verticalAlign === DEFAULT_TEXT_VERTICAL_ALIGN_TOP ? fontSize / 2 : 0;
+        const fontStyle = `${fontWeight}-${fontSize}px`;
+        const isUnderline = textDecoration === 'underline';
+        const textRenderer = (textDataList) => {
+            textDataList.forEach((data) => {
+                const { offsetX, offsetY, text, width, linkUrl } = data;
+                this.ctx.fillText(text, x + offsetX, y + offsetY + baselineOffset);
+                if (linkUrl || isUnderline) {
+                    this.line({
+                        x: x + offsetX,
+                        y: y + offsetY + AI_TABLE_OFFSET,
+                        points: [0, fontSize, width, fontSize],
+                        stroke: fillStyle
+                    });
+                }
+            });
+        };
+        if (fillStyle)
+            this.setStyle({ fillStyle });
+        this.ctx.textAlign = textAlign;
+        const cacheKey = `${fontStyle}-${maxRow}-${maxWidth || 0}-${fieldType}-${text}`;
+        const cacheTextData = textDataCache.get(cacheKey);
+        if (cacheTextData) {
+            if (this.needDraw && needDraw) {
+                textRenderer(cacheTextData.data);
+            }
+            return cacheTextData;
+        }
+        const resultData = [];
+        // 准确切分包含表情符号的字符串
+        const arrText = graphemeSplitter.splitGraphemes(text);
+        const textLength = arrText.length;
+        const ellipsisWidth = this.ctx.measureText('…').width;
+        let showText = ''; // 每个片段显示的文本
+        let showTextWidth = 0; // 每段的宽度
+        let showLineWidth = 0; // 当前每行显示文字的宽度
+        let rowCount = 0;
+        const isEllipsis = this.textEllipsis({ text, maxWidth: maxWidth }).isEllipsis;
+        for (let n = 0; n < textLength; n++) {
+            const curText = arrText[n];
+            const isLineBreak = ['\n', '\r'].includes(curText);
+            const singleText = isLineBreak ? '' : curText;
+            const composeText = showText + singleText;
+            const isLimitRow = maxRow ? rowCount >= maxRow - 1 : false;
+            const singleTextWidth = isLineBreak ? 0 : this.ctx.measureText(singleText).width;
+            showLineWidth += singleTextWidth;
+            const diffWidth = isLimitRow ? showLineWidth + (isEllipsis ? ellipsisWidth : 0) : showLineWidth;
+            const isLineEnd = diffWidth > maxWidth;
+            // 遇到换行符或行尾
+            if ((isLineEnd || isLineBreak) && rowCount < maxRow) {
+                const isLastLetter = n === arrText.length - 1;
+                resultData.push({
+                    offsetX,
+                    offsetY,
+                    width: Math.ceil(showTextWidth),
+                    text: isLimitRow ? (isLastLetter ? composeText : `${showText}…`) : showText
+                });
+                showText = singleText;
+                offsetX = 0;
+                showTextWidth = singleTextWidth;
+                showLineWidth = singleTextWidth;
+                if (isLimitRow) {
+                    showText = '';
+                    break;
+                }
+                rowCount++;
+                offsetY += lineHeight;
+                continue;
+            }
+            showText = composeText;
+            showTextWidth += singleTextWidth;
+        }
+        if (showText) {
+            resultData.push({
+                offsetX,
+                offsetY,
+                width: Math.ceil(showTextWidth),
+                text: showText
+            });
+        }
+        if (this.needDraw && needDraw) {
+            textRenderer(resultData);
+        }
+        const res = {
+            height: rowCount < maxRow ? offsetY + lineHeight : offsetY,
+            data: resultData
+        };
+        textDataCache.set(cacheKey, res);
+        return res;
+    }
+    // 绘制单行文本
+    text(options) {
+        const { x, y, text, fontSize = DEFAULT_FONT_SIZE, fillStyle = this.colors.gray800, textAlign = DEFAULT_TEXT_ALIGN_LEFT, verticalAlign = DEFAULT_TEXT_VERTICAL_ALIGN_TOP, fontWeight = DEFAULT_FONT_WEIGHT, textDecoration = DEFAULT_TEXT_DECORATION } = options;
+        const fontStyle = `${fontWeight} ${fontSize}px ${DEFAULT_FONT_FAMILY}`;
+        if (textDecoration === 'underline') {
+            const textWidth = getTextWidth(this.ctx, text, fontStyle);
+            this.line({
+                x: x,
+                y: y + AI_TABLE_OFFSET,
+                points: [0, fontSize, textWidth, fontSize],
+                stroke: fillStyle
+            });
+        }
+        const baselineOffset = verticalAlign === DEFAULT_TEXT_VERTICAL_ALIGN_TOP ? fontSize / 2 : 0;
+        if (fillStyle)
+            this.setStyle({ fillStyle });
+        this.ctx.textAlign = textAlign;
+        this.ctx.font = fontStyle;
+        this.ctx.fillText(text, x, y + baselineOffset);
+    }
+    // 绘制标签
+    tag(options) {
+        const { x, y, width, height, text, radius, background, color = this.colors.gray800, fontSize = AI_TABLE_TAG_FONT_SIZE, fontWeight = DEFAULT_FONT_WEIGHT, stroke } = options;
+        // 背景
+        this.rect({
+            x,
+            y,
+            width,
+            height,
+            radius,
+            fill: background,
+            stroke
+        });
+        this.text({
+            x: x + AI_TABLE_TAG_PADDING,
+            y: y + (height - fontSize) / 2,
+            text,
+            fillStyle: color,
+            fontSize,
+            fontWeight
+        });
+        return {
+            width,
+            height
+        };
+    }
+    image(options, crossOrigin, allowDefault) {
+        const { x, y, url, width, height, opacity = 1, clipFunc } = options;
+        const colors = AITable.getColors();
+        if (!url) {
+            return;
+        }
+        const image = imageCache.getImage(url);
+        // Not loaded successfully
+        if (image === false) {
+            if (allowDefault) {
+                this.path({
+                    x,
+                    y: y + 2,
+                    data: WebOutlinedPath,
+                    size: 16,
+                    fill: colors.gray600
+                });
+            }
+            return;
+        }
+        // Unloaded
+        if (image == null) {
+            return imageCache.loadImage(url, url, { crossOrigin });
+        }
+        const isOrigin = opacity === 1;
+        if (!clipFunc && isOrigin) {
+            return this.ctx.drawImage(image, x, y, width, height);
+        }
+        if (!clipFunc && !isOrigin) {
+            this.ctx.save();
+            this.ctx.globalAlpha = opacity;
+            this.ctx.drawImage(image, x, y, width, height);
+            this.ctx.restore();
+            return;
+        }
+        if (clipFunc) {
+            this.ctx.save();
+            this.ctx.beginPath();
+            clipFunc(this.ctx);
+            this.ctx.clip();
+            this.ctx.globalAlpha = opacity;
+            this.ctx.drawImage(image, x, y, width, height);
+            this.ctx.restore();
+        }
+    }
+    avatar(options) {
+        const { x = 0, y = 0, id, url, title, bgColor = this.colors.white, size = AITableAvatarSize.size36, type = AITableAvatarType.member, opacity = 1 } = options;
+        if (title == null || id == null)
+            return null;
+        const colors = AITable.getColors();
+        const avatarSrc = url || '';
+        const avatarName = title;
+        const avatarBg = avatarSrc ? colors.white : bgColor;
+        switch (type) {
+            case AITableAvatarType.member: {
+                const radius = size / 2;
+                if (!avatarSrc) {
+                    this.ctx.fillStyle = avatarBg;
+                    this.ctx.beginPath();
+                    this.ctx.arc(x + radius, y + radius, radius, 0, Math.PI * 2, false);
+                    this.ctx.closePath();
+                    this.ctx.fill();
+                    return this.text({
+                        x: x + radius,
+                        y: y + radius,
+                        text: avatarName,
+                        textAlign: DEFAULT_TEXT_ALIGN_CENTER,
+                        verticalAlign: DEFAULT_TEXT_VERTICAL_ALIGN_MIDDLE,
+                        fontSize: FONT_SIZE_SM,
+                        fillStyle: colors.white
+                    });
+                }
+                return this.image({
+                    name: avatarSrc,
+                    x,
+                    y,
+                    url: avatarSrc,
+                    width: size,
+                    height: size,
+                    clipFunc: (ctx) => {
+                        ctx.fillStyle = avatarBg;
+                        ctx.arc(x + radius, y + radius, radius, 0, Math.PI * 2, false);
+                        ctx.fill();
+                    },
+                    opacity
+                });
+            }
+        }
+    }
+    /**
+     * 方法将椭圆弧的端点参数化形式转换为中心参数化形式
+     * 接受弧线的端点参数，并计算出弧线的中心点坐标、起始角度、终止角度等参数
+     * 返回值：一个包含中心点坐标、半径、旋转角度、起始角度以及角度差的对象，这些参数可以直接用于绘制椭圆弧
+     * @returns [cx, cy, rx, ry, theta, dTheta, psi, fs]
+     */
+    convertEndpointToCenterParameterization(x1, y1, x2, y2, fa, fs, rx, ry, psiDeg) {
+        const psi = psiDeg * (Math.PI / 180.0);
+        const xp = (Math.cos(psi) * (x1 - x2)) / 2.0 + (Math.sin(psi) * (y1 - y2)) / 2.0;
+        const yp = (-1 * Math.sin(psi) * (x1 - x2)) / 2.0 + (Math.cos(psi) * (y1 - y2)) / 2.0;
+        const lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
+        if (lambda > 1) {
+            rx *= Math.sqrt(lambda);
+            ry *= Math.sqrt(lambda);
+        }
+        let f = Math.sqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp)));
+        if (fa === fs) {
+            f *= -1;
+        }
+        if (isNaN(f)) {
+            f = 0;
+        }
+        const cxp = (f * rx * yp) / ry;
+        const cyp = (f * -ry * xp) / rx;
+        const cx = (x1 + x2) / 2.0 + Math.cos(psi) * cxp - Math.sin(psi) * cyp;
+        const cy = (y1 + y2) / 2.0 + Math.sin(psi) * cxp + Math.cos(psi) * cyp;
+        const vMag = function (v) {
+            return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+        };
+        const vRatio = function (u, v) {
+            return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));
+        };
+        const vAngle = function (u, v) {
+            return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));
+        };
+        const theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);
+        const u = [(xp - cxp) / rx, (yp - cyp) / ry];
+        const v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];
+        let dTheta = vAngle(u, v);
+        if (vRatio(u, v) <= -1) {
+            dTheta = Math.PI;
+        }
+        if (vRatio(u, v) >= 1) {
+            dTheta = 0;
+        }
+        if (fs === 0 && dTheta > 0) {
+            dTheta = dTheta - 2 * Math.PI;
+        }
+        if (fs === 1 && dTheta < 0) {
+            dTheta = dTheta + 2 * Math.PI;
+        }
+        return [cx, cy, rx, ry, theta, dTheta, psi, fs];
+    }
+    /**
+     * 计算两个点 (x1, y1) 和 (x2, y2) 之间的直线距离
+     * @returns 两个点 (x1, y1) 和 (x2, y2) 之间的直线距离，单位与输入的坐标值相同
+     */
+    getLineLength(x1, y1, x2, y2) {
+        return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
+    }
+    /**
+     * 计算三次贝塞尔曲线上给定参数 t 对应的点的坐标.
+     * 可以在指定的 t 参数下计算出曲线上精确的一个点，这个点可以用于绘制平滑曲线的一部分
+     * @param pct - 0 到 1 之间的参数，用于指定曲线上的点的位置
+     * @param P1x - 曲线的起点 x 坐标
+     * @param P1y - 曲线的起点 y 坐标
+     * @param P2x - 曲线的第一个控制点 x 坐标
+     * @param P2y - 曲线的第一个控制点 y 坐标
+     * @param P3x - 曲线的第二个控制点 x 坐标
+     * @param P3y - 曲线的第二个控制点 y 坐标
+     * @param P4x - 曲线的终点 x 坐标
+     * @param P4y - 曲线的终点 y 坐标
+     * @returns
+     */
+    getPointOnCubicBezier(pct, P1x, P1y, P2x, P2y, P3x, P3y, P4x, P4y) {
+        function CB1(t) {
+            return t * t * t;
+        }
+        function CB2(t) {
+            return 3 * t * t * (1 - t);
+        }
+        function CB3(t) {
+            return 3 * t * (1 - t) * (1 - t);
+        }
+        function CB4(t) {
+            return (1 - t) * (1 - t) * (1 - t);
+        }
+        const x = P4x * CB1(pct) + P3x * CB2(pct) + P2x * CB3(pct) + P1x * CB4(pct);
+        const y = P4y * CB1(pct) + P3y * CB2(pct) + P2y * CB3(pct) + P1y * CB4(pct);
+        return {
+            x: x,
+            y: y
+        };
+    }
+    /**
+     * 计算二次贝塞尔曲线上给定参数 t 对应的点的坐标
+     * @param pct - 0 到 1 之间的参数，用于指定曲线上的点的位置
+     * @param P1x - 曲线的起点 x 坐标
+     * @param P1y - 曲线的起点 y 坐标
+     * @param P2x - 曲线的控制点 x 坐标
+     * @param P2y - 曲线的控制点 y 坐标
+     * @param P3x - 曲线的终点 x 坐标
+     * @param P3y - 曲线的终点 y 坐标
+     * @returns
+     */
+    getPointOnQuadraticBezier(pct, P1x, P1y, P2x, P2y, P3x, P3y) {
+        function QB1(t) {
+            return t * t;
+        }
+        function QB2(t) {
+            return 2 * t * (1 - t);
+        }
+        function QB3(t) {
+            return (1 - t) * (1 - t);
+        }
+        const x = P3x * QB1(pct) + P2x * QB2(pct) + P1x * QB3(pct);
+        const y = P3y * QB1(pct) + P2y * QB2(pct) + P1y * QB3(pct);
+        return {
+            x: x,
+            y: y
+        };
+    }
+    /**
+     * 计算椭圆弧上给定角度 θ 对应的点的坐标
+     * @param cx - 椭圆的中心点 x 坐标
+     * @param cy - 椭圆的中心点 y 坐标
+     * @param rx - 椭圆的 x 轴半径
+     * @param ry - 椭圆的 y 轴半径
+     * @param theta - 椭圆弧的起始角度
+     * @param psi - 椭圆弧的旋转角度
+     * @returns
+     */
+    getPointOnEllipticalArc(cx, cy, rx, ry, theta, psi) {
+        const cosPsi = Math.cos(psi);
+        const sinPsi = Math.sin(psi);
+        const pt = {
+            x: rx * Math.cos(theta),
+            y: ry * Math.sin(theta)
+        };
+        return {
+            x: cx + (pt.x * cosPsi - pt.y * sinPsi),
+            y: cy + (pt.x * sinPsi + pt.y * cosPsi)
+        };
+    }
+    /**
+     * 计算基于不同路径命令的长度
+     * @param x - 起点 x 坐标
+     * @param y - 起点 y 坐标
+     * @param cmd - 路径命令
+     * @param points - 与路径命令相关的点的坐标或控制参数
+     * @returns
+     */
+    calcLength(x, y, cmd, points) {
+        let len, p1, p2, t;
+        switch (cmd) {
+            case 'L':
+                return this.getLineLength(x, y, points[0], points[1]);
+            case 'C':
+                len = 0.0;
+                p1 = this.getPointOnCubicBezier(0, x, y, points[0], points[1], points[2], points[3], points[4], points[5]);
+                for (t = 0.01; t <= 1; t += 0.01) {
+                    p2 = this.getPointOnCubicBezier(t, x, y, points[0], points[1], points[2], points[3], points[4], points[5]);
+                    len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
+                    p1 = p2;
+                }
+                return len;
+            case 'Q':
+                len = 0.0;
+                p1 = this.getPointOnQuadraticBezier(0, x, y, points[0], points[1], points[2], points[3]);
+                for (t = 0.01; t <= 1; t += 0.01) {
+                    p2 = this.getPointOnQuadraticBezier(t, x, y, points[0], points[1], points[2], points[3]);
+                    len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
+                    p1 = p2;
+                }
+                return len;
+            case 'A':
+                len = 0.0;
+                const start = points[4];
+                const dTheta = points[5];
+                const end = points[4] + dTheta;
+                let inc = Math.PI / 180.0;
+                if (Math.abs(start - end) < inc) {
+                    inc = Math.abs(start - end);
+                }
+                p1 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], start, 0);
+                if (dTheta < 0) {
+                    for (t = start - inc; t > end; t -= inc) {
+                        p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t, 0);
+                        len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
+                        p1 = p2;
+                    }
+                }
+                else {
+                    for (t = start + inc; t < end; t += inc) {
+                        p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t, 0);
+                        len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
+                        p1 = p2;
+                    }
+                }
+                p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], end, 0);
+                len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);
+                return len;
+        }
+        return 0;
+    }
+    /**
+     * 解析 SVG 路径数据字符串，将其转换为一个包含路径命令和坐标点的数组对象
+     * @param data - SVG 路径数据字符串
+     * @returns
+     */
+    parsePathData(data) {
+        if (!data) {
+            return [];
+        }
+        let cs = data;
+        const cc = ['m', 'M', 'l', 'L', 'v', 'V', 'h', 'H', 'z', 'Z', 'c', 'C', 'q', 'Q', 't', 'T', 's', 'S', 'a', 'A'];
+        cs = cs.replace(new RegExp(' ', 'g'), ',');
+        for (let n = 0; n < cc.length; n++) {
+            cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);
+        }
+        const arr = cs.split('|');
+        const ca = [];
+        const coords = [];
+        let cpx = 0;
+        let cpy = 0;
+        const re = /([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:e[-+]?\d+)?)/gi;
+        let match;
+        for (let n = 1; n < arr.length; n++) {
+            let str = arr[n];
+            let c = str.charAt(0);
+            str = str.slice(1);
+            coords.length = 0;
+            while ((match = re.exec(str))) {
+                coords.push(match[0]);
+            }
+            const p = [];
+            for (let j = 0, jlen = coords.length; j < jlen; j++) {
+                if (coords[j] === '00') {
+                    p.push(0, 0);
+                    continue;
+                }
+                const parsed = parseFloat(coords[j]);
+                if (!isNaN(parsed)) {
+                    p.push(parsed);
+                }
+                else {
+                    p.push(0);
+                }
+            }
+            while (p.length > 0) {
+                if (isNaN(p[0])) {
+                    break;
+                }
+                let cmd = null;
+                let points = [];
+                const startX = cpx;
+                const startY = cpy;
+                let prevCmd, ctlPtx, ctlPty;
+                let rx, ry, psi, fa, fs, x1, y1;
+                switch (c) {
+                    case 'l':
+                        cpx += p.shift();
+                        cpy += p.shift();
+                        cmd = 'L';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'L':
+                        cpx = p.shift();
+                        cpy = p.shift();
+                        points.push(cpx, cpy);
+                        break;
+                    case 'm':
+                        const dx = p.shift();
+                        const dy = p.shift();
+                        cpx += dx;
+                        cpy += dy;
+                        cmd = 'M';
+                        if (ca.length > 2 && ca[ca.length - 1].command === 'z') {
+                            for (let idx = ca.length - 2; idx >= 0; idx--) {
+                                if (ca[idx].command === 'M') {
+                                    cpx = ca[idx].points[0] + dx;
+                                    cpy = ca[idx].points[1] + dy;
+                                    break;
+                                }
+                            }
+                        }
+                        points.push(cpx, cpy);
+                        c = 'l';
+                        break;
+                    case 'M':
+                        cpx = p.shift();
+                        cpy = p.shift();
+                        cmd = 'M';
+                        points.push(cpx, cpy);
+                        c = 'L';
+                        break;
+                    case 'h':
+                        cpx += p.shift();
+                        cmd = 'L';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'H':
+                        cpx = p.shift();
+                        cmd = 'L';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'v':
+                        cpy += p.shift();
+                        cmd = 'L';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'V':
+                        cpy = p.shift();
+                        cmd = 'L';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'C':
+                        points.push(p.shift(), p.shift(), p.shift(), p.shift());
+                        cpx = p.shift();
+                        cpy = p.shift();
+                        points.push(cpx, cpy);
+                        break;
+                    case 'c':
+                        points.push(cpx + p.shift(), cpy + p.shift(), cpx + p.shift(), cpy + p.shift());
+                        cpx += p.shift();
+                        cpy += p.shift();
+                        cmd = 'C';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'S':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        prevCmd = ca[ca.length - 1];
+                        if (prevCmd.command === 'C') {
+                            ctlPtx = cpx + (cpx - prevCmd.points[2]);
+                            ctlPty = cpy + (cpy - prevCmd.points[3]);
+                        }
+                        points.push(ctlPtx, ctlPty, p.shift(), p.shift());
+                        cpx = p.shift();
+                        cpy = p.shift();
+                        cmd = 'C';
+                        points.push(cpx, cpy);
+                        break;
+                    case 's':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        prevCmd = ca[ca.length - 1];
+                        if (prevCmd.command === 'C') {
+                            ctlPtx = cpx + (cpx - prevCmd.points[2]);
+                            ctlPty = cpy + (cpy - prevCmd.points[3]);
+                        }
+                        points.push(ctlPtx, ctlPty, cpx + p.shift(), cpy + p.shift());
+                        cpx += p.shift();
+                        cpy += p.shift();
+                        cmd = 'C';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'Q':
+                        points.push(p.shift(), p.shift());
+                        cpx = p.shift();
+                        cpy = p.shift();
+                        points.push(cpx, cpy);
+                        break;
+                    case 'q':
+                        points.push(cpx + p.shift(), cpy + p.shift());
+                        cpx += p.shift();
+                        cpy += p.shift();
+                        cmd = 'Q';
+                        points.push(cpx, cpy);
+                        break;
+                    case 'T':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        prevCmd = ca[ca.length - 1];
+                        if (prevCmd.command === 'Q') {
+                            ctlPtx = cpx + (cpx - prevCmd.points[0]);
+                            ctlPty = cpy + (cpy - prevCmd.points[1]);
+                        }
+                        cpx = p.shift();
+                        cpy = p.shift();
+                        cmd = 'Q';
+                        points.push(ctlPtx, ctlPty, cpx, cpy);
+                        break;
+                    case 't':
+                        ctlPtx = cpx;
+                        ctlPty = cpy;
+                        prevCmd = ca[ca.length - 1];
+                        if (prevCmd.command === 'Q') {
+                            ctlPtx = cpx + (cpx - prevCmd.points[0]);
+                            ctlPty = cpy + (cpy - prevCmd.points[1]);
+                        }
+                        cpx += p.shift();
+                        cpy += p.shift();
+                        cmd = 'Q';
+                        points.push(ctlPtx, ctlPty, cpx, cpy);
+                        break;
+                    case 'A':
+                        rx = p.shift();
+                        ry = p.shift();
+                        psi = p.shift();
+                        fa = p.shift();
+                        fs = p.shift();
+                        x1 = cpx;
+                        y1 = cpy;
+                        cpx = p.shift();
+                        cpy = p.shift();
+                        cmd = 'A';
+                        points = this.convertEndpointToCenterParameterization(x1, y1, cpx, cpy, fa, fs, rx, ry, psi);
+                        break;
+                    case 'a':
+                        rx = p.shift();
+                        ry = p.shift();
+                        psi = p.shift();
+                        fa = p.shift();
+                        fs = p.shift();
+                        x1 = cpx;
+                        y1 = cpy;
+                        cpx += p.shift();
+                        cpy += p.shift();
+                        cmd = 'A';
+                        points = this.convertEndpointToCenterParameterization(x1, y1, cpx, cpy, fa, fs, rx, ry, psi);
+                        break;
+                }
+                ca.push({
+                    command: cmd || c,
+                    points: points,
+                    start: {
+                        x: startX,
+                        y: startY
+                    },
+                    pathLength: this.calcLength(startX, startY, cmd || c, points)
+                });
+            }
+            if (c === 'z' || c === 'Z') {
+                ca.push({
+                    command: 'z',
+                    points: [],
+                    start: undefined,
+                    pathLength: 0
+                });
+            }
+        }
+        return ca;
+    }
+    /**
+     * 根据传入的路径数据 data 在画布上绘制路径
+     * @param options
+     */
+    path(options) {
+        const { x, y, scaleX = 1, scaleY = 1, data, fill } = options;
+        const dataArray = this.parsePathData(data);
+        this.ctx.save();
+        this.ctx.beginPath();
+        this.ctx.fillStyle = fill;
+        this.ctx.translate(x, y);
+        this.ctx.scale(scaleX, scaleY);
+        let isClosed = false;
+        for (let n = 0; n < dataArray.length; n++) {
+            const c = dataArray[n].command;
+            const p = dataArray[n].points;
+            switch (c) {
+                case 'L':
+                    this.ctx.lineTo(p[0], p[1]);
+                    break;
+                case 'M':
+                    this.ctx.moveTo(p[0], p[1]);
+                    break;
+                case 'C':
+                    this.ctx.bezierCurveTo(p[0], p[1], p[2], p[3], p[4], p[5]);
+                    break;
+                case 'Q':
+                    this.ctx.quadraticCurveTo(p[0], p[1], p[2], p[3]);
+                    break;
+                case 'A':
+                    const cx = p[0];
+                    const cy = p[1];
+                    const rx = p[2];
+                    const ry = p[3];
+                    const theta = p[4];
+                    const dTheta = p[5];
+                    const psi = p[6];
+                    const fs = p[7];
+                    const r = rx > ry ? rx : ry;
+                    const scaleX = rx > ry ? 1 : rx / ry;
+                    const scaleY = rx > ry ? ry / rx : 1;
+                    this.ctx.translate(cx, cy);
+                    this.ctx.rotate(psi);
+                    this.ctx.scale(scaleX, scaleY);
+                    this.ctx.arc(0, 0, r, theta, theta + dTheta, (1 - fs));
+                    this.ctx.scale(1 / scaleX, 1 / scaleY);
+                    this.ctx.rotate(-psi);
+                    this.ctx.translate(-cx, -cy);
+                    break;
+                case 'z':
+                    isClosed = true;
+                    this.ctx.closePath();
+                    break;
+            }
+        }
+        if (!isClosed) {
+            this.ctx.stroke();
+        }
+        else {
+            this.ctx.fill();
+        }
+        this.ctx.restore();
+    }
+}
+export const drawer = new Drawer();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drawer.js","sourceRoot":"","sources":["../../../../../packages/grid/src/renderer/drawers/drawer.ts"],"names":[],"mappings":"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","sourcesContent":["import GraphemeSplitter from 'grapheme-splitter';\nimport {\n    AI_TABLE_OFFSET,\n    AI_TABLE_TAG_FONT_SIZE,\n    AI_TABLE_TAG_PADDING,\n    DEFAULT_FONT_FAMILY,\n    DEFAULT_FONT_SIZE,\n    DEFAULT_FONT_WEIGHT,\n    DEFAULT_TEXT_ALIGN_CENTER,\n    DEFAULT_TEXT_ALIGN_LEFT,\n    DEFAULT_TEXT_DECORATION,\n    DEFAULT_TEXT_VERTICAL_ALIGN_MIDDLE,\n    DEFAULT_TEXT_VERTICAL_ALIGN_TOP,\n    DEFAULT_WRAP_TEXT_MAX_ROW,\n    FONT_SIZE_SM,\n    WebOutlinedPath\n} from '../../constants';\nimport { AITable } from '../../core';\nimport {\n    AITableArc,\n    AITableAvatarSize,\n    AITableAvatarType,\n    AITableCtxStyle,\n    AITableImage,\n    AITableLabel,\n    AITableLine,\n    AITableRect,\n    AITableText,\n    AITableTextEllipsis,\n    AITableWrapText,\n    AITableWrapTextData\n} from '../../types';\nimport { getTextWidth, imageCache, textDataCache, TextMeasure } from '../../utils';\n\n// 用于正确地分割字符串，包括表情符号\nexport const graphemeSplitter = new GraphemeSplitter();\n\n/**\n * 用于在 Canvas 上进行的各种绘图操作，包含了文本绘制、矩形绘制、路径绘制以及一些几何计算等功能\n */\nexport class Drawer {\n    ctx: CanvasRenderingContext2D = TextMeasure().context!;\n    needDraw = false;\n    colors = AITable.getColors();\n\n    public initCtx(ctx: CanvasRenderingContext2D) {\n        this.needDraw = Boolean(ctx);\n        this.ctx = ctx || TextMeasure().context!;\n        /**\n         * textBaseline 指定为 middle，兼容浏览器差异\n         */\n        this.ctx.textBaseline = DEFAULT_TEXT_VERTICAL_ALIGN_MIDDLE;\n    }\n\n    // 设置样式\n    public setStyle(options: AITableCtxStyle) {\n        const { fontSize, fontWeight, fillStyle, strokeStyle } = options;\n\n        if (fontSize || fontWeight) {\n            this.ctx.font = `${fontWeight || DEFAULT_FONT_WEIGHT} ${fontSize || DEFAULT_FONT_SIZE}px ${DEFAULT_FONT_FAMILY}`;\n        }\n        if (fillStyle) {\n            this.ctx.fillStyle = fillStyle;\n        }\n        if (strokeStyle) {\n            this.ctx.strokeStyle = strokeStyle;\n        }\n    }\n\n    // 文本省略\n    public textEllipsis(options: AITableTextEllipsis) {\n        const { text, maxWidth, fontSize = DEFAULT_FONT_SIZE, fontWeight = DEFAULT_FONT_WEIGHT } = options;\n\n        if (text == null)\n            return {\n                text: '',\n                textWidth: 0,\n                isEllipsis: false\n            };\n        const fontStyle = `${fontWeight} ${fontSize}px ${DEFAULT_FONT_FAMILY}`;\n\n        if (!maxWidth) {\n            return {\n                text,\n                textWidth: getTextWidth(this.ctx, text, fontStyle),\n                isEllipsis: false\n            };\n        }\n\n        const ellipsis = '…';\n        const textSize = text.length;\n        // 预先确定传入文本的阈值宽度\n        let guessSize = Math.ceil(maxWidth / fontSize);\n        let guessText = text.substr(0, guessSize);\n        let guessWidth = getTextWidth(this.ctx, guessText, fontStyle);\n\n        while (guessWidth <= maxWidth) {\n            if (textSize <= guessSize) {\n                return {\n                    text,\n                    textWidth: guessWidth,\n                    isEllipsis: false\n                };\n            }\n            guessSize++;\n            guessText = text.substr(0, guessSize);\n            guessWidth = getTextWidth(this.ctx, guessText, fontStyle);\n        }\n\n        const ellipsisWidth = getTextWidth(this.ctx, ellipsis, fontStyle);\n        while (guessSize >= 0 && guessWidth + ellipsisWidth > maxWidth) {\n            guessSize--;\n            guessText = text.substr(0, guessSize);\n            guessWidth = getTextWidth(this.ctx, guessText, fontStyle);\n        }\n\n        return {\n            text: `${guessText || text[0]}${ellipsis}`,\n            textWidth: maxWidth,\n            isEllipsis: true\n        };\n    }\n\n    // 绘制线段\n    public line(options: AITableLine) {\n        const { x, y, points, stroke, closed = false } = options;\n        const length = points.length;\n\n        this.ctx.save();\n        this.ctx.beginPath();\n        if (stroke) this.ctx.strokeStyle = stroke;\n        this.ctx.lineWidth = 1;\n        this.ctx.translate(x, y);\n        this.ctx.moveTo(points[0], points[1]);\n\n        for (let n = 2; n < length; n += 2) {\n            this.ctx.lineTo(points[n], points[n + 1]);\n        }\n\n        if (closed) {\n            this.ctx.closePath();\n        }\n        this.ctx.stroke();\n        this.ctx.restore();\n    }\n\n    // 绘制圆\n    public arc(options: AITableArc) {\n        const { x, y, stroke, fill, radius } = options;\n        this.ctx.beginPath();\n        if (fill) this.setStyle({ fillStyle: fill });\n        if (stroke) this.setStyle({ strokeStyle: stroke });\n        this.ctx.arc(x, y, radius, 0, 2 * Math.PI, false);\n        if (fill) {\n            this.ctx.fill();\n        }\n        if (stroke) {\n            this.ctx.stroke();\n        }\n    }\n\n    // 绘制矩形\n    public rect(options: AITableRect) {\n        const { x, y, width, height, radius, fill, stroke } = options;\n\n        this.ctx.beginPath();\n        if (fill) this.setStyle({ fillStyle: fill });\n        if (stroke) this.setStyle({ strokeStyle: stroke });\n\n        if (!radius) {\n            this.ctx.rect(x, y, width, height);\n        } else {\n            let topLeft = 0;\n            let topRight = 0;\n            let bottomLeft = 0;\n            let bottomRight = 0;\n\n            if (typeof radius === 'number') {\n                topLeft = topRight = bottomLeft = bottomRight = Math.min(radius, width / 2, height / 2);\n            } else {\n                topLeft = Math.min(radius[0] || 0, width / 2, height / 2);\n                topRight = Math.min(radius[1] || 0, width / 2, height / 2);\n                bottomRight = Math.min(radius[2] || 0, width / 2, height / 2);\n                bottomLeft = Math.min(radius[3] || 0, width / 2, height / 2);\n            }\n\n            this.ctx.moveTo(x + topLeft, y);\n            this.ctx.lineTo(x + width - topRight, y);\n            this.ctx.arc(x + width - topRight, y + topRight, topRight, (Math.PI * 3) / 2, 0, false);\n            this.ctx.lineTo(x + width, y + height - bottomRight);\n            this.ctx.arc(x + width - bottomRight, y + height - bottomRight, bottomRight, 0, Math.PI / 2, false);\n            this.ctx.lineTo(x + bottomLeft, y + height);\n            this.ctx.arc(x + bottomLeft, y + height - bottomLeft, bottomLeft, Math.PI / 2, Math.PI, false);\n            this.ctx.lineTo(x, y + topLeft);\n            this.ctx.arc(x + topLeft, y + topLeft, topLeft, Math.PI, (Math.PI * 3) / 2, false);\n        }\n\n        this.ctx.closePath();\n\n        if (fill) {\n            this.ctx.fill();\n        }\n        if (stroke) {\n            this.ctx.stroke();\n        }\n    }\n\n    public customRect(options: AITableRect) {\n        const { x, y, width, height, fill, strokes } = options;\n        if (fill) this.setStyle({ fillStyle: fill });\n        this.ctx.fillRect(x, y, width, height);\n        if (strokes) {\n            const { top, right, bottom, left } = strokes;\n            // 上边框\n            this.ctx.beginPath();\n            this.setStyle({ strokeStyle: top ?? this.colors.transparent });\n            this.ctx.moveTo(x, y);\n            this.ctx.lineTo(x + width, y);\n            this.ctx.stroke();\n            // 右边框\n            this.ctx.beginPath();\n            this.setStyle({ strokeStyle: right ?? this.colors.transparent });\n            this.ctx.moveTo(x + width, y);\n            this.ctx.lineTo(x + width, y + height);\n            this.ctx.stroke();\n            // 下边框\n            this.ctx.beginPath();\n            this.setStyle({ strokeStyle: bottom ?? this.colors.transparent });\n            this.ctx.moveTo(x, y + height);\n            this.ctx.lineTo(x + width, y + height);\n            this.ctx.stroke();\n            // 左边框\n            this.ctx.beginPath();\n            this.setStyle({ strokeStyle: left ?? this.colors.transparent });\n            this.ctx.moveTo(x, y);\n            this.ctx.lineTo(x, y + height);\n            this.ctx.stroke();\n        }\n    }\n\n    // 换行文本绘制\n    public wrapText(options: AITableWrapText) {\n        const {\n            x,\n            y,\n            text,\n            maxWidth,\n            lineHeight,\n            maxRow = DEFAULT_WRAP_TEXT_MAX_ROW,\n            fontSize = DEFAULT_FONT_SIZE,\n            fillStyle = this.colors.gray800,\n            textAlign = DEFAULT_TEXT_ALIGN_LEFT,\n            verticalAlign = DEFAULT_TEXT_VERTICAL_ALIGN_TOP,\n            fontWeight = DEFAULT_FONT_WEIGHT,\n            textDecoration = DEFAULT_TEXT_DECORATION,\n            fieldType,\n            needDraw = false\n        } = options;\n        let offsetX = 0;\n        let offsetY = 0;\n        const baselineOffset = verticalAlign === DEFAULT_TEXT_VERTICAL_ALIGN_TOP ? fontSize / 2 : 0;\n        const fontStyle = `${fontWeight}-${fontSize}px`;\n        const isUnderline = textDecoration === 'underline';\n        const textRenderer = (textDataList: any[]) => {\n            textDataList.forEach((data) => {\n                const { offsetX, offsetY, text, width, linkUrl } = data;\n                this.ctx.fillText(text, x + offsetX, y + offsetY + baselineOffset);\n                if (linkUrl || isUnderline) {\n                    this.line({\n                        x: x + offsetX,\n                        y: y + offsetY + AI_TABLE_OFFSET,\n                        points: [0, fontSize, width, fontSize],\n                        stroke: fillStyle\n                    });\n                }\n            });\n        };\n\n        if (fillStyle) this.setStyle({ fillStyle });\n        this.ctx.textAlign = textAlign;\n\n        const cacheKey = `${fontStyle}-${maxRow}-${maxWidth || 0}-${fieldType}-${text}`;\n        const cacheTextData = textDataCache.get(cacheKey);\n        if (cacheTextData) {\n            if (this.needDraw && needDraw) {\n                textRenderer(cacheTextData.data);\n            }\n            return cacheTextData;\n        }\n\n        const resultData: AITableWrapTextData = [];\n        // 准确切分包含表情符号的字符串\n        const arrText = graphemeSplitter.splitGraphemes(text);\n        const textLength = arrText.length;\n        const ellipsisWidth = this.ctx.measureText('…').width;\n        let showText = ''; // 每个片段显示的文本\n        let showTextWidth = 0; // 每段的宽度\n        let showLineWidth = 0; // 当前每行显示文字的宽度\n        let rowCount = 0;\n\n        const isEllipsis = this.textEllipsis({ text, maxWidth: maxWidth }).isEllipsis;\n\n        for (let n = 0; n < textLength; n++) {\n            const curText = arrText[n];\n            const isLineBreak = ['\\n', '\\r'].includes(curText);\n            const singleText = isLineBreak ? '' : curText;\n            const composeText = showText + singleText;\n            const isLimitRow = maxRow ? rowCount >= maxRow - 1 : false;\n            const singleTextWidth = isLineBreak ? 0 : this.ctx.measureText(singleText).width;\n            showLineWidth += singleTextWidth;\n            const diffWidth = isLimitRow ? showLineWidth + (isEllipsis ? ellipsisWidth : 0) : showLineWidth;\n            const isLineEnd = diffWidth > maxWidth;\n\n            // 遇到换行符或行尾\n            if ((isLineEnd || isLineBreak) && rowCount < maxRow) {\n                const isLastLetter = n === arrText.length - 1;\n                resultData.push({\n                    offsetX,\n                    offsetY,\n                    width: Math.ceil(showTextWidth),\n                    text: isLimitRow ? (isLastLetter ? composeText : `${showText}…`) : showText\n                });\n                showText = singleText;\n                offsetX = 0;\n                showTextWidth = singleTextWidth;\n                showLineWidth = singleTextWidth;\n\n                if (isLimitRow) {\n                    showText = '';\n                    break;\n                }\n                rowCount++;\n                offsetY += lineHeight;\n                continue;\n            }\n\n            showText = composeText;\n            showTextWidth += singleTextWidth;\n        }\n\n        if (showText) {\n            resultData.push({\n                offsetX,\n                offsetY,\n                width: Math.ceil(showTextWidth),\n                text: showText\n            });\n        }\n\n        if (this.needDraw && needDraw) {\n            textRenderer(resultData);\n        }\n\n        const res = {\n            height: rowCount < maxRow ? offsetY + lineHeight : offsetY,\n            data: resultData\n        };\n\n        textDataCache.set(cacheKey, res);\n        return res;\n    }\n\n    // 绘制单行文本\n    public text(options: AITableText) {\n        const {\n            x,\n            y,\n            text,\n            fontSize = DEFAULT_FONT_SIZE,\n            fillStyle = this.colors.gray800,\n            textAlign = DEFAULT_TEXT_ALIGN_LEFT,\n            verticalAlign = DEFAULT_TEXT_VERTICAL_ALIGN_TOP,\n            fontWeight = DEFAULT_FONT_WEIGHT,\n            textDecoration = DEFAULT_TEXT_DECORATION\n        } = options;\n\n        const fontStyle = `${fontWeight} ${fontSize}px ${DEFAULT_FONT_FAMILY}`;\n\n        if (textDecoration === 'underline') {\n            const textWidth = getTextWidth(this.ctx, text, fontStyle);\n            this.line({\n                x: x,\n                y: y + AI_TABLE_OFFSET,\n                points: [0, fontSize, textWidth, fontSize],\n                stroke: fillStyle\n            });\n        }\n\n        const baselineOffset = verticalAlign === DEFAULT_TEXT_VERTICAL_ALIGN_TOP ? fontSize / 2 : 0;\n        if (fillStyle) this.setStyle({ fillStyle });\n        this.ctx.textAlign = textAlign;\n        this.ctx.font = fontStyle;\n        this.ctx.fillText(text, x, y + baselineOffset);\n    }\n\n    // 绘制标签\n    public tag(options: AITableLabel): { width: number; height: number } {\n        const {\n            x,\n            y,\n            width,\n            height,\n            text,\n            radius,\n            background,\n            color = this.colors.gray800,\n            fontSize = AI_TABLE_TAG_FONT_SIZE,\n            fontWeight = DEFAULT_FONT_WEIGHT,\n            stroke\n        } = options;\n\n        // 背景\n        this.rect({\n            x,\n            y,\n            width,\n            height,\n            radius,\n            fill: background,\n            stroke\n        });\n\n        this.text({\n            x: x + AI_TABLE_TAG_PADDING,\n            y: y + (height - fontSize) / 2,\n            text,\n            fillStyle: color,\n            fontSize,\n            fontWeight\n        });\n\n        return {\n            width,\n            height\n        };\n    }\n\n    public image(options: AITableImage, crossOrigin?: boolean, allowDefault?: boolean) {\n        const { x, y, url, width, height, opacity = 1, clipFunc } = options;\n        const colors = AITable.getColors();\n        if (!url) {\n            return;\n        }\n        const image = imageCache.getImage(url);\n        // Not loaded successfully\n        if (image === false) {\n            if (allowDefault) {\n                this.path({\n                    x,\n                    y: y + 2,\n                    data: WebOutlinedPath,\n                    size: 16,\n                    fill: colors.gray600\n                });\n            }\n            return;\n        }\n        // Unloaded\n        if (image == null) {\n            return imageCache.loadImage(url, url, { crossOrigin });\n        }\n        const isOrigin = opacity === 1;\n\n        if (!clipFunc && isOrigin) {\n            return this.ctx.drawImage(image, x, y, width, height);\n        }\n\n        if (!clipFunc && !isOrigin) {\n            this.ctx.save();\n            this.ctx.globalAlpha = opacity;\n            this.ctx.drawImage(image, x, y, width, height);\n            this.ctx.restore();\n            return;\n        }\n\n        if (clipFunc) {\n            this.ctx.save();\n            this.ctx.beginPath();\n            clipFunc(this.ctx);\n            this.ctx.clip();\n            this.ctx.globalAlpha = opacity;\n            this.ctx.drawImage(image, x, y, width, height);\n            this.ctx.restore();\n        }\n    }\n\n    public avatar(options: {\n        x: number;\n        y: number;\n        url: string;\n        id: string;\n        title: string;\n        type?: AITableAvatarType;\n        size?: AITableAvatarSize;\n        opacity?: number;\n        bgColor?: string;\n    }) {\n        const {\n            x = 0,\n            y = 0,\n            id,\n            url,\n            title,\n            bgColor = this.colors.white,\n            size = AITableAvatarSize.size36,\n            type = AITableAvatarType.member,\n            opacity = 1\n        } = options;\n\n        if (title == null || id == null) return null;\n        const colors = AITable.getColors();\n        const avatarSrc = url || '';\n        const avatarName = title;\n        const avatarBg = avatarSrc ? colors.white : bgColor;\n\n        switch (type) {\n            case AITableAvatarType.member: {\n                const radius = size / 2;\n                if (!avatarSrc) {\n                    this.ctx.fillStyle = avatarBg;\n                    this.ctx.beginPath();\n                    this.ctx.arc(x + radius, y + radius, radius, 0, Math.PI * 2, false);\n                    this.ctx.closePath();\n                    this.ctx.fill();\n                    return this.text({\n                        x: x + radius,\n                        y: y + radius,\n                        text: avatarName,\n                        textAlign: DEFAULT_TEXT_ALIGN_CENTER,\n                        verticalAlign: DEFAULT_TEXT_VERTICAL_ALIGN_MIDDLE,\n                        fontSize: FONT_SIZE_SM,\n                        fillStyle: colors.white\n                    });\n                }\n                return this.image({\n                    name: avatarSrc,\n                    x,\n                    y,\n                    url: avatarSrc,\n                    width: size,\n                    height: size,\n                    clipFunc: (ctx) => {\n                        ctx.fillStyle = avatarBg;\n                        ctx.arc(x + radius, y + radius, radius, 0, Math.PI * 2, false);\n                        ctx.fill();\n                    },\n                    opacity\n                });\n            }\n        }\n    }\n\n    /**\n     * 方法将椭圆弧的端点参数化形式转换为中心参数化形式\n     * 接受弧线的端点参数，并计算出弧线的中心点坐标、起始角度、终止角度等参数\n     * 返回值：一个包含中心点坐标、半径、旋转角度、起始角度以及角度差的对象，这些参数可以直接用于绘制椭圆弧\n     * @returns [cx, cy, rx, ry, theta, dTheta, psi, fs]\n     */\n    private convertEndpointToCenterParameterization(\n        x1: number,\n        y1: number,\n        x2: number,\n        y2: number,\n        fa: any,\n        fs: number,\n        rx: number,\n        ry: number,\n        psiDeg: number\n    ) {\n        const psi = psiDeg * (Math.PI / 180.0);\n        const xp = (Math.cos(psi) * (x1 - x2)) / 2.0 + (Math.sin(psi) * (y1 - y2)) / 2.0;\n        const yp = (-1 * Math.sin(psi) * (x1 - x2)) / 2.0 + (Math.cos(psi) * (y1 - y2)) / 2.0;\n\n        const lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);\n\n        if (lambda > 1) {\n            rx *= Math.sqrt(lambda);\n            ry *= Math.sqrt(lambda);\n        }\n\n        let f = Math.sqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp)));\n\n        if (fa === fs) {\n            f *= -1;\n        }\n        if (isNaN(f)) {\n            f = 0;\n        }\n\n        const cxp = (f * rx * yp) / ry;\n        const cyp = (f * -ry * xp) / rx;\n\n        const cx = (x1 + x2) / 2.0 + Math.cos(psi) * cxp - Math.sin(psi) * cyp;\n        const cy = (y1 + y2) / 2.0 + Math.sin(psi) * cxp + Math.cos(psi) * cyp;\n\n        const vMag = function (v: number[]) {\n            return Math.sqrt(v[0] * v[0] + v[1] * v[1]);\n        };\n        const vRatio = function (u: number[], v: number[]) {\n            return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v));\n        };\n        const vAngle = function (u: number[], v: number[]) {\n            return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));\n        };\n        const theta = vAngle([1, 0], [(xp - cxp) / rx, (yp - cyp) / ry]);\n        const u = [(xp - cxp) / rx, (yp - cyp) / ry];\n        const v = [(-1 * xp - cxp) / rx, (-1 * yp - cyp) / ry];\n        let dTheta = vAngle(u, v);\n\n        if (vRatio(u, v) <= -1) {\n            dTheta = Math.PI;\n        }\n        if (vRatio(u, v) >= 1) {\n            dTheta = 0;\n        }\n        if (fs === 0 && dTheta > 0) {\n            dTheta = dTheta - 2 * Math.PI;\n        }\n        if (fs === 1 && dTheta < 0) {\n            dTheta = dTheta + 2 * Math.PI;\n        }\n        return [cx, cy, rx, ry, theta, dTheta, psi, fs];\n    }\n\n    /**\n     * 计算两个点 (x1, y1) 和 (x2, y2) 之间的直线距离\n     * @returns 两个点 (x1, y1) 和 (x2, y2) 之间的直线距离，单位与输入的坐标值相同\n     */\n    private getLineLength(x1: number, y1: number, x2: number, y2: number) {\n        return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));\n    }\n\n    /**\n     * 计算三次贝塞尔曲线上给定参数 t 对应的点的坐标.\n     * 可以在指定的 t 参数下计算出曲线上精确的一个点，这个点可以用于绘制平滑曲线的一部分\n     * @param pct - 0 到 1 之间的参数，用于指定曲线上的点的位置\n     * @param P1x - 曲线的起点 x 坐标\n     * @param P1y - 曲线的起点 y 坐标\n     * @param P2x - 曲线的第一个控制点 x 坐标\n     * @param P2y - 曲线的第一个控制点 y 坐标\n     * @param P3x - 曲线的第二个控制点 x 坐标\n     * @param P3y - 曲线的第二个控制点 y 坐标\n     * @param P4x - 曲线的终点 x 坐标\n     * @param P4y - 曲线的终点 y 坐标\n     * @returns\n     */\n    private getPointOnCubicBezier(\n        pct: number,\n        P1x: number,\n        P1y: number,\n        P2x: number,\n        P2y: number,\n        P3x: number,\n        P3y: number,\n        P4x: number,\n        P4y: number\n    ) {\n        function CB1(t: number) {\n            return t * t * t;\n        }\n\n        function CB2(t: number) {\n            return 3 * t * t * (1 - t);\n        }\n\n        function CB3(t: number) {\n            return 3 * t * (1 - t) * (1 - t);\n        }\n\n        function CB4(t: number) {\n            return (1 - t) * (1 - t) * (1 - t);\n        }\n\n        const x = P4x * CB1(pct) + P3x * CB2(pct) + P2x * CB3(pct) + P1x * CB4(pct);\n        const y = P4y * CB1(pct) + P3y * CB2(pct) + P2y * CB3(pct) + P1y * CB4(pct);\n\n        return {\n            x: x,\n            y: y\n        };\n    }\n\n    /**\n     * 计算二次贝塞尔曲线上给定参数 t 对应的点的坐标\n     * @param pct - 0 到 1 之间的参数，用于指定曲线上的点的位置\n     * @param P1x - 曲线的起点 x 坐标\n     * @param P1y - 曲线的起点 y 坐标\n     * @param P2x - 曲线的控制点 x 坐标\n     * @param P2y - 曲线的控制点 y 坐标\n     * @param P3x - 曲线的终点 x 坐标\n     * @param P3y - 曲线的终点 y 坐标\n     * @returns\n     */\n    private getPointOnQuadraticBezier(pct: number, P1x: number, P1y: number, P2x: number, P2y: number, P3x: number, P3y: number) {\n        function QB1(t: number) {\n            return t * t;\n        }\n\n        function QB2(t: number) {\n            return 2 * t * (1 - t);\n        }\n\n        function QB3(t: number) {\n            return (1 - t) * (1 - t);\n        }\n\n        const x = P3x * QB1(pct) + P2x * QB2(pct) + P1x * QB3(pct);\n        const y = P3y * QB1(pct) + P2y * QB2(pct) + P1y * QB3(pct);\n\n        return {\n            x: x,\n            y: y\n        };\n    }\n\n    /**\n     * 计算椭圆弧上给定角度 θ 对应的点的坐标\n     * @param cx - 椭圆的中心点 x 坐标\n     * @param cy - 椭圆的中心点 y 坐标\n     * @param rx - 椭圆的 x 轴半径\n     * @param ry - 椭圆的 y 轴半径\n     * @param theta - 椭圆弧的起始角度\n     * @param psi - 椭圆弧的旋转角度\n     * @returns\n     */\n    private getPointOnEllipticalArc(cx: number, cy: number, rx: number, ry: number, theta: number, psi: number) {\n        const cosPsi = Math.cos(psi);\n        const sinPsi = Math.sin(psi);\n        const pt = {\n            x: rx * Math.cos(theta),\n            y: ry * Math.sin(theta)\n        };\n        return {\n            x: cx + (pt.x * cosPsi - pt.y * sinPsi),\n            y: cy + (pt.x * sinPsi + pt.y * cosPsi)\n        };\n    }\n\n    /**\n     * 计算基于不同路径命令的长度\n     * @param x - 起点 x 坐标\n     * @param y - 起点 y 坐标\n     * @param cmd - 路径命令\n     * @param points - 与路径命令相关的点的坐标或控制参数\n     * @returns\n     */\n    private calcLength(x: number, y: number, cmd: string, points: number[]) {\n        let len, p1, p2, t;\n\n        switch (cmd) {\n            case 'L':\n                return this.getLineLength(x, y, points[0], points[1]);\n            case 'C':\n                len = 0.0;\n                p1 = this.getPointOnCubicBezier(0, x, y, points[0], points[1], points[2], points[3], points[4], points[5]);\n                for (t = 0.01; t <= 1; t += 0.01) {\n                    p2 = this.getPointOnCubicBezier(t, x, y, points[0], points[1], points[2], points[3], points[4], points[5]);\n                    len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);\n                    p1 = p2;\n                }\n                return len;\n            case 'Q':\n                len = 0.0;\n                p1 = this.getPointOnQuadraticBezier(0, x, y, points[0], points[1], points[2], points[3]);\n                for (t = 0.01; t <= 1; t += 0.01) {\n                    p2 = this.getPointOnQuadraticBezier(t, x, y, points[0], points[1], points[2], points[3]);\n                    len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);\n                    p1 = p2;\n                }\n                return len;\n            case 'A':\n                len = 0.0;\n                const start = points[4];\n                const dTheta = points[5];\n                const end = points[4] + dTheta;\n                let inc = Math.PI / 180.0;\n                if (Math.abs(start - end) < inc) {\n                    inc = Math.abs(start - end);\n                }\n                p1 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], start, 0);\n                if (dTheta < 0) {\n                    for (t = start - inc; t > end; t -= inc) {\n                        p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t, 0);\n                        len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);\n                        p1 = p2;\n                    }\n                } else {\n                    for (t = start + inc; t < end; t += inc) {\n                        p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], t, 0);\n                        len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);\n                        p1 = p2;\n                    }\n                }\n                p2 = this.getPointOnEllipticalArc(points[0], points[1], points[2], points[3], end, 0);\n                len += this.getLineLength(p1.x, p1.y, p2.x, p2.y);\n                return len;\n        }\n        return 0;\n    }\n\n    /**\n     * 解析 SVG 路径数据字符串，将其转换为一个包含路径命令和坐标点的数组对象\n     * @param data - SVG 路径数据字符串\n     * @returns\n     */\n    private parsePathData(data: string) {\n        if (!data) {\n            return [];\n        }\n\n        let cs = data;\n        const cc = ['m', 'M', 'l', 'L', 'v', 'V', 'h', 'H', 'z', 'Z', 'c', 'C', 'q', 'Q', 't', 'T', 's', 'S', 'a', 'A'];\n\n        cs = cs.replace(new RegExp(' ', 'g'), ',');\n        for (let n = 0; n < cc.length; n++) {\n            cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]);\n        }\n        const arr = cs.split('|');\n        const ca: any = [];\n        const coords: any = [];\n        let cpx = 0;\n        let cpy = 0;\n\n        const re = /([-+]?((\\d+\\.\\d+)|((\\d+)|(\\.\\d+)))(?:e[-+]?\\d+)?)/gi;\n        let match: RegExpExecArray | null;\n        for (let n = 1; n < arr.length; n++) {\n            let str = arr[n];\n            let c = str.charAt(0);\n            str = str.slice(1);\n\n            coords.length = 0;\n            while ((match = re.exec(str))) {\n                coords.push(match[0]);\n            }\n\n            const p: any = [];\n\n            for (let j = 0, jlen = coords.length; j < jlen; j++) {\n                if (coords[j] === '00') {\n                    p.push(0, 0);\n                    continue;\n                }\n                const parsed = parseFloat(coords[j]);\n                if (!isNaN(parsed)) {\n                    p.push(parsed);\n                } else {\n                    p.push(0);\n                }\n            }\n\n            while (p.length > 0) {\n                if (isNaN(p[0])) {\n                    break;\n                }\n\n                let cmd: string | null = null;\n                let points: any = [];\n                const startX = cpx;\n                const startY = cpy;\n                let prevCmd, ctlPtx, ctlPty;\n                let rx, ry, psi, fa, fs, x1, y1;\n\n                switch (c) {\n                    case 'l':\n                        cpx += p.shift();\n                        cpy += p.shift();\n                        cmd = 'L';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'L':\n                        cpx = p.shift();\n                        cpy = p.shift();\n                        points.push(cpx, cpy);\n                        break;\n                    case 'm':\n                        const dx = p.shift();\n                        const dy = p.shift();\n                        cpx += dx;\n                        cpy += dy;\n                        cmd = 'M';\n                        if (ca.length > 2 && ca[ca.length - 1].command === 'z') {\n                            for (let idx = ca.length - 2; idx >= 0; idx--) {\n                                if (ca[idx].command === 'M') {\n                                    cpx = ca[idx].points[0] + dx;\n                                    cpy = ca[idx].points[1] + dy;\n                                    break;\n                                }\n                            }\n                        }\n                        points.push(cpx, cpy);\n                        c = 'l';\n                        break;\n                    case 'M':\n                        cpx = p.shift();\n                        cpy = p.shift();\n                        cmd = 'M';\n                        points.push(cpx, cpy);\n                        c = 'L';\n                        break;\n\n                    case 'h':\n                        cpx += p.shift();\n                        cmd = 'L';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'H':\n                        cpx = p.shift();\n                        cmd = 'L';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'v':\n                        cpy += p.shift();\n                        cmd = 'L';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'V':\n                        cpy = p.shift();\n                        cmd = 'L';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'C':\n                        points.push(p.shift(), p.shift(), p.shift(), p.shift());\n                        cpx = p.shift();\n                        cpy = p.shift();\n                        points.push(cpx, cpy);\n                        break;\n                    case 'c':\n                        points.push(cpx + p.shift(), cpy + p.shift(), cpx + p.shift(), cpy + p.shift());\n                        cpx += p.shift();\n                        cpy += p.shift();\n                        cmd = 'C';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'S':\n                        ctlPtx = cpx;\n                        ctlPty = cpy;\n                        prevCmd = ca[ca.length - 1];\n                        if (prevCmd.command === 'C') {\n                            ctlPtx = cpx + (cpx - prevCmd.points[2]);\n                            ctlPty = cpy + (cpy - prevCmd.points[3]);\n                        }\n                        points.push(ctlPtx, ctlPty, p.shift(), p.shift());\n                        cpx = p.shift();\n                        cpy = p.shift();\n                        cmd = 'C';\n                        points.push(cpx, cpy);\n                        break;\n                    case 's':\n                        ctlPtx = cpx;\n                        ctlPty = cpy;\n                        prevCmd = ca[ca.length - 1];\n                        if (prevCmd.command === 'C') {\n                            ctlPtx = cpx + (cpx - prevCmd.points[2]);\n                            ctlPty = cpy + (cpy - prevCmd.points[3]);\n                        }\n                        points.push(ctlPtx, ctlPty, cpx + p.shift(), cpy + p.shift());\n                        cpx += p.shift();\n                        cpy += p.shift();\n                        cmd = 'C';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'Q':\n                        points.push(p.shift(), p.shift());\n                        cpx = p.shift();\n                        cpy = p.shift();\n                        points.push(cpx, cpy);\n                        break;\n                    case 'q':\n                        points.push(cpx + p.shift(), cpy + p.shift());\n                        cpx += p.shift();\n                        cpy += p.shift();\n                        cmd = 'Q';\n                        points.push(cpx, cpy);\n                        break;\n                    case 'T':\n                        ctlPtx = cpx;\n                        ctlPty = cpy;\n                        prevCmd = ca[ca.length - 1];\n                        if (prevCmd.command === 'Q') {\n                            ctlPtx = cpx + (cpx - prevCmd.points[0]);\n                            ctlPty = cpy + (cpy - prevCmd.points[1]);\n                        }\n                        cpx = p.shift();\n                        cpy = p.shift();\n                        cmd = 'Q';\n                        points.push(ctlPtx, ctlPty, cpx, cpy);\n                        break;\n                    case 't':\n                        ctlPtx = cpx;\n                        ctlPty = cpy;\n                        prevCmd = ca[ca.length - 1];\n                        if (prevCmd.command === 'Q') {\n                            ctlPtx = cpx + (cpx - prevCmd.points[0]);\n                            ctlPty = cpy + (cpy - prevCmd.points[1]);\n                        }\n                        cpx += p.shift();\n                        cpy += p.shift();\n                        cmd = 'Q';\n                        points.push(ctlPtx, ctlPty, cpx, cpy);\n                        break;\n                    case 'A':\n                        rx = p.shift();\n                        ry = p.shift();\n                        psi = p.shift();\n                        fa = p.shift();\n                        fs = p.shift();\n                        x1 = cpx;\n                        y1 = cpy;\n                        cpx = p.shift();\n                        cpy = p.shift();\n                        cmd = 'A';\n                        points = this.convertEndpointToCenterParameterization(x1, y1, cpx, cpy, fa, fs, rx, ry, psi);\n                        break;\n                    case 'a':\n                        rx = p.shift();\n                        ry = p.shift();\n                        psi = p.shift();\n                        fa = p.shift();\n                        fs = p.shift();\n                        x1 = cpx;\n                        y1 = cpy;\n                        cpx += p.shift();\n                        cpy += p.shift();\n                        cmd = 'A';\n                        points = this.convertEndpointToCenterParameterization(x1, y1, cpx, cpy, fa, fs, rx, ry, psi);\n                        break;\n                }\n\n                ca.push({\n                    command: cmd || c,\n                    points: points,\n                    start: {\n                        x: startX,\n                        y: startY\n                    },\n                    pathLength: this.calcLength(startX, startY, cmd || c, points)\n                });\n            }\n\n            if (c === 'z' || c === 'Z') {\n                ca.push({\n                    command: 'z',\n                    points: [],\n                    start: undefined,\n                    pathLength: 0\n                });\n            }\n        }\n\n        return ca;\n    }\n\n    /**\n     * 根据传入的路径数据 data 在画布上绘制路径\n     * @param options\n     */\n    public path(options: { x: number; y: number; data: string; size?: number; scaleX?: number; scaleY?: number; fill: string }) {\n        const { x, y, scaleX = 1, scaleY = 1, data, fill } = options;\n        const dataArray = this.parsePathData(data);\n\n        this.ctx.save();\n        this.ctx.beginPath();\n        this.ctx.fillStyle = fill;\n        this.ctx.translate(x, y);\n        this.ctx.scale(scaleX, scaleY);\n        let isClosed = false;\n        for (let n = 0; n < dataArray.length; n++) {\n            const c = dataArray[n].command;\n            const p = dataArray[n].points;\n            switch (c) {\n                case 'L':\n                    this.ctx.lineTo(p[0], p[1]);\n                    break;\n                case 'M':\n                    this.ctx.moveTo(p[0], p[1]);\n                    break;\n                case 'C':\n                    this.ctx.bezierCurveTo(p[0], p[1], p[2], p[3], p[4], p[5]);\n                    break;\n                case 'Q':\n                    this.ctx.quadraticCurveTo(p[0], p[1], p[2], p[3]);\n                    break;\n                case 'A':\n                    const cx = p[0];\n                    const cy = p[1];\n                    const rx = p[2];\n                    const ry = p[3];\n                    const theta = p[4];\n                    const dTheta = p[5];\n                    const psi = p[6];\n                    const fs = p[7];\n                    const r = rx > ry ? rx : ry;\n                    const scaleX = rx > ry ? 1 : rx / ry;\n                    const scaleY = rx > ry ? ry / rx : 1;\n\n                    this.ctx.translate(cx, cy);\n                    this.ctx.rotate(psi);\n                    this.ctx.scale(scaleX, scaleY);\n                    this.ctx.arc(0, 0, r, theta, theta + dTheta, (1 - fs) as any);\n                    this.ctx.scale(1 / scaleX, 1 / scaleY);\n                    this.ctx.rotate(-psi);\n                    this.ctx.translate(-cx, -cy);\n\n                    break;\n                case 'z':\n                    isClosed = true;\n                    this.ctx.closePath();\n                    break;\n            }\n        }\n\n        if (!isClosed) {\n            this.ctx.stroke();\n        } else {\n            this.ctx.fill();\n        }\n        this.ctx.restore();\n    }\n}\n\nexport const drawer = new Drawer();\n"]}