svg-path-simplify 0.0.5 → 0.0.8

package/dist/svg-path-simplify.js

@@ -28,14 +28,28 @@
       }
   }
 
+  function renderPath(svg, d = '', stroke = 'green', strokeWidth = '1%', render = true) {
+
+      let path = `<path d="${d}" fill="none" stroke="${stroke}"  stroke-width="${strokeWidth}" /> `;
+
+      if (render) {
+          svg.insertAdjacentHTML("beforeend", path);
+      } else {
+          return path;
+      }
+
+  }
+
   function detectInputType(input) {
       let type = 'string';
+      /*
       if (input instanceof HTMLImageElement) return "img";
       if (input instanceof SVGElement) return "svg";
       if (input instanceof HTMLCanvasElement) return "canvas";
       if (input instanceof File) return "file";
       if (input instanceof ArrayBuffer) return "buffer";
       if (input instanceof Blob) return "blob";
+      */
       if (Array.isArray(input)) return "array";
 
       if (typeof input === "string") {
@@ -93,19 +107,24 @@
    * http://jsfiddle.net/justin_c_rounds/Gd2S2/light/
    */
 
-  function checkLineIntersection(p1, p2, p3, p4, exact = true) {
+  function checkLineIntersection(p1=null, p2=null, p3=null, p4=null, exact = true, debug=false) {
       // if the lines intersect, the result contains the x and y of the intersection (treating the lines as infinite) and booleans for whether line segment 1 or line segment 2 contain the point
       let denominator, a, b, numerator1, numerator2;
       let intersectionPoint = {};
 
+      if(!p1 || !p2 || !p3 || !p4){
+          if(debug) console.warn('points missing');
+          return false
+      }
+
       try {
           denominator = ((p4.y - p3.y) * (p2.x - p1.x)) - ((p4.x - p3.x) * (p2.y - p1.y));
           if (denominator == 0) {
               return false;
           }
-
       } catch {
-          console.log('!catch', p1, p2, 'p3:', p3, p4);
+          if(debug) console.warn('!catch', p1, p2, 'p3:', p3, 'p4:', p4);
+          return false
       }
 
       a = p1.y - p3.y;
@@ -122,8 +141,6 @@
           y: p1.y + (a * (p2.y - p1.y))
       };
 
-      // console.log('intersectionPoint', intersectionPoint, p1, p2);
-
       let intersection = false;
       // if line1 is a segment and line2 is infinite, they intersect if:
       if ((a > 0 && a < 1) && (b > 0 && b < 1)) {
@@ -523,6 +540,110 @@
       return tArr;
   }
 
+  /**
+   * based on Nikos M.'s answer
+   * how-do-you-calculate-the-axis-aligned-bounding-box-of-an-ellipse
+   * https://stackoverflow.com/questions/87734/#75031511
+   * See also: https://github.com/foo123/Geometrize
+   */
+  function getArcExtemes(p0, values) {
+      // compute point on ellipse from angle around ellipse (theta)
+      const arc = (theta, cx, cy, rx, ry, alpha) => {
+          // theta is angle in radians around arc
+          // alpha is angle of rotation of ellipse in radians
+          var cos = Math.cos(alpha),
+              sin = Math.sin(alpha),
+              x = rx * Math.cos(theta),
+              y = ry * Math.sin(theta);
+
+          return {
+              x: cx + cos * x - sin * y,
+              y: cy + sin * x + cos * y
+          };
+      };
+
+      let arcData = svgArcToCenterParam(p0.x, p0.y, values[0], values[1], values[2], values[3], values[4], values[5], values[6]);
+      let { rx, ry, cx, cy, endAngle, deltaAngle } = arcData;
+
+      // arc rotation
+      let deg = values[2];
+
+      // final on path point
+      let p = { x: values[5], y: values[6] };
+
+      // collect extreme points – add end point
+      let extremes = [p];
+
+      // rotation to radians
+      let alpha = deg * Math.PI / 180;
+      let tan = Math.tan(alpha),
+          p1, p2, p3, p4, theta;
+
+      /**
+      * find min/max from zeroes of directional derivative along x and y
+      * along x axis
+      */
+      theta = Math.atan2(-ry * tan, rx);
+
+      let angle1 = theta;
+      let angle2 = theta + Math.PI;
+      let angle3 = Math.atan2(ry, rx * tan);
+      let angle4 = angle3 + Math.PI;
+
+      // inner bounding box
+      let xArr = [p0.x, p.x];
+      let yArr = [p0.y, p.y];
+      let xMin = Math.min(...xArr);
+      let xMax = Math.max(...xArr);
+      let yMin = Math.min(...yArr);
+      let yMax = Math.max(...yArr);
+
+      // on path point close after start
+      let angleAfterStart = endAngle - deltaAngle * 0.001;
+      let pP2 = arc(angleAfterStart, cx, cy, rx, ry, alpha);
+
+      // on path point close before end
+      let angleBeforeEnd = endAngle - deltaAngle * 0.999;
+      let pP3 = arc(angleBeforeEnd, cx, cy, rx, ry, alpha);
+
+      /**
+       * expected extremes
+       * if leaving inner bounding box
+       * (between segment start and end point)
+       * otherwise exclude elliptic extreme points
+      */
+
+      // right
+      if (pP2.x > xMax || pP3.x > xMax) {
+          // get point for this theta
+          p1 = arc(angle1, cx, cy, rx, ry, alpha);
+          extremes.push(p1);
+      }
+
+      // left
+      if (pP2.x < xMin || pP3.x < xMin) {
+          // get anti-symmetric point
+          p2 = arc(angle2, cx, cy, rx, ry, alpha);
+          extremes.push(p2);
+      }
+
+      // top
+      if (pP2.y < yMin || pP3.y < yMin) {
+          // get anti-symmetric point
+          p4 = arc(angle4, cx, cy, rx, ry, alpha);
+          extremes.push(p4);
+      }
+
+      // bottom
+      if (pP2.y > yMax || pP3.y > yMax) {
+          // get point for this theta
+          p3 = arc(angle3, cx, cy, rx, ry, alpha);
+          extremes.push(p3);
+      }
+
+      return extremes;
+  }
+
   // cubic bezier.
   function cubicBezierExtremeT(p0, cp1, cp2, p) {
       let [x0, y0, x1, y1, x2, y2, x3, y3] = [p0.x, p0.y, cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
@@ -631,90 +752,6 @@
       return extemeT
   }
 
-  function commandIsFlat(points, tolerance = 0.025) {
-
-      let p0 = points[0];
-      let p = points[points.length - 1];
-
-      let xArr = points.map(pt => { return pt.x });
-      let yArr = points.map(pt => { return pt.y });
-
-      let xMin = Math.min(...xArr);
-      let xMax = Math.max(...xArr);
-      let yMin = Math.min(...yArr);
-      let yMax = Math.max(...yArr);
-      let w = xMax - xMin;
-      let h = yMax - yMin;
-
-      if (points.length < 3 || (w === 0 || h === 0)) {
-          return { area: 0, flat: true, thresh: 0.0001, ratio: 0 };
-      }
-
-      let squareDist = getSquareDistance(p0, p);
-      let squareDist1 = getSquareDistance(p0, points[0]);
-      let squareDist2 = points.length > 3 ? getSquareDistance(p, points[1]) : squareDist1;
-      let squareDistAvg = (squareDist1 + squareDist2) / 2;
-
-      tolerance = 0.5;
-      let thresh = (w + h) * 0.5 * tolerance;
-
-      let area = 0;
-      for (let i = 0, l = points.length; i < l; i++) {
-          let addX = points[i].x;
-          let addY = points[i === points.length - 1 ? 0 : i + 1].y;
-          let subX = points[i === points.length - 1 ? 0 : i + 1].x;
-          let subY = points[i].y;
-          area += addX * addY * 0.5 - subX * subY * 0.5;
-      }
-
-      area = +Math.abs(area).toFixed(9);
-      let areaThresh = 1000;
-
-      let ratio = area / (squareDistAvg);
-
-      let isFlat = area === 0 ? true : area < squareDistAvg / areaThresh;
-
-      return { area: area, flat: isFlat, thresh: thresh, ratio: ratio, squareDist: squareDist, areaThresh: squareDist / areaThresh };
-  }
-
-  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);
-
-      if(!cross1) return true
-
-      let dx0 = p.x - p0.x;
-      let dy0 = p.y - p0.y;
-      let cross0 = Math.abs(dx0 * dy1 - dy0 * dx1);
-
-      if(!cross0) return true
-
-      let rat = (cross0/cross1);
-
-      if (rat<1.1 ) {
-
-          isFlat = true;
-      }
-
-      return isFlat;
-
-  }
-
   /**
    * sloppy distance calculation
    * based on x/y differences
@@ -885,6 +922,7 @@
 
           if(tArr.length){
               let commandsSplit = splitCommandAtTValues(p0, values, tArr);
+
               pathDataNew.push(...commandsSplit);
               extremeCount += commandsSplit.length;
           }else {
@@ -1181,6 +1219,73 @@
       return poly;
   }
 
+  /**
+   * get exact path BBox
+   * calculating extremes for all command types
+   */
+
+  function getPathDataBBox(pathData) {
+
+      // save extreme values
+      let xMin = Infinity;
+      let xMax = -Infinity;
+      let yMin = Infinity;
+      let yMax = -Infinity;
+
+      const setXYmaxMin = (pt) => {
+          if (pt.x < xMin) {
+              xMin = pt.x;
+          }
+          if (pt.x > xMax) {
+              xMax = pt.x;
+          }
+          if (pt.y < yMin) {
+              yMin = pt.y;
+          }
+          if (pt.y > yMax) {
+              yMax = pt.y;
+          }
+      };
+
+      for (let i = 0; i < pathData.length; i++) {
+          let com = pathData[i];
+          let { type, values } = com;
+          let valuesL = values.length;
+          let comPrev = pathData[i - 1] ? pathData[i - 1] : pathData[i];
+          let valuesPrev = comPrev.values;
+          let valuesPrevL = valuesPrev.length;
+
+          if (valuesL) {
+              let p0 = { x: valuesPrev[valuesPrevL - 2], y: valuesPrev[valuesPrevL - 1] };
+              let p = { x: values[valuesL - 2], y: values[valuesL - 1] };
+              // add final on path point
+              setXYmaxMin(p);
+
+              if (type === 'C' || type === 'Q') {
+                  let cp1 = { x: values[0], y: values[1] };
+                  let cp2 = type === 'C' ? { x: values[2], y: values[3] } : cp1;
+                  let pts = type === 'C' ? [p0, cp1, cp2, p] : [p0, cp1, p];
+
+                  let bezierExtremesT = getBezierExtremeT(pts);
+                  bezierExtremesT.forEach(t => {
+                      let pt = pointAtT(pts, t);
+                      setXYmaxMin(pt);
+                  });
+              }
+
+              else if (type === 'A') {
+                  let arcExtremes = getArcExtemes(p0, values);
+                  arcExtremes.forEach(pt => {
+                      setXYmaxMin(pt);
+                  });
+              }
+          }
+      }
+
+      let bbox = { x: xMin, y: yMin, width: xMax - xMin, height: yMax - yMin };
+      return bbox
+  }
+
   /**
    * get pathdata area
    */
@@ -1456,7 +1561,7 @@
       return d;
   }
 
-  function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
+  function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, debug = false) {
 
       // cubic Bézier derivative
       const cubicDerivative = (p0, p1, p2, p3, t) => {
@@ -1478,8 +1583,9 @@
       let commands = [com1, com2];
 
       // detect dominant 
-      let dist1 = getSquareDistance(com1.p0, com1.p);
-      let dist2 = getSquareDistance(com2.p0, com2.p);
+      let dist1 = getDistAv(com1.p0, com1.p);
+      let dist2 = getDistAv(com2.p0, com2.p);
+
       let reverse = dist1 > dist2;
 
       // backup original commands
@@ -1541,7 +1647,6 @@
       t0 -= dot(r, dP) / dot(dP, dP);
 
       // construct merged cubic over [t0, 1]
-
       let Q0 = pointAtT([com2.p0, com2.cp1, com2.cp2, com2.p], t0);
       let Q3 = com2.p;
 
@@ -1569,7 +1674,9 @@
           };
       }
 
