@leafer/path 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-present, Chao (Leafer) Wan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @leafer/path

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@leafer/path",
+  "version": "1.0.0-alpha.1",
+  "description": "@leafer/path",
+  "author": "Chao (Leafer) Wan",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "files": ["src"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leaferjs/leafer.git"
+  },
+  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/path",
+  "bugs": "https://github.com/leaferjs/leafer/issues",
+  "keywords": [
+    "leafer",
+    "leaferjs"
+  ],
+  "dependencies": {
+    "@leafer/math": "1.0.0-alpha.1"
+  },
+  "devDependencies": {
+     "@leafer/interface": "1.0.0-alpha.1"
+  }
+}

package/src/BezierHelper.ts

@@ -0,0 +1,157 @@
+import { IPointData, ITwoPointBoundsData, IPathCommandData } from '@leafer/interface'
+import { TwoPointBoundsHelper } from '@leafer/math'
+
+import { PathCommandMap } from './PathCommandMap'
+
+
+const tempPoint = {} as IPointData
+const { sin, cos, sqrt, atan2, ceil, abs, PI } = Math
+const { setPoint, addPoint } = TwoPointBoundsHelper
+
+export const BezierHelper = {
+
+    getFromACommand(fromX: number, fromY: number, rx: number, ry: number, rotateAngle: number, largeFlag: number, sweepFlag: number, toX: number, toY: number): IPathCommandData { //  [...CCommandData, ...CCommandData]
+
+        const localToX = toX - fromX
+        const localToY = toY - fromY
+
+        const rotation = rotateAngle * PI / 180
+        const sinRotation = sin(rotation)
+        const cosRotation = cos(rotation)
+
+        const ax = -cosRotation * localToX * 0.5 - sinRotation * localToY * 0.5
+        const ay = -cosRotation * localToY * 0.5 + sinRotation * localToX * 0.5
+        const rxSquare = rx * rx
+        const rySquare = ry * ry
+        const pySquare = ay * ay
+        const pxSquare = ax * ax
+        const a = rxSquare * rySquare - rxSquare * pySquare - rySquare * pxSquare
+        let sr = 0
+
+        if (a < 0) {
+            const scale = sqrt(1 - a / (rxSquare * rySquare))
+            rx *= scale
+            ry *= scale
+        } else {
+            const sign = largeFlag === sweepFlag ? -1 : 1
+            sr = sign * sqrt(a / (rxSquare * pySquare + rySquare * pxSquare))
+        }
+
+        const cx = sr * rx * ay / ry
+        const cy = -sr * ry * ax / rx
+        const cx1 = cosRotation * cx - sinRotation * cy + localToX * 0.5
+        const cy1 = sinRotation * cx + cosRotation * cy + localToY * 0.5
+
+        let r1 = atan2((ay - cy) / ry, (ax - cx) / rx)
+        let r2 = atan2((-ay - cy) / ry, (-ax - cx) / rx)
+        let totalRadian = r2 - r1
+
+        if (sweepFlag === 0 && totalRadian > 0) {
+            totalRadian -= 2 * PI
+        } else if (sweepFlag === 1 && totalRadian < 0) {
+            totalRadian += 2 * PI
+        }
+
+        // segments arc
+        const data: IPathCommandData = []
+        const segments = ceil(abs(totalRadian / PI * 2))
+        const segmentRadian = totalRadian / segments
+        const sinSegmentRadian2 = sin(segmentRadian / 2)
+        const sinSegmentRadian4 = sin(segmentRadian / 4)
+        const controlRadian = 8 / 3 * sinSegmentRadian4 * sinSegmentRadian4 / sinSegmentRadian2
+
+        r1 = 0
+        r2 = atan2((ay - cy) / ry, (ax - cx) / rx)
+        let startRadian = r2 - r1
+        let endRadian = startRadian + segmentRadian
+        let cosStart = cos(startRadian)
+        let sinStart = sin(startRadian)
+        let cosEnd: number, sinEnd: number
+        let startX = 0, startY = 0
+
+        let x: number, y: number, x1: number, y1: number, x2: number, y2: number
+        for (let i = 0; i < segments; i++) {
+
+            cosEnd = cos(endRadian)
+            sinEnd = sin(endRadian)
+
+            // segment bezier
+            x = cosRotation * rx * cosEnd - sinRotation * ry * sinEnd + cx1
+            y = sinRotation * rx * cosEnd + cosRotation * ry * sinEnd + cy1
+            x1 = startX + controlRadian * (-cosRotation * rx * sinStart - sinRotation * ry * cosStart)
+            y1 = startY + controlRadian * (-sinRotation * rx * sinStart + cosRotation * ry * cosStart)
+            x2 = x + controlRadian * (cosRotation * rx * sinEnd + sinRotation * ry * cosEnd)
+            y2 = y + controlRadian * (sinRotation * rx * sinEnd - cosRotation * ry * cosEnd)
+
+            data.push(PathCommandMap.C, x1 + fromX, y1 + fromY, x2 + fromX, y2 + fromY, x + fromX, y + fromY)
+
+            startX = x
+            startY = y
+            startRadian = endRadian
+            cosStart = cosEnd
+            sinStart = sinEnd
+            endRadian += segmentRadian
+
+        }
+
+        return data
+
+    },
+
+    toTwoPointBounds(fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number, pointBounds: ITwoPointBoundsData): void {
+
+        const tList = []
+        let a, b, c, t, t1, t2, v, sqrtV
+        let f = fromX, z1 = x1, z2 = x2, o = toX
+
+        for (let i = 0; i < 2; ++i) {
+
+            if (i == 1) {
+                f = fromY, z1 = y1, z2 = y2, o = toY
+            }
+
+            a = -3 * f + 9 * z1 - 9 * z2 + 3 * o
+            b = 6 * f - 12 * z1 + 6 * z2
+            c = 3 * z1 - 3 * f
+
+            if (Math.abs(a) < 1e-12) {
+                if (Math.abs(b) < 1e-12) continue
+                t = -c / b
+                if (0 < t && t < 1) tList.push(t)
+                continue
+            }
+
+            v = b * b - 4 * c * a
+            sqrtV = Math.sqrt(v)
+            if (v < 0) continue
+
+            t1 = (-b + sqrtV) / (2 * a)
+            if (0 < t1 && t1 < 1) tList.push(t1)
+            t2 = (-b - sqrtV) / (2 * a)
+            if (0 < t2 && t2 < 1) tList.push(t2)
+        }
+
+        setPoint(pointBounds, fromX, fromY)
+        addPoint(pointBounds, toX, toY)
+
+        for (let i = 0, len = tList.length; i < len; i++) {
+            B.getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint)
+            addPoint(pointBounds, tempPoint.x, tempPoint.y)
+        }
+    },
+
+    getPointAndSet(t: number, fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number, setPoint: IPointData): void {
+        const o = 1 - t, a = o * o * o, b = 3 * o * o * t, c = 3 * o * t * t, d = t * t * t
+        setPoint.x = a * fromX + b * x1 + c * x2 + d * toX
+        setPoint.y = a * fromY + b * y1 + c * y2 + d * toY
+    },
+
+    getPoint(t: number, fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number): IPointData {
+        const point = {} as IPointData
+        B.getPointAndSet(t, fromX, fromY, x1, y1, x2, y2, toX, toY, point)
+        return point
+    }
+
+}
+
+const B = BezierHelper

