{"version":3,"sources":["jsdelivr-header.js","/npm/getpathdatatwo@0.9.8/getPathData2.js"],"names":[],"mappings":"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","file":"/npm/getpathdatatwo@0.9.8/getPathData2.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/getpathdatatwo@0.9.8/getPathData2.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/** \r\n* getPathData2 v 0.9.8\r\n* Convert svg paths from \r\n* - d attribute strings\r\n* - path or geometry elements (e.g. circle, rect, ellipse etc.) \r\n* via getPathData2() method\r\n* \r\n* Based on the svg working draft \r\n* https://svgwg.org/specs/paths/#InterfaceSVGPathData\r\n* \r\n* Heavily inspired by Jarek Foksa's polyfill\r\n* https://github.com/jarek-foksa/path-data-polyfill\r\n*/\r\n\r\n/**\r\n* custom pathData() and setPathData() methods\r\n**/\r\nSVGGeometryElement.prototype.getPathData2 = function (options = {}) {\r\n    let pathData = [];\r\n    let type = this.nodeName;\r\n    let d, x, y, width, height, r, rx, ry, cx, cy;\r\n    let svg, vB, svgW, svgH, css;\r\n\r\n    /**\r\n     * bugfix fro chromium\r\n     * ensures we can get the absolute baseVal.values\r\n     */\r\n    if (type !== 'path') {\r\n        css = window.getComputedStyle(this).fill\r\n    }\r\n\r\n    switch (type) {\r\n        case 'path':\r\n            d = this.getAttribute(\"d\");\r\n            pathData = parseDtoPathData(d);\r\n            break;\r\n\r\n        case 'rect':\r\n            x = this.x.baseVal.value;\r\n            y = this.y.baseVal.value;\r\n            width = this.width.baseVal.value;\r\n            height = this.height.baseVal.value;\r\n            rx = this.rx.baseVal.value;\r\n            ry = this.ry.baseVal.value;\r\n\r\n            if (!rx && !ry) {\r\n                pathData = [\r\n                    { type: \"M\", values: [x, y] },\r\n                    { type: \"H\", values: [x + width] },\r\n                    { type: \"V\", values: [y + height] },\r\n                    { type: \"H\", values: [x] },\r\n                    { type: \"Z\", values: [] }\r\n                ];\r\n            } else {\r\n\r\n                if (rx > width / 2) {\r\n                    rx = width / 2;\r\n                }\r\n                if (ry > height / 2) {\r\n                    ry = height / 2;\r\n                }\r\n\r\n                pathData = [\r\n                    { type: \"M\", values: [x + rx, y] },\r\n                    { type: \"H\", values: [x + width - rx] },\r\n                    { type: \"A\", values: [rx, ry, 0, 0, 1, x + width, y + ry] },\r\n                    { type: \"V\", values: [y + height - ry] },\r\n                    { type: \"A\", values: [rx, ry, 0, 0, 1, x + width - rx, y + height] },\r\n                    { type: \"H\", values: [x + rx] },\r\n                    { type: \"A\", values: [rx, ry, 0, 0, 1, x, y + height - ry] },\r\n                    { type: \"V\", values: [y + ry] },\r\n                    { type: \"A\", values: [rx, ry, 0, 0, 1, x + rx, y] },\r\n                    { type: \"Z\", values: [] }\r\n                ];\r\n            }\r\n            break;\r\n\r\n        case 'circle':\r\n        case 'ellipse':\r\n            cx = this.cx.baseVal.value;\r\n            cy = this.cy.baseVal.value;\r\n            if (type === 'circle') {\r\n                r = this.r.baseVal.value;\r\n            }\r\n            rx = this.rx ? this.rx.baseVal.value : r;\r\n            ry = this.ry ? this.ry.baseVal.value : r;\r\n\r\n            pathData = [\r\n                { type: \"M\", values: [cx + rx, cy] },\r\n                { type: \"A\", values: [rx, ry, 0, 1, 1, cx - rx, cy] },\r\n                { type: \"A\", values: [rx, ry, 0, 1, 1, cx + rx, cy] },\r\n            ];\r\n\r\n            break;\r\n        case 'line':\r\n            pathData = [\r\n                { type: \"M\", values: [this.x1.baseVal.value, this.y1.baseVal.value] },\r\n                { type: \"L\", values: [this.x2.baseVal.value, this.y2.baseVal.value] }\r\n            ];\r\n            break;\r\n        case 'polygon':\r\n        case 'polyline':\r\n            for (let i = 0; i < this.points.numberOfItems; i++) {\r\n                let point = this.points.getItem(i);\r\n                pathData.push({\r\n                    type: (i === 0 ? \"M\" : \"L\"),\r\n                    values: [point.x, point.y]\r\n                });\r\n            }\r\n            if (type === 'polygon') {\r\n                pathData.push({\r\n                    type: \"Z\",\r\n                    values: []\r\n                });\r\n            }\r\n            break;\r\n    }\r\n\r\n    /**\r\n     * normalize commands \r\n     * for processing you usually need \r\n     * absolute and longhand commands\r\n     */\r\n\r\n    if (options.normalize === true) {\r\n        options =\r\n        {\r\n            toAbsolute: true,\r\n            arcToCubic: true,\r\n            arcAccuracy: 1,\r\n            quadraticToCubic: true,\r\n            toLonghands: true,\r\n        }\r\n    }\r\n\r\n    if (Object.keys(options).length) {\r\n        pathData = convertPathData(pathData, options)\r\n    }\r\n\r\n    if(svg){\r\n        //svg.remove()\r\n    }\r\n\r\n    return pathData;\r\n};\r\n\r\n// set pathData with optimizations\r\nSVGPathElement.prototype.setPathData2 = function (pathData, options = {}) {\r\n\r\n    let defaults = {\r\n        // shorthand for toRelative, toShorthandshands\r\n        optimize: false,\r\n        toAbsolute: false,\r\n        toRelative: false,\r\n        quadraticToCubic: false,\r\n        toLonghands: false,\r\n        cleanClosePath: false,\r\n\r\n        // arcs to cubic bezier\r\n        arcToCubic: false,\r\n        arcAccuracy: 1,\r\n\r\n        //only for set pathdata\r\n        minify: false,\r\n        decimals: -1, //rounding\r\n        toShorthands: false, //apply shorthands\r\n    }\r\n\r\n    // merge defaults\r\n    options = {\r\n        ...defaults,\r\n        ...options\r\n    }\r\n\r\n    let { optimize, decimals, minify, toRelative, toAbsolute, quadraticToCubic, arcToCubic, arcAccuracy, toLonghands, toShorthands, cleanClosePath } = options\r\n\r\n    if (optimize) {\r\n        toShorthands = true\r\n        toRelative = true\r\n        decimals = 3,\r\n            cleanClosePath = true\r\n    }\r\n\r\n    if (cleanClosePath && lastCom.type.toLowerCase() === 'z') {\r\n\r\n        let secondLast = pathData[pathData.length - 2];\r\n        let secondLastValues = secondLast.values\r\n\r\n        //let lastCurve\r\n        if (secondLast.type === 'L' && secondLast.values.join(',') === pathData[0].values.join(',')) {\r\n            //remove last lineto\r\n            pathData.splice(pathData.length - 2, 1)\r\n        }\r\n\r\n        if (secondLast.type !== 'L' && [secondLastValues[secondLastValues.length - 2], secondLastValues[secondLastValues.length - 1]].join(',') === pathData[0].values.join(',')) {\r\n            // remove last command\r\n            pathData.pop()\r\n        }\r\n    }\r\n\r\n    if (quadraticToCubic || arcToCubic) {\r\n        pathData = convertPathData(pathData, options)\r\n    }\r\n\r\n    if (toShorthands) {\r\n        pathData = pathDataToShorthands(pathData, decimals)\r\n    }\r\n    else if (toLonghands) {\r\n        pathData = pathDataToLonghands(pathData, decimals)\r\n    }\r\n\r\n    if (toRelative) {\r\n        pathData = pathDataToRelative(pathData, decimals)\r\n    }\r\n    else if (toAbsolute) {\r\n        pathData = pathDataToAbsolute(pathData, decimals)\r\n    }\r\n\r\n    let d = pathDataToD(pathData, decimals, minify);\r\n    this.setAttribute(\"d\", d);\r\n};\r\n\r\n\r\n/**\r\n * retrieve patData from primitives:\r\n * <circle>, <ellipse>, <rect>, <polygon>, <polyline>, <line>, \r\n */\r\nSVGGeometryElement.prototype.convertShapeToPath = function (options = {}) {\r\n    let pathData = this.getPathData2(options);\r\n\r\n    // create path element\r\n    let path = document.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\r\n\r\n    // get all attributes as object\r\n    const setAttributes = (el, attributes, exclude = []) => {\r\n        for (key in attributes) {\r\n            if (exclude.indexOf(key) === -1) {\r\n                el.setAttribute(key, attributes[key]);\r\n            }\r\n        }\r\n    }\r\n    const getAttributes = (el) => {\r\n        let attArr = [...el.attributes];\r\n        let attObj = {};\r\n        attArr.forEach((att) => {\r\n            attObj[att.nodeName] = att.nodeValue;\r\n        });\r\n        return attObj;\r\n    }\r\n\r\n    let attributes = getAttributes(this);\r\n\r\n    //exclude attributes not needed for paths\r\n    let exclude = [\"x\", \"y\", \"x1\", \"y1\", \"x2\", \"y2\", \"cx\", \"cy\", \"r\", \"rx\", \"ry\", \"points\", \"width\", \"height\"];\r\n\r\n    // copy attributes to path and set pathData\r\n    setAttributes(path, attributes, exclude);\r\n    path.setPathData2(pathData, options);\r\n    this.replaceWith(path);\r\n    return path;\r\n}\r\n\r\n\r\n/**\r\n * parse d to an optimized pathData array\r\n * a shorthand wrapper function to retrieve optimized data\r\n * uses the same options as setPathData2() method\r\n */\r\n\r\nfunction parseDtoPathDataOpt(d, options = {}) {\r\n    let pathData = parseDtoPathData(d);\r\n    pathData = convertPathData(pathData, options)\r\n    return pathData;\r\n}\r\n\r\n\r\n/**\r\n * parse pathData from d attribute\r\n * the core function to parse the pathData array from a d string\r\n **/\r\nfunction parseDtoPathData(d) {\r\n    let dClean = d\r\n        // remove new lines and tabs\r\n        .replace(/[\\n\\r\\t]/g, \"\")\r\n        // replace comma with space\r\n        .replace(/,/g, \" \")\r\n        // add space before minus sign\r\n        .replace(/(\\d+)(\\-)/g, \"$1 $2\")\r\n        // decompose multiple adjacent decimal delimiters like 0.5.5.5 => 0.5 0.5 0.5\r\n        .replace(/(\\.)(?=(\\d+\\.\\d+)+)(\\d+)/g, \"$1$3 \")\r\n        // add new lines before valid command letters\r\n        .replace(/([mlcsqtahvz])/gi, \"\\n$1 \")\r\n        // remove duplicate whitespace\r\n        .replace(/\\ {2,}/g, \" \")\r\n        // remove whitespace from right and left\r\n        .trim();\r\n\r\n    // split commands\r\n    let commands = dClean.split(\"\\n\").map((val) => {\r\n        return val.trim();\r\n    });\r\n\r\n    // compile pathData\r\n    let pathData = [];\r\n    let comLengths = { m: 2, a: 7, c: 6, h: 1, l: 2, q: 4, s: 4, t: 2, v: 1, z: 0 };\r\n    let errors = [];\r\n\r\n    // normalize convatenated larceArc and sweep flags\r\n    const unravelArcValues = (values)=>{\r\n        let chunksize=7, n=0, arcComs=[]\r\n        for (let i = 0; i < values.length; i++) {\r\n            let com = values[i]\r\n        \r\n            // reset counter\r\n            if (n >= chunksize) {\r\n                n = 0\r\n            }\r\n            // if 3. or 4. parameter longer than 1\r\n            if ((n === 3 || n === 4) && com.length > 1) {\r\n        \r\n                let largeArc = n === 3 ? com.substring(0, 1) : ''\r\n                let sweep = n === 3 ? com.substring(1, 2) : com.substring(0, 1)\r\n                let finalX = n === 3 ? com.substring(2) : com.substring(1)\r\n                let comN = [largeArc, sweep, finalX].filter(Boolean)\r\n                arcComs.push(comN)\r\n                n+=comN.length\r\n        \r\n            } else {\r\n                // regular\r\n                arcComs.push(com)\r\n                n++\r\n            }\r\n        }\r\n        return arcComs.flat().filter(Boolean);\r\n    }\r\n\r\n    for (let i = 0; i < commands.length; i++) {\r\n        let com = commands[i].split(\" \");\r\n        let type = com.shift();\r\n        let typeRel = type.toLowerCase();\r\n        let isRel = type === typeRel;\r\n\r\n        /**\r\n         * large arc and sweep flags\r\n         * are boolean and can be concatenated like\r\n         * 11 or 01\r\n         * or be concatenated with the final on path points like\r\n         * 1110 10 => 1 1 10 10\r\n         */\r\n        if (typeRel === \"a\") {\r\n            com = unravelArcValues(com)\r\n            console.log(com);\r\n        }\r\n\r\n        // convert to numbers\r\n        let values = com.map((val) => {\r\n            return parseFloat(val);\r\n        });\r\n\r\n        // if string contains repeated shorthand commands - split them\r\n        let chunkSize = comLengths[typeRel];\r\n        let chunk = values.slice(0, chunkSize);\r\n        pathData.push({ type: type, values: chunk });\r\n\r\n        // too few values\r\n        if (chunk.length < chunkSize) {\r\n            errors.push(\r\n                `${i}. command (${type}) has ${chunk.length}/${chunkSize} values - ${chunkSize - chunk.length} too few`\r\n            );\r\n        }\r\n\r\n        // has implicit commands\r\n        if (values.length > chunkSize) {\r\n            let typeImplicit = typeRel === \"m\" ? (isRel ? \"l\" : \"L\") : type;\r\n            for (let i = chunkSize; i < values.length; i += chunkSize) {\r\n                let chunk = values.slice(i, i + chunkSize);\r\n                pathData.push({ type: typeImplicit, values: chunk });\r\n                if (chunk.length !== chunkSize) {\r\n                    errors.push(\r\n                        `${i}. command (${type}) has ${chunk.length + chunkSize}/${chunkSize} - ${chunk.length} values too many `\r\n                    );\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (errors.length) {\r\n        console.log(errors);\r\n    }\r\n\r\n    /**\r\n     * first M is always absolute/uppercase -\r\n     * unless it adds relative linetos\r\n     * (facilitates d concatenating)\r\n     */\r\n    pathData[0].type = 'M'\r\n    return pathData;\r\n}\r\n\r\n\r\n\r\n/**\r\n * converts all commands to absolute\r\n * optional: convert shorthands; arcs to cubics \r\n */\r\n\r\nfunction convertPathData(pathData, options) {\r\n\r\n    // analyze pathdata\r\n    let commandTokens = pathData.map(com => { return com.type }).join('')\r\n    let hasRel = /[astvqmhlc]/g.test(commandTokens);\r\n    let hasShorthands = /[hstv]/gi.test(commandTokens);\r\n    let hasQuadratics = /[qt]/gi.test(commandTokens);\r\n    let hasArcs = /[a]/gi.test(commandTokens);\r\n\r\n    // merge default options\r\n    let defaults = {\r\n        toAbsolute: true,\r\n        toRelative: false,\r\n        quadraticToCubic: false,\r\n        toLonghands: true,\r\n        toShorthands: false,\r\n        arcToCubic: false,\r\n        arcAccuracy: 1,\r\n        decimals: -1,\r\n    }\r\n\r\n    options = {\r\n        ...defaults,\r\n        ...options\r\n    }\r\n\r\n    let { toAbsolute, toRelative, quadraticToCubic, toLonghands, toShorthands, arcToCubic, arcAccuracy, decimals } = options;\r\n\r\n    // nothing to convert – passthrough\r\n    if (!hasRel && !hasShorthands && !hasQuadratics && !hasArcs && !toRelative && !toShorthands) {\r\n        return pathData\r\n    }\r\n\r\n    /**\r\n     * convert to absolute\r\n     */\r\n\r\n    // add M\r\n    let pathDataAbs = [pathData[0]];\r\n    let lastX = pathData[0].values[0];\r\n    let lastY = pathData[0].values[1];\r\n    let offX = lastX;\r\n    let offY = lastY;\r\n\r\n\r\n    /**\r\n     * arcToCubic, quadraticToCubic, toLonghands  \r\n     * will force toAbsolute conversion\r\n     */\r\n\r\n    if (arcToCubic || toLonghands || quadraticToCubic) {\r\n        toAbsolute = true\r\n    }\r\n\r\n    for (let i = 1; i < pathData.length; i++) {\r\n        let com = pathData[i];\r\n        let { type, values } = com;\r\n        let typeRel = type.toLowerCase();\r\n        let typeAbs = type.toUpperCase();\r\n        let valuesL = values.length;\r\n        let isRelative = type === typeRel;\r\n        let comPrev = pathData[i - 1];\r\n        let valuesPrev = comPrev.values;\r\n        let valuesPrevL = valuesPrev.length;\r\n        let p0 = { x: valuesPrev[valuesPrevL - 2], y: valuesPrev[valuesPrevL - 1] };\r\n\r\n        if (isRelative && toAbsolute) {\r\n            com.type = typeAbs;\r\n            switch (typeRel) {\r\n                case \"a\":\r\n                    com.values = [\r\n                        values[0],\r\n                        values[1],\r\n                        values[2],\r\n                        values[3],\r\n                        values[4],\r\n                        values[5] + offX,\r\n                        values[6] + offY\r\n                    ];\r\n                    break;\r\n\r\n\r\n                case \"h\":\r\n                case \"v\":\r\n                    com.values = type === 'h' ? [values[0] + offX] : [values[0] + offY];\r\n                    break;\r\n\r\n                case 'm':\r\n                case 'l':\r\n                case 't':\r\n                    com.values = [values[0] + offX, values[1] + offY]\r\n                    break;\r\n\r\n                case \"c\":\r\n                    com.values = [\r\n                        values[0] + offX,\r\n                        values[1] + offY,\r\n                        values[2] + offX,\r\n                        values[3] + offY,\r\n                        values[4] + offX,\r\n                        values[5] + offY\r\n                    ];\r\n                    break;\r\n\r\n                case \"q\":\r\n                case \"s\":\r\n                    com.values = [\r\n                        values[0] + offX,\r\n                        values[1] + offY,\r\n                        values[2] + offX,\r\n                        values[3] + offY,\r\n                    ];\r\n                    break;\r\n            }\r\n        }\r\n        // is absolute\r\n        else {\r\n            offX = 0;\r\n            offY = 0;\r\n        }\r\n\r\n        /**\r\n         * convert shorthands\r\n         */\r\n        if (toLonghands && hasShorthands || (com.type === 'T' && quadraticToCubic)) {\r\n            let cp1X, cp1Y, cpN1X, cpN1Y, cp2X, cp2Y;\r\n            if (com.type === 'H' || com.type === 'V') {\r\n                com.values = com.type === 'H' ? [com.values[0], lastY] : [lastX, com.values[0]];\r\n                com.type = 'L';\r\n            }\r\n            else if (com.type === 'T' || com.type === 'S') {\r\n\r\n                [cp1X, cp1Y] = [valuesPrev[0], valuesPrev[1]];\r\n                [cp2X, cp2Y] = valuesPrevL > 2 ? [valuesPrev[2], valuesPrev[3]] : [valuesPrev[0], valuesPrev[1]];\r\n\r\n                // new control point\r\n                cpN1X = com.type === 'T' ? lastX + (lastX - cp1X) : 2 * lastX - cp2X;\r\n                cpN1Y = com.type === 'T' ? lastY + (lastY - cp1Y) : 2 * lastY - cp2Y;\r\n\r\n                com.values = [cpN1X, cpN1Y, com.values].flat();\r\n                com.type = com.type === 'T' ? 'Q' : 'C';\r\n            }\r\n        }\r\n\r\n        // convert quadratic to cubic\r\n        if (quadraticToCubic && hasQuadratics && com.type === 'Q') {\r\n            com = quadratic2Cubic(p0, com.values)\r\n        }\r\n\r\n        //convert arcs to cubics\r\n        if (arcToCubic && hasArcs && com.type === 'A') {\r\n            // add all C commands instead of Arc\r\n            let cubicArcs = arcToBezier({ x: lastX, y: lastY }, com.values, arcAccuracy);\r\n            cubicArcs.forEach((cubicArc) => {\r\n                pathDataAbs.push(cubicArc);\r\n            });\r\n\r\n        } else {\r\n            // add command\r\n            pathDataAbs.push(com)\r\n        }\r\n\r\n        // update offsets\r\n        lastX = valuesL > 1 ? values[valuesL - 2] + offX : (typeRel === 'h' ? values[0] + offX : lastX);\r\n        lastY = valuesL > 1 ? values[valuesL - 1] + offY : (typeRel === 'v' ? values[0] + offY : lastY);\r\n        offX = lastX;\r\n        offY = lastY;\r\n    };\r\n\r\n\r\n    // to shorthands\r\n    if (toShorthands) {\r\n        pathDataAbs = pathDataToShorthands(pathDataAbs, decimals)\r\n    }\r\n\r\n    // to Relative\r\n    if (toRelative) {\r\n        pathDataAbs = pathDataToRelative(pathDataAbs, decimals)\r\n    }\r\n\r\n    return pathDataAbs;\r\n}\r\n\r\n\r\n/** \r\n * convert arctocommands to cubic bezier\r\n * based on puzrin's a2c.js\r\n * https://github.com/fontello/svgpath/blob/master/lib/a2c.js\r\n * returns pathData array\r\n*/\r\n\r\nfunction arcToBezier(p0, values, splitSegments = 1) {\r\n    const TAU = Math.PI * 2;\r\n    let [rx, ry, rotation, largeArcFlag, sweepFlag, x, y] = values;\r\n\r\n    if (rx === 0 || ry === 0) {\r\n        return []\r\n    }\r\n\r\n    let phi = rotation ? rotation * TAU / 360 : 0;\r\n    let sinphi = phi ? Math.sin(phi) : 0\r\n    let cosphi = phi ? Math.cos(phi) : 1\r\n    let pxp = cosphi * (p0.x - x) / 2 + sinphi * (p0.y - y) / 2\r\n    let pyp = -sinphi * (p0.x - x) / 2 + cosphi * (p0.y - y) / 2\r\n\r\n    if (pxp === 0 && pyp === 0) {\r\n        return []\r\n    }\r\n    rx = Math.abs(rx)\r\n    ry = Math.abs(ry)\r\n    let lambda =\r\n        pxp * pxp / (rx * rx) +\r\n        pyp * pyp / (ry * ry)\r\n    if (lambda > 1) {\r\n        let lambdaRt = Math.sqrt(lambda);\r\n        rx *= lambdaRt\r\n        ry *= lambdaRt\r\n    }\r\n\r\n    /** \r\n     * parametrize arc to \r\n     * get center point start and end angles\r\n     */\r\n    let rxsq = rx * rx,\r\n        rysq = rx === ry ? rxsq : ry * ry\r\n\r\n    let pxpsq = pxp * pxp,\r\n        pypsq = pyp * pyp\r\n    let radicant = (rxsq * rysq) - (rxsq * pypsq) - (rysq * pxpsq)\r\n\r\n    if (radicant <= 0) {\r\n        radicant = 0\r\n    } else {\r\n        radicant /= (rxsq * pypsq) + (rysq * pxpsq)\r\n        radicant = Math.sqrt(radicant) * (largeArcFlag === sweepFlag ? -1 : 1)\r\n    }\r\n\r\n    let centerxp = radicant ? radicant * rx / ry * pyp : 0\r\n    let centeryp = radicant ? radicant * -ry / rx * pxp : 0\r\n    let centerx = cosphi * centerxp - sinphi * centeryp + (p0.x + x) / 2\r\n    let centery = sinphi * centerxp + cosphi * centeryp + (p0.y + y) / 2\r\n\r\n    let vx1 = (pxp - centerxp) / rx\r\n    let vy1 = (pyp - centeryp) / ry\r\n    let vx2 = (-pxp - centerxp) / rx\r\n    let vy2 = (-pyp - centeryp) / ry\r\n\r\n    // get start and end angle\r\n    const vectorAngle = (ux, uy, vx, vy) => {\r\n        let dot = +(ux * vx + uy * vy).toFixed(9)\r\n        if (dot === 1 || dot === -1) {\r\n            return dot === 1 ? 0 : Math.PI\r\n        }\r\n        dot = dot > 1 ? 1 : (dot < -1 ? -1 : dot)\r\n        let sign = (ux * vy - uy * vx < 0) ? -1 : 1\r\n        return sign * Math.acos(dot);\r\n    }\r\n\r\n    let ang1 = vectorAngle(1, 0, vx1, vy1),\r\n        ang2 = vectorAngle(vx1, vy1, vx2, vy2)\r\n\r\n    if (sweepFlag === 0 && ang2 > 0) {\r\n        ang2 -= Math.PI * 2\r\n    }\r\n    else if (sweepFlag === 1 && ang2 < 0) {\r\n        ang2 += Math.PI * 2\r\n    }\r\n\r\n    let ratio = +(Math.abs(ang2) / (TAU / 4)).toFixed(0)\r\n\r\n    // increase segments for more accureate length calculations\r\n    let segments = ratio * splitSegments;\r\n    ang2 /= segments\r\n    let pathData = [];\r\n\r\n\r\n    // If 90 degree circular arc, use a constant\r\n    // https://pomax.github.io/bezierinfo/#circles_cubic\r\n    // k=0.551784777779014\r\n    const angle90 = 1.5707963267948966;\r\n    const k = 0.551785\r\n    let a = ang2 === angle90 ? k :\r\n        (\r\n            ang2 === -angle90 ? -k : 4 / 3 * Math.tan(ang2 / 4)\r\n        );\r\n\r\n    let cos2 = ang2 ? Math.cos(ang2) : 1;\r\n    let sin2 = ang2 ? Math.sin(ang2) : 0;\r\n    let type = 'C'\r\n\r\n    const approxUnitArc = (ang1, ang2, a, cos2, sin2) => {\r\n        let x1 = ang1 != ang2 ? Math.cos(ang1) : cos2;\r\n        let y1 = ang1 != ang2 ? Math.sin(ang1) : sin2;\r\n        let x2 = Math.cos(ang1 + ang2);\r\n        let y2 = Math.sin(ang1 + ang2);\r\n\r\n        return [\r\n            { x: x1 - y1 * a, y: y1 + x1 * a },\r\n            { x: x2 + y2 * a, y: y2 - x2 * a },\r\n            { x: x2, y: y2 }\r\n        ];\r\n    }\r\n\r\n    for (let i = 0; i < segments; i++) {\r\n        let com = { type: type, values: [] }\r\n        let curve = approxUnitArc(ang1, ang2, a, cos2, sin2);\r\n\r\n        curve.forEach((pt) => {\r\n            let x = pt.x * rx\r\n            let y = pt.y * ry\r\n            com.values.push(cosphi * x - sinphi * y + centerx, sinphi * x + cosphi * y + centery)\r\n        })\r\n        pathData.push(com);\r\n        ang1 += ang2\r\n    }\r\n\r\n    return pathData;\r\n}\r\n\r\n\r\n/**\r\n * convert quadratic commands to cubic\r\n */\r\nfunction quadratic2Cubic(p0, com) {\r\n    if (Array.isArray(p0)) {\r\n        p0 = {\r\n            x: p0[0],\r\n            y: p0[1]\r\n        }\r\n    }\r\n    let cp1 = {\r\n        x: p0.x + 2 / 3 * (com[0] - p0.x),\r\n        y: p0.y + 2 / 3 * (com[1] - p0.y)\r\n    }\r\n    let cp2 = {\r\n        x: com[2] + 2 / 3 * (com[0] - com[2]),\r\n        y: com[3] + 2 / 3 * (com[1] - com[3])\r\n    }\r\n    return ({ type: \"C\", values: [cp1.x, cp1.y, cp2.x, cp2.y, com[2], com[3]] });\r\n}\r\n\r\n/**\r\n * This is just a port of Dmitry Baranovskiy's \r\n * pathToRelative/Absolute methods used in snap.svg\r\n * https://github.com/adobe-webplatform/Snap.svg/\r\n * \r\n * Demo: https://codepen.io/herrstrietzel/pen/poVKbgL\r\n */\r\n\r\n// convert to relative commands\r\nfunction pathDataToRelative(pathData, decimals = -1) {\r\n\r\n    // round coordinates to prevent distortions\r\n    if (decimals >= 0) {\r\n        pathData[0].values = pathData[0].values.map(val => { return +val.toFixed(decimals) })\r\n    }\r\n\r\n    let M = pathData[0].values;\r\n    let x = M[0],\r\n        y = M[1],\r\n        mx = x,\r\n        my = y;\r\n\r\n\r\n    // loop through commands\r\n    for (let i = 1; i < pathData.length; i++) {\r\n        let com = pathData[i];\r\n\r\n        // round coordinates to prevent distortions\r\n        if (decimals >= 0 && com.values.length) {\r\n            com.values = com.values.map(val => { return +val.toFixed(decimals) })\r\n        }\r\n        let { type, values } = com;\r\n        let typeRel = type.toLowerCase();\r\n\r\n\r\n        // is absolute\r\n        if (type != typeRel) {\r\n            type = typeRel;\r\n            com.type = type;\r\n            // check current command types\r\n            switch (typeRel) {\r\n                case \"a\":\r\n                    values[5] = +(values[5] - x);\r\n                    values[6] = +(values[6] - y);\r\n                    break;\r\n                case \"v\":\r\n                    values[0] = +(values[0] - y);\r\n                    break;\r\n                case \"m\":\r\n                    mx = values[0];\r\n                    my = values[1];\r\n                default:\r\n                    // other commands\r\n                    if (values.length) {\r\n                        for (let v = 0; v < values.length; v++) {\r\n                            // even value indices are y coordinates\r\n                            values[v] = values[v] - (v % 2 ? y : x);\r\n                        }\r\n                    }\r\n            }\r\n        }\r\n        // is already relative\r\n        else {\r\n            if (type == \"m\") {\r\n                mx = values[0] + x;\r\n                my = values[1] + y;\r\n            }\r\n        }\r\n        let vLen = values.length;\r\n        switch (type) {\r\n            case \"z\":\r\n                x = mx;\r\n                y = my;\r\n                break;\r\n            case \"h\":\r\n                x += values[vLen - 1];\r\n                break;\r\n            case \"v\":\r\n                y += values[vLen - 1];\r\n                break;\r\n            default:\r\n                x += values[vLen - 2];\r\n                y += values[vLen - 1];\r\n        }\r\n        // round final relative values\r\n        if (decimals >= 0) {\r\n            com.values = com.values.map(val => { return +val.toFixed(decimals) })\r\n        }\r\n    }\r\n    return pathData;\r\n}\r\n\r\nfunction pathDataToAbsolute(pathData, decimals = -1) {\r\n\r\n    // round coordinates to prevent distortions\r\n    if (decimals >= 0) {\r\n        pathData[0].values = pathData[0].values.map(val => { return +val.toFixed(decimals) })\r\n    }\r\n\r\n    let M = pathData[0].values;\r\n    let x = M[0],\r\n        y = M[1],\r\n        mx = x,\r\n        my = y;\r\n\r\n    // loop through commands\r\n    for (let i = 1; i < pathData.length; i++) {\r\n        let com = pathData[i];\r\n\r\n        // round coordinates to prevent distortions\r\n        if (decimals >= 0 && com.values.length) {\r\n            com.values = com.values.map(val => { return +val.toFixed(decimals) })\r\n        }\r\n\r\n        let { type, values } = com;\r\n        let typeAbs = type.toUpperCase();\r\n\r\n        if (type != typeAbs) {\r\n            type = typeAbs;\r\n            com.type = type;\r\n            // check current command types\r\n            switch (typeAbs) {\r\n                case \"A\":\r\n                    values[5] = +(values[5] + x);\r\n                    values[6] = +(values[6] + y);\r\n                    break;\r\n\r\n                case \"V\":\r\n                    values[0] = +(values[0] + y);\r\n                    break;\r\n\r\n                case \"H\":\r\n                    values[0] = +(values[0] + x);\r\n                    break;\r\n\r\n                case \"M\":\r\n                    mx = +values[0] + x;\r\n                    my = +values[1] + y;\r\n\r\n                default:\r\n                    // other commands\r\n                    if (values.length) {\r\n                        for (let v = 0; v < values.length; v++) {\r\n                            // even value indices are y coordinates\r\n                            values[v] = values[v] + (v % 2 ? y : x);\r\n                        }\r\n                    }\r\n            }\r\n        }\r\n        // is already absolute\r\n        let vLen = values.length;\r\n        switch (type) {\r\n            case \"Z\":\r\n                x = +mx;\r\n                y = +my;\r\n                break;\r\n            case \"H\":\r\n                x = values[0];\r\n                break;\r\n            case \"V\":\r\n                y = values[0];\r\n                break;\r\n            case \"M\":\r\n                mx = values[vLen - 2];\r\n                my = values[vLen - 1];\r\n\r\n            default:\r\n                x = values[vLen - 2];\r\n                y = values[vLen - 1];\r\n        }\r\n        // round final absolute values\r\n        if (decimals >= 0) {\r\n            com.values = com.values.map(val => { return +val.toFixed(decimals) })\r\n        }\r\n    }\r\n    return pathData;\r\n}\r\n\r\n\r\n/**\r\n * decompose/convert shorthands to \"longhand\" commands:\r\n * H, V, S, T => L, L, C, Q\r\n * reversed method: pathDataToShorthands()\r\n */\r\n\r\nfunction pathDataToLonghands(pathData, decimals = -1) {\r\n    pathData = pathDataToAbsolute(pathData, decimals);\r\n\r\n    let pathDataLonghand = [];\r\n    let comPrev = {\r\n        type: \"M\",\r\n        values: pathData[0].values\r\n    };\r\n    pathDataLonghand.push(comPrev);\r\n\r\n    for (let i = 1; i < pathData.length; i++) {\r\n        let com = pathData[i];\r\n        let { type, values } = com;\r\n        let valuesL = values.length;\r\n        let valuesPrev = comPrev.values;\r\n        let valuesPrevL = valuesPrev.length;\r\n        let [x, y] = [values[valuesL - 2], values[valuesL - 1]];\r\n        let cp1X, cp1Y, cpN1X, cpN1Y, cpN2X, cpN2Y, cp2X, cp2Y;\r\n        let [prevX, prevY] = [\r\n            valuesPrev[valuesPrevL - 2],\r\n            valuesPrev[valuesPrevL - 1]\r\n        ];\r\n        switch (type) {\r\n            case \"H\":\r\n                comPrev = {\r\n                    type: \"L\",\r\n                    values: [values[0], prevY]\r\n                };\r\n                break;\r\n            case \"V\":\r\n                comPrev = {\r\n                    type: \"L\",\r\n                    values: [prevX, values[0]]\r\n                };\r\n                break;\r\n            case \"T\":\r\n                [cp1X, cp1Y] = [valuesPrev[0], valuesPrev[1]];\r\n                [prevX, prevY] = [\r\n                    valuesPrev[valuesPrevL - 2],\r\n                    valuesPrev[valuesPrevL - 1]\r\n                ];\r\n                // new control point\r\n                cpN1X = prevX + (prevX - cp1X);\r\n                cpN1Y = prevY + (prevY - cp1Y);\r\n                comPrev = {\r\n                    type: \"Q\",\r\n                    values: [cpN1X, cpN1Y, x, y]\r\n                };\r\n                break;\r\n            case \"S\":\r\n                [cp1X, cp1Y] = [valuesPrev[0], valuesPrev[1]];\r\n                [cp2X, cp2Y] =\r\n                    valuesPrevL > 2 ?\r\n                        [valuesPrev[2], valuesPrev[3]] :\r\n                        [valuesPrev[0], valuesPrev[1]];\r\n                [prevX, prevY] = [\r\n                    valuesPrev[valuesPrevL - 2],\r\n                    valuesPrev[valuesPrevL - 1]\r\n                ];\r\n                // new control points\r\n                cpN1X = 2 * prevX - cp2X;\r\n                cpN1Y = 2 * prevY - cp2Y;\r\n                cpN2X = values[0];\r\n                cpN2Y = values[1];\r\n                comPrev = {\r\n                    type: \"C\",\r\n                    values: [cpN1X, cpN1Y, cpN2X, cpN2Y, x, y]\r\n                };\r\n\r\n                break;\r\n            default:\r\n                comPrev = {\r\n                    type: type,\r\n                    values: values\r\n                };\r\n        }\r\n        // round final longhand values\r\n        if (decimals >= 0) {\r\n            comPrev.values = comPrev.values.map(val => { return +val.toFixed(decimals) })\r\n        }\r\n\r\n        pathDataLonghand.push(comPrev);\r\n    }\r\n    return pathDataLonghand;\r\n}\r\n\r\n/**\r\n * apply shorthand commands if possible\r\n * L, L, C, Q => H, V, S, T\r\n * reversed method: pathDataToLonghands()\r\n */\r\nfunction pathDataToShorthands(pathData, decimals = -1) {\r\n    pathData = pathDataToAbsolute(pathData, decimals);\r\n    let comShort = {\r\n        type: \"M\",\r\n        values: pathData[0].values\r\n    };\r\n    let pathDataShorts = [comShort];\r\n    for (let i = 1; i < pathData.length; i++) {\r\n        let com = pathData[i];\r\n        let { type, values } = com;\r\n        let valuesL = values.length;\r\n        let comPrev = pathData[i - 1];\r\n        let valuesPrev = comPrev.values;\r\n        let valuesPrevL = valuesPrev.length;\r\n        let [x, y] = [values[valuesL - 2], values[valuesL - 1]];\r\n        let cp1X, cp1Y, cp2X, cp2Y;\r\n        let [prevX, prevY] = [\r\n            valuesPrev[valuesPrevL - 2],\r\n            valuesPrev[valuesPrevL - 1]\r\n        ];\r\n        let val0R, cpN1XR, val1R, cpN1YR, cpN1X, cpN1Y, cpN2X, cpN2Y, prevXR, prevYR;\r\n\r\n        switch (type) {\r\n            case \"L\":\r\n                [val0R, prevXR, val1R, prevYR] = [\r\n                    values[0],\r\n                    prevX,\r\n                    values[1],\r\n                    prevY\r\n                ].map((val) => {\r\n                    return +(val * 2).toFixed(1);\r\n                });\r\n\r\n                if (prevYR == val1R && prevXR !== val0R) {\r\n                    comShort = {\r\n                        type: \"H\",\r\n                        values: [values[0]]\r\n                    };\r\n                } else if (prevXR == val0R && prevYR !== val1R) {\r\n                    comShort = {\r\n                        type: \"V\",\r\n                        values: [values[1]]\r\n                    };\r\n                } else {\r\n                    comShort = com;\r\n                }\r\n                break;\r\n            case \"Q\":\r\n                [cp1X, cp1Y] = [valuesPrev[0], valuesPrev[1]];\r\n                [prevX, prevY] = [\r\n                    valuesPrev[valuesPrevL - 2],\r\n                    valuesPrev[valuesPrevL - 1]\r\n                ];\r\n                // Q control point\r\n                cpN1X = prevX + (prevX - cp1X);\r\n                cpN1Y = prevY + (prevY - cp1Y);\r\n\r\n                /**\r\n                * control points can be reflected\r\n                * use rounded values for better tolerance\r\n                */\r\n                [val0R, cpN1XR, val1R, cpN1YR] = [\r\n                    values[0],\r\n                    cpN1X,\r\n                    values[1],\r\n                    cpN1Y\r\n                ].map((val) => {\r\n                    return +(val).toFixed(1);\r\n                });\r\n\r\n                if (val0R == cpN1XR && val1R == cpN1YR) {\r\n                    comShort = {\r\n                        type: \"T\",\r\n                        values: [x, y]\r\n                    };\r\n                } else {\r\n                    comShort = com;\r\n                }\r\n                break;\r\n            case \"C\":\r\n                [cp1X, cp1Y] = [valuesPrev[0], valuesPrev[1]];\r\n                [cp2X, cp2Y] =\r\n                    valuesPrevL > 2 ?\r\n                        [valuesPrev[2], valuesPrev[3]] :\r\n                        [valuesPrev[0], valuesPrev[1]];\r\n                [prevX, prevY] = [\r\n                    valuesPrev[valuesPrevL - 2],\r\n                    valuesPrev[valuesPrevL - 1]\r\n                ];\r\n                // C control points\r\n                cpN1X = 2 * prevX - cp2X;\r\n                cpN1Y = 2 * prevY - cp2Y;\r\n                cpN2X = values[2];\r\n                cpN2Y = values[3];\r\n\r\n                /**\r\n                * control points can be reflected\r\n                * use rounded values for better tolerance\r\n                */\r\n                [val0R, cpN1XR, val1R, cpN1YR] = [\r\n                    values[0],\r\n                    cpN1X,\r\n                    values[1],\r\n                    cpN1Y\r\n                ].map((val) => {\r\n                    return +(val * 3).toFixed(0);\r\n                });\r\n\r\n                if (val0R == cpN1XR && val1R == cpN1YR) {\r\n                    comShort = {\r\n                        type: \"S\",\r\n                        values: [cpN2X, cpN2Y, x, y]\r\n                    };\r\n                } else {\r\n                    comShort = com;\r\n                }\r\n                break;\r\n            default:\r\n                comShort = {\r\n                    type: type,\r\n                    values: values\r\n                };\r\n        }\r\n\r\n        // round final values\r\n        if (decimals >= 0) {\r\n            comShort.values = comShort.values.map(val => { return +val.toFixed(decimals) })\r\n        }\r\n\r\n        pathDataShorts.push(comShort);\r\n    }\r\n    return pathDataShorts;\r\n}\r\n\r\n\r\n/**\r\n* serialize pathData array to \r\n* d attribute string \r\n*/\r\nfunction pathDataToD(pathData, decimals = -1, minify = false) {\r\n    // implicit l command\r\n    if (pathData[1].type === \"l\" && minify) {\r\n        pathData[0].type = \"m\";\r\n    }\r\n    let d = `${pathData[0].type}${pathData[0].values.join(\" \")}`;\r\n    for (let i = 1; i < pathData.length; i++) {\r\n        let com0 = pathData[i - 1];\r\n        let com = pathData[i];\r\n\r\n        let type = (com0.type === com.type && minify) ?\r\n            \" \" : (\r\n                (com0.type === \"m\" && com.type === \"l\") ||\r\n                (com0.type === \"M\" && com.type === \"l\") ||\r\n                (com0.type === \"M\" && com.type === \"L\")\r\n            ) && minify ?\r\n                \" \" : com.type;\r\n\r\n        // round\r\n        if (com.values.length && decimals >= 0) {\r\n            com.values = com.values.map(val => { return +val.toFixed(decimals) })\r\n        }\r\n        d += `${type}${com.values.join(\" \")}`;\r\n    }\r\n\r\n\r\n    if (minify) {\r\n        d = d\r\n            .replaceAll(\" 0.\", \" .\")\r\n            .replaceAll(\" -\", \"-\")\r\n            .replaceAll(\"-0.\", \"-.\")\r\n            .replace(/\\s+([mlcsqtahvz])/gi, \"$1\")\r\n            .replaceAll(\"Z\", \"z\");\r\n    }\r\n\r\n    return d;\r\n}\r\n\r\n\r\n/**\r\n * round pathData\r\n * decimals=-1 => no rounding\r\n */\r\nfunction roundPathData(pathData, decimals = -1) {\r\n    pathData.forEach((com, c) => {\r\n        if (decimals >= 0) {\r\n            com.values.forEach((val, v) => {\r\n                pathData[c].values[v] = +val.toFixed(decimals);\r\n            });\r\n        }\r\n    });\r\n    return pathData;\r\n}\r\n"]}