-      let ptM = pointAtT([result.p0, result.cp1, result.cp2, result.p], 0.5, false, true);
+      let tMid = (1 - t0) * 0.5;
+
+      let ptM = pointAtT([result.p0, result.cp1, result.cp2, result.p], tMid, false, true);
       let seg1_cp2 = ptM.cpts[2];
 
       let ptI_1 = checkLineIntersection(ptM, seg1_cp2, result.p0, ptI, false);
@@ -1579,17 +1686,18 @@
       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 );
-      if(cp_intersection){
+      let cp_intersection = checkLineIntersection(com1_o.p0, cp1_2, com2_o.p, cp2_2, true);
+      if (cp_intersection) {
 
           return commands;
       }
 
+      if (debug) renderPoint(markers, ptM, 'purple');
+
       result.cp1 = cp1_2;
       result.cp2 = cp2_2;
 
-      // check distances
-
+      // check distances between original starting point and extrapolated
       let dist3 = getDistAv(com1_o.p0, result.p0);
       let dist4 = getDistAv(com2_o.p, result.p);
       let dist5 = (dist3 + dist4);
@@ -1601,11 +1709,24 @@
       result.corner = com2_o.corner;
       result.dimA = com2_o.dimA;
       result.directionChange = com2_o.directionChange;
+      result.type = 'C';
       result.values = [result.cp1.x, result.cp1.y, result.cp2.x, result.cp2.y, result.p.x, result.p.y];
 
-      // check if completely off
+      // extrapolated starting point is not completely off
       if (dist5 < maxDist) {
 
+          // split t to meet original mid segment start point
+          let tSplit = reverse ? 1 + t0 : Math.abs(t0);
+
+          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) {
+
+              return commands;
+          }
+
           // compare combined with original area
           let pathData0 = [
               { type: 'M', values: [com1_o.p0.x, com1_o.p0.y] },
@@ -1622,16 +1743,18 @@
           let areaN = getPathArea(pathDataN);
           let areaDiff = Math.abs(areaN / area0 - 1);
 
-          result.error = areaDiff * 10 * tolerance;
+          result.error = areaDiff * 5 * tolerance;
 
-          pathDataToD(pathDataN);
+          if (debug) {
+              let d = pathDataToD(pathDataN);
+              renderPath(markers, d, 'orange');
+          }
 
-          // success
-          if (areaDiff < 0.01) {
+          // success!!!
+          if (areaDiff < 0.05 * tolerance) {
               commands = [result];
 
-          }
-
+          } 
       }
 
       return commands
@@ -1715,14 +1838,6 @@
       } // end 1st try
 
       