package/src/PathCommandMap.ts

@@ -0,0 +1,107 @@
+import { INumberMap, IStringMap } from '@leafer/interface'
+
+
+export const PathCommandMap: INumberMap = {
+    M: 1, //moveto
+    m: 10,
+    L: 2, //lineto
+    l: 20,
+    H: 3, //horizontal lineto
+    h: 30,
+    V: 4, //vertical lineto
+    v: 40,
+    C: 5, //curveto
+    c: 50,
+    S: 6, //smooth curveto
+    s: 60,
+    Q: 7, //quadratic Belzier curve
+    q: 70,
+    T: 8, //smooth quadratic Belzier curveto
+    t: 80,
+    A: 9, //elliptical Arc
+    a: 90,
+    Z: 11, //closepath
+    z: 11,
+
+    // 非svg标准的canvas绘图命令
+    rect: 100,
+    roundRect: 101,
+    ellipse: 102,
+    arc: 103,
+    arcTo: 104
+}
+
+export const PathCommandLengthMap: INumberMap = {
+    M: 3, //moveto
+    m: 3,
+    L: 3, //lineto
+    l: 3,
+    H: 2, //horizontal lineto
+    h: 2,
+    V: 2, //vertical lineto
+    v: 2,
+    C: 7, //curveto
+    c: 7,
+    S: 5, //smooth curveto
+    s: 5,
+    Q: 5, //quadratic Belzier curve
+    q: 5,
+    T: 3, //smooth quadratic Belzier curveto
+    t: 3,
+    A: 8, //elliptical Arc
+    a: 8,
+    Z: 1, //closepath
+    z: 1,
+
+    // 非svg标准的canvas绘图命令
+    rect: 5,
+    roundRect: 6,
+    ellipse: 9,
+    arc: 7,
+    arcTo: 6
+}
+
+export const PathCommandNeedConvertMap: INumberMap = { // convert to:  M L C Q Z
+    // M: 1, //moveto
+    m: 10,
+    // L: 2, //lineto
+    l: 20,
+    H: 3, //horizontal lineto
+    h: 30,
+    V: 4, //vertical lineto
+    v: 40,
+    // C: 5, //curveto
+    c: 50,
+    S: 6, //smooth curveto
+    s: 60,
+    // Q: 7, //quadratic Belzier curve
+    q: 70,
+    T: 8, //smooth quadratic Belzier curveto
+    t: 80,
+    A: 9, //elliptical Arc
+    a: 90,
+    // Z: 11, //closepath
+    // z: 11
+
+    // 非svg标准的canvas绘图命令
+    rect: 100,
+    roundRect: 101,
+    ellipse: 102,
+    arc: 103,
+    arcTo: 104
+}
+
+
+const P = PathCommandMap
+
+export const NumberPathCommandMap: IStringMap = {}
+for (let key in P) {
+    NumberPathCommandMap[P[key]] = key
+}
+// {1: 'M'}
+
+export const NumberPathCommandLengthMap: INumberMap = {}
+for (let key in P) {
+    NumberPathCommandLengthMap[P[key]] = PathCommandLengthMap[key]
+}
+// {1: 3}

