svg-path-simplify 0.4.2 → 0.4.4

package/dist/svg-path-simplify.pathdata.esm.js

@@ -1,78 +1,327 @@
+const rad2Deg = 180/Math.PI;  
+const deg2rad = Math.PI/180;
+
+function validateSVG(markup, allowed = {}) {
+  allowed = {
+    ...{
+
+      useElsNested: 5000,
+      hasScripts: false,
+      hasEntity: false,
+      fileSizeKB: 10000,
+      isSymbolSprite: false,
+      isSvgFont: false
+    },
+    ...allowed
+  };
+
+  let fileReport = analyzeSVG(markup, allowed);
+  let isValid = true;
+  let log = [];
+
+  if (!fileReport.hasEls) {
+    log.push("no elements");
+    isValid = false;
+  }
+
+  if (Object.keys(fileReport).length) {
+    if (fileReport.isBillionLaugh === true) {
+      log.push(`suspicious: might contain billion laugh attack`);
+      isValid = false;
+    }
+
+    for (let key in allowed) {
+      let val = allowed[key];
+      let valRep = fileReport[key];
+      if (typeof val === "number" && valRep > val) {
+        log.push(`allowed "${key}" exceeded: ${valRep} / ${val} `);
+        isValid = false;
+      }
+      if (valRep === true && val === false) {
+        log.push(`not allowed: "${key}" `);
+        isValid = false;
+      }
+    }
+  } else {
+    isValid = false;
+  }
+
+  /*
+  if (!isValid) {
+    log = ["SVG not valid"].concat(log);
+
+    if (Object.keys(fileReport).length) {
+      console.warn(fileReport);
+    }
+  }
+  */
+
+  return { isValid, log, fileReport };
+}
+
+function analyzeSVG(markup, allowed = {}) {
+  markup = markup.trim();
+  let doc, svg;
+  let fileSizeKB = +(markup.length / 1024).toFixed(3);
+
+  let fileReport = {
+    totalEls: 1,
+    hasEls: true,
+    hasDefs: false,
+    geometryEls: [],
+    useEls: 0,
+    useElsNested: 0,
+    nonsensePaths: 0,
+    isSuspicious: false,
+    isBillionLaugh: false,
+    hasScripts: false,
+    hasPrologue: false,
+    hasEntity: false,
+    isPathData:false,
+    fileSizeKB,
+    hasXmlns: markup.includes("http://www.w3.org/2000/svg"),
+    isSymbolSprite: false,
+    isSvgFont: markup.includes("<glyph>")
+  };
+
+  let maxNested = allowed.useElsNested ? allowed.useElsNested : 2000;
+
+  /**
+   * analyze nestes use references
+   */
+  const countUseRefs = (useEls, maxNested = 2000) => {
+    let nestedCount = 0;
+
+    for (let i = 0; i < useEls.length && nestedCount < maxNested; i++) {
+      let use = useEls[i];
+      let refId = use.getAttribute("xlink:href")
+        ? use.getAttribute("xlink:href")
+        : use.getAttribute("href");
+      refId = refId ? refId.replace("#", "") : "";
+
+      use.setAttribute("href", "#" + refId);
+
+      let refEl = svg.getElementById(refId);
+      let nestedUse = refEl.querySelectorAll("use");
+      let nestedUseLength = nestedUse.length;
+      nestedCount += nestedUseLength;
+
+      // query nested use references
+      for (let n = 0; n < nestedUse.length && nestedCount < maxNested; n++) {
+        let nested = nestedUse[n];
+        let id1 = nested.getAttribute("href").replace("#", "");
+        let refEl1 = svg.getElementById(id1);
+        let nestedUse1 = refEl1.querySelectorAll("use");
+        nestedCount += nestedUse1.length;
+      }
+    }
+    fileReport.useElsNested = nestedCount;
+    return nestedCount;
+  };
+  let hasEntity = /\<\!ENTITY/gi.test(markup);
+  let hasScripts = /\<script/gi.test(markup) ? true : false;
+  let hasUse = /\<use/gi.test(markup) ? true : false;
+  let hasEls = /[\<path|\<polygon|\<polyline|\<rect|\<circle|\<ellipse|\<line|\<text|\<foreignObject]/gi.test(markup);
+  let hasDefs = /[\<filter|\<linearGradient|\<radialGradient|\<pattern|\<animate|\<animateMotion|\<animateTransform|\<clipPath|\<mask|\<symbol|\<marker]/gi.test(markup);
+
+  let isPathData = (markup.startsWith('M') || markup.startsWith('m')) && !/[\<svg|\<\/svg]/gi.test(markup);
+  fileReport.isPathData = isPathData;
+
+  // seems OK
+  if (!hasEntity && !hasUse && !hasScripts && (hasEls || hasDefs) && fileSizeKB < allowed.fileSizeKB) {
+    fileReport.hasEls = hasEls;
+    fileReport.hasDefs = hasDefs;
+
+    return fileReport
+  }
+
+  // Contains xml entity definition: highly suspicious - stop parsing!
+  if (allowed.hasEntity === false && hasEntity) {
+    fileReport.hasEntity = true;
+
+  }
+
+  /**
+   * sanitizing for parsing:
+   * remove xml prologue and comments
+   */
+  markup = markup
+    .replace(/\<\?xml.+\?\>|\<\!DOCTYPE.+]\>/g, "")
+    .replace(/(<!--.*?-->)|(<!--[\S\s]+?-->)|(<!--[\S\s]*?$)/g, "");
+
+  /**
+   * Try to parse svg:
+   * invalid svg will return false via "catch"
+   */
+  try {
+
+    doc = new DOMParser().parseFromString(markup, "text/html");
+    svg = doc.querySelector("svg");
+
+    // paths containing only a M command
+    let nonsensePaths = svg.querySelectorAll('path[d="M0,0"], path[d="M0 0"]').length;
+    let useEls = svg.querySelectorAll("use").length;
+
+    // create analyzing object
+    fileReport.totalEls = svg.querySelectorAll("*").length;
+    fileReport.geometryEls = svg.querySelectorAll(
+      "path, rect, circle, ellipse, polygon, polyline, line"
+    ).length;
+
+    fileReport.hasScripts = hasScripts;
+    fileReport.useEls = useEls;
+    fileReport.nonsensePaths = nonsensePaths;
+    fileReport.isSuspicious = false;
+    fileReport.isBillionLaugh = false;
+    fileReport.hasXmlns = svg.getAttribute("xmlns")
+      ? svg.getAttribute("xmlns") === "http://www.w3.org/2000/svg"
+        ? true
+        : false
+      : false;
+    fileReport.isSymbolSprite = 
+    svg.querySelectorAll("symbol").length &&
+      svg.querySelectorAll("use").length === 0
+      ? true
+      : false;
+    fileReport.isSvgFont = svg.querySelectorAll("glyph").length ? true : false;
+
+    let totalEls = fileReport.totalEls;
+    let totalUseEls = fileReport.useEls;
+    let usePercentage = (100 / totalEls) * totalUseEls;
+
+    // if percentage of use elements is higher than 75% - suspicious
+    if (usePercentage > 75) {
+      fileReport.isSuspicious = true;
+
+      // check nested use references
+      let nestedCount = countUseRefs(svg.querySelectorAll("use"), maxNested);
+      if (nestedCount >= maxNested) {
+        fileReport.isBillionLaugh = true;
+      }
+    }
+
+    return fileReport;
+  } catch {
+    // svg file has malformed markup
+    console.warn("svg could not be parsed");
+    return false;
+  }
+}
+
 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";