-      /*
-      if (extrapolateDominant && com2.extreme) {
-          renderPoint(markers, com2.p)
-
-      }
-      */
-
-      
 
       // try extrapolated dominant curve
 
@@ -1791,25 +1906,59 @@
 
   function findSplitT(com1, com2) {
 
-      // control tangent intersection
-      let pt1 = checkLineIntersection(com1.p0, com1.cp1, com2.cp2, com2.p, false);
+      let len3 = getDistance(com1.cp2, com1.p);
+      let len4 = getDistance(com1.cp2, com2.cp1);
 
-      // intersection 2nd cp1 tangent and global tangent intersection
-      let ptI = checkLineIntersection(pt1, com2.p, com2.p0, com2.cp1, false);
+      let t = Math.min(len3) / len4;
 
-      let len1 = getDistance(pt1, com2.p);
-      let len2 = getDistance(ptI, com2.p);
+      return t
+  }
 
-      let t = 1 - len2 / len1;
+  function checkBezierFlatness(p0, cpts, p) {
 
-      // check self intersections
+      let isFlat = false;
 
-      let len3 = getDistance(com1.cp2, com1.p);
-      let len4 = getDistance(com1.cp2, com2.cp1);
+      let isCubic = cpts.length === 2;
 
-      t = Math.min(len3) / len4;
+      let cp1 = cpts[0];
+      let cp2 = isCubic ? cpts[1] : cp1;
 
-      return t
+      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);
+
+      if (!cross1) return true
+
+      let dx0 = p.x - p0.x;
+      let dy0 = p.y - p0.y;
+      let cross0 = Math.abs(dx0 * dy1 - dy0 * dx1);
+
+      if (!cross0) return true
+
+      let area = getPolygonArea([p0,...cpts, p], true);
+      let dist1 = getSquareDistance(p0, p);
+      let thresh = dist1/200;
+
+     // if(area<thresh) return true;
+      isFlat = area<thresh;
+
+      /*
+
+      let rat = (cross0 / cross1)
+
+      if (rat < 1.1) {
+          console.log('cross', cross0, cross1, 'rat', rat );
+          isFlat = true;
+      }
+      */
+
+      return isFlat;
 
   }
 
@@ -1855,7 +2004,6 @@
            * this way we can skip certain tests
            */
           let commandPts = [p0];
-          let isFlat = false;
 
           // init properties
           com.idx = c - 1;
@@ -1886,7 +2034,7 @@
           com.p0 = p0;
           com.p = p;
 
-          let cp1, cp2, cp1N, cp2N, pN, typeN, area1;
+          let cp1, cp2, cp1N, pN, typeN, area1;
 
           let dimA = getDistAv(p0, p);
           com.dimA = dimA;
@@ -1926,6 +2074,7 @@
               if (type === 'C') commandPts.push(cp2);
               commandPts.push(p);
 