package/src/PathConvert.ts

@@ -0,0 +1,241 @@
+import { IPathCommandData } from '@leafer/interface'
+import { StringNumberMap } from '@leafer/math'
+import { PathCommandMap as Command, PathCommandNeedConvertMap as NeedConvertCommand, PathCommandLengthMap as CommandLength, NumberPathCommandMap as CommandName, NumberPathCommandLengthMap as NumberCommandLength } from './PathCommandMap'
+
+import { BezierHelper } from './BezierHelper'
+
+
+interface ICurrentCommand {
+    name?: number
+    length?: number
+    index?: number
+}
+
+
+const { M, m, L, l, H, h, V, v, C, c, S, s, Q, q, T, t, A, a, Z, z } = Command
+const { getFromACommand } = BezierHelper
+
+export const PathConvert = {
+
+    current: {} as ICurrentCommand,
+
+    stringify(data: IPathCommandData): string {
+        let i = 0, len = data.length, count: number, str: string = '', command: number, lastCommand: number
+        while (i < len) {
+            command = data[i]
+            count = NumberCommandLength[command]
+            if (command === lastCommand) {
+                str += ' ' // 重复的命令可以省略
+            } else {
+                str += CommandName[command]
+            }
+
+            for (let j = 1; j < count; j++) {
+                str += data[i + j];
+                (j === count - 1) || (str += ' ')
+            }
+
+            lastCommand = command
+            i += count
+        }
+        return str
+    },
+
+    parse(pathString: string, convert: boolean = true): IPathCommandData {
+
+        let needConvert: boolean, char: string, num = ''
+        const data: IPathCommandData = []
+
+        for (let i = 0, len = pathString.length; i < len; i++) {
+
+            char = pathString[i]
+
+            if (StringNumberMap[char]) {
+
+                num += char
+
+            } else if (Command[char]) {
+
+                if (num) { pushData(data, Number(num)); num = '' }
+
+                current.name = Command[char]
+                current.length = CommandLength[char]
+                current.index = 0
+                pushData(data, current.name)
+
+                if (!needConvert && NeedConvertCommand[char]) needConvert = true
+
+            } else {
+
+                if (char === '-') { // L-34-35
+                    if (num) { pushData(data, Number(num)) }
+                    num = char
+                } else {
+                    if (num) { pushData(data, Number(num)); num = '' }
+                }
+
+            }
+
+        }
+
+        if (num) pushData(data, Number(num))
+
+        //console.log(pathString, P._data)
+        return (convert && needConvert) ? PathConvert.convertToSimple(data) : data
+    },
+
+    convertToSimple(old: IPathCommandData): IPathCommandData {
+
+        let x = 0, y = 0, x1 = 0, y1 = 0, i = 0, len = old.length, controlX: number, controlY: number, command: number, lastCommand: number, smooth: boolean
+        const data: IPathCommandData = []
+
+        while (i < len) {
+
+            command = old[i]
+
+            switch (command) {
+                //moveto x,y
+                case m:
+                    old[i + 1] += x
+                    old[i + 2] += y
+                case M:
+                    x = old[i + 1]
+                    y = old[i + 2]
+                    data.push(M, x, y)
+                    i += 3
+                    break
+
+                //horizontal lineto x
+                case h:
+                    old[i + 1] += x
+                case H:
+                    x = old[i + 1]
+                    data.push(L, x, y)
+                    i += 2
+                    break
+
+                //vertical lineto y
+                case v:
+                    old[i + 1] += y
+                case V:
+                    y = old[i + 1]
+                    data.push(L, x, y)
+                    i += 2
+                    break
+
+                //lineto x,y
+                case l:
+                    old[i + 1] += x
+                    old[i + 2] += y
+                case L:
+                    x = old[i + 1]
+                    y = old[i + 2]
+                    data.push(L, x, y)
+                    i += 3
+                    break
+
+                //smooth bezierCurveTo x2,y2,x,y
+                case s:  //smooth
+                    old[i + 1] += x
+                    old[i + 2] += y
+                    old[i + 3] += x
+                    old[i + 4] += y
+                    command = S
+                case S:
+                    smooth = (lastCommand === C) || (lastCommand === S)
+                    x1 = smooth ? (x * 2 - controlX) : old[i + 1]
+                    y1 = smooth ? (y * 2 - controlY) : old[i + 2]
+                    controlX = old[i + 1]
+                    controlY = old[i + 2]
+                    x = old[i + 3]
+                    y = old[i + 4]
+                    data.push(C, x1, y1, controlX, controlY, x, y)
+                    i += 5
+                    break
+
+                //bezierCurveTo x1,y1,x2,y2,x,y
+                case c:
+                    old[i + 1] += x
+                    old[i + 2] += y
+                    old[i + 3] += x
+                    old[i + 4] += y
+                    old[i + 5] += x
+                    old[i + 6] += y
+                    command = C
+                case C:
+                    controlX = old[i + 3]
+                    controlY = old[i + 4]
+                    x = old[i + 5]
+                    y = old[i + 6]
+                    data.push(C, old[i + 1], old[i + 2], controlX, controlY, x, y)
+                    i += 7
+                    break
+
+                //smooth quadraticCurveTo x,y
+                case t:
+                    old[i + 1] += x
+                    old[i + 2] += y
+                    command = T
+                case T:  //smooth
+                    smooth = (lastCommand === Q) || (lastCommand === T)
+                    controlX = smooth ? (x * 2 - controlX) : old[i + 1]
+                    controlY = smooth ? (y * 2 - controlY) : old[i + 2]
+                    x = old[i + 1]
+                    y = old[i + 2]
+                    data.push(Q, controlX, controlY, x, y)
+                    i += 3
+                    break
+
+                //quadraticCurveTo x1,y1,x,y
+                case q:
+                    old[i + 1] += x
+                    old[i + 2] += y
+                    old[i + 3] += x
+                    old[i + 4] += y
+                    command = Q
+                case Q:
+                    controlX = old[i + 1]
+                    controlY = old[i + 2]
+                    x = old[i + 3]
+                    y = old[i + 4]
+                    data.push(Q, controlX, controlY, x, y)
+                    i += 5
+                    break
+
+                //ellipticalArc rx ry x-axis-rotation large-arc-flag sweep-flag x y
+                case a:
+                    old[i + 6] += x
+                    old[i + 7] += y
+                case A:
+                    data.push(...getFromACommand(x, y, old[i + 1], old[i + 2], old[i + 3], old[i + 4], old[i + 5], old[i + 6], old[i + 7])) // convert bezier
+                    x = old[i + 6]
+                    y = old[i + 7]
+                    i += 8
+                    break
+                case z:
+                case Z:
+                    data.push(Z)
+                    i++
+                    break
+            }
+
+            lastCommand = command
+        }
+
+        return data
+
+    },
+
+    pushData(data: IPathCommandData, num: number) {
+        if (current.index === current.length) { // 单个命令，多个数据的情况
+            current.index = 1
+            data.push(current.name)
+        }
+
+        data.push(num)
+        current.index++
+    }
+
+}
+
+const { current, pushData } = PathConvert

