svg-path-simplify 0.0.2 → 0.0.5

package/dist/svg-path-simplify.js

@@ -28,6 +28,48 @@
       }
   }
 
+  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") {
+          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));
+
+          
+          if(isSVG) {
+              type='svgMarkup';
+          }
+          else if(isPathData) {
+              type='pathDataString';
+          }
+          else if(isPolyString) {
+              type='polyString';
+          }
+
+          else {
+              let url = /^(file:|https?:\/\/|\/|\.\/|\.\.\/)/.test(input);
+              let dataUrl = input.startsWith('data:image');
+              type = url || dataUrl ? "url" : "string";
+          }
+
+          return type
+      }
+
+      type = typeof input;
+      let constructor = input.constructor.name;
+
+      return (constructor || type).toLowerCase();
+  }
+
   /*
   import {abs, acos, asin, atan, atan2, ceil, cos, exp, floor,
       log, max, min, pow, random, round, sin, sqrt, tan, PI} from '/.constants.js';
@@ -80,7 +122,7 @@
           y: p1.y + (a * (p2.y - p1.y))
       };
 
-     // console.log('intersectionPoint', intersectionPoint, p1, p2);
+      // console.log('intersectionPoint', intersectionPoint, p1, p2);
 
       let intersection = false;
       // if line1 is a segment and line2 is infinite, they intersect if:
@@ -635,14 +677,60 @@
       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
    */
   function getDistAv(pt1, pt2) {
-      let diffX = Math.abs(pt1.x - pt2.x);
-      let diffY = Math.abs(pt1.y - pt2.y);
+
+      let diffX = Math.abs(pt2.x - pt1.x);
+      let diffY = Math.abs(pt2.y - pt1.y);
       let diff = (diffX + diffY) / 2;
+
+      /*
+      let diffX = pt2.x - pt1.x;
+      let diffY = pt2.y - pt1.y;
+      let diff = Math.abs(diffX + diffY) / 2;
+      */
+
       return diff;
   }
 
@@ -1282,24 +1370,24 @@
 
       optimize = parseFloat(optimize);
 
+      let len = pathData.length;
       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 suff = beautify ? `\n` : ' ';
+      let separator_command = beautify ? `\n` : (minify ? '' : ' ');
+      let separator_type =  !minify ? ' ' : '';
 
-      if (minify) {
-          d = `${pathData[0].type} ${pathData[0].values.join(" ")}`;
-      } else {
-          d = `${pathData[0].type} ${pathData[0].values.join(" ")}${suff}`;
-      }
+      d = `${pathData[0].type}${separator_type}${pathData[0].values.join(" ")}${separator_command}`;
 
-      for (let i = 1, len = pathData.length; i < len; i++) {
+      for (let i = 1; i < len; i++) {
           let com0 = pathData[i - 1];
           let com = pathData[i];
           let { type, values } = com;
@@ -1317,8 +1405,6 @@
           type = (com0.type === com.type && com.type.toLowerCase() !== 'm' && minify)
               ? " "
               : (
-                  (com0.type === "m" && com.type === "l") ||
-                  (com0.type === "M" && com.type === "l") ||
                   (com0.type === "M" && com.type === "L")
               ) && minify
                   ? " "
@@ -1347,16 +1433,15 @@
                   }
 
                   valsString += valStr;
-
                   prevWasFloat = isSmallFloat;
               }
 
-              d += `${type}${valsString}`;
+              d += `${type}${separator_type}${valsString}${separator_command}`;
 
           }
           // regular non-minified output
           else {
-              d += `${type} ${values.join(' ')}${suff}`;
+              d += `${type}${separator_type}${values.join(' ')}${separator_command}`;
           }
       }
 
@@ -1960,7 +2045,8 @@
       let p0 =  M;
       let p = M;
       pathData[0].decimals = 0;