+              /*
               let commandFlatness = commandIsFlat(commandPts);
               isFlat = commandFlatness.flat;
               com.flat = isFlat;
@@ -1933,6 +2082,7 @@
               if (isFlat) {
                   com.extreme = false;
               }
+              */
           }
 
           /**
@@ -1941,7 +2091,7 @@
            * so we interpret maximum x/y on-path points as well as extremes
            * but we ignore linetos to allow chunk compilation
            */
-          if (!isFlat && type !== 'L' && (p.x === left || p.y === top || p.x === right || p.y === bottom)) {
+          if (type !== 'L' && (p.x === left || p.y === top || p.x === right || p.y === bottom)) {
               com.extreme = true;
           }
 
@@ -1954,7 +2104,7 @@
               pN = comN ? { x: comNValsL[0], y: comNValsL[1] } : null;
 
               cp1N = { x: comN.values[0], y: comN.values[1] };
-              cp2N = comN.type === 'C' ? { x: comN.values[2], y: comN.values[3] } : null;
+              comN.type === 'C' ? { x: comN.values[2], y: comN.values[3] } : null;
           }
 
           /**
@@ -1984,19 +2134,15 @@
                   // check extremes
                   let cpts = commandPts.slice(1);
 
-                  let w = pN ? Math.abs(pN.x - p0.x) : 0;
-                  let h = pN ? Math.abs(pN.y - p0.y) : 0;
-                  let thresh = (w + h) / 2 * 0.1;
-                  let pts1 = type === 'C' ? [p, cp1N, cp2N, pN] : [p, cp1N, pN];
-
-                  let flatness2 = commandIsFlat(pts1, thresh);
-                  let isFlat2 = flatness2.flat;
+                  pN ? Math.abs(pN.x - p0.x) : 0;
+                  pN ? Math.abs(pN.y - p0.y) : 0;
 
                   /**
                    * if current and next cubic are flat
                    * we don't flag them as extremes to allow simplification
                    */
