svg-path-simplify 0.0.8 → 0.0.9

package/dist/svg-path-simplify.node.js

@@ -49,23 +49,29 @@ function detectInputType(input) {
     if (input instanceof ArrayBuffer) return "buffer";
     if (input instanceof Blob) return "blob";
     */
-    if (Array.isArray(input)) return "array";
+    if (Array.isArray(input)) {
+        if (input[0]?.type && input[0]?.values 
+        ) {
+            return "pathData";
+        }
+
+        return "array";
+    }
 
     if (typeof input === "string") {
         input = input.trim();
         let isSVG = input.includes('<svg') && input.includes('</svg');
         let isPathData = input.startsWith('M') || input.startsWith('m');
-        let isPolyString = !isNaN(input.substring(0, 1)) && !isNaN(input.substring(input.length-1, input.length));
+        let isPolyString = !isNaN(input.substring(0, 1)) && !isNaN(input.substring(input.length - 1, input.length));
 
-        
-        if(isSVG) {
-            type='svgMarkup';
+        if (isSVG) {
+            type = 'svgMarkup';
         }
-        else if(isPathData) {
-            type='pathDataString';
+        else if (isPathData) {
+            type = 'pathDataString';
         }
-        else if(isPolyString) {
-            type='polyString';
+        else if (isPolyString) {
+            type = 'polyString';
         }
 
         else {
@@ -774,27 +780,23 @@ function getDistAv(pt1, pt2) {
  * split compound paths into 
  * sub path data array
  */
-function splitSubpaths(pathData) {
 
+function splitSubpaths(pathData) {
     let subPathArr = [];
+    let current = [pathData[0]];
+    let l = pathData.length;
 
-    
-    try{
-        let subPathIndices = pathData.map((com, i) => (com.type.toLowerCase() === 'm' ? i : -1)).filter(i => i !== -1);
+    for (let i = 1; i < l; i++) {
+        let com = pathData[i];
 
-    }catch{
-        console.log('catch', pathData);
+        if (com.type === 'M' || com.type === 'm') {
+            subPathArr.push(current);
+            current = [];
+        }
+        current.push(com);
     }
 
-    let subPathIndices = pathData.map((com, i) => (com.type.toLowerCase() === 'm' ? i : -1)).filter(i => i !== -1);
-
-    // no compound path
-    if (subPathIndices.length === 1) {
-        return [pathData]
-    }
-    subPathIndices.forEach((index, i) => {
-        subPathArr.push(pathData.slice(index, subPathIndices[i + 1]));
-    });
+    if (current.length) subPathArr.push(current);
 
     return subPathArr;
 }
@@ -1478,13 +1480,6 @@ function pathDataToD(pathData, optimize = 0) {
     let beautify = optimize > 1;
     let minify = beautify || optimize ? false : true;
 
-    // Convert first "M" to "m" if followed by "l" (when minified)
-    /*
-    if (pathData[1].type === "l" && minify) {
-        pathData[0].type = "m";
-    }
-    */
-
     let d = '';
     let separator_command = beautify ? `\n` : (minify ? '' : ' ');
     let separator_type =  !minify ? ' ' : '';
@@ -1506,13 +1501,11 @@ function pathDataToD(pathData, optimize = 0) {
         }
 
         // Omit type for repeated commands
-        type = (com0.type === com.type && com.type.toLowerCase() !== 'm' && minify)
+        type = (minify && com0.type === com.type && com.type.toLowerCase() !== 'm' )
             ? " "
-            : (
-                (com0.type === "M" && com.type === "L")
-            ) && minify
+            : (minify && com0.type === "M" && com.type === "L"
                 ? " "
-                : com.type;
+                : com.type);
 
         // concatenate subsequent floating point values
         if (minify) {
@@ -1662,6 +1655,7 @@ function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, debug = f
         cp1: Q1,
         cp2: Q2,
         p: Q3,
+        t0
     };
 
     if (reverse) {
@@ -1670,6 +1664,7 @@ function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, debug = f
             cp1: Q2,
             cp2: Q1,
             p: Q0,
+            t0
         };
     }
 
@@ -1681,8 +1676,8 @@ function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, debug = f
     let ptI_1 = checkLineIntersection(ptM, seg1_cp2, result.p0, ptI, false);
     let ptI_2 = checkLineIntersection(ptM, seg1_cp2, result.p, ptI, false);
 
-    let cp1_2 = interpolate(result.p0, ptI_1, 1.333);
-    let cp2_2 = interpolate(result.p, ptI_2, 1.333);
+    let cp1_2 = interpolate(result.p0, ptI_1, 1.333  );
+    let cp2_2 = interpolate(result.p, ptI_2, 1.333  );
 
     // test self intersections and exit 
     let cp_intersection = checkLineIntersection(com1_o.p0, cp1_2, com2_o.p, cp2_2, true);
@@ -1714,14 +1709,24 @@ function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, debug = f
     // extrapolated starting point is not completely off
     if (dist5 < maxDist) {
 
+        /*
+        let tTotal = 1 + Math.abs(t0);
+        let tSplit = reverse ? 1 + t0 : Math.abs(t0);
+
+        let pO = pointAtT([com2_o.p0, com2_o.cp1, com2_o.cp2, com2_o.p], t0);
+*/
+
         // split t to meet original mid segment start point
         let tSplit = reverse ? 1 + t0 : Math.abs(t0);
 
+        let tTotal = 1 + Math.abs(t0);
+        tSplit = reverse ? 1 + t0 : Math.abs(t0) / tTotal;
+
         let ptSplit = pointAtT([result.p0, result.cp1, result.cp2, result.p], tSplit);
         let distSplit = getDistAv(ptSplit, com1.p);
 
         // not close enough - exit
-        if (distSplit > maxDist * tolerance) {
+        if (distSplit > maxDist * tolerance ) {
 
             return commands;
         }
@@ -1760,21 +1765,122 @@ function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, debug = f
 
 }
 
-function combineCubicPairs(com1, com2, extrapolateDominant = false, tolerance = 1) {
+function simplifyPathDataCubic(pathData, {
+    keepExtremes = true,
+    keepInflections = true,
+    keepCorners = true,
+    extrapolateDominant = true,
+    tolerance = 1,
+} = {}) {
+
+    let pathDataN = [pathData[0]];
+    let l = pathData.length;
+
+    for (let i = 2; l && i <= l; i++) {
+        let com = pathData[i - 1];
+        let comN = i < l ? pathData[i] : null;
+        let typeN = comN?.type || null;
+
+        let isDirChange = com?.directionChange || null;
+        let isDirChangeN = comN?.directionChange || null;
+
+        let { type, values, p0, p, cp1 = null, cp2 = null, extreme = false, corner = false, dimA = 0 } = com;
+
+        // next is also cubic
+        if (type === 'C' && typeN === 'C') {
+
+            // cannot be combined as crossing extremes or corners
+            if (
+                (keepInflections && isDirChangeN) ||
+                (keepCorners && corner) ||
+                (!isDirChange && keepExtremes && extreme)
+            ) {
+
+                pathDataN.push(com);
+            }
+
+            // try simplification
+            else {
+
+                let combined = combineCubicPairs(com, comN, {tolerance});
+                let error = 0;
+
+                // combining successful! try next segment
+                if (combined.length === 1) {
+                    com = combined[0];
+                    let offset = 1;
+
+                    // add cumulative error to prevent distortions
+                    error += com.error;
+
+                    // find next candidates
+
+                    for (let n = i + 1; error < tolerance && n < l; n++) {
+                        let comN = pathData[n];
+                        if (comN.type !== 'C' ||
+                            (
+                                (keepInflections && comN.directionChange) ||
+                                (keepCorners && com.corner) ||
+                                (keepExtremes && com.extreme)
+                            )
+                        ) {
+                            break
+                        }
+
+                        let combined = combineCubicPairs(com, comN, {tolerance});
+                        if (combined.length === 1) {
+                            // add cumulative error to prevent distortions
+
+                            error += combined[0].error * 0.5;
+
+                            offset++;
+                        }
+                        com = combined[0];
+                    }
+
+                    pathDataN.push(com);
+
+                    if (i < l) {
+                        i += offset;
+                    }
+
+                } else {
+                    pathDataN.push(com);
+                }
+            }
+
+        } // end of bezier command
+
+        // other commands
+        else {
+            pathDataN.push(com);
+        }
+
+    } // end command loop
+
+    return pathDataN
+}
+
+function combineCubicPairs(com1, com2, {
+    tolerance = 1
+} = {}) {
 
     let commands = [com1, com2];
+
+    // assume 2 segments are result of a segment split
     let t = findSplitT(com1, com2);
 
     let distAv1 = getDistAv(com1.p0, com1.p);
     let distAv2 = getDistAv(com2.p0, com2.p);
-    let distMin = Math.min(distAv1, distAv2);
+    let distMin = Math.max(0, Math.min(distAv1, distAv2));
 
-    let distScale = 0.05;
+    let distScale = 0.06;
     let maxDist = distMin * distScale * tolerance;
 
-    let comS = getExtrapolatedCommand(com1, com2, t, t);
+    // get hypothetical combined command
+    let comS = getExtrapolatedCommand(com1, com2, t);
 
-    // test on path point against original
+    // test new point-at-t against original mid segment starting point
     let pt = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t);
 
     let dist0 = getDistAv(com1.p, pt);
@@ -1785,12 +1891,6 @@ function combineCubicPairs(com1, com2, extrapolateDominant = false, tolerance =
     // collect error data
     let error = dist0;
 
-    /*
-    if (com2.directionChange) {
-
-    }
-    */
-
     if (close) {
 
         /**
@@ -1836,29 +1936,9 @@ function combineCubicPairs(com1, com2, extrapolateDominant = false, tolerance =
 
     } // end 1st try
 
-    
-
-    // try extrapolated dominant curve
-
-    //  && !com1.extreme
-    if (extrapolateDominant && !success  ) {
-
-        let combinedEx = getCombinedByDominant(com1, com2, maxDist, tolerance);
-
-        if(combinedEx.length===1){
-            success = true;
-            comS = combinedEx[0];
-            error = comS.error;
-
-        }
-
-    
-    }
-
     // add meta
     if (success) {
 
-        
         // correct to exact start and end points
         comS.p0 = com1.p0;
         comS.p = com2.p;
@@ -1881,26 +1961,23 @@ function combineCubicPairs(com1, com2, extrapolateDominant = false, tolerance =
     return commands;
 }
 
-function getExtrapolatedCommand(com1, com2, t1 = 0, t2 = 0) {
+function getExtrapolatedCommand(com1, com2, t = 0) {
 
     let { p0, cp1 } = com1;
     let { p, cp2 } = com2;
 
     // extrapolate control points
-    let cp1_S = {
-        x: (cp1.x - (1 - t1) * p0.x) / t1,
-        y: (cp1.y - (1 - t1) * p0.y) / t1
+    cp1 = {
+        x: (cp1.x - (1 - t) * p0.x) / t,
+        y: (cp1.y - (1 - t) * p0.y) / t
     };
 
-    let cp2_S = {
-        x: (cp2.x - t2 * p.x) / (1 - t2),
-        y: (cp2.y - t2 * p.y) / (1 - t2)
+    cp2 = {
+        x: (cp2.x - t * p.x) / (1 - t),
+        y: (cp2.y - t * p.y) / (1 - t)
     };
 
-    let comS = { p0, cp1: cp1_S, cp2: cp2_S, p };
-
-    return comS
-
+    return { p0, cp1, cp2, p };
 }
 
 function findSplitT(com1, com2) {
@@ -1913,52 +1990,40 @@ function findSplitT(com1, com2) {
     return t
 }
 
-function checkBezierFlatness(p0, cpts, p) {
-
-    let isFlat = false;
-
-    let isCubic = cpts.length === 2;
-
-    let cp1 = cpts[0];
-    let cp2 = isCubic ? cpts[1] : cp1;
-
-    if (p0.x === cp1.x && p0.y === cp1.y && p.x === cp2.x && p.y === cp2.y) return true;
-
-    let dx1 = cp1.x - p0.x;
-    let dy1 = cp1.y - p0.y;
-
-    let dx2 = p.x - cp2.x;
-    let dy2 = p.y - cp2.y;
-
-    let cross1 = Math.abs(dx1 * dy2 - dy1 * dx2);
+function commandIsFlat(points, {
+    tolerance = 1,
+    debug=false
+} = {}) {
 
-    if (!cross1) return true
+    let isFlat=false;
+    let report = {
+        flat:true,
+        steepness:0
+    };
 
-    let dx0 = p.x - p0.x;
-    let dy0 = p.y - p0.y;
-    let cross0 = Math.abs(dx0 * dy1 - dy0 * dx1);
+    let p0 = points[0];
+    let p = points[points.length - 1];
 
-    if (!cross0) return true
+    let xSet = new Set([...points.map(pt => +pt.x.toFixed(8))]);
+    let ySet = new Set([...points.map(pt => +pt.y.toFixed(8))]);
 
-    let area = getPolygonArea([p0,...cpts, p], true);
-    let dist1 = getSquareDistance(p0, p);
-    let thresh = dist1/200;
+    // must be flat
+    if(xSet.size===1 || ySet.size===1) return !debug ? true : report;
 
-   // if(area<thresh) return true;
-    isFlat = area<thresh;
+    let squareDist = getSquareDistance(p0, p);
+    let threshold = squareDist / 1000 * tolerance;
+    let area = getPolygonArea(points, true);
 
-    /*
+    // flat enough
+    if(area < threshold) isFlat = true;
 
-    let rat = (cross0 / cross1)
+    if(debug){
+        report.flat = isFlat;
 
-    if (rat < 1.1) {
-        console.log('cross', cross0, cross1, 'rat', rat );
-        isFlat = true;
+        report.steepness = area/squareDist*10;
     }
-    */
-
-    return isFlat;
 
+    return !debug ? isFlat : report;
 }
 
 function analyzePathData(pathData = []) {
@@ -2074,14 +2139,17 @@ function analyzePathData(pathData = []) {
             commandPts.push(p);
 
             /*
+
             let commandFlatness = commandIsFlat(commandPts);
             isFlat = commandFlatness.flat;
             com.flat = isFlat;
 
             if (isFlat) {
                 com.extreme = false;
+
             }
             */
+
         }
 
         /**
@@ -2191,7 +2259,7 @@ function detectAccuracy(pathData) {
     let p = M;
     pathData[0].decimals = 0;
 
-    let dims = new Set();
+    let dims = [];
 
     // add average distances
     for (let i = 0, len = pathData.length; i < len; i++) {
@@ -2204,7 +2272,7 @@ function detectAccuracy(pathData) {
         // use existing averave dimension value or calculate
         let dimA = com.dimA ? +com.dimA.toFixed(8) : type !== 'M' ? +getDistAv(p0, p).toFixed(8) : 0;
 
-        if (dimA) dims.add(dimA);
+        if (dimA) dims.push(dimA);
 
         if (type === 'M') {
             M = p;
@@ -2212,7 +2280,7 @@ function detectAccuracy(pathData) {
         p0 = p;
     }
 
-    let dim_min = Array.from(dims).sort();
+    let dim_min = dims.sort();
 
     /*
     let minVal = dim_min.length > 15 ?
@@ -2238,19 +2306,24 @@ function detectAccuracy(pathData) {
  * based on suggested accuracy in path data
  */
 function roundPathData(pathData, decimals = -1) {
-    // has recommended decimals
-    let hasDecimal = decimals == 'auto' && pathData[0].hasOwnProperty('decimals') ? true : false;
 
-    for (let c = 0, len = pathData.length; c < len; c++) {
-        let com = pathData[c];
+    let len = pathData.length;
 
-        if (decimals > -1 || hasDecimal) {
-            decimals = hasDecimal ? com.decimals : decimals;
+    for (let c = 0; c < len; c++) {
 
-            pathData[c].values = com.values.map(val => { return val ? +val.toFixed(decimals) : val });
+        let values = pathData[c].values;
+        let valLen = values.length;
 
+        if (valLen && (decimals > -1) ) {
+
+            for(let v=0; v<valLen; v++){
+
+                pathData[c].values[v] =  +values[v].toFixed(decimals);
+            }
         }
-    }    return pathData;
+    }
+
+    return pathData;
 }
 
 function revertCubicQuadratic(p0 = {}, cp1 = {}, cp2 = {}, p = {}) {
@@ -2268,7 +2341,7 @@ function revertCubicQuadratic(p0 = {}, cp1 = {}, cp2 = {}, p = {}) {
     let values = [cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
     let comN = {type, values};
 
-    if (dist1 < threshold) {
+    if (dist1 && threshold && dist1 < threshold) {
         cp1_Q = checkLineIntersection(p0, cp1, p, cp2, false);
         if (cp1_Q) {
 
@@ -2293,9 +2366,10 @@ function convertPathData(pathData, {
     if (toShorthands) pathData = pathDataToShorthands(pathData);
 
     // pre round - before relative conversion to minimize distortions
-    pathData = roundPathData(pathData, decimals);
+    if(decimals>-1 && toRelative) pathData = roundPathData(pathData, decimals);
     if (toRelative) pathData = pathDataToRelative(pathData);
     if (decimals > -1) pathData = roundPathData(pathData, decimals);
+
     return pathData
 }
 
@@ -2597,7 +2671,7 @@ function pathDataToLonghands(pathData, decimals = -1, test = true) {
  * L, L, C, Q => H, V, S, T
  * reversed method: pathDataToLonghands()
  */
-function pathDataToShorthands(pathData, decimals = -1, test = true) {
+function pathDataToShorthands(pathData, decimals = -1, test = false) {
 
     /** 
     * analyze pathdata – if you're sure your data is already absolute skip it via test=false
@@ -2608,29 +2682,28 @@ function pathDataToShorthands(pathData, decimals = -1, test = true) {
         hasRel = /[astvqmhlc]/g.test(commandTokens);
     }
 
-    pathData = test && hasRel ? pathDataToAbsolute(pathData, decimals) : pathData;
+    pathData = test && hasRel ? pathDataToAbsoluteOrRelative(pathData) : pathData;
+
+    let len = pathData.length;
+    let pathDataShorts = new Array(len);
 
     let comShort = {
         type: "M",
         values: pathData[0].values
     };
 
-    if (pathData[0].decimals) {
-
-        comShort.decimals = pathData[0].decimals;
-    }
-
-    let pathDataShorts = [comShort];
+    pathDataShorts[0] = comShort;
 
     let p0 = { x: pathData[0].values[0], y: pathData[0].values[1] };
     let p;
     let tolerance = 0.01;
 
-    for (let i = 1, len = pathData.length; i < len; i++) {
+    for (let i = 1; i < len; i++) {
 
         let com = pathData[i];
         let { type, values } = com;
-        let valuesLast = values.slice(-2);
+        let valuesLen = values.length;
+        let valuesLast = [values[valuesLen-2], values[valuesLen-1]];
 
         // previoius command
         let comPrev = pathData[i - 1];
@@ -2678,7 +2751,8 @@ function pathDataToShorthands(pathData, decimals = -1, test = true) {
                 if (typePrev !== 'Q') {
 
                     p0 = { x: valuesLast[0], y: valuesLast[1] };
-                    pathDataShorts.push(com);
+
+                    pathDataShorts[i] = com;
                     continue;
                 }
 
@@ -2707,7 +2781,8 @@ function pathDataToShorthands(pathData, decimals = -1, test = true) {
 
                 if (typePrev !== 'C') {
 
-                    pathDataShorts.push(com);
+                    pathDataShorts[i] = com;
+
                     p0 = { x: valuesLast[0], y: valuesLast[1] };
                     continue;
                 }
@@ -2749,8 +2824,10 @@ function pathDataToShorthands(pathData, decimals = -1, test = true) {
         }
 
         p0 = { x: valuesLast[0], y: valuesLast[1] };
-        pathDataShorts.push(comShort);
+        pathDataShorts[i] = comShort;
+
     }
+
     return pathDataShorts;
 }
 
@@ -3195,10 +3272,10 @@ function normalizePathData(pathData = [],
         quadraticToCubic = false,
         arcToCubic = false,
         arcAccuracy = 2,
-    } = {},
 
-    {
+        // assume we need full normalization
         hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true, testTypes = false
+
     } = {}
 ) {
 
@@ -3249,15 +3326,28 @@ function parsePathDataNormalized(d,
     } = {}
 ) {
 
-    let pathDataObj = parsePathDataString(d);
-    let { hasRelatives, hasShorthands, hasQuadratics, hasArcs } = pathDataObj;
-    let pathData = pathDataObj.pathData;
+    // is already array
+    let isArray = Array.isArray(d);
+
+    // normalize native pathData to regular array
+    let hasConstructor = isArray && typeof d[0] === 'object' && typeof d[0].constructor === 'function';
+    /*
+    if (hasConstructor) {
+        d = d.map(com => { return { type: com.type, values: com.values } })
+        console.log('hasConstructor', hasConstructor, (typeof d[0].constructor), d);
+    }
+    */
+
+    let pathDataObj = isArray ? d : parsePathDataString(d);
+
+    let { hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true } = pathDataObj;
+    let pathData = hasConstructor ? pathDataObj : pathDataObj.pathData;
 
     // normalize
     pathData = normalizePathData(pathData,
-        { toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy },
-
-        { hasRelatives, hasShorthands, hasQuadratics, hasArcs }
+        { toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy,
+        hasRelatives, hasShorthands, hasQuadratics, hasArcs 
+        },
     );
 
     return pathData;
@@ -3609,7 +3699,8 @@ function parsePathDataString(d, debug = true) {
         if (debug === 'log') {
             console.log(feedback);
         } else {
-            throw new Error(feedback)
+
+            console.warn(feedback);
         }
     }
 
@@ -3641,22 +3732,22 @@ function stringifyPathData(pathData) {
     return pathData.map(com => { return `${com.type} ${com.values.join(' ')}` }).join(' ');
 }
 
-function shapeElToPath(el){
+function shapeElToPath(el) {
 
     let nodeName = el.nodeName.toLowerCase();
-    if(nodeName==='path')return el;
+    if (nodeName === 'path') return el;
 
     let pathData = getPathDataFromEl(el);
-    let d = pathData.map(com=>{return `${com.type} ${com.values} `}).join(' ');
-    let attributes = [...el.attributes].map(att=>att.name);
+    let d = pathData.map(com => { return `${com.type} ${com.values} ` }).join(' ');
+    let attributes = [...el.attributes].map(att => att.name);
 
     let pathN = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-    pathN.setAttribute('d', d );
+    pathN.setAttribute('d', d);
 
     let exclude = ['x', 'y', 'cx', 'cy', 'dx', 'dy', 'r', 'rx', 'ry', 'width', 'height', 'points'];
 
-    attributes.forEach(att=>{
-        if(!exclude.includes(att)){
+    attributes.forEach(att => {
+        if (!exclude.includes(att)) {
             let val = el.getAttribute(att);
             pathN.setAttribute(att, val);
         }
@@ -3667,7 +3758,7 @@ function shapeElToPath(el){
 }
 
 // retrieve pathdata from svg geometry elements
-function getPathDataFromEl(el, stringify=false) {
+function getPathDataFromEl(el, stringify = false) {
 
     let pathData = [];
     let type = el.nodeName;
@@ -3825,7 +3916,9 @@ function getPathDataFromEl(el, stringify=false) {
             attNames = ['cx', 'cy', 'rx', 'ry', 'r'];
             ({ cx, cy, r, rx, ry } = getAtts(attNames));
 
-            if (type === 'circle') {
+            let isCircle = type === 'circle';
+
+            if (isCircle) {
                 r = r;
                 rx = r;
                 ry = r;
@@ -3834,10 +3927,14 @@ function getPathDataFromEl(el, stringify=false) {
                 ry = ry ? ry : r;
             }
 
+            // simplified radii for cirecles
+            let rxS = isCircle && r>=1 ? 1 : rx;
+            let ryS = isCircle && r>=1 ? 1 : rx;
+
             pathData = [
                 { type: "M", values: [cx + rx, cy] },
-                { type: "A", values: [rx, ry, 0, 1, 1, cx - rx, cy] },
-                { type: "A", values: [rx, ry, 0, 1, 1, cx + rx, cy] },
+                { type: "A", values: [rxS, ryS, 0, 1, 1, cx - rx, cy] },
+                { type: "A", values: [rxS, ryS, 0, 1, 1, cx + rx, cy] },
             ];
 
             break;
@@ -3869,22 +3966,28 @@ function getPathDataFromEl(el, stringify=false) {
             break;
     }
 
-    return stringify ? stringifyPathData(pathData): pathData;
+    return stringify ? stringifyPathData(pathData) : pathData;
 
 }
 
-function pathDataRemoveColinear(pathData, tolerance = 1, flatBezierToLinetos = true) {
+function pathDataRemoveColinear(pathData, {
+    tolerance = 1, 
+
+    flatBezierToLinetos = true
+}={}) {
 
     let pathDataN = [pathData[0]];
+
     let M = { x: pathData[0].values[0], y: pathData[0].values[1] };
     let p0 = M;
     let p = M;
     pathData[pathData.length - 1].type.toLowerCase() === 'z';
 
     for (let c = 1, l = pathData.length; c < l; c++) {
-        let comPrev = pathData[c - 1];
+
         let com = pathData[c];
         let comN = pathData[c + 1] || pathData[l - 1];
+
         let p1 = comN.type.toLowerCase() === 'z' ? M : { x: comN.values[comN.values.length - 2], y: comN.values[comN.values.length - 1] };
 
         let { type, values } = com;
@@ -3893,11 +3996,9 @@ function pathDataRemoveColinear(pathData, tolerance = 1, flatBezierToLinetos = t
 
         let area = getPolygonArea([p0, p, p1], true);
 
-        getSquareDistance(p0, p);
-        getSquareDistance(p, p1);
         let distSquare = getSquareDistance(p0, p1);
 
-        let distMax = distSquare / 200 * tolerance;
+        let distMax = distSquare ? distSquare / 333 * tolerance : 0;
 
         let isFlat = area < distMax;
         let isFlatBez = false;
@@ -3911,31 +4012,38 @@ function pathDataRemoveColinear(pathData, tolerance = 1, flatBezierToLinetos = t
             [{ x: values[0], y: values[1] }, { x: values[2], y: values[3] }] :
             (type === 'Q' ? [{ x: values[0], y: values[1] }] : []);
 
-            isFlatBez = checkBezierFlatness(p0, cpts, p);
-
-           // console.log();
+            isFlatBez = commandIsFlat([p0, ...cpts, p],{tolerance});
 
-            if (isFlatBez  && c < l - 1 && comPrev.type !== 'C') {
+            if (isFlatBez  && c < l - 1  ) {
                 type = "L";
                 com.type = "L";
                 com.values = valsL;
 
             }
-
         }
 
-        // update end point
-        p0 = p;
-
         // colinear – exclude arcs (as always =) as semicircles won't have an area
 
         if ( isFlat && c < l - 1 && (type === 'L' || (flatBezierToLinetos && isFlatBez)) ) {
-
             
+            /*
+            console.log(area, distMax );
+
+            if(p0.x === p.x && p0.y === p.y){
+
+            }
+
+            renderPoint(markers, p0, 'blue', '1.5%', '1')
+            renderPoint(markers, p, 'red', '1%', '1')
+            renderPoint(markers, p1, 'cyan', '0.5%', '1')
+            */
 
             continue;
         }
 
+        // update end point
+        p0 = p;
+
         if (type === 'M') {
             M = p;
             p0 = M;
@@ -3956,6 +4064,7 @@ function pathDataRemoveColinear(pathData, tolerance = 1, flatBezierToLinetos = t
 
 function removeOrphanedM(pathData) {
 
+    let pathDataN = [];
     for (let i = 0, l = pathData.length; i < l; i++) {
         let com = pathData[i];
         if (!com) continue;
@@ -3964,14 +4073,14 @@ function removeOrphanedM(pathData) {
         if ((type === 'M' || type === 'm')) {
 
             if (!comN || (comN && (comN.type === 'Z' || comN.type === 'z'))) {
-                pathData[i] = null;
-                pathData[i + 1] = null;
+                if(comN) i++;
+                continue
             }
         }
+        pathDataN.push(com);
     }
 
-    pathData = pathData.filter(Boolean);
-    return pathData;
+    return pathDataN;
 
 }
 
@@ -4002,19 +4111,23 @@ function removeZeroLengthLinetos(pathData) {
 
     for (let c = 1, l = pathData.length; c < l; c++) {
         let com = pathData[c];
+        let comPrev = pathData[c-1]; 
+        let comNext = pathData[c+1] || null;
         let { type, values } = com;
 
-        let valsLen = values.length;
+        // zero length segments are simetimes used in icons for dots
+        let isDot = comPrev.type.toLowerCase() ==='m' && !comNext;
 
+        let valsLen = values.length;
         p = { x: values[valsLen-2], y: values[valsLen-1] };
 
         // skip lineto
-        if (type === 'L' && p.x === p0.x && p.y === p0.y) {
+        if (!isDot && type === 'L' && p.x === p0.x && p.y === p0.y) {
             continue
         }
 
         // skip minified zero length
-        if (type === 'l' || type === 'v' || type === 'h') {
+        if (!isDot && (type === 'l' || type === 'v' || type === 'h')) {
             let noLength = type === 'l' ? (values.join('') === '00') : values[0] === 0;
             if(noLength) continue
         } 
@@ -4116,7 +4229,7 @@ function optimizeClosePath(pathData, removeFinalLineto = true, reorder = true) {
         }
         // use top most command
         else {
-            indices = indices.sort((a, b) => +a.y.toFixed(1) - +b.y.toFixed(1) || a.x - b.x);
+            indices = indices.sort((a, b) => +a.y.toFixed(8) - +b.y.toFixed(8) || a.x - b.x);
             newIndex = indices[0].index;
         }
 
@@ -4124,7 +4237,7 @@ function optimizeClosePath(pathData, removeFinalLineto = true, reorder = true) {
         pathData = newIndex ? shiftSvgStartingPoint(pathData, newIndex) : pathData;
     }
 
-    M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(7) };
+    M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(8) };
 
     len = pathData.length;
 
@@ -4238,149 +4351,61 @@ function addClosePathLineto(pathData) {
     return pathData;
 }
 
-/**
- * reverse pathdata
- * make sure all command coordinates are absolute and
- * shorthands are converted to long notation
- */
-function reversePathData(pathData, {
-    arcToCubic = false,
-    quadraticToCubic = false,
-    toClockwise = false,
-    returnD = false
+function refineAdjacentExtremes(pathData, {
+    threshold = null, tolerance = 1
 } = {}) {
 
-    /**
-     * Add closing lineto:
-     * needed for path reversing or adding points
-     */
-    const addClosePathLineto = (pathData) => {
-        let closed = pathData[pathData.length - 1].type.toLowerCase() === "z";
-        let M = pathData[0];
-        let [x0, y0] = [M.values[0], M.values[1]];
-        let lastCom = closed ? pathData[pathData.length - 2] : pathData[pathData.length - 1];
-        let [xE, yE] = [lastCom.values[lastCom.values.length - 2], lastCom.values[lastCom.values.length - 1]];
-
-        if (closed && (x0 != xE || y0 != yE)) {
-
-            pathData.pop();
-            pathData.push(
-                {
-                    type: "L",
-                    values: [x0, y0]
-                },
-                {
-                    type: "Z",
-                    values: []
-                }
-            );
-        }
-        return pathData;
-    };
-
-    // helper to rearrange control points for all command types
-    const reverseControlPoints = (type, values) => {
-        let controlPoints = [];
-        let endPoints = [];
-        if (type !== "A") {
-            for (let p = 0; p < values.length; p += 2) {
-                controlPoints.push([values[p], values[p + 1]]);
-            }
-            endPoints = controlPoints.pop();
-            controlPoints.reverse();
-        }
-        // is arc
-        else {
-
-            let sweep = values[4] == 0 ? 1 : 0;
-            controlPoints = [values[0], values[1], values[2], values[3], sweep];
-            endPoints = [values[5], values[6]];
-        }
-        return { controlPoints, endPoints };
-    };
-
-    // start compiling new path data
-    let pathDataNew = [];
+    if (!threshold) {
+        let bb = getPathDataBBox(pathData);
+        threshold = (bb.width + bb.height) / 2 * 0.05;
 
-    let closed =
-        pathData[pathData.length - 1].type.toLowerCase() === "z" ? true : false;
-    if (closed) {
-        // add lineto closing space between Z and M
-        pathData = addClosePathLineto(pathData);
-        // remove Z closepath
-        pathData.pop();
     }
 
-    // define last point as new M if path isn't closed
-    let valuesLast = pathData[pathData.length - 1].values;
-    let valuesLastL = valuesLast.length;
-    let M = closed
-        ? pathData[0]
-        : {
-            type: "M",
-            values: [valuesLast[valuesLastL - 2], valuesLast[valuesLastL - 1]]
-        };
-    // starting M stays the same – unless the path is not closed
-    pathDataNew.push(M);
+    let l = pathData.length;
 
-    // reverse path data command order for processing
-    pathData.reverse();
-    for (let i = 1; i < pathData.length; i++) {
+    for (let i = 0; i < l; i++) {
         let com = pathData[i];
-        let type = com.type;
-        let values = com.values;
-        let comPrev = pathData[i - 1];
-        let typePrev = comPrev.type;
-        let valuesPrev = comPrev.values;
+        let { type, values, extreme, corner = false, dimA, p0, p } = com;
+        let comN = pathData[i + 1] ? pathData[i + 1] : null;
+        let comN2 = pathData[i + 2] ? pathData[i + 2] : null;
 
-        // get reversed control points and new end coordinates
-        let controlPointsPrev = reverseControlPoints(typePrev, valuesPrev).controlPoints;
-        let endPoints = reverseControlPoints(type, values).endPoints;
+        // check dist
+        let diff = comN ? getDistAv(p, comN.p) : Infinity;
+        let isCose = diff < threshold;
 
-        // create new path data
-        let newValues = [];
-        newValues = [controlPointsPrev, endPoints].flat();
-        pathDataNew.push({
-            type: typePrev,
-            values: newValues.flat()
-        });
-    }
+        let diff2 = comN2 ? getDistAv(comN2.p, comN.p) : Infinity;
+        let isCose2 = diff2 < threshold;
 
-    // add previously removed Z close path
-    if (closed) {
-        pathDataNew.push({
-            type: "z",
-            values: []
-        });
-    }
+        // next is extreme
+        if (comN && type === 'C' && comN.type === 'C' && extreme && comN2 && comN2.extreme) {
 
-    return pathDataNew;
-}
+            if (isCose2 || isCose) {
 
-function refineAdjacentExtremes(pathData, {
-    threshold = null, tolerance = 1
-} = {}) {
+                // extrapolate
+                let comEx = getCombinedByDominant(comN, comN2, threshold, tolerance, false);
 
-    if (!threshold) {
-        let bb = getPathDataBBox(pathData);
-        threshold = (bb.width + bb.height) / 2 * 0.05;
+                if (comEx.length === 1) {
 
-    }
+                    pathData[i + 1] = null;
+                    comEx = comEx[0];
 
-    let l = pathData.length;
+                    pathData[i + 2].values = [comEx.cp1.x, comEx.cp1.y, comEx.cp2.x, comEx.cp2.y, comEx.p.x, comEx.p.y];
+                    pathData[i + 2].cp1 = comEx.cp1;
+                    pathData[i + 2].cp2 = comEx.cp2;
+                    pathData[i + 2].p0 = comEx.p0;
+                    pathData[i + 2].p = comEx.p;
+                    pathData[i + 2].extreme = comEx.extreme;
 
-    for (let i = 0; i < l; i++) {
-        let com = pathData[i];
-        let { type, values, extreme, corner=false, dimA, p0, p } = com;
-        let comN = pathData[i + 1] ? pathData[i + 1] : null;
+                    i++;
+                    continue
+                }
+            }
 
-        // adjacent 
+        }
 
-        if (comN && type === 'C' && comN.type === 'C' && extreme && !corner) {
+        // short after extreme
 
-            // check dist
-            let diff = getDistAv(p, comN.p);
-            let isCose = diff < threshold;
+        if (comN && type === 'C' && comN.type === 'C' && extreme ) {
 
             if (isCose) {
 
@@ -4393,11 +4418,23 @@ function refineAdjacentExtremes(pathData, {
                 let ptI;
                 let t = 1;
 
+                let area0 = getPolygonArea([com.p0, com.p , comN.p]);
+                // cpts area
+                let area1 = getPolygonArea([com.p0, com.cp1, com.cp2, com.p]);
+
+                // sign change: is corner => skip
+                if ( (area0<0 && area1>0)  || (area0>0 && area1<0)) {
+
+                    continue;
+                }
+
+                
                 if (comN.extreme) {
 
                     // extend cp2
                     if (horizontal) {
                         t = Math.abs(Math.abs(comN.cp2.x - comN.p.x) / Math.abs(com.cp2.x - com.p.x));
+                        t = Math.min(1, t);
 
                         ptI = interpolate(comN.p, com.cp2, 1 + t);
                         com.cp2.x = ptI.x;
@@ -4406,6 +4443,8 @@ function refineAdjacentExtremes(pathData, {
                     else {
 
                         t = Math.abs(Math.abs(comN.cp2.y - comN.p.y) / Math.abs(com.cp2.y - com.p.y));
+                        t = Math.min(1, t);
+
                         ptI = interpolate(comN.p, com.cp2, 1 + t);
                         com.cp2.y = ptI.y;
                     }
@@ -4423,35 +4462,12 @@ function refineAdjacentExtremes(pathData, {
 
                 }
 
-                // extend fist command
-                else {
-
-                    let comN2 = pathData[i + 2] ? pathData[i + 2] : null;
-                    if (!comN2 && comN2.type !== 'C') continue
-
-                    // extrapolate
-                    let comEx = getCombinedByDominant(comN, comN2, threshold, tolerance, false);
-
-                    if (comEx.length === 1) {
-                        pathData[i + 1] = null;
-
-                        comEx = comEx[0];
-
-                        pathData[i + 2].values = [comEx.cp1.x, comEx.cp1.y, comEx.cp2.x, comEx.cp2.y, comEx.p.x, comEx.p.y];
-                        pathData[i + 2].cp1 = comEx.cp1;
-                        pathData[i + 2].cp2 = comEx.cp2;
-                        pathData[i + 2].p0 = comEx.p0;
-                        pathData[i + 2].p = comEx.p;
-                        pathData[i + 2].extreme = comEx.extreme;
-
-                        i++;
-                        continue
-                    }
-
-                }
-
             }
         }
+
+        /*
+        */
+
     }
 
     // remove commands
@@ -4478,11 +4494,7 @@ function refineAdjacentExtremes(pathData, {
 
     if (penultimateCom && penultimateCom.type === 'C' && isCose && isClosingTo && fistExt) {
 
-        Math.abs(fistExt.cp1.x - M.x);
-        Math.abs(fistExt.cp1.y - M.y);
-
         let comEx = getCombinedByDominant(penultimateCom, lastCom, threshold, tolerance, false);
-        console.log('comEx', comEx);
 
         if (comEx.length === 1) {
             pathData[lastIdx - 1] = comEx[0];
@@ -4518,7 +4530,7 @@ function cleanUpSVG(svgMarkup, {
     .querySelector("svg");
   
   
-  let allowed=['viewBox', 'xmlns', 'width', 'height', 'id', 'class', 'fill', 'stroke', 'stroke-width'];
+  let allowed=['viewBox', 'xmlns', 'width', 'height', 'id', 'class', 'fill', 'stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin'];
   removeExcludedAttribues(svg, allowed);
   
   let removeEls = ['metadata', 'script'];
@@ -4589,6 +4601,156 @@ function stringifySVG(svg){
   return markup
 }
 
+function refineRoundedCorners(pathData, {
+    threshold = 0,
+    tolerance = 1
+} = {}) {
+
+    let l = pathData.length;
+
+    // add fist command
+    let pathDataN = [pathData[0]];
+
+    let isClosed = pathData[l - 1].type.toLowerCase() === 'z';
+    let lastOff = isClosed ? 2 : 1;
+
+    let comLast = pathData[l - lastOff];
+    let lastIsLine = comLast.type === 'L';
+    let lastIsBez = comLast.type === 'C';
+    let firstIsLine = pathData[1].type === 'L';
+    let firstIsBez = pathData[1].type === 'C';
+
+    let normalizeClose = isClosed && firstIsBez;
+
+    // normalize closepath to lineto
+    if (normalizeClose) {
+        pathData[l - 1].values = pathData[0].values;
+        pathData[l - 1].type = 'L';
+        lastIsLine = true;
+    }
+
+    for (let i = 1; i < l; i++) {
+        let com = pathData[i];
+        let { type } = com;
+        let comN = pathData[i + 1] ? pathData[i + 1] : null;
+
+        // search small cubic segments enclosed by linetos
+        if ((type === 'L' && comN && comN.type === 'C') ||
+            (type === 'C' && comN && comN.type === 'L')
+
+        ) {
+            let comL0 = com;
+            let comL1 = null;
+            let comBez = [];
+            let offset = 0;
+
+            // start to end
+            if (i === 1 && firstIsBez && lastIsLine) {
+                comBez = [pathData[1]];
+                comL0 = pathData[l - 1];
+                comL1 = comN;
+
+            }
+
+            // closing corner to start
+            if (isClosed && lastIsBez && firstIsLine && i === l - lastOff - 1) {
+                comL1 = pathData[1];
+                comBez = [pathData[l - lastOff]];
+
+            }
+
+            for (let j = i + 1; j < l; j++) {
+                let comN = pathData[j] ? pathData[j] : null;
+                let comPrev = pathData[j - 1];
+
+                if (comPrev.type === 'C') {
+                    comBez.push(comPrev);
+                }
+
+                if (comN.type === 'L' && comPrev.type === 'C') {
+                    comL1 = comN;
+                    break;
+                }
+                offset++;
+            }
+
+            if (comL1) {
+
+                // linetos
+                let len1 = getDistAv(comL0.p0, comL0.p);
+                let len2 = getDistAv(comL1.p0, comL1.p);
+
+                // bezier
+
+                let comBezLen = comBez.length;
+                let len3 = getDistAv(comBez[0].p0, comBez[comBezLen - 1].p);
+
+                // check concaveness by area sign change
+                let area1 = getPolygonArea([comL0.p0, comL0.p, comL1.p0, comL1.p], false);
+                let area2 = getPolygonArea([comBez[0].p0, comBez[0].cp1, comBez[0].cp2, comBez[0].p], false);
+
+                let signChange = (area1 < 0 && area2 > 0) || (area1 > 0 && area2 < 0);
+
+                if (comBez && !signChange && len3 < threshold && len1 > len3 && len2 > len3) {
+
+                    let ptQ = checkLineIntersection(comL0.p0, comL0.p, comL1.p0, comL1.p, false);
+                    if (ptQ) {
+
+                        /*
+                        let dist1 = getDistAv(ptQ, comL0.p)
+                        let dist2 = getDistAv(ptQ, comL1.p0)
+                        let diff = Math.abs(dist1-dist2)
+                        let rat =  diff/Math.max(dist1, dist2)
+                        console.log('rat', rat);
+                        */
+
+                        /*
+                        // adjust curve start and end to meet original
+                        let t = 1
+
+                        let p0_2 = pointAtT([ptQ, comL0.p], t)
+
+                        comL0.p = p0_2
+                        comL0.values = [p0_2.x, p0_2.y]
+
+                        let p_2 = pointAtT([ptQ, comL1.p0], t)
+
+                        comL1.p0 = p_2
+
+                        */
+
+                        let comQ = { type: 'Q', values: [ptQ.x, ptQ.y, comL1.p0.x, comL1.p0.y] };
+                        comQ.p0 = comL0.p;
+                        comQ.cp1 = ptQ;
+                        comQ.p = comL1.p0;
+
+                        // add quadratic command
+                        pathDataN.push(comL0, comQ);
+                        i += offset;
+                        continue;
+                    }
+                }
+            }
+        }
+
+        // skip last lineto
+        if (normalizeClose && i === l - 1 && type === 'L') {
+            continue
+        }
+
+        pathDataN.push(com);
+
+    }
+
+    // revert close path normalization
+    if (normalizeClose) {
+        pathDataN.push({ type: 'Z', values: [] });
+    }
+
+    return pathDataN;
+
+}
+
 function svgPathSimplify(input = '', {
 
     // return svg markup or object
@@ -4607,11 +4769,14 @@ function svgPathSimplify(input = '', {
 
     simplifyBezier = true,
     optimizeOrder = true,
+    removeZeroLength = true,
     removeColinear = true,
     flatBezierToLinetos = true,
     revertToQuadratics = true,
 
     refineExtremes = true,
+    refineCorners = false, 
+
     keepExtremes = true,
     keepCorners = true,
     extrapolateDominant = true,
@@ -4656,27 +4821,38 @@ function svgPathSimplify(input = '', {
      */
 
     // original size
-    svgSize = new Blob([input]).size;
 
-    // single path
+    svgSize = input.length;
+
+    // mode:0 – single path
     if (!mode) {
         if (inputType === 'pathDataString') {
             d = input;
         } else if (inputType === 'polyString') {
             d = 'M' + input;
         }
+        else if (inputType === 'pathData') {
+            d = input;
+
+            // stringify to compare lengths
+
+            let dStr = d.map(com=>{return `${com.type} ${com.values.join(' ')}`}).join(' ') ;
+            svgSize = dStr.length;
+
+        }
+
         paths.push({ d, el: null });
     }
-    // process svg
+    // mode:1 – process complete svg DOM
     else {
 
         let returnDom = true;
         svg = cleanUpSVG(input, { returnDom, removeHidden, removeUnused }
         );
 
-        if(shapesToPaths){
+        if (shapesToPaths) {
             let shapes = svg.querySelectorAll('polygon, polyline, line, rect, circle, ellipse');
-            shapes.forEach(shape=>{
+            shapes.forEach(shape => {
                 let path = shapeElToPath(shape);
                 shape.replaceWith(path);
             });
@@ -4691,6 +4867,7 @@ function svgPathSimplify(input = '', {
 
     /**
      * process all paths
+     * try simplifications and removals
      */
 
     // SVG optimization options
@@ -4703,37 +4880,35 @@ function svgPathSimplify(input = '', {
     // combinded path data for SVGs with mergePaths enabled
     let pathData_merged = [];
 
-    paths.forEach(path => {
+    for (let i = 0, l = paths.length; l && i < l; i++) {
+
+        let path = paths[i];
         let { d, el } = path;
 
-        let pathDataO = parsePathDataNormalized(d, { quadraticToCubic, toAbsolute, arcToCubic });
+        let pathData = parsePathDataNormalized(d, { quadraticToCubic, toAbsolute, arcToCubic });
 
         // count commands for evaluation
-        let comCount = pathDataO.length;
-
-        // create clone for fallback
-
-        let pathData = pathDataO;
+        let comCount = pathData.length;
 
-        if(removeOrphanSubpaths) pathData = removeOrphanedM(pathData);
+        if (removeOrphanSubpaths) pathData = removeOrphanedM(pathData);
 
         /**
          * get sub paths
          */
         let subPathArr = splitSubpaths(pathData);
+        let lenSub = subPathArr.length;
 
         // cleaned up pathData
-        let pathDataArrN = [];
 
-        for (let i = 0, l = subPathArr.length; i < l; i++) {
+        // reset array
+        let pathDataFlat = [];
 
-            let pathDataSub = subPathArr[i];
+        for (let i = 0; i < lenSub; i++) {
 
-            // try simplification in reversed order
-            if (reverse) pathDataSub = reversePathData(pathDataSub);
+            let pathDataSub = subPathArr[i];
 
             // remove zero length linetos
-            if (removeColinear) pathDataSub = removeZeroLengthLinetos(pathDataSub);
+            if (removeColinear || removeZeroLength) pathDataSub = removeZeroLengthLinetos(pathDataSub);
 
             // add extremes
 
@@ -4743,56 +4918,63 @@ function svgPathSimplify(input = '', {
             // sort to top left
             if (optimizeOrder) pathDataSub = pathDataToTopLeft(pathDataSub);
 
-            // remove colinear/flat
-            if (removeColinear) pathDataSub = pathDataRemoveColinear(pathDataSub, tolerance, flatBezierToLinetos);
+            // Preprocessing: remove colinear - ignore flat beziers (removed later)
+            if (removeColinear) pathDataSub = pathDataRemoveColinear(pathDataSub, { tolerance, flatBezierToLinetos: false });
 
             // analyze pathdata to add info about signicant properties such as extremes, corners
             let pathDataPlus = analyzePathData(pathDataSub);
 
             // simplify beziers
             let { pathData, bb, dimA } = pathDataPlus;
-
             pathData = simplifyBezier ? simplifyPathDataCubic(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance, reverse }) : pathData;
 
             // refine extremes
-            if(refineExtremes){
+            if (refineExtremes) {
                 let thresholdEx = (bb.width + bb.height) / 2 * 0.05;
-                pathData = refineAdjacentExtremes(pathData, {threshold:thresholdEx, tolerance});
+                pathData = refineAdjacentExtremes(pathData, { threshold: thresholdEx, tolerance });
             }
 
             // cubic to arcs
             if (cubicToArc) {
 
-                let thresh = 3;
+                let thresh = 1;
 
-                pathData.forEach((com, c) => {
+                for(let c=0, l=pathData.length; c<l; c++){
+                    let com = pathData[c];
                     let { type, values, p0, cp1 = null, cp2 = null, p = null } = com;
                     if (type === 'C') {
 
                         let comA = cubicCommandToArc(p0, cp1, cp2, p, thresh);
                         if (comA.isArc) pathData[c] = comA.com;
-
                     }
-                });
+                }
 
                 // combine adjacent cubics
                 pathData = combineArcs(pathData);
 
             }
 
+            // post processing: remove flat beziers
+            if (removeColinear && flatBezierToLinetos) {
+                pathData = pathDataRemoveColinear(pathData, { tolerance, flatBezierToLinetos });
+            }
+
+            // refine corners
+            if(refineCorners){
+                let threshold = (bb.width + bb.height) / 2 * 0.1;
+                pathData = refineRoundedCorners(pathData, { threshold, tolerance });
+
+            }
+
             // simplify to quadratics
             if (revertToQuadratics) {
-                pathData.forEach((com, c) => {
+                for(let c=0, l=pathData.length; c<l; c++){
+                    let com = pathData[c];
                     let { type, values, p0, cp1 = null, cp2 = null, p = null } = com;
                     if (type === 'C') {
 
                         let comQ = revertCubicQuadratic(p0, cp1, cp2, p);
                         if (comQ.type === 'Q') {
-                            /*
-                            comQ.p0 = com.p0
-                            comQ.cp1 = {x:comQ.values[0], y:comQ.values[1]}
-                            comQ.p = com.p
-                            */
                             comQ.extreme = com.extreme;
                             comQ.corner = com.corner;
                             comQ.dimA = com.dimA;
@@ -4800,20 +4982,25 @@ function svgPathSimplify(input = '', {
                             pathData[c] = comQ;
                         }
                     }
-                });
+                }
             }
 
             // optimize close path
             if (optimizeOrder) pathData = optimizeClosePath(pathData);
 
-            // poly
-
             // update
-            pathDataArrN.push(pathData);
+            pathDataFlat.push(...pathData);
+
         }
 
         // flatten compound paths 
-        pathData = pathDataArrN.flat();
+        pathData = pathDataFlat;
+
+        if (autoAccuracy) {
+            decimals = detectAccuracy(pathData);
+            pathOptions.decimals = decimals;
+
+        }
 
         // collect for merged svg paths 
         if (el && mergePaths) {
@@ -4822,15 +5009,6 @@ function svgPathSimplify(input = '', {
         // single output
         else {
 
-            /**
-             * detect accuracy
-             */
-            if (autoAccuracy) {
-                decimals = detectAccuracy(pathData);
-                pathOptions.decimals = decimals;
-
-            }
-
             // optimize path data
             pathData = convertPathData(pathData, pathOptions);
 
@@ -4841,7 +5019,9 @@ function svgPathSimplify(input = '', {
             let comCountS = pathData.length;
 
             let dOpt = pathDataToD(pathData, minifyD);
-            svgSizeOpt = new Blob([dOpt]).size;
+
+            svgSizeOpt = dOpt.length;
+
             compression = +(100 / svgSize * (svgSizeOpt)).toFixed(2);
 
             path.d = dOpt;
@@ -4857,19 +5037,18 @@ function svgPathSimplify(input = '', {
             // apply new path for svgs
             if (el) el.setAttribute('d', dOpt);
         }
-    });
-
+    }
     /**
      *  stringify new SVG
      */
     if (mode) {
 
         if (pathData_merged.length) {
+
             // optimize path data
             let pathData = convertPathData(pathData_merged, pathOptions);
 
             // remove zero-length segments introduced by rounding
-
             pathData = removeZeroLengthLinetos(pathData);
 
             let dOpt = pathDataToD(pathData, minifyD);
@@ -4888,7 +5067,8 @@ function svgPathSimplify(input = '', {
         }
 
         svg = stringifySVG(svg);
-        svgSizeOpt = new Blob([svg]).size;
+
+        svgSizeOpt = svg.length;
 
         compression = +(100 / svgSize * (svgSizeOpt)).toFixed(2);
 
@@ -4909,104 +5089,6 @@ function svgPathSimplify(input = '', {
 
 }
 
-function simplifyPathDataCubic(pathData, {
-    keepExtremes = true,
-    keepInflections = true,
-    keepCorners = true,
-    extrapolateDominant = true,
-    tolerance = 1,
-    reverse = false
-} = {}) {
-
-    let pathDataN = [pathData[0]];
-
-    for (let i = 2, l = pathData.length; l && i <= l; i++) {
-        let com = pathData[i - 1];
-        let comN = i < l ? pathData[i] : null;
-        let typeN = comN?.type || null;
-
-        let isDirChange = com?.directionChange || null;
-        let isDirChangeN = comN?.directionChange || null;
-
-        let { type, values, p0, p, cp1 = null, cp2 = null, extreme = false, corner = false, dimA = 0 } = com;
-
-        // next is also cubic
-        if (type === 'C' && typeN === 'C') {
-
-            // cannot be combined as crossing extremes or corners
-            if (
-                (keepInflections && isDirChangeN) ||
-                (keepCorners && corner) ||
-                (!isDirChange && keepExtremes && extreme)
-            ) {
-
-                pathDataN.push(com);
-            }
-
-            // try simplification
-            else {
-
-                let combined = combineCubicPairs(com, comN, extrapolateDominant, tolerance);
-                let error = 0;
-
-                // combining successful! try next segment
-                if (combined.length === 1) {
-                    com = combined[0];
-                    let offset = 1;
-
-                    // add cumulative error to prevent distortions
-                    error += com.error;
-
-                    // find next candidates
-                    for (let n = i + 1; error < tolerance && n < l; n++) {
-                        let comN = pathData[n];
-                        if (comN.type !== 'C' ||
-                            (
-                                (keepInflections && comN.directionChange) ||
-                                (keepCorners && com.corner) ||
-                                (keepExtremes && com.extreme)
-                            )
-                        ) {
-                            break
-                        }
-
-                        let combined = combineCubicPairs(com, comN, extrapolateDominant, tolerance);
-                        if (combined.length === 1) {
-                            // add cumulative error to prevent distortions
-
-                            error += combined[0].error * 0.5;
-
-                            offset++;
-                        }
-                        com = combined[0];
-                    }
-
-                    pathDataN.push(com);
-
-                    if (i < l) {
-                        i += offset;
-                    }
-
-                } else {
-                    pathDataN.push(com);
-                }
-            }
-
-        } // end of bezier command
-
-        // other commands
-        else {
-            pathDataN.push(com);
-        }
-
-    } // end command loop
-
-    // reverse back
-    if (reverse) pathDataN = reversePathData(pathDataN);
-
-    return pathDataN
-}
-
 const {
     abs, acos, asin, atan, atan2, ceil, cos, exp, floor,
     log, hypot, max, min, pow, random, round, sin, sqrt, tan, PI