package/src/PathCreator.ts

@@ -0,0 +1,64 @@
+import { IPathCommandData } from '@leafer/interface'
+import { PathCommandMap } from './PathCommandMap'
+
+
+let data: IPathCommandData
+const { M, L, C, Q, Z, rect, roundRect, ellipse, arc, arcTo } = PathCommandMap
+
+export const PathCreator = {
+
+    begin(commandData: IPathCommandData): void {
+        data = commandData
+    },
+
+    end(): void {
+        data = undefined
+    },
+
+    // draw
+
+    moveTo(x: number, y: number): void {
+        data.push(M, x, y)
+    },
+
+    lineTo(x: number, y: number): void {
+        data.push(L, x, y)
+    },
+
+    bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): void {
+        data.push(C, x1, y1, x2, y2, x, y)
+    },
+
+    quadraticCurveTo(x1: number, y1: number, x: number, y: number): void {
+        data.push(Q, x1, y1, x, y)
+    },
+
+    close(end?: boolean): void {
+        data.push(Z)
+        if (end) data = undefined
+    },
+
+
+    // 非svg标准的canvas绘图命令
+
+    rect(x: number, y: number, width: number, height: number): void {
+        data.push(rect, x, y, width, height)
+    },
+
+    roundRect(x: number, y: number, width: number, height: number, cornerRadius?: number | number[]): void {
+        data.push(roundRect, x, y, width, height, cornerRadius as unknown as number)
+    },
+
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void {
+        data.push(ellipse, x, y, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise as unknown as number)
+    },
+
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void {
+        data.push(arc, x, y, radius, startAngle, endAngle, counterclockwise as unknown as number)
+    },
+
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void {
+        data.push(arcTo, x1, y1, x2, y2, radius)
+    }
+
+}