-                  let hasExtremes = (isFlat && isFlat2) ? false : (!com.extreme ? bezierhasExtreme(p0, cpts, angleThreshold) : true);
+
+                  let hasExtremes = (!com.extreme ? bezierhasExtreme(p0, cpts, angleThreshold) : true);
 
                   if (hasExtremes) {
                       com.extreme = true;
@@ -2042,7 +2188,7 @@
 
       // Reference first MoveTo command (M)
       let M = { x: pathData[0].values[0], y: pathData[0].values[1] };
-      let p0 =  M;
+      let p0 = M;
       let p = M;
       pathData[0].decimals = 0;
 
@@ -2054,28 +2200,33 @@
           let { type, values } = com;
 
           let lastVals = values.length ? values.slice(-2) : [M.x, M.y];
-          p={x:lastVals[0], y:lastVals[1]};
+          p = { x: lastVals[0], y: lastVals[1] };
 
           // use existing averave dimension value or calculate
-          let dimA = com.dimA ? +com.dimA.toFixed(8) : type!=='M' ? +getDistAv(p0, p).toFixed(8) : 0;
+          let dimA = com.dimA ? +com.dimA.toFixed(8) : type !== 'M' ? +getDistAv(p0, p).toFixed(8) : 0;
 
-          if(dimA) dims.add(dimA);
-          
+          if (dimA) dims.add(dimA);
 
-          if(type==='M'){
-              M=p;
+          if (type === 'M') {
+              M = p;
           }
           p0 = p;
       }
 
       let dim_min = Array.from(dims).sort();
-      let sliceIdx = Math.ceil(dim_min.length/8);
-      dim_min = dim_min.slice(0, sliceIdx );
 
-      let dimVal = dim_min.reduce((a,b)=>a+b, 0) / sliceIdx;
+      /*
+      let minVal = dim_min.length > 15 ?
+          (dim_min[0] + dim_min[2]) / 2 :
+          dim_min[0];
+      */
+          
+      let sliceIdx = Math.ceil(dim_min.length / 10);
+      dim_min = dim_min.slice(0, sliceIdx);
+      let minVal = dim_min.reduce((a, b) => a + b, 0) / sliceIdx;
 
-      let threshold = 50;
-      let decimalsAuto = dimVal > threshold ? 0 : Math.floor(threshold / dimVal).toString().length;
+      let threshold = 40;
+      let decimalsAuto = minVal > threshold*1.5 ? 0 : Math.floor(threshold / minVal).toString().length;
 
       // clamp
       return Math.min(Math.max(0, decimalsAuto), 8)
@@ -2091,13 +2242,13 @@
       // 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];
+      for (let c = 0, len = pathData.length; c < len; c++) {
+          let com = pathData[c];
 
-          if (decimals >-1 || hasDecimal) {
+          if (decimals > -1 || hasDecimal) {
               decimals = hasDecimal ? com.decimals : decimals;
 
-              pathData[c].values = com.values.map(val=>{return val ? +val.toFixed(decimals) : val });
+              pathData[c].values = com.values.map(val => { return val ? +val.toFixed(decimals) : val });
 
           }
       }    return pathData;
@@ -2116,17 +2267,21 @@
       let cp1_Q = null;
       let type = 'C';
       let values = [cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
+      let comN = {type, values};
 
       if (dist1 < threshold) {
           cp1_Q = checkLineIntersection(p0, cp1, p, cp2, false);
           if (cp1_Q) {
 
-              type = 'Q';
-              values = [cp1_Q.x, cp1_Q.y, p.x, p.y];
+              comN.type = 'Q';
+              comN.values = [cp1_Q.x, cp1_Q.y, p.x, p.y];
+              comN.p0 = p0;
+              comN.cp1 = cp1_Q;
+              comN.p = p;
           }
       }
 
-      return { type, values }
+      return comN
 
   }
 
@@ -3483,6 +3638,242 @@
 
   }
 
+  function stringifyPathData(pathData) {
+      return pathData.map(com => { return `${com.type} ${com.values.join(' ')}` }).join(' ');
+  }
+
+  function shapeElToPath(el){
+
+      let nodeName = el.nodeName.toLowerCase();
+      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 pathN = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+      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)){
+              let val = el.getAttribute(att);
+              pathN.setAttribute(att, val);
+          }
+      });
+
+      return pathN
+
+  }
+
+  // retrieve pathdata from svg geometry elements
+  function getPathDataFromEl(el, stringify=false) {
+
+      let pathData = [];
+      let type = el.nodeName;
+      let atts, attNames, d, x, y, width, height, r, rx, ry, cx, cy, x1, x2, y1, y2;
+
+      // convert relative or absolute units 
+      const svgElUnitsToPixel = (el, decimals = 9) => {
+
+          const svg = el.nodeName !== "svg" ? el.closest("svg") : el;
+
+          // convert real life units to pixels
+          const translateUnitToPixel = (value) => {
+
+              if (value === null) {
+                  return 0
+              }
+
+              let dpi = 96;
+              let unit = value.match(/([a-z]+)/gi);
+              unit = unit ? unit[0] : "";
+              let val = parseFloat(value);
+              let rat;
+
+              // no unit - already pixes/user unit
+              if (!unit) {
+                  return val;
+              }
+
+              switch (unit) {
+                  case "in":
+                      rat = dpi;
+                      break;
+                  case "pt":
+                      rat = (1 / 72) * 96;
+                      break;
+                  case "cm":
+                      rat = (1 / 2.54) * 96;
+                      break;
+                  case "mm":
+                      rat = ((1 / 2.54) * 96) / 10;
+                      break;
+                  // just a default approximation
+                  case "em":
+                  case "rem":
+                      rat = 16;
+                      break;
+                  default:
+                      rat = 1;
+              }
+              let valuePx = val * rat;
+              return +valuePx.toFixed(decimals);
+          };
+
+          // svg width and height attributes
+          let width = svg.getAttribute("width");
+          width = width ? translateUnitToPixel(width) : 300;
+          let height = svg.getAttribute("height");
+          height = width ? translateUnitToPixel(height) : 150;
+
+          let vB = svg.getAttribute("viewBox");
+          vB = vB
+              ? vB
+                  .replace(/,/g, " ")
+                  .split(" ")
+                  .filter(Boolean)
+                  .map((val) => {
+                      return +val;
+                  })
+              : [];
+
+          let w = vB.length ? vB[2] : width;
+          let h = vB.length ? vB[3] : height;
+          let scaleX = w / 100;
+          let scaleY = h / 100;
+          let scalRoot = Math.sqrt((Math.pow(scaleX, 2) + Math.pow(scaleY, 2)) / 2);
+
+          let attsH = ["x", "width", "x1", "x2", "rx", "cx", "r"];
+          let attsV = ["y", "height", "y1", "y2", "ry", "cy"];
+
+          let atts = el.getAttributeNames();
+          atts.forEach((att) => {
+              let val = el.getAttribute(att);
+              let valAbs = val;
+              if (attsH.includes(att) || attsV.includes(att)) {
+                  let scale = attsH.includes(att) ? scaleX : scaleY;
+                  scale = att === "r" && w != h ? scalRoot : scale;
+                  let unit = val.match(/([a-z|%]+)/gi);
+                  unit = unit ? unit[0] : "";
+                  if (val.includes("%")) {
+                      valAbs = parseFloat(val) * scale;
+                  }
+
+                  else {
+                      valAbs = translateUnitToPixel(val);
+                  }
+                  el.setAttribute(att, +valAbs);
+              }
+          });
+      };
+
+      svgElUnitsToPixel(el);
+
+      const getAtts = (attNames) => {
+          atts = {};
+          attNames.forEach(att => {
+              atts[att] = +el.getAttribute(att);
+          });
+          return atts
+      };
+
+      switch (type) {
+          case 'path':
+              d = el.getAttribute("d");
+              pathData = parsePathDataNormalized(d);
+              break;
+
+          case 'rect':
+              attNames = ['x', 'y', 'width', 'height', 'rx', 'ry'];
+              ({ x, y, width, height, rx, ry } = getAtts(attNames));
+
+              if (!rx && !ry) {
+                  pathData = [
+                      { type: "M", values: [x, y] },
+                      { type: "L", values: [x + width, y] },
+                      { type: "L", values: [x + width, y + height] },
+                      { type: "L", values: [x, y + height] },
+                      { type: "Z", values: [] }
+                  ];
+              } else {
+
+                  if (rx > width / 2) {
+                      rx = width / 2;
+                  }
+                  if (ry > height / 2) {
+                      ry = height / 2;
+                  }
+                  pathData = [
+                      { type: "M", values: [x + rx, y] },
+                      { type: "L", values: [x + width - rx, y] },
+                      { type: "A", values: [rx, ry, 0, 0, 1, x + width, y + ry] },
+                      { type: "L", values: [x + width, y + height - ry] },
+                      { type: "A", values: [rx, ry, 0, 0, 1, x + width - rx, y + height] },
+                      { type: "L", values: [x + rx, y + height] },
+                      { type: "A", values: [rx, ry, 0, 0, 1, x, y + height - ry] },
+                      { type: "L", values: [x, y + ry] },
+                      { type: "A", values: [rx, ry, 0, 0, 1, x + rx, y] },
+                      { type: "Z", values: [] }
+                  ];
+              }
+              break;
+
+          case 'circle':
+          case 'ellipse':
+
+              attNames = ['cx', 'cy', 'rx', 'ry', 'r'];
+              ({ cx, cy, r, rx, ry } = getAtts(attNames));
+
+              if (type === 'circle') {
+                  r = r;
+                  rx = r;
+                  ry = r;
+              } else {
+                  rx = rx ? rx : r;
+                  ry = ry ? ry : r;
+              }
+
+              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] },
+              ];
+
+              break;
+          case 'line':
+              attNames = ['x1', 'y1', 'x2', 'y2'];
+              ({ x1, y1, x2, y2 } = getAtts(attNames));
+              pathData = [
+                  { type: "M", values: [x1, y1] },
+                  { type: "L", values: [x2, y2] }
+              ];
+              break;
+          case 'polygon':
+          case 'polyline':
+
+              let points = el.getAttribute('points').replaceAll(',', ' ').split(' ').filter(Boolean);
+
+              for (let i = 0; i < points.length; i += 2) {
+                  pathData.push({
+                      type: (i === 0 ? "M" : "L"),
+                      values: [+points[i], +points[i + 1]]
+                  });
+              }
+              if (type === 'polygon') {
+                  pathData.push({
+                      type: "Z",
+                      values: []
+                  });
+              }
+              break;
+      }
+
+      return stringify ? stringifyPathData(pathData): pathData;
+
+  }
+
   function pathDataRemoveColinear(pathData, tolerance = 1, flatBezierToLinetos = true) {
 
       let pathDataN = [pathData[0]];
@@ -3503,8 +3894,11 @@
 
           let area = getPolygonArea([p0, p, p1], true);
 
+          getSquareDistance(p0, p);
+          getSquareDistance(p, p1);
           let distSquare = getSquareDistance(p0, p1);
-          let distMax = distSquare / 100 * tolerance;
+
+          let distMax = distSquare / 200 * tolerance;
 
           let isFlat = area < distMax;
           let isFlatBez = false;
@@ -3519,6 +3913,7 @@
               (type === 'Q' ? [{ x: values[0], y: values[1] }] : []);
 
               isFlatBez = checkBezierFlatness(p0, cpts, p);
+
              // console.log();
 
               if (isFlatBez  && c < l - 1 && comPrev.type !== 'C') {
@@ -3534,7 +3929,10 @@
           p0 = p;
 
           // colinear – exclude arcs (as always =) as semicircles won't have an area
-          if ( isFlat && c < l - 1 && (type === 'L' || (flatBezierToLinetos && isFlatBez))) {
+
+          if ( isFlat && c < l - 1 && (type === 'L' || (flatBezierToLinetos && isFlatBez)) ) {
+
+              
 
               continue;
           }
@@ -3557,6 +3955,44 @@
 
   }
 
+  function removeOrphanedM(pathData) {
+
+      for (let i = 0, l = pathData.length; i < l; i++) {
+          let com = pathData[i];
+          if (!com) continue;
+          let { type = null, values = [] } = com;
+          let comN = pathData[i + 1] ? pathData[i + 1] : null;
+          if ((type === 'M' || type === 'm')) {
+
+              if (!comN || (comN && (comN.type === 'Z' || comN.type === 'z'))) {
+                  pathData[i] = null;
+                  pathData[i + 1] = null;
+              }
+          }
+      }
+
+      pathData = pathData.filter(Boolean);
+      return pathData;
+
+  }
+
+  /*
+  // remove zero-length segments introduced by rounding
+  export function removeZeroLengthLinetos_post(pathData) {
+      let pathDataOpt = []
+      pathData.forEach((com, i) => {
+          let { type, values } = com;
+          if (type === 'l' || type === 'v' || type === 'h') {
+              let hasLength = type === 'l' ? (values.join('') !== '00') : values[0] !== 0
+              if (hasLength) pathDataOpt.push(com)
+          } else {
+              pathDataOpt.push(com)
+          }
+      })
+      return pathDataOpt
+  }
+  */
+
   function removeZeroLengthLinetos(pathData) {
 
       let M = { x: pathData[0].values[0], y: pathData[0].values[1] };
@@ -3569,14 +4005,21 @@
           let com = pathData[c];
           let { type, values } = com;
 
-          let valsL = values.slice(-2);
-          p = { x: valsL[0], y: valsL[1] };
+          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) {
               continue
           }
 
+          // skip minified zero length
+          if (type === 'l' || type === 'v' || type === 'h') {
+              let noLength = type === 'l' ? (values.join('') === '00') : values[0] === 0;
+              if(noLength) continue
+          } 
+
           pathDataN.push(com);
           p0 = p;
       }
@@ -3915,6 +4358,152 @@
       return pathDataNew;
   }
 