-      let minDim = Infinity;
+
+      let dims = new Set();
 
       // add average distances
       for (let i = 0, len = pathData.length; i < len; i++) {
@@ -1973,8 +2059,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 && dimA<minDim) minDim = dimA;
-
+          if(dimA) dims.add(dimA);
           
 
           if(type==='M'){
@@ -1983,7 +2068,14 @@
           p0 = p;
       }
 
-      let decimalsAuto = Math.floor(50 / minDim).toString().length;
+      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 threshold = 50;
+      let decimalsAuto = dimVal > threshold ? 0 : Math.floor(threshold / dimVal).toString().length;
 
       // clamp
       return Math.min(Math.max(0, decimalsAuto), 8)
@@ -3403,33 +3495,37 @@
           let comPrev = pathData[c - 1];
           let com = pathData[c];
           let comN = pathData[c + 1] || pathData[l - 1];
-          let p1 = comN.type === 'Z' ? M : { x: comN.values[comN.values.length - 2], y: comN.values[comN.values.length - 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;
           let valsL = values.slice(-2);
           p = type !== 'Z' ? { x: valsL[0], y: valsL[1] } : M;
 
-          let cpts = type === 'C' ?
-              [{ x: values[0], y: values[1] }, { x: values[2], y: values[3] }] :
-              (type === 'Q' ? [{ x: values[0], y: values[1] }] : []);
+          let area = getPolygonArea([p0, p, p1], true);
 
-          let area = getPolygonArea([p0, ...cpts, p, p1], true);
-          let distSquare = getSquareDistance(p0, p);
-          let distMax = distSquare / 500 * tolerance;
+          let distSquare = getSquareDistance(p0, p1);
+          let distMax = distSquare / 100 * tolerance;
 
-          let isFlat = area < distMax; 
-          
-          if(!flatBezierToLinetos && type==='C') isFlat = false;
+          let isFlat = area < distMax;
+          let isFlatBez = false;
+
+          if (!flatBezierToLinetos && type === 'C') isFlat = false;
 
           // convert flat beziers to linetos
-          if (flatBezierToLinetos && type === 'C') {
+          if (flatBezierToLinetos && (type === 'C' || type === 'Q')) {
+
+              let cpts = type === 'C' ?
+              [{ x: values[0], y: values[1] }, { x: values[2], y: values[3] }] :
+              (type === 'Q' ? [{ x: values[0], y: values[1] }] : []);
 
-              let areaBez = getPolygonArea([p0, ...cpts, p], true);
-              let isFlatBez = areaBez < distSquare / 1000;
+              isFlatBez = checkBezierFlatness(p0, cpts, p);
+             // console.log();
 
-              if (isFlatBez && comPrev.type !== 'C') {
+              if (isFlatBez  && c < l - 1 && comPrev.type !== 'C') {
+                  type = "L";
                   com.type = "L";
                   com.values = valsL;
+
               }
 
           }
@@ -3438,7 +3534,8 @@
           p0 = p;
 
           // colinear – exclude arcs (as always =) as semicircles won't have an area
-          if (type !== 'A' && isFlat && c < l - 1) {
+          if ( isFlat && c < l - 1 && (type === 'L' || (flatBezierToLinetos && isFlatBez))) {
+
               continue;
           }
 
@@ -3488,11 +3585,43 @@
 
   }
 
-  function pathDataToTopLeft(pathData, removeFinalLineto = false, reorder = true) {
+  function pathDataToTopLeft(pathData) {
+
+      let len = pathData.length;
+      let isClosed = pathData[len - 1].type.toLowerCase() === 'z';
+
+      // we can't change starting point for non closed paths
+      if (!isClosed) {
+          return pathData
+      }
+
+      let newIndex = 0;
+
+      let indices = [];
+      for (let i = 0; i < len; i++) {
+          let com = pathData[i];
+          let { type, values } = com;
+          let valsLen = values.length;
+          if (valsLen) {
+              let p = { type: type, x: values[valsLen-2], y: values[valsLen-1], index: 0};
+              p.index = i;
+              indices.push(p);
+          }
+      }
+
+      // reorder  to top left most
+
+      indices = indices.sort((a, b) => +a.y.toFixed(3) - +b.y.toFixed(3) );
+      newIndex = indices[0].index;
+
+      return  newIndex ? shiftSvgStartingPoint(pathData, newIndex) : pathData;
+  }
+
+  function optimizeClosePath(pathData, removeFinalLineto = true, reorder = true) {
 
       let pathDataNew = [];
       let len = pathData.length;
-      let M = { x: pathData[0].values[0], y: pathData[0].values[1] };
+      let M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(8) };
       let isClosed = pathData[len - 1].type.toLowerCase() === 'z';
 
       let linetos = pathData.filter(com => com.type === 'L');
@@ -3500,17 +3629,17 @@
       // check if order is ideal
       let penultimateCom = pathData[len - 2];
       let penultimateType = penultimateCom.type;
-      let penultimateComCoords = penultimateCom.values.slice(-2).map(val=>+val.toFixed(8));
+      let penultimateComCoords = penultimateCom.values.slice(-2).map(val => +val.toFixed(8));
 
       // last L command ends at M 
-      let isClosingCommand =  penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y;
+      let isClosingCommand = penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y;
 
       // if last segment is not closing or a lineto
-      let skipReorder = pathData[1].type!=='L' && (!isClosingCommand || penultimateType==='L' );
-      skipReorder=false;
+      let skipReorder = pathData[1].type !== 'L' && (!isClosingCommand || penultimateType === 'L');
+      skipReorder = false;
 
       // we can't change starting point for non closed paths
-      if (!isClosed ) {
+      if (!isClosed) {
           return pathData
       }
 
@@ -3537,15 +3666,15 @@
           // find top most lineto
 
           if (linetos.length) {
-              let curveAfterLine = indices.filter(com => (com.type !== 'L' && com.type !== 'M') && com.prevCom && 
-              com.prevCom === 'L' || com.prevCom==='M' && penultimateType==='L' ).sort((a, b) => a.y - b.y || a.x-b.x)[0];
+              let curveAfterLine = indices.filter(com => (com.type !== 'L' && com.type !== 'M') && com.prevCom &&
+                  com.prevCom === 'L' || com.prevCom === 'M' && penultimateType === 'L').sort((a, b) => a.y - b.y || a.x - b.x)[0];
 
               newIndex = curveAfterLine ? curveAfterLine.index - 1 : 0;
 
           }
           // 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(1) - +b.y.toFixed(1) || a.x - b.x);
               newIndex = indices[0].index;
           }
 
@@ -3553,12 +3682,14 @@
           pathData = newIndex ? shiftSvgStartingPoint(pathData, newIndex) : pathData;
       }
 
+      M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(7) };
+
       len = pathData.length;
 
       // remove last lineto
       penultimateCom = pathData[len - 2];
       penultimateType = penultimateCom.type;
-      penultimateComCoords = penultimateCom.values.slice(-2);
+      penultimateComCoords = penultimateCom.values.slice(-2).map(val=>+val.toFixed(8));
 
       isClosingCommand = penultimateType === 'L' && penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y;
 
@@ -3784,7 +3915,93 @@
       return pathDataNew;
   }
 
-  function svgPathSimplify(d = '', {
+  function cleanUpSVG(svgMarkup, {
+    returnDom=false, 
+    removeHidden=true,
+    removeUnused=true,
+  }={}) {
+    svgMarkup = cleanSvgPrologue(svgMarkup);
+    
+    // replace namespaced refs 
+    svgMarkup = svgMarkup.replaceAll("xlink:href=", "href=");
+    
+    let svg = new DOMParser()
+      .parseFromString(svgMarkup, "text/html")
+      .querySelector("svg");
+    
+    
+    let allowed=['viewBox', 'xmlns', 'width', 'height', 'id', 'class'];
+    removeExcludedAttribues(svg, allowed);
+    
+    let removeEls = ['metadata', 'script'];
+    
+    let els = svg.querySelectorAll('*');
+    els.forEach(el=>{
+      let name = el.nodeName;    
+      // remove hidden elements
+      let style = el.getAttribute('style') || '';
+      let isHiddenByStyle = style ? style.trim().includes('display:none') : false;
+      let isHidden = (el.getAttribute('display') && el.getAttribute('display') === 'none') || isHiddenByStyle;
+      if(name.includes(':') || removeEls.includes(name) || (removeHidden && isHidden )) {
+        el.remove();
+      }else {
+        // remove BS elements
+        removeNameSpaceAtts(el);
+      }
+    });
+
+    if(returnDom) return svg
+
+    let markup = stringifySVG(svg);
+    console.log(markup);
+
+    return markup;
+  }
+
+  function cleanSvgPrologue(svgString) {
+    return (
+      svgString
+        // Remove XML prologues like <?xml ... ?>
+        .replace(/<\?xml[\s\S]*?\?>/gi, "")
+        // Remove DOCTYPE declarations
+        .replace(/<!DOCTYPE[\s\S]*?>/gi, "")
+        // Remove comments <!-- ... -->
+        .replace(/<!--[\s\S]*?-->/g, "")
+        // Trim extra whitespace
+        .trim()
+    );
+  }
+
+  function removeExcludedAttribues(el, allowed=['viewBox', 'xmlns', 'width', 'height', 'id', 'class']){
+    let atts = [...el.attributes].map((att) => att.name);
+    atts.forEach((att) => {
+      if (!allowed.includes(att)) {
+        el.removeAttribute(att);
+      }
+    });
+  }
+
+  function removeNameSpaceAtts(el) {
+    let atts = [...el.attributes].map((att) => att.name);
+    atts.forEach((att) => {
+      if (att.includes(":")) {
+        el.removeAttribute(att);
+      }
+    });
+  }
+
+  function stringifySVG(svg){
+      let markup = new XMLSerializer().serializeToString(svg);
+    markup = markup
+    .replace(/\t/g, "")
+    .replace(/[\n\r|]/g, "\n")
+    .replace(/\n\s*\n/g, '\n')
+    .replace(/ +/g, ' ');
+
+    return markup
+  }
+
+  function svgPathSimplify(input = '', {
       toAbsolute = true,
       toRelative = true,
       toShorthands = true,
@@ -3812,126 +4029,233 @@
       revertToQuadratics = true,
       minifyD = 0,
       tolerance = 1,
-      reverse = false
+      reverse = false,
+
+      // svg cleanup options
+      removeHidden = true,
+      removeUnused = true,
+
+      // return svg markup or object
+      getObject = false
+
   } = {}) {
 
-      let pathDataO = parsePathDataNormalized(d, { quadraticToCubic, toAbsolute, arcToCubic });
+      // clamp tolerance 
+      tolerance = Math.max(0.1, tolerance);
+
+      let inputType = detectInputType(input);
 
-      // create clone for fallback
-      let pathData = JSON.parse(JSON.stringify(pathDataO));
+      let svg = '';
+      let svgSize = 0;
+      let svgSizeOpt = 0;
+      let compression = 0;
+      let report = {};
+      let d = '';
+      let mode = inputType === 'svgMarkup' ? 1 : 0;
 
-      // count commands for evaluation
-      let comCount = pathDataO.length;
+      let paths = [];
 
       /**
-       * get sub paths
+       * normalize input
+       * switch mode
        */
-      let subPathArr = splitSubpaths(pathData);
 
-      // cleaned up pathData
-      let pathDataArrN = [];
+      // original size
+      svgSize = new Blob([input]).size;
 
-      for (let i = 0, l = subPathArr.length; i < l; i++) {
+      // single path
+      if (!mode) {
+          if (inputType === 'pathDataString') {
+              d = input;
+          } else if (inputType === 'polyString') {
+              d = 'M' + input;
+          }
+          paths.push({ d, el: null });
+      }
+      // process svg
+      else {
 
-          let pathDataSub = subPathArr[i];
+          let returnDom = true;
+          svg = cleanUpSVG(input, { returnDom, removeHidden, removeUnused }
+          );
 
-          // try simplification in reversed order
-          if (reverse) pathDataSub = reversePathData(pathDataSub);
+          // collect paths
+          let pathEls = svg.querySelectorAll('path');
+          pathEls.forEach(path => {
+              paths.push({ d: path.getAttribute('d'), el: path });
+          });
+      }
 
-          // remove zero length linetos
-          if (removeColinear) pathDataSub = removeZeroLengthLinetos(pathDataSub);
+      /**
+       * process all paths
+       */
+      paths.forEach(path => {
+          let { d, el } = path;
 
-          // add extremes
+          let pathDataO = parsePathDataNormalized(d, { quadraticToCubic, toAbsolute, arcToCubic });
 
-          let tMin = 0, tMax = 1;
-          if (addExtremes) pathDataSub = addExtremePoints(pathDataSub, tMin, tMax);
+          // create clone for fallback
+          let pathData = JSON.parse(JSON.stringify(pathDataO));
 
-          // sort to top left
-          if (optimizeOrder) pathDataSub = pathDataToTopLeft(pathDataSub);
+          // count commands for evaluation
+          let comCount = pathDataO.length;
 
-          // remove colinear/flat
-          if (removeColinear) pathDataSub = pathDataRemoveColinear(pathDataSub, tolerance, flatBezierToLinetos);
+          /**
+           * get sub paths
+           */
+          let subPathArr = splitSubpaths(pathData);
 
-          // analyze pathdata to add info about signicant properties such as extremes, corners
-          let pathDataPlus = analyzePathData(pathDataSub);
+          // cleaned up pathData
+          let pathDataArrN = [];
 
-          // simplify beziers
-          let { pathData, bb, dimA } = pathDataPlus;
+          for (let i = 0, l = subPathArr.length; i < l; i++) {
 
-          let pathDataN = pathData;
+              let pathDataSub = subPathArr[i];
 
-          
-          pathDataN = simplifyBezier ? simplifyPathData(pathDataN, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance, reverse }) : pathDataN;
+              // try simplification in reversed order
+              if (reverse) pathDataSub = reversePathData(pathDataSub);
 
-          // cubic to arcs
-          if(cubicToArc){
+              // remove zero length linetos
+              if (removeColinear) pathDataSub = removeZeroLengthLinetos(pathDataSub);
 
-              let thresh = 3;
+              // add extremes
 
-              pathDataN.forEach((com, c) => {
-                  let { type, values, p0, cp1 = null, cp2 = null, p = null } = com;
-                  if (type === 'C') {
+              let tMin = 0, tMax = 1;
+              if (addExtremes) pathDataSub = addExtremePoints(pathDataSub, tMin, tMax);
 
-                      let comA = cubicCommandToArc(p0, cp1, cp2, p, thresh);
-                      if(comA.isArc) pathDataN[c] = comA.com;
+              // sort to top left
+              if (optimizeOrder) pathDataSub = pathDataToTopLeft(pathDataSub);
 
-                  }
-              });
+              // remove colinear/flat
+              if (removeColinear) pathDataSub = pathDataRemoveColinear(pathDataSub, tolerance, flatBezierToLinetos);
+
+              // 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 ? simplifyPathData(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance, reverse }) : pathData;
+
+              // cubic to arcs
+              if (cubicToArc) {
+
+                  let thresh = 3;
+
+                  pathData.forEach((com, 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);
 
-              // combine adjacent cubics
-              pathDataN = combineArcs(pathDataN);
+              }
+
+              // simplify to quadratics
+              if (revertToQuadratics) {
+                  pathData.forEach((com, 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') pathData[c] = comQ;
+                      }
+                  });
+              }
+
+              // optimize close path
+              if(optimizeOrder) pathData=optimizeClosePath(pathData);
+
+              // update
+              pathDataArrN.push(pathData);
           }
 
-          // simplify to quadratics
-          if (revertToQuadratics) {
-              pathDataN.forEach((com, c) => {
-                  let { type, values, p0, cp1 = null, cp2 = null, p = null } = com;
-                  if (type === 'C') {
+          
+          // flatten compound paths 
+          pathData = pathDataArrN.flat();
 
-                      let comQ = revertCubicQuadratic(p0, cp1, cp2, p);
-                      if (comQ.type === 'Q') pathDataN[c] = comQ;
-                  }
-              });
+          /**
+           * detect accuracy
+           */
+          if (autoAccuracy) {
+              decimals = detectAccuracy(pathData);
           }
 
-          // update
-          pathDataArrN.push(pathDataN);
-      }
+          // optimize
+          let pathOptions = {
+              toRelative,
+              toShorthands,
+              decimals,
+          };
 
-      // merge pathdata
-      let pathDataFlat = pathDataArrN.flat();
+          // optimize path data
+          pathData = convertPathData(pathData, pathOptions);
 
-      /**
-       * detect accuracy
-       */
-      if (autoAccuracy) {
-          decimals = detectAccuracy(pathDataFlat);
-      }
+          // remove zero-length segments introduced by rounding
+          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);
+              }
+          });
 
-      // compare command count
-      let comCountS = pathDataFlat.length;
+          pathData = pathDataOpt;
 
-      // optimize
-      let pathOptions = {
-          toRelative,
-          toShorthands,
-          decimals,
-      };
+          // compare command count
+          let comCountS = pathData.length;
 
-      // optimize path data
-      pathData = convertPathData(pathDataFlat, pathOptions);
-      let dOpt = pathDataToD(pathData, minifyD);
+          let dOpt = pathDataToD(pathData, minifyD);
+          svgSizeOpt = new Blob([dOpt]).size;
 
-      let report = {
-          original: comCount,
-          new: comCountS,
-          saved: comCount - comCountS,
-          decimals,
-          success: comCountS < comCount
-      };
+          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);
+
+      });
 
-      return { pathData, d: dOpt, report };
+      // stringify new SVG
+      if (mode) {
+          svg = new XMLSerializer().serializeToString(svg);
+          svgSizeOpt = new Blob([svg]).size;
+
+          compression = +(100 / svgSize * (svgSizeOpt)).toFixed(2);
+
+          svgSize = +(svgSize / 1024).toFixed(3);
+          svgSizeOpt = +(svgSizeOpt / 1024).toFixed(3);
+
+          report = {
+              svgSize,
+              svgSizeOpt,
+              compression
+          };
+
+      } else {
+          ({ d, report } = paths[0]);
+      }
+
+      return !getObject ? (d ? d : svg) : { svg, d, report, inputType, mode };
 
   }
 
@@ -3961,9 +4285,9 @@
 
               // cannot be combined as crossing extremes or corners
               if (
-                      (keepInflections && isDirChangeN) ||
-                      (keepCorners && corner) ||
-                      (!isDirChange && keepExtremes && extreme)
+                  (keepInflections && isDirChangeN) ||
+                  (keepCorners && corner) ||
+                  (!isDirChange && keepExtremes && extreme)
               ) {
 
                   pathDataN.push(com);
@@ -4027,6 +4351,39 @@
       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
@@ -4037,6 +4394,7 @@
   // IIFE 
   if (typeof window !== 'undefined') {
       window.svgPathSimplify = svgPathSimplify;
+      window.getViewBox = getViewBox;
       window.renderPoint = renderPoint;
   }
 
@@ -4050,6 +4408,7 @@
   exports.cos = cos;
   exports.exp = exp;
   exports.floor = floor;
+  exports.getViewBox = getViewBox;
   exports.hypot = hypot;
   exports.log = log;
   exports.max = max;