-    */
+    let log = '';
+    let isValid = true;
+
+    let result = {
+        inputType:'',
+        isValid:true,
+        fileReport:{},
+    };
+
     if (Array.isArray(input)) {
 
+        result.inputType = "array";
+
         // nested array
         if (Array.isArray(input[0])) {
 
-            if(input[0].length===2){
+            if (input[0].length === 2) {
 
-                return 'polyArray'
+                result.inputType = 'polyArray';
             }
 
-            else if (Array.isArray(input[0][0]) && input[0][0].length === 2 ) {
+            else if (Array.isArray(input[0][0]) && input[0][0].length === 2) {
 
-                return 'polyComplexArray'
+                result.inputType = 'polyComplexArray';
             }
             else if (input[0][0].x !== undefined && input[0][0].y !== undefined) {
 
-                return 'polyComplexObjectArray'
+                result.inputType = 'polyComplexObjectArray';
             }
+
         }
 
         // is point array
-        else if (input[0].x!==undefined && input[0].y!==undefined) {
+        else if (input[0].x !== undefined && input[0].y !== undefined) {
 
-            return 'polyObjectArray'
+            result.inputType = 'polyObjectArray';
         }
 
         // path data array
         else if (input[0]?.type && input[0]?.values
         ) {
-            return "pathData"
-
+            result.inputType = "pathData";
         }
 
-        return "array";
+        return result;
     }
 
     if (typeof input === "string") {
         input = input.trim();
         let isSVG = input.includes('<svg') && input.includes('</svg');
+        let isSymbol = input.startsWith('<symbol') && input.includes('</symbol');
         let isPathData = input.startsWith('M') || input.startsWith('m');
         let isPolyString = !isNaN(input.substring(0, 1)) && !isNaN(input.substring(input.length - 1, input.length));
+        let isJson = isNumberJson(input);
 
         if (isSVG) {
-            type = 'svgMarkup';
+            let validate = validateSVG(input);
+            ({isValid, log} = validate) ;
+            if(!isValid){
+
+                result.inputType = 'invalid';
+                result.isValid=false,
+
+                result.log = log;
+            }else {
+                result.inputType = 'svgMarkup';
+            }
+
+            result.fileReport = validate.fileReport;
+
+        }
+
+        else if (isJson) {
+            result.inputType = 'json';
+        }
+
+        else if (isSymbol) {
+            result.inputType = 'symbol';
         }
         else if (isPathData) {
-            type = 'pathDataString';
+            result.inputType = 'pathDataString';
         }
         else if (isPolyString) {
-            type = 'polyString';
+            result.inputType = 'polyString';
         }
 
         else {
             let url = /^(file:|https?:\/\/|\/|\.\/|\.\.\/)/.test(input);
             let dataUrl = input.startsWith('data:image');
-            type = url || dataUrl ? "url" : "string";
+            result.inputType = url || dataUrl ? "url" : "string";
         }
 
-        return type
+        return result
     }
 
-    type = typeof input;
-    let constructor = input.constructor.name;
+    result.inputType = (input.constructor.name || typeof input ).toLowerCase();
+
+    return result;
+}
+
+function isNumberJson(str) {
+
+    str = str.trim();
+
+    let hasNumber = /\d/.test(str);
+    let hasInvalid = /[abcdfghijklmnopqrstuvwz]/gi.test(str);
+    if (!hasNumber || hasInvalid) return false
+
+    // is JSON like
+    let isJson = str.startsWith('[') && str.endsWith(']');
 
-    return (constructor || type).toLowerCase();
+    return isJson
+    
 }
 
 function renderPoint(
@@ -102,18 +351,6 @@ function renderPoint(
     }
 }
 
-function renderPath(svg, d = '', stroke = 'green', strokeWidth = '1%', opacity="1", render = true) {
-
-    let path = `<path d="${d}" fill="none" stroke="${stroke}"  stroke-width="${strokeWidth}" stroke-opacity="${opacity}" /> `;
-
-    if (render) {
-        svg.insertAdjacentHTML("beforeend", path);
-    } else {
-        return path;
-    }
-
-}
-
 /*
 import {abs, acos, asin, atan, atan2, ceil, cos, exp, floor,
     log, max, min, pow, random, round, sin, sqrt, tan, PI} from '/.constants.js';
@@ -330,6 +567,7 @@ function pointAtT(pts, t = 0.5, getTangent = false, getCpts = false, returnArray
             let t1 = 1 - t;
 
             // cubic beziers
+            /*
             if (isCubic) {
                 pt = {
                     x:
@@ -345,11 +583,29 @@ function pointAtT(pts, t = 0.5, getTangent = false, getCpts = false, returnArray
                 };
 
             }
+            */
+
+            if (isCubic) {
+                pt = {
+                    x:
+                        t1 * t1 * t1 * p0.x +
+                        3 * t1 * t1 * t * cp1.x +
+                        3 * t1 * t * t * cp2.x +
+                        t * t * t * p.x,
+                    y:
+                        t1 * t1 * t1 * p0.y +
+                        3 * t1 * t1 * t * cp1.y +
+                        3 * t1 * t * t * cp2.y +
+                        t * t * t * p.y,
+                };
+
+            }
+
             // quadratic beziers
             else {
                 pt = {
-                    x: t1 * t1 * p0.x + 2 * t1 * t * cp1.x + t ** 2 * p.x,
-                    y: t1 * t1 * p0.y + 2 * t1 * t * cp1.y + t ** 2 * p.y,
+                    x: t1 * t1 * p0.x + 2 * t1 * t * cp1.x + t * t * p.x,
+                    y: t1 * t1 * p0.y + 2 * t1 * t * cp1.y + t * t * p.y,
                 };
             }
 
@@ -384,7 +640,36 @@ function pointAtT(pts, t = 0.5, getTangent = false, getCpts = false, returnArray
 /**
  * get vertices from path command final on-path points
  */
-function getPathDataVertices(pathData) {
+
+function getPathDataVertices(pathData=[], includeCpts = false, decimals = -1) {
+    let polyPoints = [];
+
+    pathData.forEach((com) => {
+        let { type, values } = com;
+
+        // get final on path point from last 2 values
+        if (values.length) {
+
+            // round
+            if (decimals > -1) values = values.map(val => +val.toFixed(decimals));
+
+            if (includeCpts) {
+
+                for (let i = 1; i < values.length; i += 2) {
+                    polyPoints.push({ x: values[i - 1], y: values[i] });
+                }
+
+            } else {
+                polyPoints.push({ x: values[values.length - 2], y: values[values.length - 1] });
+            }
+
+        }
+    });
+    return polyPoints;
+}
+
+/*
+export function getPathDataVertices(pathData) {
     let polyPoints = [];
     let p0 = { x: pathData[0].values[0], y: pathData[0].values[1] };
 
@@ -399,22 +684,30 @@ function getPathDataVertices(pathData) {
         }
     });
     return polyPoints;
-}
+};
+*/
 
 /**
  *  based on @cuixiping;
  *  https://stackoverflow.com/questions/9017100/calculate-center-of-svg-arc/12329083#12329083
  */
-function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, sweep, x2, y2) {
+
+function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, sweep, x2, y2, normalize = true
+) {
 
     // helper for angle calculation
-    const getAngle = (cx, cy, x, y) => {
-        return atan2(y - cy, x - cx);
+    const getAngle = (cx, cy, x, y, normalize = true) => {
+        let angle = Math.atan2(y - cy, x - cx);
+        if (normalize && angle < 0) angle += Math.PI * 2;
+        return angle
     };
 
     // make sure rx, ry are positive
-    rx = abs(rx);
-    ry = abs(ry);
+    rx = Math.abs(rx);
+    ry = Math.abs(ry);
+
+    // normalize xAxis rotation
+    xAxisRotation = rx === ry ? 0 : (xAxisRotation < 0 && normalize ? xAxisRotation + 360 : xAxisRotation);
 
     // create data object
     let arcData = {
@@ -438,53 +731,11 @@ function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, sweep, x2,
         throw Error("rx and ry can not be 0");
     }
 
-    let shortcut = true;
-
-    if (rx === ry && shortcut) {
-
-        // test semicircles
-        let diffX = Math.abs(x2 - x1);
-        let diffY = Math.abs(y2 - y1);
-        let r = diffX;
-
-        let xMin = Math.min(x1, x2),
-            yMin = Math.min(y1, y2),
-            PIHalf = Math.PI * 0.5;
-
-        // semi circles
-        if (diffX === 0 && diffY || diffY === 0 && diffX) {
-
-            r = diffX === 0 && diffY ? diffY / 2 : diffX / 2;
-            arcData.rx = r;
-            arcData.ry = r;
-
-            // verical
-            if (diffX === 0 && diffY) {
-                arcData.cx = x1;
-                arcData.cy = yMin + diffY / 2;
-                arcData.startAngle = y1 > y2 ? PIHalf : -PIHalf;
-                arcData.endAngle = y1 > y2 ? -PIHalf : PIHalf;
-                arcData.deltaAngle = sweep ? Math.PI : -Math.PI;
-
-            }
-            // horizontal
-            else if (diffY === 0 && diffX) {
-                arcData.cx = xMin + diffX / 2;
-                arcData.cy = y1;
-                arcData.startAngle = x1 > x2 ? Math.PI : 0;
-                arcData.endAngle = x1 > x2 ? -Math.PI : Math.PI;
-                arcData.deltaAngle = sweep ? Math.PI : -Math.PI;
-            }
-
-            return arcData;
-        }
-    }
-
     /**
      * if rx===ry x-axis rotation is ignored
      * otherwise convert degrees to radians
      */
-    let phi = rx === ry ? 0 : (xAxisRotation * PI) / 180;
+    let phi = rx === ry ? 0 : xAxisRotation * deg2rad;
     let cx, cy;
 
     let s_phi = !phi ? 0 : Math.sin(phi);
@@ -503,8 +754,9 @@ function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, sweep, x2,
     //   Step 3: Ensure radii are large enough
     let lambda = (x1_ * x1_) / (rx * rx) + (y1_ * y1_) / (ry * ry);
     if (lambda > 1) {
-        rx = rx * Math.sqrt(lambda);
-        ry = ry * Math.sqrt(lambda);
+        let lambdaRoot = Math.sqrt(lambda);
+        rx = rx * lambdaRoot;
+        ry = ry * lambdaRoot;
 
         // save real rx/ry
         arcData.rx = rx;
@@ -520,7 +772,7 @@ function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, sweep, x2,
         throw Error("start point can not be same as end point");
     }
     let coe = Math.sqrt(Math.abs((rxry * rxry - sum_of_sq) / sum_of_sq));
-    if (largeArc == sweep) {
+    if (largeArc === sweep) {
         coe = -coe;
     }
 
@@ -540,24 +792,33 @@ function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, sweep, x2,
      * calculate angles between center point and
      * commands starting and final on path point
      */
-    let startAngle = getAngle(cx, cy, x1, y1);
-    let endAngle = getAngle(cx, cy, x2, y2);
+    let startAngle = getAngle(cx, cy, x1, y1, normalize);
+    let endAngle = getAngle(cx, cy, x2, y2, normalize);
 
     // adjust end angle
-    if (!sweep && endAngle > startAngle) {
-
-        endAngle -= Math.PI * 2;
-    }
-
-    if (sweep && startAngle > endAngle) {
 
-        endAngle = endAngle <= 0 ? endAngle + Math.PI * 2 : endAngle;
+    // Adjust angles based on sweep direction
+    if (sweep) {
+        // Clockwise
+        if (endAngle < startAngle) {
+            endAngle += Math.PI * 2;
+        }
+    } else {
+        // Counterclockwise
+        if (endAngle > startAngle) {
+            endAngle -= Math.PI * 2;
+        }
     }
 
     let deltaAngle = endAngle - startAngle;
+
+    // The rest of your code remains the same
     arcData.startAngle = startAngle;
+    arcData.startAngle_deg = startAngle * rad2Deg;
     arcData.endAngle = endAngle;
+    arcData.endAngle_deg = endAngle * rad2Deg;
     arcData.deltaAngle = deltaAngle;
+    arcData.deltaAngle_deg = deltaAngle * rad2Deg;
 
     return arcData;
 }
@@ -660,12 +921,6 @@ function getBezierExtremeT(pts, { addExtremes = true, addSemiExtremes = false }
     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) => {
@@ -1063,7 +1318,7 @@ function getDistance(p1, p2, isArray = false) {
     let dx = isArray ? p2[0] - p1[0] : (p2.x - p1.x);
     let dy = isArray ? p2[1] - p1[1] : (p2.y - p1.y);
 
-    return sqrt(dx * dx + dy * dy);
+    return Math.sqrt(dx * dx + dy * dy);
 }
 
 function getSquareDistance(p1, p2) {
@@ -1391,6 +1646,36 @@ function splitCommandAtTValues(p0, values, tArr, returnCommand = true) {
     return segmentPoints;
 }
 
+/**
+ * round path data
+ * either by explicit decimal value or
+ * based on suggested accuracy in path data
+ */
+function roundPathData(pathData, decimalsGlobal = -1) {
+
+    if (decimalsGlobal < 0) return pathData;
+
+    let len = pathData.length;
+    let decimals = decimalsGlobal;
+    let decimalsArc = decimals < 3 ? decimals+2 : decimals;
+
+    for (let c = 0; c < len; c++) {
+        let com = pathData[c];
+        let { type, values } = com;
+        let valLen = values.length;
+        if (!valLen) continue
+
+        let isArc = type.toLowerCase() === 'a';
+
+        for (let v = 0; v < valLen; v++) {
+            // allow higher accuracy for arc radii (... it's always arcs)
+            pathData[c].values[v] = isArc && v < 2 ? roundTo(values[v], decimalsArc) : roundTo(values[v], decimals);
+        }
+    }
+
+    return pathData;
+}
+
 function detectAccuracy(pathData) {
     let dims = [];
 
@@ -1412,7 +1697,7 @@ function detectAccuracy(pathData) {
 
     let dim_min = dims.sort();
 
-    let sliceIdx = Math.ceil(dim_min.length / 8);
+    let sliceIdx = Math.ceil(dim_min.length / 6);
     dim_min = dim_min.slice(0, sliceIdx);
     let minVal = dim_min.reduce((a, b) => a + b, 0) / sliceIdx;
 
@@ -1424,38 +1709,29 @@ function detectAccuracy(pathData) {
 
 }
 
-function roundTo(num = 0, decimals = 3) {
-    if (!decimals) return Math.round(num);
-    let factor = 10 ** decimals;
-    return Math.round(num * factor) / factor;
-}
-
 /**
- * round path data
- * either by explicit decimal value or
- * based on suggested accuracy in path data
+ * rounding helper
+ * allows for quantized rounding
+ * e.g 0.5 decimals s
  */
-function roundPathData(pathData, decimalsGlobal = -1) {
-
-    if (decimalsGlobal < 0) return pathData;
-
-    let len = pathData.length;
-
-    let decimals = decimalsGlobal;
+function roundTo(num = 0, decimals = 3) {
+    if (decimals < 0) return num;
+    // Normal integer rounding
+    if (!decimals) return Math.round(num);
 
-    for (let c = 0; c < len; c++) {
-        let com = pathData[c];
-        let {values} = com;
+    // stepped rounding
+    let intPart = Math.floor(decimals);
 
-        let valLen = values.length;
-        if (!valLen) continue
+    if (intPart !== decimals) {
+        let f = +(decimals - intPart).toFixed(2);
+        f = f > 0.5 ? (Math.floor((f) / 0.5) * 0.5) : f;
 
-        for (let v = 0; v < valLen; v++) {
-            pathData[c].values[v] = roundTo(values[v], decimals);
-        }
+        let step = 10 ** -intPart * f;
+        return +(Math.round(num / step) * step).toFixed(8);
     }
 
-    return pathData;
+    let factor = 10 ** decimals;
+    return Math.round(num * factor) / factor;
 }
 
 /**
@@ -1843,20 +2119,24 @@ function getPolygonArea(points, absolute=false) {
 * d attribute string 
 */
 
-function pathDataToD(pathData, optimize = 0) {
-
-    optimize = parseFloat(optimize);
+function pathDataToD(pathData, mode = 0) {
 
+    mode = parseFloat(mode);
+    /*
+    0 = max minification
+    0.5 = safe
+    1 = verbose
+    2 = beautify
+    */
     let len = pathData.length;
-    let beautify = optimize > 1;
-    let minify = beautify || optimize ? false : true;
 
-    let d = '';
     let valsString = pathData[0].values.join(" ");
-    let separator_command = beautify ? `\n` : (minify ? '' : ' ');
-    let separator_type = !minify ? ' ' : '';
+    let separator_command = mode > 1 ? `\n` :
+        ((mode < 1) ? '' : ' ');
+    let separator_type = mode > 0.5 ? ' ' : '';
 
-    d = `${pathData[0].type}${separator_type}${valsString}${separator_command}`;
+    // 1st command
+    let d = `${pathData[0].type}${separator_type}${valsString}${separator_command}`;
 
     for (let i = 1; i < len; i++) {
         let com0 = pathData[i - 1];
@@ -1865,7 +2145,7 @@ function pathDataToD(pathData, optimize = 0) {
         valsString = '';
 
         // Minify Arc commands (A/a) – actually sucks!
-        if (minify && (type === 'A' || type === 'a')) {
+        if (!mode && (type === 'A' || type === 'a')) {
             values = [
                 values[0], values[1], values[2],
                 `${values[3]}${values[4]}${values[5]}`,
@@ -1874,14 +2154,14 @@ function pathDataToD(pathData, optimize = 0) {
         }
 
         // Omit type for repeated commands
-        type = (minify && com0.type === com.type && com.type.toLowerCase() !== 'm')
+        type = ((mode < 1) && com0.type === com.type && com.type.toLowerCase() !== 'm')
             ? " "
-            : (minify && com0.type === "M" && com.type === "L"
+            : ((mode < 1) && com0.type === "M" && com.type === "L"
                 ? " "
                 : com.type);
 
         // concatenate subsequent floating point values
-        if (minify) {
+        if (!mode) {
 
             let prevWasFloat = false;
 
@@ -1905,22 +2185,23 @@ function pathDataToD(pathData, optimize = 0) {
                 prevWasFloat = isSmallFloat;
             }
 
-            d += `${type}${separator_type}${valsString}${separator_command}`;
-
         }
         // regular non-minified output
         else {
-            d += `${type}${separator_type}${values.join(' ')}${separator_command}`;
+            valsString = values.join(' ');
         }
+
+        if(i===len-1) separator_command='';
+        d += `${type}${separator_type}${valsString}${separator_command}`;
     }
 
-    if (minify) {
+    if (mode < 1) {
         d = d
             .replace(/[A-Za-z]0(?=\.)/g, m => m[0])
             .replace(/ 0\./g, " .") // Space before small decimals
             .replace(/ -/g, "-")     // Remove space before negatives
             .replace(/-0\./g, "-.")  // Remove leading zero from negative decimals
-            .replace(/Z/g, "z");     // Convert uppercase 'Z' to lowercase
+            .replace(/Z/g, "z");    // Convert uppercase 'Z' to lowercase
     }
 
     return d;
@@ -2260,9 +2541,9 @@ function combineCubicPairs(com1, com2, {
     let comS = getExtrapolatedCommand(com1, com2, t);
 
     // test new point-at-t against original mid segment starting point
-    let pt = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t);
+    let ptI = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t);
 
-    let dist0 = getDistManhattan(com1.p, pt);
+    let dist0 = getDistManhattan(com1.p, ptI);
     let dist1 = 0, dist2 = 0;
     let close = dist0 < maxDist;
     let success = false;
@@ -2277,29 +2558,40 @@ function combineCubicPairs(com1, com2, {
          * to prevent distortions
          */
 
-        // 2nd segment mid
-        let pt_2 = pointAtT([com2.p0, com2.cp1, com2.cp2, com2.p], 0.5);
+        // 1st segment mid
+        let ptM_seg1 = pointAtT([com1.p0, com1.cp1, com1.cp2, com1.p], 0.5);
 
-        // simplified path
-        let t3 = (1 + t) * 0.5;
-        let ptS_2 = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t3);
-        dist1 = getDistManhattan(pt_2, ptS_2);
+        let t2 = t * 0.5;
+        // combined interpolated mid point
+        let ptI_seg1 = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t2);
+        dist1 = getDistManhattan(ptM_seg1, ptI_seg1);
 
         error += dist1;
 
         if (dist1 < maxDist) {
 
-            // 1st segment mid
-            let pt_1 = pointAtT([com1.p0, com1.cp1, com1.cp2, com1.p], 0.5);
+            // 2nd segment mid
+            let ptM_seg2 = pointAtT([com2.p0, com2.cp1, com2.cp2, com2.p], 0.5);
 
-            let t2 = t * 0.5;
-            let ptS_1 = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t2);
-            dist2 = getDistManhattan(pt_1, ptS_1);
+            // simplified path
+            let t3 = (1 + t) * 0.5;
+            let ptI_seg2 = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t3);
+            dist2 = getDistManhattan(ptM_seg2, ptI_seg2);
 
             error += dist2;
 
             if (error < maxDist) success = true;
 
+            /*
+            renderPoint(markers, ptM_seg1, 'cyan')
+            renderPoint(markers, pt, 'orange', '1.5%', '1')
+            renderPoint(markers, ptM_seg2, 'orange')
+
+            renderPoint(markers, com1.p, 'green')
+
+            renderPoint(markers, ptI_seg1, 'purple')
+            */
+
         }
 
     } // end 1st try
@@ -2464,6 +2756,7 @@ function analyzePathData(pathData = [], {
         let com = pathData[c - 1];
         let { type, values, p0, p, cp1 = null, cp2 = null, squareDist = 0, cptArea = 0, dimA = 0 } = com;
 
+        let comPrev = pathData[c-2];
         let comN = pathData[c] || null;
 
         // init properties
@@ -2482,6 +2775,7 @@ function analyzePathData(pathData = [], {
 
         // bezier types
         let isBezier = type === 'Q' || type === 'C';
+        let isArc = type === 'A';
         let isBezierN = comN && (comN.type === 'Q' || comN.type === 'C');
 
         /**
@@ -2528,6 +2822,22 @@ function analyzePathData(pathData = [], {
             }
         }
 
+        // check extremes introduce by small arcs
+        else if(isArc && comN && ((comPrev.type==='C' || comPrev.type==='Q') || (comN.type==='C' || comN.type==='Q'))  ){
+            let distN = comN ? comN.dimA : 0;
+            let isShort = com.dimA < (comPrev.dimA + distN) * 0.1;
+            let smallRadius = com.values[0] === com.values[1] && (com.values[0] < 1);
+
+            if(isShort && smallRadius){
+                let bb = getPolyBBox([comPrev.p0, comN.p]);
+                if(p.x>bb.right || p.x<bb.x || p.y<bb.y || p.y>bb.bottom){
+                    hasExtremes = true;
+
+                }
+            }
+
+        }
+
         if (hasExtremes) com.extreme = true;
 
         // Corners and semi extremes 
@@ -2797,6 +3107,7 @@ const sanitizeArc = (val='', valueIndex=0) => {
 };
 
 function parsePathDataString(d, debug = true, limit=0) {
+    if(!d) return []
     d = d.trim();
 
     if(limit) console.log('!!!limit', limit);
@@ -3080,50 +3391,10 @@ function parsePathDataString(d, debug = true, limit=0) {
 
 }
 
-function parsePathDataNormalized(d,
-    {
-        // necessary for most calculations
-        toAbsolute = true,
-        toLonghands = true,
-
-        // not necessary unless you need cubics only
-        quadraticToCubic = false,
-
-        // mostly a fallback if arc calculations fail      
-        arcToCubic = false,
-        // arc to cubic precision - adds more segments for better precision     
-        arcAccuracy = 4,
-    } = {}
-) {
-
-    // 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
-        },
-    );
-
-    return pathData;
-}
-
+/**
+ * wrapper function for 
+ * all path data conversion
+ */
 function convertPathData(pathData, {
     toShorthands = true,
     toLonghands = false,
@@ -3139,6 +3410,7 @@ function convertPathData(pathData, {
     hasShorthands = true,
     hasQuadratics = true,
     hasArcs = true,
+    isPoly = false,
     optimizeArcs = true,
     testTypes = false
 
@@ -3159,6 +3431,7 @@ function convertPathData(pathData, {
 
     // some params exclude each other
     toRelative = toAbsolute ? false : toRelative;
+
     toShorthands = toLonghands ? false : toShorthands;
 
     if (toAbsolute) pathData = pathDataToAbsolute(pathData);
@@ -3173,22 +3446,24 @@ function convertPathData(pathData, {
 
     if (hasQuadratics && quadraticToCubic) pathData = pathDataQuadraticToCubic(pathData);
 
-    if(toMixed) toRelative = true;
+    if (toMixed) toRelative = true;
 
     // pre round - before relative conversion to minimize distortions
     if (decimals > -1 && toRelative) pathData = roundPathData(pathData, decimals);
 
     // clone absolute pathdata
-    if(toMixed){
+    if (toMixed) {
         pathDataAbs = JSON.parse(JSON.stringify(pathData));
     }
 
     if (toRelative) pathData = pathDataToRelative(pathData);
+
+    // final rounding
     if (decimals > -1) pathData = roundPathData(pathData, decimals);
 
     // choose most compact commands: relative or absolute
-    if(toMixed){
-        for(let i=0; i<pathData.length; i++){
+    if (toMixed) {
+        for (let i = 0; i < pathData.length; i++) {
             let com = pathData[i];
             let comA = pathDataAbs[i];
             // compare Lengths
@@ -3198,7 +3473,7 @@ function convertPathData(pathData, {
             let lenR = comStr.length;
             let lenA = comStrA.length;
 
-            if(lenA<lenR){
+            if (lenA < lenR) {
 
                 pathData[i] = pathDataAbs[i];
             }
@@ -3208,81 +3483,147 @@ function convertPathData(pathData, {
     return pathData
 }
 
-/**
- * 
- * @param {*} pathData 
- * @returns 
- */
-
-function optimizeArcPathData(pathData = []) {
-
-    let remove =[];
+function parsePathDataNormalized(d,
+    {
+        // necessary for most calculations
+        toAbsolute = true,
+        toLonghands = true,
 
-    pathData.forEach((com, i) => {
-        let { type, values } = com;
-        if (type === 'A') {
-            let [rx, ry, largeArc, x, y] = [values[0], values[1], values[3], values[5], values[6]];
-            let comPrev = pathData[i - 1];
-            let [x0, y0] = [comPrev.values[comPrev.values.length - 2], comPrev.values[comPrev.values.length - 1]];
-            let M = { x: x0, y: y0 };
-            let p = { x, y };
+        // not necessary unless you need cubics only
+        quadraticToCubic = false,
 
-            if(rx===0 || ry===0){
-                pathData[i]= null;
-                remove.push(i);
+        // mostly a fallback if arc calculations fail      
+        arcToCubic = false,
+        // arc to cubic precision - adds more segments for better precision     
+        arcAccuracy = 4,
+    } = {}
+) {
 
-            }
+    // is already array
+    let isArray = Array.isArray(d);
 
-            // rx and ry are large enough
-            if (rx >= 1 && (x === x0 || y === y0)) {
-                let diff = Math.abs(rx - ry) / rx;
+    // 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);
+    }
+    */
 
-                // rx~==ry 
-                if (diff < 0.01) {
+    let pathDataObj = isArray ? d : parsePathDataString(d);
 
-                    // test radius against mid point
-                    let pMid = interpolate(M, p, 0.5);                    
-                    let distM = getDistance(pMid, M);
-                    let rDiff = Math.abs(distM - rx) / rx;
+    let { hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true } = pathDataObj;
+    let pathData = hasConstructor ? pathDataObj : pathDataObj.pathData;
 
-                    // half distance between mid and start point should be ~ equal
-                    if(rDiff<0.01){
-                        pathData[i].values[0] = 1;
-                        pathData[i].values[1] = 1;
-                        pathData[i].values[2] = 0;
-                    }
-                }
-            }
-        }
-    });
+    // normalize
+    pathData = normalizePathData(pathData,
+        {
+            toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy,
+            hasRelatives, hasShorthands, hasQuadratics, hasArcs
+        },
+    );
 
-    if(remove.length) pathData = pathData.filter(Boolean);
     return pathData;
 }
 
 /**
- * parse normalized
+ * 
+ * @param {*} pathData 
+ * @returns 
  */
 
-function normalizePathData(pathData = [],
-    {
-        toAbsolute = true,
-        toLonghands = true,
-        quadraticToCubic = false,
-        arcToCubic = false,
-        arcAccuracy = 2,
+function optimizeArcPathData(pathData = []) {
+    let l = pathData.length;
+    let pathDataN = [];
 
-        // assume we need full normalization
-        hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true, testTypes = false
+    for (let i = 0; i < l; i++) {
+        let com = pathData[i];
+        let { type, values } = com;
 
-    } = {}
-) {
+        if (type !== 'A') {
+            pathDataN.push(com);
+            continue
+        }
 
-    return convertPathData(pathData, { toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy, hasRelatives, hasShorthands, hasQuadratics, hasArcs, testTypes, decimals: -1 })
+        let [rx, ry, largeArc, x, y] = [values[0], values[1], values[3], values[5], values[6]];
+        let comPrev = pathData[i - 1];
+        let [x0, y0] = [comPrev.values[comPrev.values.length - 2], comPrev.values[comPrev.values.length - 1]];
+        let M = { x: x0, y: y0 };
+        let p = { x, y };
+
+        if (rx === 0 || ry === 0) {
+            pathData[i] = null;
+        }
+
+        // test for elliptic
+        let rat = rx / ry;
+        let error = rx !== ry ? Math.abs(1 - rat) : 0;
+
+        if (error > 0.01) {
+
+            pathDataN.push(com);
+            continue
+
+        }
+
+        // xAxis rotation is futile for circular arcs - reset
+        com.values[2] = 0;
+
+        /**
+         * test semi circles
+         * rx and ry are large enough
+         */
+
+        // 1. horizontal or vertical
+        let thresh = getDistManhattan(M, p) * 0.001;
+        let diffX = Math.abs(x - x0);
+        let diffY = Math.abs(y - y0);
+
+        let isHorizontal = diffY < thresh;
+        let isVertical = diffX < thresh;
+
+        // minify rx and ry
+        if (isHorizontal || isVertical) {
+
+            // check if semi circle
+            let needsTrueR = isHorizontal ? rx*1.9 > diffX : ry*1.9 > diffY;
+
+            // is semicircle we can simplify rx
+            if (!needsTrueR) {
+
+                rx = rx >= 1 ? 1 : (rx > 0.5 ? 0.5 : rx);
+            }
+
+            com.values[0] = rx;
+            com.values[1] = rx;
+            pathDataN.push(com);
+            continue
+
+        }
+
+        // 2. get true radius - if rx ~= diameter/distance  we have a semicircle
+        let r = getDistance(M, p) * 0.5;
+        error = rx / r;
+
+        if (error < 0.5) {
+            rx = r >= 1 ? 1 : (r > 0.5 ? 0.5 : r);
+        }
+
+        com.values[0] = rx;
+        com.values[1] = rx;
+        pathDataN.push(com);
+
+    }
+
+    return pathDataN;
 }
 
-/*
-export function normalizePathData(pathData = [],
+/**
+ * parse normalized
+ */
+
+function normalizePathData(pathData = [],
     {
         toAbsolute = true,
         toLonghands = true,
@@ -3296,31 +3637,8 @@ export function normalizePathData(pathData = [],
     } = {}
 ) {
 
-    // pathdata properties - test= true adds a manual test 
-    if (testTypes) {
-
-        let commands = Array.from(new Set(pathData.map(com => com.type))).join('');
-        hasRelatives = /[lcqamts]/gi.test(commands);
-        hasQuadratics = /[qt]/gi.test(commands);
-        hasArcs = /[a]/gi.test(commands);
-        hasShorthands = /[vhst]/gi.test(commands);
-        isPoly = /[mlz]/gi.test(commands);
-    }
-
-    if ((hasQuadratics && quadraticToCubic) || (hasArcs && arcToCubic)) {
-        toLonghands = true
-        toAbsolute = true
-    }
-
-    if (hasRelatives && toAbsolute) pathData = pathDataToAbsoluteOrRelative(pathData, false);
-    if (hasShorthands && toLonghands) pathData = pathDataToLonghands(pathData, -1, false);
-    if (hasArcs && arcToCubic) pathData = pathDataArcsToCubics(pathData, arcAccuracy);
-    if (hasQuadratics && quadraticToCubic) pathData = pathDataQuadraticToCubic(pathData);
-
-    return pathData;
-
+    return convertPathData(pathData, { toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy, hasRelatives, hasShorthands, hasQuadratics, hasArcs, testTypes, decimals: -1 })
 }
-*/
 
 function revertCubicQuadratic(p0 = {}, cp1 = {}, cp2 = {}, p = {}, tolerance = 1) {
 
@@ -4201,7 +4519,7 @@ function pathDataToTopLeft(pathData) {
         let { type, values } = com;
         let valsLen = values.length;
         if (valsLen) {
-            let p = { type: type, x: values[valsLen-2], y: values[valsLen-1], index: 0};
+            let p = { type: type, x: values[valsLen - 2], y: values[valsLen - 1], index: 0 };
             p.index = i;
             indices.push(p);
         }
@@ -4209,113 +4527,111 @@ function pathDataToTopLeft(pathData) {
 
     // reorder  to top left most
 
-    indices = indices.sort((a, b) => +a.y.toFixed(8) - +b.y.toFixed(8) || 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;
 
-    return  newIndex ? shiftSvgStartingPoint(pathData, newIndex) : pathData;
+    return newIndex ? shiftSvgStartingPoint(pathData, newIndex) : pathData;
 }
 
-function optimizeClosePath(pathData, {removeFinalLineto = true, autoClose = true}={}) {
+function optimizeClosePath(pathData, { removeFinalLineto = true, autoClose = true } = {}) {
 
-    let pathDataNew = [];
+    let pathDataN = pathData;
     let l = pathData.length;
     let M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(8) };
     let isClosed = pathData[l - 1].type.toLowerCase() === 'z';
 
-    let linetos = pathData.filter(com => com.type === 'L');
-
-    // check if order is ideal
-    let idxPenultimate = isClosed ? l-2 : l-1;
+    let hasLinetos = false;
 
+    // check if path is closed by explicit lineto
+    let idxPenultimate = isClosed ? l - 2 : l - 1;
     let penultimateCom = pathData[idxPenultimate];
     let penultimateType = penultimateCom.type;
     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 hasClosingCommand = penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y;
+    let lastIsLine = penultimateType === 'L';
 
-    // add closepath Z to enable order optimizations
-    if(!isClosed && autoClose && isClosingCommand){
-
-        /*
-        // adjust final coords
-        let valsLast = pathData[idxPenultimate].values
-        let valsLastLen = valsLast.length;
-        pathData[idxPenultimate].values[valsLastLen-2] = M.x
-        pathData[idxPenultimate].values[valsLastLen-1] = M.y
-        */
-        
-        pathData.push({type:'Z', values:[]});
-        isClosed = true;
-        l++;
-    }
+    // create index
+    let indices = [];
+    for (let i = 0; i < l; i++) {
+        let com = pathData[i];
+        let { type, values, p0, p } = com;
 
-    // if last segment is not closing or a lineto
-    let skipReorder = pathData[1].type !== 'L' && (!isClosingCommand || penultimateCom.type === 'L');
-    skipReorder = false;
+        if(type==='L') hasLinetos = true;
 
-    // we can't change starting point for non closed paths
-    if (!isClosed) {
-        return pathData
-    }
+        // exclude Z
+        if (values.length) {
+            values.slice(-2);
 
-    let newIndex = 0;
+            let x = Math.min(p0.x, p.x);
+            let y = Math.min(p0.y, p.y);
 
-    if (!skipReorder) {
+            let prevCom = pathData[i - 1] ? pathData[i - 1] : pathData[idxPenultimate];
+            let prevType = prevCom.type;
 
-        let indices = [];
-        for (let i = 0; i < l; i++) {
-            let com = pathData[i];
-            let { type, values } = com;
-            if (values.length) {
-                let valsL = values.slice(-2);
-                let prevL = pathData[i - 1] && pathData[i - 1].type === 'L';
-                let nextL = pathData[i + 1] && pathData[i + 1].type === 'L';
-                let prevCom = pathData[i - 1] ? pathData[i - 1].type.toUpperCase() : null;
-                let nextCom = pathData[i + 1] ? pathData[i + 1].type.toUpperCase() : null;
-                let p = { type: type, x: valsL[0], y: valsL[1], dist: 0, index: 0, prevL, nextL, prevCom, nextCom };
-                p.index = i;
-                indices.push(p);
-            }
+            let item = { type: type, x, y, index: 0, prevType };
+            item.index = i;
+            indices.push(item);
         }
 
-        // find top most lineto
+    }
+
+    let xMin = Infinity;
+    let yMin = Infinity;
+    let idx_top = null;
+    let len = indices.length;
 
-        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];
+    for (let i = 0; i < len; i++) {
+        let com = indices[i];
+        let { type, index, x, y, prevType } = com;
 
-            newIndex = curveAfterLine ? curveAfterLine.index - 1 : 0;
+        if (hasLinetos && prevType === 'L') {
+            if (x < xMin && y < yMin) {
+                idx_top = index-1;
+            }
 
-        }
-        // use top most command
-        else {
-            indices = indices.sort((a, b) => +a.y.toFixed(8) - +b.y.toFixed(8) || a.x - b.x);
-            newIndex = indices[0].index;
-        }
+            if (y < yMin) {
+                yMin = y;
+            }
 
-        // reorder 
-        pathData = newIndex ? shiftSvgStartingPoint(pathData, newIndex) : pathData;
+            if (x < xMin) {
+                xMin = x;
+            }
+        }
     }
 
-    M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(8) };
+    // shift to better starting point
+    if (idx_top) {
+        pathDataN = shiftSvgStartingPoint(pathDataN, idx_top);
 
-    l = pathData.length;
+        // update penultimate - reorder might have added new close paths
+        l = pathDataN.length;
+        M = { x: +pathDataN[0].values[0].toFixed(8), y: +pathDataN[0].values[1].toFixed(8) };
 
-    // remove last lineto
-    penultimateCom = pathData[l - 2];
-    penultimateType = penultimateCom.type;
-    penultimateComCoords = penultimateCom.values.slice(-2).map(val=>+val.toFixed(8));
+        idxPenultimate = isClosed ? l - 2 : l - 1;
+        penultimateCom = pathDataN[idxPenultimate];
+        penultimateType = penultimateCom.type;
+        penultimateComCoords = penultimateCom.values.slice(-2).map(val => +val.toFixed(8));
+        lastIsLine = penultimateType ==='L';
+
+        // last L command ends at M 
+        hasClosingCommand = penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y;
+
+    }
 
-    isClosingCommand = penultimateType === 'L' && penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y;
+    // remove unnecessary closing lineto
+    if (removeFinalLineto && hasClosingCommand && lastIsLine) {
+        pathDataN.splice(l - 2, 1);
+    }
 
-    if (removeFinalLineto && isClosingCommand) {
-        pathData.splice(l - 2, 1);
+    // add close path
+    if (autoClose && !isClosed && hasClosingCommand) {
+        pathDataN.push({ type: 'Z', values: [] });
     }
 
-    pathDataNew.push(...pathData);
+    return pathDataN
 
-    return pathDataNew
 }
 
 /**
@@ -4525,8 +4841,130 @@ function refineAdjacentExtremes(pathData, {
 
 }
 
+function getArcFromPoly(pts, precise = false) {
+    if (pts.length < 3) return false
+
+    // Pick 3 well-spaced points
+    let len = pts.length;
+    let idx1 = Math.floor(len * 0.333);
+    let idx2 = Math.floor(len * 0.666);
+    let idx3 = Math.floor(len * 0.5);
+
+    let p1 = pts[0];
+    let p2 = pts[idx3];
+    let p3 = pts[len - 1];
+
+    // Radius (use start point)
+    let pts1 = [p1, p2, p3];
+    let centroid = getPolyArcCentroid(pts1);
+
+    let r = 0, deltaAngle = 0, startAngle = 0, endAngle = 0, angleData = {};
+
+    // check if radii are consistent
+    if (precise) {
+
+        /**
+         * check multiple centroids
+         * if the polyline can be expressed as 
+         * an arc - all centroids should be close
+         */
+
+        if (len > 3) {
+            let centroid1 = getPolyArcCentroid([p1, pts[idx1], p3]);
+            let centroid2 = getPolyArcCentroid([p1, pts[idx2], p3]);
+
+            if (!centroid1 || !centroid2) return false;
+
+            let dist0 = getDistManhattan(centroid, p2);
+            let dist1 = getDistManhattan(centroid, centroid1);
+            let dist2 = getDistManhattan(centroid, centroid2);
+            let errorCentroid = (dist1 + dist2);
+
+            // centroids diverging too much 
+            if (errorCentroid > dist0 * 0.05) {
+
+                return false
+            }
+
+        }
+
+        let rSqMid = getSquareDistance(centroid, p2);
+
+        for (let i = 0; i < len; i++) {
+            let pt = pts[i];
+            let rSq = getSquareDistance(centroid, pt);
+            let error = Math.abs(rSqMid - rSq) / rSqMid;
+
+            if (error > 0.0025) {
+                /*
+                console.log('error', error, len, idx1, idx2, idx3);
+                renderPoint(markers, centroid, 'orange')
+                renderPoint(markers, p1, 'green')
+                renderPoint(markers, p2)
+                renderPoint(markers, p3, 'purple')
+                */
+                return false;
+            }
+        }
+
+        // calculate proper radius
+        r = Math.sqrt(rSqMid);
+        angleData = getDeltaAngle(centroid, p1, p3);
+        ({ deltaAngle, startAngle, endAngle } = angleData);
+
+    } else {
+        r = getDistance(centroid, p1);
+        angleData = getDeltaAngle(centroid, p1, p3);
+        ({ deltaAngle, startAngle, endAngle } = angleData);
+    }
+
+    return {
+        centroid,
+        r,
+        startAngle,
+        endAngle,
+        deltaAngle
+    };
+}
+
+function getPolyArcCentroid(pts = []) {
+
+    pts = pts.filter(pt => pt !== undefined);
+    if (pts.length < 3) return false
+
+    let p1 = pts[0];
+    let p2 = pts[Math.floor(pts.length / 2)];
+    let p3 = pts[pts.length - 1];
+
+    let x1 = p1.x, y1 = p1.y;
+    let x2 = p2.x, y2 = p2.y;
+    let x3 = p3.x, y3 = p3.y;
+
+    let a = x1 - x2;
+    let b = y1 - y2;
+    let c = x1 - x3;
+    let d = y1 - y3;
+
+    let e = ((x1 * x1 - x2 * x2) + (y1 * y1 - y2 * y2)) / 2;
+    let f = ((x1 * x1 - x3 * x3) + (y1 * y1 - y3 * y3)) / 2;
+
+    let det = a * d - b * c;
+
+    // colinear points
+    if (Math.abs(det) < 1e-10) {
+        return false;
+    }
+
+    // find center of arc
+    let cx = (d * e - b * f) / det;
+    let cy = (-c * e + a * f) / det;
+    let centroid = { x: cx, y: cy };
+    return centroid
+}
+
 function refineRoundedCorners(pathData, {
     threshold = 0,
+    simplifyQuadraticCorners = false,
     tolerance = 1
 } = {}) {
 
@@ -4551,6 +4989,9 @@ function refineRoundedCorners(pathData, {
     let firstIsLine = pathData[1].type === 'L';
     let firstIsBez = pathData[1].type === 'C';
 
+    // in case we have simplified a corner connecting to the start
+    let M_adj = null;
+
     let normalizeClose = isClosed && firstIsBez && (lastIsLine || zIsLineto);
 
     // normalize closepath to lineto
@@ -4590,15 +5031,17 @@ function refineRoundedCorners(pathData, {
             // closing corner to start
             if (isClosed && lastIsBez && firstIsLine && i === l - lastOff - 1) {
                 comL1 = pathData[1];
+
                 comBez = [pathData[l - lastOff]];
 
             }
 
+            // collect enclosed bezier segments
             for (let j = i + 1; j < l; j++) {
                 let comN = pathData[j] ? pathData[j] : null;
                 let comPrev = pathData[j - 1];
 
-                if (comPrev.type === 'C') {
+                if (comPrev.type === 'C' && j > 2) {
                     comBez.push(comPrev);
                 }
 
@@ -4629,39 +5072,67 @@ function refineRoundedCorners(pathData, {
                 let bezThresh = len3 * 0.5 * tolerance;
                 let isSmall = bezThresh < len1 && bezThresh < len2;
 
+                /*
+                */
+
                 if (comBez.length && !signChange && isSmall) {
 
-                    let isFlatBezier = Math.abs(area2) < getSquareDistance(comBez[0].p0, comBez[0].p) * 0.005;
+                    let isSquare = false;
+
+                    if (comBez.length === 1) {
+                        let dx = Math.abs(comBez[0].p.x - comBez[0].p0.x);
+                        let dy = Math.abs(comBez[0].p.y - comBez[0].p0.y);
+                        let diff = (dx - dy);
+                        let rat = Math.abs(diff / dx);
+                        isSquare = rat < 0.01;
+                    }
+
+                    let preferArcs = true;
+                    preferArcs = false;
+
+                    // if rectangular prefer arcs
+                    if (preferArcs && isSquare) {
+
+                        let pM = pointAtT([comBez[0].p0, comBez[0].cp1, comBez[0].cp2, comBez[0].p], 0.5);
+
+                        let arcProps = getArcFromPoly([comBez[0].p0, pM, comBez[0].p]);
+                        let { r, centroid, deltaAngle } = arcProps;
+
+                        let sweep = deltaAngle > 0 ? 1 : 0;
+
+                        let largeArc = 0;
+
+                        let comArc = { type: 'A', values: [r, r, 0, largeArc, sweep, comBez[0].p.x, comBez[0].p.y] };
+
+                        pathDataN.push(comL0, comArc);
+                        i += offset;
+                        continue
+
+                    }
+
+                    let areaThresh = getSquareDistance(comBez[0].p0, comBez[0].p) * 0.005;
+                    let isFlatBezier = Math.abs(area2) < areaThresh;
+                    let isFlatBezier2 = Math.abs(area2) < areaThresh * 10;
+
                     let ptQ = !isFlatBezier ? checkLineIntersection(comL0.p0, comL0.p, comL1.p, comL1.p0, false, true) : null;
 
-                    if (!ptQ) {
+                    // exit: is rather flat or has no intersection
+
+                    if (!ptQ || (isFlatBezier2 && comBez.length === 1)) {
                         pathDataN.push(com);
                         continue
                     }
 
-                    // check sign change
+                    // check sign change - exit if present
                     if (ptQ) {
                         let area0 = getPolygonArea([comL0.p0, comL0.p, comL1.p0, comL1.p], false);
                         let area0_abs = Math.abs(area0);
                         let area1 = getPolygonArea([comL0.p0, comL0.p, ptQ, comL1.p0, comL1.p], false);
                         let area1_abs = Math.abs(area1);
                         let areaDiff = Math.abs(area0_abs - area1_abs) / area0_abs;
-
-                        /*
-                        renderPoint(markers, comL0.p0, 'green', '0.5%', '0.5')
-                        renderPoint(markers, comL0.p, 'red', '1.5%', '0.5')
-                        renderPoint(markers, comL1.p0, 'blue', '0.5%', '0.5')
-                        renderPoint(markers, comL1.p, 'orange', '0.5%', '0.5')
-                        if(!area0) {
-                            pathDataN.push(com);
-                            continue
-                        }
-                        */
-
                         let signChange = area0 < 0 && area1 > 0 || area0 > 0 && area1 < 0;
 
                         if (!ptQ || signChange || areaDiff > 0.5) {
-
                             pathDataN.push(com);
                             continue
                         }
@@ -4676,24 +5147,67 @@ function refineRoundedCorners(pathData, {
 
                     // not in tolerance – return original command
                     if (bezThresh && dist1 > bezThresh && dist1 > len3 * 0.3) {
-
                         pathDataN.push(com);
                         continue;
 
-                    } else {
+                    }
 
-                        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;
+                    // return simplified quadratic Bézier command
+                    let p_Q = comL1.p0;
 
-                        // add quadratic command
-                        pathDataN.push(comL0, comQ);
-                        i += offset;
+                    // adjust previous end point to better fit the cubic curvature
+                    let adjustQ = !simplifyQuadraticCorners;
+
+                    if (adjustQ) {
+
+                        let t = 0.1666;
+                        let p0_adj = interpolate(ptQ, comL0.p, (1 + t));
+                        p_Q = interpolate(ptQ, comL1.p0, (1 + t));
+
+                        // round for large enough segments
+                        let isH = ptQ.y===comL0.p.y;
+                        let isV = ptQ.x===comL0.p.x;
+                        let isH2 = ptQ.y===comL1.p0.y;
+                        let isV2 = ptQ.x===comL1.p0.x;
+
+                        if(isSquare && com.dimA>3){
+                            let dec = 0.5;
+                            if(isH) p0_adj.x = roundTo(p0_adj.x, dec);
+                            if(isV) p0_adj.y = roundTo(p0_adj.y, dec);
+                            if(isH2) p_Q.x = roundTo(p_Q.x, dec);
+                            if(isV2) p_Q.y = roundTo(p_Q.y, dec);
+                        }
+
+                        /*
+                        renderPoint(markers, p0_adj, 'orange')
+                        renderPoint(markers, p_Q, 'orange')
+                        renderPoint(markers, comL0.p, 'green')
+                        renderPoint(markers, comL1.p0, 'magenta')
+                        */
+
+                        // set new M starting point
+                        if (i === l - lastOff - 1) {
+
+                            M_adj = p_Q;
+                        }
+
+                        // adjust previous lineto end point
+                        comL0.values = [p0_adj.x, p0_adj.y];
+                        comL0.p = p0_adj;
 
-                        continue;
                     }
 
+                    let comQ = { type: 'Q', values: [ptQ.x, ptQ.y, p_Q.x, p_Q.y] };
+                    comQ.cp1 = ptQ;
+                    comQ.p0 = comL0.p;
+                    comQ.p = p_Q;
+
+                    // add quadratic command
+                    pathDataN.push(comL0, comQ);
+
+                    i += offset;
+                    continue;
+
                 }
             }
         }
@@ -4707,6 +5221,12 @@ function refineRoundedCorners(pathData, {
 
     }
 
+    // correct starting point connecting with last corner rounding
+    if (M_adj) {
+        pathDataN[0].values = [M_adj.x, M_adj.y];
+        pathDataN[0].p0 = M_adj;
+    }
+
     // revert close path normalization
     if (normalizeClose || (isClosed && pathDataN[pathDataN.length - 1].type !== 'Z')) {
         pathDataN.push({ type: 'Z', values: [] });
@@ -4716,51 +5236,101 @@ function refineRoundedCorners(pathData, {
 
 }
 
-function getArcFromPoly(pts) {
-    if (pts.length < 3) return false
+function refineClosingCommand(pathData = [], {
+    threshold = 0,
+} = {}) {
 
-    // Pick 3 well-spaced points
-    let  p1 = pts[0];
-    let  p2 = pts[Math.floor(pts.length / 2)];
-    let  p3 = pts[pts.length - 1];
+    let l = pathData.length;
+    let comLast = pathData[l - 1];
+    let isClosed = comLast.type.toLowerCase() === 'z';
+    let idxPenultimate = isClosed ? l - 2 : l - 1;
+    let comPenultimate = isClosed ? pathData[idxPenultimate] : pathData[idxPenultimate];
+    let valsPen = comPenultimate.values.slice(-2);
 
-    let  x1 = p1.x, y1 = p1.y;
-    let  x2 = p2.x, y2 = p2.y;
-    let  x3 = p3.x, y3 = p3.y;
+    let M = { x: pathData[0].values[0], y: pathData[0].values[1] };
+    let pPen = { x: valsPen[0], y: valsPen[1] };
+    let dist = getDistAv(M, pPen);
 
-    let  a = x1 - x2;
-    let  b = y1 - y2;
-    let  c = x1 - x3;
-    let  d = y1 - y3;
+    // adjust last coordinates for better reordering
+    if (dist && dist < threshold) {
 
-    let  e = ((x1 * x1 - x2 * x2) + (y1 * y1 - y2 * y2)) / 2;
-    let  f = ((x1 * x1 - x3 * x3) + (y1 * y1 - y3 * y3)) / 2;
+        let valsLast = pathData[idxPenultimate].values;
+        let valsLastLen = valsLast.length;
+        pathData[idxPenultimate].values[valsLastLen - 2] = M.x;
+        pathData[idxPenultimate].values[valsLastLen - 1] = M.y;
 
-    let  det = a * d - b * c;
+        // adjust cpts
+        let comFirst = pathData[1];
 
-    if (Math.abs(det) < 1e-10) {
-        console.warn("Points are collinear or numerically unstable");
-        return false;
+        if (comFirst.type === 'C' && comPenultimate.type === 'C') {
+            let dx1 = Math.abs(comFirst.values[0] - comPenultimate.values[2]);
+            let dy1 = Math.abs(comFirst.values[1] - comPenultimate.values[3]);
+
+            let dx2 = Math.abs(pathData[1].values[0] - comFirst.values[0]);
+            let dy2 = Math.abs(pathData[1].values[1] - comFirst.values[1]);
+
+            let dx3 = Math.abs(pathData[1].values[0] - comPenultimate.values[2]);
+            let dy3 = Math.abs(pathData[1].values[1] - comPenultimate.values[3]);
+
+            let ver = dx2 < threshold && dx3 < threshold && dy1;
+            let hor = (dy2 < threshold && dy3 < threshold) && dx1;
+
+            if (dx1 && dx1 < threshold && ver) {
+
+                pathData[1].values[0] = M.x;
+                pathData[idxPenultimate].values[2] = M.x;
+            }
+
+            if (dy1 && dy1 < threshold && hor) {
+
+                pathData[1].values[1] = M.y;
+                pathData[idxPenultimate].values[3] = M.y;
+            }
+
+        }
     }
 
-    // find center of arc
-    let  cx = (d * e - b * f) / det;
-    let  cy = (-c * e + a * f) / det;
-    let  centroid = { x: cx, y: cy };
+    return pathData;
 
-    // Radius (use start point)
-    let  r = getDistance(centroid, p1);
+}
 
-    let angleData = getDeltaAngle(centroid, p1, p3);
-    let {deltaAngle, startAngle, endAngle} = angleData;
+function pathDataRevertCubicToQuadratic(pathData, tolerance=1) {
 
-    return {
-        centroid,
-        r,
-        startAngle,
-        endAngle,
-        deltaAngle
-    };
+    for (let c = 1, 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, tolerance);
+            if (comQ.type === 'Q') {
+                comQ.extreme = com.extreme;
+                comQ.corner = com.corner;
+                comQ.dimA = com.dimA;
+                comQ.squareDist = com.squareDist;
+                pathData[c] = comQ;
+            }
+        }
+    }
+    return pathData
+}
+
+function pathDataLineToCubic(pathData) {
+
+    for (let c = 1, l = pathData.length; c < l; c++) {
+        let com = pathData[c];
+        let { type, values, p0, cp1 = null, cp2 = null, p = null } = com;
+        if (type === 'L') {
+
+            let cp1 = interpolate(p0, p, 0.333);
+            let cp2 = interpolate(p, p0, 0.333);
+
+            pathData[c].type = 'C';
+            pathData[c].values = [cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
+            pathData[c].cp1 = cp1;
+            pathData[c].cp2 = cp2;
+
+        }
+    }
+    return pathData
 }
 
 function refineRoundSegments(pathData, {
@@ -4779,9 +5349,6 @@ function refineRoundSegments(pathData, {
     // add fist command
     let pathDataN = [pathData[0]];
 
-    // just for debugging
-    let pathDataTest = [];
-
     for (let i = 1; i < l; i++) {
         let com = pathData[i];
         let { type } = com;
@@ -4808,11 +5375,12 @@ function refineRoundSegments(pathData, {
 
         // 2. line-line-bezier-line-line
         if (
+            comN2 && comN3 &&
             comP.type === 'L' &&
             type === 'L' &&
             comBez &&
             comN2.type === 'L' &&
-            comN3 && (comN3.type === 'L' || comN3.type === 'Z')
+            (comN3.type === 'L' || comN3.type === 'Z')
         ) {
 
             L1 = [com.p0, com.p];
@@ -4839,10 +5407,10 @@ function refineRoundSegments(pathData, {
         }
 
         // 1. line-bezier-bezier-line
-        else if ((type === 'C' || type === 'Q') && comP.type === 'L') {
+        else if (comN && (type === 'C' || type === 'Q') && comP.type === 'L') {
 
             // 1.2 next is cubic next is lineto
-            if ((comN.type === 'C' || comN.type === 'Q') && comN2.type === 'L') {
+            if (comN2 && comN2.type === 'L' && (comN.type === 'C' || comN.type === 'Q')) {
 
                 combine = true;
 
@@ -4901,16 +5469,19 @@ function refineRoundSegments(pathData, {
                         }
                     );
 
-                    if(bezierCommands.length === 1){
+                    if (bezierCommands.length === 1) {
 
                         // prefer more compact quadratic - otherwise arcs
                         let comBezier = revertCubicQuadratic(p0_S, bezierCommands[0].cp1, bezierCommands[0].cp2, p_S);
 
                         if (comBezier.type === 'Q') {
                             toCubic = true;
+                        }else {
+                            comBezier = bezierCommands[0];
                         }
 
                         com = comBezier;
+
                     }
 
                     // prefer arcs if 2 cubics are required
@@ -4930,25 +5501,28 @@ function refineRoundSegments(pathData, {
 
                     // test rendering
 
+                    /*
                     if (debug) {
                         // arcs
                         if (!toCubic) {
                             pathDataTest = [
                                 { type: 'M', values: [p0_S.x, p0_S.y] },
                                 { type: 'A', values: [r, r, xAxisRotation, largeArc, sweep, p_S.x, p_S.y] },
-                            ];
+                            ]
                         }
                         // cubics
                         else {
                             pathDataTest = [
                                 { type: 'M', values: [p0_S.x, p0_S.y] },
                                 ...bezierCommands
-                            ];
+                            ]
+
                         }
 
                         let d = pathDataToD(pathDataTest);
-                        renderPath(markers, d, 'orange', '0.5%', '0.5');
+                        renderPath(markers, d, 'orange', '0.5%', '0.5')
                     }
+                    */
 
                     pathDataN.push(com);
                     i++;
@@ -4965,104 +5539,6 @@ function refineRoundSegments(pathData, {
     return pathDataN;
 }
 
-function refineClosingCommand(pathData = [], {
-    threshold = 0,
-} = {}) {
-
-    let l = pathData.length;
-    let comLast = pathData[l - 1];
-    let isClosed = comLast.type.toLowerCase() === 'z';
-    let idxPenultimate = isClosed ? l - 2 : l - 1;
-    let comPenultimate = isClosed ? pathData[idxPenultimate] : pathData[idxPenultimate];
-    let valsPen = comPenultimate.values.slice(-2);
-
-    let M = { x: pathData[0].values[0], y: pathData[0].values[1] };
-    let pPen = { x: valsPen[0], y: valsPen[1] };
-    let dist = getDistAv(M, pPen);
-
-    // adjust last coordinates for better reordering
-    if (dist && dist < threshold) {
-
-        let valsLast = pathData[idxPenultimate].values;
-        let valsLastLen = valsLast.length;
-        pathData[idxPenultimate].values[valsLastLen - 2] = M.x;
-        pathData[idxPenultimate].values[valsLastLen - 1] = M.y;
-
-        // adjust cpts
-        let comFirst = pathData[1];
-
-        if (comFirst.type === 'C' && comPenultimate.type === 'C') {
-            let dx1 = Math.abs(comFirst.values[0] - comPenultimate.values[2]);
-            let dy1 = Math.abs(comFirst.values[1] - comPenultimate.values[3]);
-
-            let dx2 = Math.abs(pathData[1].values[0] - comFirst.values[0]);
-            let dy2 = Math.abs(pathData[1].values[1] - comFirst.values[1]);
-
-            let dx3 = Math.abs(pathData[1].values[0] - comPenultimate.values[2]);
-            let dy3 = Math.abs(pathData[1].values[1] - comPenultimate.values[3]);
-
-            let ver = dx2 < threshold && dx3 < threshold && dy1;
-            let hor = (dy2 < threshold && dy3 < threshold) && dx1;
-
-            if (dx1 && dx1 < threshold && ver) {
-
-                pathData[1].values[0] = M.x;
-                pathData[idxPenultimate].values[2] = M.x;
-            }
-
-            if (dy1 && dy1 < threshold && hor) {
-
-                pathData[1].values[1] = M.y;
-                pathData[idxPenultimate].values[3] = M.y;
-            }
-
-        }
-    }
-
-    return pathData;
-
-}
-
-function pathDataRevertCubicToQuadratic(pathData, tolerance=1) {
-
-    for (let c = 1, 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, tolerance);
-            if (comQ.type === 'Q') {
-                comQ.extreme = com.extreme;
-                comQ.corner = com.corner;
-                comQ.dimA = com.dimA;
-                comQ.squareDist = com.squareDist;
-                pathData[c] = comQ;
-            }
-        }
-    }
-    return pathData
-}
-
-function pathDataLineToCubic(pathData) {
-
-    for (let c = 1, l = pathData.length; c < l; c++) {
-        let com = pathData[c];
-        let { type, values, p0, cp1 = null, cp2 = null, p = null } = com;
-        if (type === 'L') {
-
-            let cp1 = interpolate(p0, p, 0.333);
-            let cp2 = interpolate(p, p0, 0.333);
-
-            pathData[c].type = 'C';
-            pathData[c].values = [cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
-            pathData[c].cp1 = cp1;
-            pathData[c].cp2 = cp2;
-
-        }
-    }
-    return pathData
-}
-
 function simplifyPathData(input = '', {
 
     toAbsolute = true,
@@ -5120,7 +5596,10 @@ function simplifyPathData(input = '', {
     let yArr = [];
 
     // mode:0 – single path
-    let inputType = detectInputType(input);
+
+    let inputDetection = detectInputType(input);
+    let {inputType, log} = inputDetection;
+
     if (inputType === 'pathDataString') {
         d = input;
     } else if (inputType === 'polyString') {