package/src/PathHelper.ts

@@ -0,0 +1,113 @@
+import { ICanvasDrawPath, ITwoPointBoundsData, IPathCommandData } from '@leafer/interface'
+import { TwoPointBoundsHelper } from '@leafer/math'
+
+import { BezierHelper } from './BezierHelper'
+import { PathCommandMap as Command } from './PathCommandMap'
+
+
+const { M, L, C, Q, Z, ellipse: E } = Command
+const { toTwoPointBounds } = BezierHelper
+const { add, addPoint, setPoint } = TwoPointBoundsHelper
+
+const tempPointBounds = {} as ITwoPointBoundsData
+
+export const PathHelper = {
+
+    applyCorner(data: IPathCommandData, cornerRadius: number, cornerSmoothing?: number): IPathCommandData {
+        return data
+    },
+
+    toTwoPointBounds(data: IPathCommandData, setPointBounds: ITwoPointBoundsData): void {
+
+        let command: number
+        let i: number = 0, x: number, y: number, x1: number, y1: number, toX: number, toY: number
+
+        const len = data.length
+
+        while (i < len) {
+            command = data[i]
+
+            if (i === 0) {
+                (command === M) ? setPoint(setPointBounds, data[1], data[2]) : setPoint(setPointBounds, 0, 0)
+            }
+
+            switch (command) {
+                case M: //moveto x,y
+                case L: //lineto x,y
+                    x = data[i + 1]
+                    y = data[i + 2]
+                    addPoint(setPointBounds, x, y)
+                    i += 3
+                    break
+                case C: //bezierCurveTo x1,y1,x2,y2,x,y
+                    toX = data[i + 5]
+                    toY = data[i + 6]
+                    toTwoPointBounds(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY, tempPointBounds)
+                    add(setPointBounds, tempPointBounds)
+                    x = toX
+                    y = toY
+                    i += 7
+                    break
+                case Q: //quadraticCurveTo x1,y1,x,y
+                    x1 = data[i + 1]
+                    y1 = data[i + 2]
+                    toX = data[i + 3]
+                    toY = data[i + 4]
+                    toTwoPointBounds(x, y, x1, y1, x1, y1, toX, toY, tempPointBounds)
+                    add(setPointBounds, tempPointBounds)
+                    x = toX
+                    y = toY
+                    i += 5
+                    break
+                case Z: //closepath
+                    i += 1
+                    break
+            }
+        }
+
+        //  增加1px的扩展，否则会有问题
+        setPointBounds.minX--
+        setPointBounds.minY--
+        setPointBounds.maxX++
+        setPointBounds.maxY++
+
+    },
+
+    drawData(drawer: ICanvasDrawPath, data: IPathCommandData): void {
+        let command: number
+        let i = 0, len = data.length
+
+        while (i < len) {
+            command = data[i]
+            switch (command) {
+                case M:  //moveto x,y
+                    drawer.moveTo(data[i + 1], data[i + 2])
+                    i += 3
+                    break
+                case L:  //lineto x,y
+                    drawer.lineTo(data[i + 1], data[i + 2])
+                    i += 3
+                    break
+                case C:  //bezierCurveTo x1,y1,x2,y2,x,y
+                    drawer.bezierCurveTo(data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6])
+                    i += 7
+                    break
+                case Q:  //quadraticCurveTo x1,y1,x,y
+                    drawer.quadraticCurveTo(data[i + 1], data[i + 2], data[i + 3], data[i + 4])
+                    i += 5
+                    break
+                case Z:  //closepath
+                    drawer.closePath()
+                    i += 1
+                    break
+
+                // 非svg标准的canvas绘图命令
+                case E:
+                    drawer.ellipse(data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6], data[i + 7], data[i + 8] as unknown as boolean)
+                    i += 9
+                    break
+            }
+        }
+    }
+
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { PathConvert } from './PathConvert'
+export { PathHelper } from './PathHelper'
+export { PathCreator } from './PathCreator'
+export { BezierHelper } from './BezierHelper'
+export { PathCommandMap, PathCommandNeedConvertMap, NumberPathCommandMap, NumberPathCommandLengthMap } from './PathCommandMap'