+  function refineAdjacentExtremes(pathData, {
+      threshold = null, tolerance = 1
+  } = {}) {
+
+      if (!threshold) {
+          let bb = getPathDataBBox(pathData);
+          threshold = (bb.width + bb.height) / 2 * 0.05;
+
+      }
+
+      let l = pathData.length;
+
+      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;
+
+          // adjacent 
+
+          if (comN && type === 'C' && comN.type === 'C' && extreme && !corner) {
+
+              // check dist
+              let diff = getDistAv(p, comN.p);
+              let isCose = diff < threshold;
+
+              if (isCose) {
+
+                  let dx1 = (com.cp1.x - comN.p0.x);
+                  let dy1 = (com.cp1.y - comN.p0.y);
+
+                  let horizontal = Math.abs(dy1) < Math.abs(dx1);
+
+                  let pN = comN.p;
+                  let ptI;
+                  let t = 1;
+
+                  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));
+
+                          ptI = interpolate(comN.p, com.cp2, 1 + t);
+                          com.cp2.x = ptI.x;
+
+                      }
+                      else {
+
+                          t = Math.abs(Math.abs(comN.cp2.y - comN.p.y) / Math.abs(com.cp2.y - com.p.y));
+                          ptI = interpolate(comN.p, com.cp2, 1 + t);
+                          com.cp2.y = ptI.y;
+                      }
+
+                      pathData[i + 1].values = [com.cp1.x, com.cp1.y, com.cp2.x, com.cp2.y, pN.x, pN.y];
+                      pathData[i + 1].cp1 = com.cp1;
+                      pathData[i + 1].cp2 = com.cp2;
+                      pathData[i + 1].p0 = com.p0;
+                      pathData[i + 1].p = pN;
+                      pathData[i + 1].extreme = true;
+
+                      // nullify 1st
+                      pathData[i] = null;
+                      continue
+
+                  }
+
+                  // 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
+      pathData = pathData.filter(Boolean);
+      l = pathData.length;
+
+      /**
+       * refine closing commands
+       */
+
+      let closed = pathData[l - 1].type.toLowerCase() === 'z';
+      let lastIdx = closed ? l - 2 : l - 1;
+      let lastCom = pathData[lastIdx];
+      let penultimateCom = pathData[lastIdx - 1] || null;
+      let M = { x: pathData[0].values[0], y: pathData[0].values[1] };
+
+      let dec = 8;
+      let lastVals = lastCom.values.slice(-2);
+      let isClosingTo = +lastVals[0].toFixed(dec) === +M.x.toFixed(dec) && +lastVals[1].toFixed(dec) === +M.y.toFixed(dec);
+      let fistExt = pathData[1].type === 'C' && pathData[1].extreme ? pathData[1] : null;
+
+      let diff = getDistAv(lastCom.p0, lastCom.p);
+      let isCose = diff < threshold;
+
+      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];
+              pathData[lastIdx] = null;
+              pathData = pathData.filter(Boolean);
+          }
+
+      }
+
+      return pathData
+
+  }
+
+  function removeEmptySVGEls(svg) {
+    let els = svg.querySelectorAll('g, defs');
+    els.forEach(el => {
+        if (!el.children.length) el.remove();
+    });
+  }
+
   function cleanUpSVG(svgMarkup, {
     returnDom=false, 
     removeHidden=true,
@@ -3930,7 +4519,7 @@
       .querySelector("svg");
     
     
-    let allowed=['viewBox', 'xmlns', 'width', 'height', 'id', 'class'];
+    let allowed=['viewBox', 'xmlns', 'width', 'height', 'id', 'class', 'fill', 'stroke', 'stroke-width'];
     removeExcludedAttribues(svg, allowed);
     
     let removeEls = ['metadata', 'script'];
@@ -4002,10 +4591,13 @@
   }
 
   function svgPathSimplify(input = '', {
+
+      // return svg markup or object
+      getObject = false,
+
       toAbsolute = true,
       toRelative = true,
       toShorthands = true,
-      decimals = 3,
 
       // not necessary unless you need cubics only
       quadraticToCubic = true,
@@ -4014,29 +4606,33 @@
       arcToCubic = false,
       cubicToArc = false,
 
-      // arc to cubic precision - adds more segments for better precision     
-      arcAccuracy = 4,
-      keepExtremes = true,
-      keepCorners = true,
-      keepInflections = true,
-      extrapolateDominant = false,
-      addExtremes = false,
+      simplifyBezier = true,
       optimizeOrder = true,
       removeColinear = true,
-      simplifyBezier = true,
-      autoAccuracy = true,
       flatBezierToLinetos = true,
       revertToQuadratics = true,
+
+      refineExtremes = true,
+      keepExtremes = true,
+      keepCorners = true,
+      extrapolateDominant = true,
+      keepInflections = false,
+      addExtremes = false,
+      removeOrphanSubpaths = false,
+
+      // svg path optimizations
+      decimals = 3,
+      autoAccuracy = true,
+
       minifyD = 0,
       tolerance = 1,
       reverse = false,
 
       // svg cleanup options
+      mergePaths = false,
       removeHidden = true,
       removeUnused = true,
-
-      // return svg markup or object
-      getObject = false
+      shapesToPaths = true,
 
   } = {}) {
 
@@ -4079,6 +4675,14 @@
           svg = cleanUpSVG(input, { returnDom, removeHidden, removeUnused }
           );
 
+          if(shapesToPaths){
+              let shapes = svg.querySelectorAll('polygon, polyline, line, rect, circle, ellipse');
+              shapes.forEach(shape=>{
+                  let path = shapeElToPath(shape);
+                  shape.replaceWith(path);
+              });
+          }
+
           // collect paths
           let pathEls = svg.querySelectorAll('path');
           pathEls.forEach(path => {
@@ -4089,17 +4693,31 @@
       /**
        * process all paths
        */
+
+      // SVG optimization options
+      let pathOptions = {
+          toRelative,
+          toShorthands,
+          decimals,
+      };
+
+      // combinded path data for SVGs with mergePaths enabled
+      let pathData_merged = [];
+
       paths.forEach(path => {
           let { d, el } = path;
 
           let pathDataO = parsePathDataNormalized(d, { quadraticToCubic, toAbsolute, arcToCubic });
 
-          // create clone for fallback
-          let pathData = JSON.parse(JSON.stringify(pathDataO));
-
           // count commands for evaluation
           let comCount = pathDataO.length;
 
+          // create clone for fallback
+
+          let pathData = pathDataO;
+
+          if(removeOrphanSubpaths) pathData = removeOrphanedM(pathData);
+
           /**
            * get sub paths
            */
@@ -4135,7 +4753,13 @@
               // simplify beziers
               let { pathData, bb, dimA } = pathDataPlus;
 
-              pathData = simplifyBezier ? simplifyPathData(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance, reverse }) : pathData;
+              pathData = simplifyBezier ? simplifyPathDataCubic(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance, reverse }) : pathData;
+
+              // refine extremes
+              if(refineExtremes){
+                  let thresholdEx = (bb.width + bb.height) / 2 * 0.05;
+                  pathData = refineAdjacentExtremes(pathData, {threshold:thresholdEx, tolerance});
+              }
 
               // cubic to arcs
               if (cubicToArc) {
@@ -4164,80 +4788,107 @@
                       if (type === 'C') {
 
                           let comQ = revertCubicQuadratic(p0, cp1, cp2, p);
-                          if (comQ.type === 'Q') pathData[c] = comQ;
+                          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;
+
+                              pathData[c] = comQ;
+                          }
                       }
                   });
               }
 
               // optimize close path
-              if(optimizeOrder) pathData=optimizeClosePath(pathData);
+              if (optimizeOrder) pathData = optimizeClosePath(pathData);
+
+              // poly
 
               // update
               pathDataArrN.push(pathData);
           }
 
