svg-path-simplify 0.0.8 → 0.0.9

package/dist/svg-path-simplify.js

@@ -50,23 +50,29 @@
       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 {
@@ -775,27 +781,23 @@
    * 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;
   }
@@ -1479,13 +1481,6 @@
       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 ? ' ' : '';
@@ -1507,13 +1502,11 @@
           }
 
           // 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) {
@@ -1663,6 +1656,7 @@
           cp1: Q1,
           cp2: Q2,
           p: Q3,
+          t0
       };
 
       if (reverse) {
@@ -1671,6 +1665,7 @@
               cp1: Q2,
               cp2: Q1,
               p: Q0,
+              t0
           };
       }
 
@@ -1682,8 +1677,8 @@
       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);
@@ -1715,14 +1710,24 @@
       // 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;
           }
@@ -1761,21 +1766,122 @@
 
   }
 
-  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);
@@ -1786,12 +1892,6 @@
       // collect error data
       let error = dist0;
 
-      /*
-      if (com2.directionChange) {
-
-      }
-      */
-
       if (close) {
 
           /**
@@ -1837,29 +1937,9 @@
 
       } // 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;
@@ -1882,26 +1962,23 @@
       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) {
@@ -1914,52 +1991,40 @@
       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 = []) {
@@ -2075,14 +2140,17 @@
               commandPts.push(p);
 
               /*
+
               let commandFlatness = commandIsFlat(commandPts);
               isFlat = commandFlatness.flat;
               com.flat = isFlat;
 
               if (isFlat) {
                   com.extreme = false;
+
               }
               */
+
           }
 
           /**
@@ -2192,7 +2260,7 @@
       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++) {
@@ -2205,7 +2273,7 @@
           // 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;
@@ -2213,7 +2281,7 @@
           p0 = p;
       }
 
-      let dim_min = Array.from(dims).sort();
+      let dim_min = dims.sort();
 
       /*
       let minVal = dim_min.length > 15 ?
@@ -2239,19 +2307,24 @@
    * 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 = {}) {
@@ -2269,7 +2342,7 @@
       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) {
 
@@ -2294,9 +2367,10 @@
       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
   }
 
@@ -2598,7 +2672,7 @@
    * 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
@@ -2609,29 +2683,28 @@
           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];
@@ -2679,7 +2752,8 @@
                   if (typePrev !== 'Q') {
 
                       p0 = { x: valuesLast[0], y: valuesLast[1] };
-                      pathDataShorts.push(com);
+
+                      pathDataShorts[i] = com;
                       continue;
                   }
 
@@ -2708,7 +2782,8 @@
 
                   if (typePrev !== 'C') {
 
-                      pathDataShorts.push(com);
+                      pathDataShorts[i] = com;
+
                       p0 = { x: valuesLast[0], y: valuesLast[1] };
                       continue;
                   }
@@ -2750,8 +2825,10 @@
           }
 
           p0 = { x: valuesLast[0], y: valuesLast[1] };
-          pathDataShorts.push(comShort);
+          pathDataShorts[i] = comShort;
+
       }
+
       return pathDataShorts;
   }
 
@@ -3196,10 +3273,10 @@
           quadraticToCubic = false,
           arcToCubic = false,
           arcAccuracy = 2,
-      } = {},
 
-      {
+          // assume we need full normalization
           hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true, testTypes = false
+
       } = {}
   ) {
 
@@ -3250,15 +3327,28 @@
       } = {}
   ) {
 
-      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;
@@ -3610,7 +3700,8 @@
           if (debug === 'log') {
               console.log(feedback);
           } else {
-              throw new Error(feedback)
+
+              console.warn(feedback);
           }
       }
 
@@ -3642,22 +3733,22 @@
       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);
           }
@@ -3668,7 +3759,7 @@
   }
 
   // retrieve pathdata from svg geometry elements
-  function getPathDataFromEl(el, stringify=false) {
+  function getPathDataFromEl(el, stringify = false) {
 
       let pathData = [];
       let type = el.nodeName;
@@ -3826,7 +3917,9 @@
               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;
@@ -3835,10 +3928,14 @@
                   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;
@@ -3870,22 +3967,28 @@
               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;
@@ -3894,11 +3997,9 @@
 
           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;
@@ -3912,31 +4013,38 @@
               [{ 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;
@@ -3957,6 +4065,7 @@
 
   function removeOrphanedM(pathData) {
 
+      let pathDataN = [];
       for (let i = 0, l = pathData.length; i < l; i++) {
           let com = pathData[i];
           if (!com) continue;
@@ -3965,14 +4074,14 @@
           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;
 
   }
 
@@ -4003,19 +4112,23 @@
 
       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
           } 
@@ -4117,7 +4230,7 @@
           }
           // 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;
           }
 
@@ -4125,7 +4238,7 @@
           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;
 
@@ -4239,149 +4352,61 @@
       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) {
 
@@ -4394,11 +4419,23 @@
                   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;
@@ -4407,6 +4444,8 @@
                       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;
                       }
@@ -4424,35 +4463,12 @@
 
                   }
 
-                  // 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
@@ -4479,11 +4495,7 @@
 
       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];
@@ -4519,7 +4531,7 @@
       .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'];
@@ -4590,6 +4602,156 @@
     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
@@ -4608,11 +4770,14 @@
 
       simplifyBezier = true,
       optimizeOrder = true,
+      removeZeroLength = true,
       removeColinear = true,
       flatBezierToLinetos = true,
       revertToQuadratics = true,
 
       refineExtremes = true,
+      refineCorners = false, 
+
       keepExtremes = true,
       keepCorners = true,
       extrapolateDominant = true,
@@ -4657,27 +4822,38 @@
        */
 
       // 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);
               });
@@ -4692,6 +4868,7 @@
 
       /**
        * process all paths
+       * try simplifications and removals
        */
 
       // SVG optimization options
@@ -4704,37 +4881,35 @@
       // 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
 
@@ -4744,56 +4919,63 @@
               // 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;
@@ -4801,20 +4983,25 @@
                               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) {
@@ -4823,15 +5010,6 @@
           // single output
           else {
 
-              /**
-               * detect accuracy
-               */
-              if (autoAccuracy) {
-                  decimals = detectAccuracy(pathData);
-                  pathOptions.decimals = decimals;
-
-              }
-
               // optimize path data
               pathData = convertPathData(pathData, pathOptions);
 
@@ -4842,7 +5020,9 @@
               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;
@@ -4858,19 +5038,18 @@
               // 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);
@@ -4889,7 +5068,8 @@
           }
 
           svg = stringifySVG(svg);
-          svgSizeOpt = new Blob([svg]).size;
+
+          svgSizeOpt = svg.length;
 
           compression = +(100 / svgSize * (svgSizeOpt)).toFixed(2);
 
@@ -4910,104 +5090,6 @@
 
   }
 
-  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