-          
           // flatten compound paths 
           pathData = pathDataArrN.flat();
 
-          /**
-           * detect accuracy
-           */
-          if (autoAccuracy) {
-              decimals = detectAccuracy(pathData);
+          // collect for merged svg paths 
+          if (el && mergePaths) {
+              pathData_merged.push(...pathData);
           }
+          // single output
+          else {
 
-          // optimize
-          let pathOptions = {
-              toRelative,
-              toShorthands,
-              decimals,
-          };
-
-          // optimize path data
-          pathData = convertPathData(pathData, pathOptions);
-
-          // remove zero-length segments introduced by rounding
-          let pathDataOpt = [];
+              /**
+               * detect accuracy
+               */
+              if (autoAccuracy) {
+                  decimals = detectAccuracy(pathData);
+                  pathOptions.decimals = decimals;
 
-          pathData.forEach((com, i) => {
-              let { type, values } = com;
-              if (type === 'l' || type === 'v' || type === 'h') {
-                  let hasLength = type === 'l' ? (values.join('') !== '00') : values[0] !== 0;
-                  if (hasLength) pathDataOpt.push(com);
-              } else {
-                  pathDataOpt.push(com);
               }
-          });
-
-          pathData = pathDataOpt;
 
-          // compare command count
-          let comCountS = pathData.length;
+              // optimize path data
+              pathData = convertPathData(pathData, pathOptions);
 
-          let dOpt = pathDataToD(pathData, minifyD);
-          svgSizeOpt = new Blob([dOpt]).size;
+              // remove zero-length segments introduced by rounding
+              pathData = removeZeroLengthLinetos(pathData);
 
-          compression = +(100 / svgSize * (svgSizeOpt)).toFixed(2);
+              // compare command count
+              let comCountS = pathData.length;
 
-          path.d = dOpt;
-          path.report = {
-              original: comCount,
-              new: comCountS,
-              saved: comCount - comCountS,
-              compression,
-              decimals,
+              let dOpt = pathDataToD(pathData, minifyD);
+              svgSizeOpt = new Blob([dOpt]).size;
+              compression = +(100 / svgSize * (svgSizeOpt)).toFixed(2);
 
-          };
+              path.d = dOpt;
+              path.report = {
+                  original: comCount,
+                  new: comCountS,
+                  saved: comCount - comCountS,
+                  compression,
+                  decimals,
 
-          // apply new path for svgs
-          if (el) el.setAttribute('d', dOpt);
+              };
 
+              // apply new path for svgs
+              if (el) el.setAttribute('d', dOpt);
+          }
       });
 
-      // stringify new SVG
+      /**
+       *  stringify new SVG
+       */
       if (mode) {
-          svg = new XMLSerializer().serializeToString(svg);
+
+          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);
+
+              // apply new path for svgs
+              paths[0].el.setAttribute('d', dOpt);
+
+              // remove other paths
+              for (let i = 1; i < paths.length; i++) {
+                  let pathEl = paths[i].el;
+                  if (pathEl) pathEl.remove();
+              }
+
+              // remove empty groups e.g groups
+              removeEmptySVGEls(svg);
+          }
+
+          svg = stringifySVG(svg);
           svgSizeOpt = new Blob([svg]).size;
 
           compression = +(100 / svgSize * (svgSizeOpt)).toFixed(2);
@@ -4259,7 +4910,7 @@
 
   }
 
-  function simplifyPathData(pathData, {
+  function simplifyPathDataCubic(pathData, {
       keepExtremes = true,
       keepInflections = true,
       keepCorners = true,
@@ -4303,6 +4954,8 @@
                   if (combined.length === 1) {
                       com = combined[0];
                       let offset = 1;
+
+                      // add cumulative error to prevent distortions
                       error += com.error;
 
                       // find next candidates
@@ -4320,6 +4973,10 @@
 
                           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];
@@ -4351,51 +5008,21 @@
       return pathDataN
   }
 
-  /**
-   * get viewBox 
-   * either from explicit attribute or
-   * width and height attributes
-   */
-
-  function getViewBox(svg = null, round = false) {
-
-      // browser default
-      if (!svg) return { x: 0, y: 0, width: 300, height: 150 }
-
-      let style = window.getComputedStyle(svg);
-
-      // the baseVal API method also converts physical units to pixels/user-units
-      let w = svg.hasAttribute('width') ? svg.width.baseVal.value : parseFloat(style.width) || 300;
-      let h = svg.hasAttribute('height') ? svg.height.baseVal.value : parseFloat(style.height) || 150;
-
-      let viewBox = svg.getAttribute('viewBox') ? svg.viewBox.baseVal : { x: 0, y: 0, width: w, height: h };
-
-      // remove SVG constructor
-      let { x, y, width, height } = viewBox;
-      viewBox = { x, y, width, height };
-
-      // round to integers
-      if (round) {
-          for (let prop in viewBox) {
-              viewBox[prop] = Math.ceil(viewBox[prop]);
-          }
-      }
-
-      return viewBox
-  }
-
   const {
       abs, acos, asin, atan, atan2, ceil, cos, exp, floor,
       log, hypot, max, min, pow, random, round, sin, sqrt, tan, PI
   } = Math;
 
-  // just for visual debugging
+  /*
+  import {XMLSerializerPoly, DOMParserPoly} from './dom_polyfills';
+  export {XMLSerializerPoly as XMLSerializerPoly};
+  export {DOMParserPoly as DOMParserPoly};
+  */
 
   // IIFE 
   if (typeof window !== 'undefined') {
       window.svgPathSimplify = svgPathSimplify;
-      window.getViewBox = getViewBox;
-      window.renderPoint = renderPoint;
+
   }
 
   exports.PI = PI;
@@ -4408,7 +5035,6 @@
   exports.cos = cos;
   exports.exp = exp;
   exports.floor = floor;
-  exports.getViewBox = getViewBox;
   exports.hypot = hypot;
   exports.log = log;
   exports.max = max;