svg-path-simplify 0.0.9 → 0.1.2

package/src/svgii/pathData_refine_round.js

@@ -0,0 +1,222 @@
+import { checkLineIntersection, getAngle, getDistAv, getDistance, getPointOnEllipse, getSquareDistance, pointAtT, rotatePoint } from "./geometry";
+import { getPolygonArea } from "./geometry_area";
+import { getArcFromPoly } from "./geometry_deduceRadius";
+import { arcToBezierResolved, revertCubicQuadratic } from "./pathData_convert";
+import { pathDataToD } from "./pathData_stringify";
+import { renderPath, renderPoint, renderPoly } from "./visualize";
+
+export function refineRoundSegments(pathData, {
+    threshold = 0,
+    tolerance = 1,
+    // take arcs or cubic beziers
+    toCubic = false,
+    debug = false
+} = {}) {
+
+
+    // min size threshold for corners
+    threshold *= tolerance;
+
+    let l = pathData.length;
+
+    // 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;
+        let comP = pathData[i - 1];
+        let comN = pathData[i + 1] ? pathData[i + 1] : null;
+        let comN2 = pathData[i + 2] ? pathData[i + 2] : null;
+        let comN3 = pathData[i + 3] ? pathData[i + 3] : null;
+        let comBez = null;
+
+        if ((com.type === 'C' || com.type === 'Q')) comBez = com;
+        else if (comN && (comN.type === 'C' || comN.type === 'Q')) comBez = comN;
+
+
+        let cpts = comBez ? (comBez.type === 'C' ? [comBez.p0, comBez.cp1, comBez.cp2, comBez.p] : [comBez.p0, comBez.cp1, comBez.p]) : []
+
+        let areaBez = 0;
+        let areaLines = 0;
+        let signChange = false;
+        let L1, L2;
+        let combine = false
+
+        let p0_S, p_S;
+        let poly = []
+        let pMid;
+
+
+        // 2. line-line-bezier-line-line
+        if (
+            comP.type === 'L' &&
+            type === 'L' &&
+            comBez &&
+            comN2.type === 'L' &&
+            comN3 && (comN3.type === 'L' || comN3.type === 'Z')
+        ) {
+
+            L1 = [com.p0, com.p];
+            L2 = [comN2.p0, comN2.p];
+            p0_S = com.p0
+            p_S = comN2.p
+
+            // don't allow sign changes
+            areaBez = getPolygonArea(cpts, false)
+            areaLines = getPolygonArea([...L1, ...L2], false)
+            signChange = (areaBez < 0 && areaLines > 0) || (areaBez > 0 && areaLines < 0)
+
+            if (!signChange) {
+
+                // mid point of mid bezier
+                pMid = pointAtT(cpts, 0.5)
+
+                // add to poly
+                poly = [p0_S, pMid, p_S]
+
+                combine = true
+            }
+
+        }
+
+        // 1. line-bezier-bezier-line
+        else if ((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') {
+
+                combine = true
+
+                L1 = [comP.p0, comP.p];
+                L2 = [comN2.p0, comN2.p];
+                p0_S = comP.p
+                p_S = comN2.p0
+
+                // mid point of mid bezier
+                pMid = comBez.p
+
+                // add to poly
+                poly = [p0_S, comBez.p, p_S]
+
+
+            }
+        }
+
+
+        /**
+         * calculate either combined
+         * cubic or arc commands
+         */
+        if (combine) {
+
+
+            // try to find center of arc
+            let arcProps = getArcFromPoly(poly)
+            if (arcProps) {
+
+                let { centroid, r, deltaAngle, startAngle, endAngle } = arcProps;
+
+                let xAxisRotation = 0;
+                let sweep = deltaAngle > 0 ? 1 : 0;
+                let largeArc = Math.abs(deltaAngle) > Math.PI ? 1 : 0;
+
+                let pCM = rotatePoint(p0_S, centroid.x, centroid.y, deltaAngle * 0.5)
+
+
+                let dist2 = getDistAv(pCM, pMid)
+                let thresh = getDistAv(p0_S, p_S) * 0.05
+                let bezierCommands;
+
+                // point is close enough
+                if (dist2 < thresh) {
+
+                    //toCubic = false;
+
+                    bezierCommands = arcToBezierResolved(
+                        {
+                            p0: p0_S,
+                            p: p_S,
+                            centroid,
+                            rx: r,
+                            ry: r,
+                            xAxisRotation,
+                            sweep,
+                            largeArc,
+                            deltaAngle,
+                            startAngle,
+                            endAngle
+                        }
+                    );
+
+                    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
+                        }
+
+                        com = comBezier
+                    }
+
+
+                    // prefer arcs if 2 cubics are required
+                    if (bezierCommands.length > 1) toCubic = false;
+
+
+                    //toCubic = false
+
+                    // return elliptic arc commands
+                    if (!toCubic) {
+                        // rewrite simplified command
+                        com.type = 'A'
+                        com.values = [r, r, xAxisRotation, largeArc, sweep, p_S.x, p_S.y];
+                    }
+
+                    com.p0 = p0_S;
+                    com.p = p_S;
+                    com.extreme = false;
+                    com.corner = false;
+
+                    // test rendering
+                    //debug=true
+
+                    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')
+                    }
+
+                    pathDataN.push(com);
+                    i++
+                    continue
+
+                }
+            }
+        }
+
+        // pass through
+        pathDataN.push(com)
+    }
+
+    return pathDataN;
+}

package/src/svgii/pathData_remove_collinear.js

@@ -24,11 +24,14 @@ export function pathDataRemoveColinear(pathData, {
         //let p1 = comN.type.toLowerCase() === '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 area = getPolygonArea([p0, p, p1], true)
+
+        let area = p1 ? getPolygonArea([p0, p, p1], true) : Infinity
+
 
         //let distSquare0 = getSquareDistance(p0, p)
         //let distSquare1 = getSquareDistance(p, p1)
@@ -56,14 +59,14 @@ export function pathDataRemoveColinear(pathData, {
                 type = "L"
                 com.type = "L"
                 com.values = valsL
-                //renderPoint(markers, p, 'cyan', '1%', '0.5')
+                //renderPoint(markers, p, 'cyan', '2%', '0.5')
             }
         }
 
 
         // colinear – exclude arcs (as always =) as semicircles won't have an area
         //&& comN.type==='L'
-        if ( isFlat && c < l - 1 && (type === 'L' || (flatBezierToLinetos && isFlatBez)) ) {
+        if ( isFlat && c < l - 1  && comN.type!=='A' && (type === 'L' || (flatBezierToLinetos && isFlatBez)) ) {
             
             /*
             console.log(area, distMax );
@@ -78,6 +81,8 @@ export function pathDataRemoveColinear(pathData, {
             renderPoint(markers, p1, 'cyan', '0.5%', '1')
             */
 
+            //renderPoint(markers, p, 'blue', '1%', '1')
+
 
             continue;
         }

package/src/svgii/pathData_remove_short.js

@@ -0,0 +1,66 @@
+import { getDistAv } from "./geometry";
+import { renderPoint } from "./visualize";
+
+export 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) {
+        //console.log('dist', dist, 'threshold', threshold, comPenultimate);
+        //renderPoint(markers, pPen)
+
+        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]
+        //console.log(comFirst, comPenultimate);
+
+        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;
+
+            //console.log(dy1);
+            if (dx1 && dx1 < threshold && ver) {
+                //console.log('adjust v');
+                pathData[1].values[0] = M.x
+                pathData[idxPenultimate].values[2] = M.x
+            }
+
+            if (dy1 && dy1 < threshold && hor) {
+                //console.log('should be y extreme');
+                pathData[1].values[1] = M.y
+                pathData[idxPenultimate].values[3] = M.y
+            }
+
+        }
+    }
+
+    return pathData;
+
+
+}

package/src/svgii/pathData_reorder.js

@@ -47,28 +47,44 @@ export function pathDataToTopLeft(pathData) {
 
 
 
-export function optimizeClosePath(pathData, removeFinalLineto = true, reorder = true) {
+export function optimizeClosePath(pathData, {removeFinalLineto = true, autoClose = true}={}) {
 
     let pathDataNew = [];
-    let len = pathData.length;
+    let l = pathData.length;
     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 isClosed = pathData[l - 1].type.toLowerCase() === 'z'
 
     let linetos = pathData.filter(com => com.type === 'L')
 
-    //return pathData;
-
 
     // check if order is ideal
-    let penultimateCom = pathData[len - 2];
+    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
 
+    // 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++
+    }
+
     // if last segment is not closing or a lineto
-    let skipReorder = pathData[1].type !== 'L' && (!isClosingCommand || penultimateType === 'L')
+    let skipReorder = pathData[1].type !== 'L' && (!isClosingCommand || penultimateCom.type === 'L')
     skipReorder = false
 
 
@@ -82,7 +98,7 @@ export function optimizeClosePath(pathData, removeFinalLineto = true, reorder =
     if (!skipReorder) {
         //get top most index
         let indices = [];
-        for (let i = 0, len = pathData.length; i < len; i++) {
+        for (let i = 0; i < l; i++) {
             let com = pathData[i];
             let { type, values } = com;
             if (values.length) {
@@ -122,10 +138,10 @@ export function optimizeClosePath(pathData, removeFinalLineto = true, reorder =
 
     M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(8) }
 
-    len = pathData.length
+    l = pathData.length
 
     // remove last lineto
-    penultimateCom = pathData[len - 2];
+    penultimateCom = pathData[l - 2];
     penultimateType = penultimateCom.type;
     penultimateComCoords = penultimateCom.values.slice(-2).map(val=>+val.toFixed(8))
 
@@ -134,7 +150,7 @@ export function optimizeClosePath(pathData, removeFinalLineto = true, reorder =
     //console.log('penultimateCom', isClosingCommand, penultimateCom.values, M);
 
     if (removeFinalLineto && isClosingCommand) {
-        pathData.splice(len - 2, 1)
+        pathData.splice(l - 2, 1)
     }
 
     pathDataNew.push(...pathData);

package/src/svgii/pathData_simplify_refineCorners.js

@@ -1,4 +1,4 @@
-import { checkLineIntersection, getDistAv, interpolate, pointAtT } from "./geometry";
+import { checkLineIntersection, getDistAv, getSquareDistance, interpolate, pointAtT } from "./geometry";
 import { getPolygonArea } from "./geometry_area";
 import { commandIsFlat } from "./geometry_flatness";
 import { renderPoint } from "./visualize";
@@ -8,12 +8,20 @@ export function refineRoundedCorners(pathData, {
     tolerance = 1
 } = {}) {
 
+
+    // min size threshold for corners
+    threshold *= tolerance;
+
     let l = pathData.length;
 
     // add fist command
     let pathDataN = [pathData[0]]
 
     let isClosed = pathData[l - 1].type.toLowerCase() === 'z';
+    let zIsLineto = isClosed ?
+    (pathData[l-1].p.x === pathData[0].p0.x && pathData[l-1].p.y === pathData[0].p0.y)
+     : false ;
+
     let lastOff = isClosed ? 2 : 1;
 
     let comLast = pathData[l - lastOff];
@@ -24,7 +32,9 @@ export function refineRoundedCorners(pathData, {
 
     //console.log('lastIsLine', lastIsLine, 'firstIsLine', firstIsLine, 'lastIsBez', lastIsBez, 'firstIsBez', firstIsBez, 'isClosed', isClosed, 'comLast1', comLast1);
 
-    let normalizeClose = isClosed && firstIsBez;
+    let normalizeClose = isClosed && firstIsBez && (lastIsLine || zIsLineto);
+    let adjustStart = false
+    //normalizeClose = false
     //console.log('normalizeClose', normalizeClose);
 
     // normalize closepath to lineto
@@ -42,9 +52,8 @@ export function refineRoundedCorners(pathData, {
         // search small cubic segments enclosed by linetos
         if ((type === 'L' && comN && comN.type === 'C') ||
             (type === 'C' && comN && comN.type === 'L')
-
         ) {
-            let comL0 = com;
+            let comL0 = type==='L' ? com : null;
             let comL1 = null;
             let comBez = [];
             let offset = 0;
@@ -54,7 +63,12 @@ export function refineRoundedCorners(pathData, {
                 comBez = [pathData[1]]
                 comL0 = pathData[l - 1]
                 comL1 = comN
-                //renderPoint(markers, com.p, 'orange')
+                //renderPoint(markers, com.p, 'purple')
+            }
+
+            if(!comL0) {
+                pathDataN.push(com)
+                continue
             }
 
             // closing corner to start
@@ -93,49 +107,50 @@ export function refineRoundedCorners(pathData, {
                 // check concaveness by area sign change
                 let area1 = getPolygonArea([comL0.p0, comL0.p, comL1.p0, comL1.p], false)
                 let area2 = getPolygonArea([comBez[0].p0, comBez[0].cp1, comBez[0].cp2, comBez[0].p], false)
+                //let isFlatBezier = area2 < getSquareDistance(comL0.p, comL1.p)*0.001
 
                 let signChange = (area1 < 0 && area2 > 0) || (area1 > 0 && area2 < 0)
 
-                if (comBez && !signChange && len3 < threshold && len1 > len3 && len2 > len3) {
+                // exclude mid bezier segments that are larger than surrounding linetos
+                let bezThresh = len3*0.5 * tolerance
+                let isSmall = bezThresh < len1 && bezThresh < len2 ;
 
-                    let ptQ = checkLineIntersection(comL0.p0, comL0.p, comL1.p0, comL1.p, false)
-                    if (ptQ) {
+                //len1 > len3 && len2 > len3
+                if (comBez.length && !signChange &&  isSmall ) {
 
-                        /*
-                        let dist1 = getDistAv(ptQ, comL0.p)
-                        let dist2 = getDistAv(ptQ, comL1.p0)
-                        let diff = Math.abs(dist1-dist2)
-                        let rat =  diff/Math.max(dist1, dist2)
-                        console.log('rat', rat);
-                        */
+                    let isFlatBezier = Math.abs(area2) <= getSquareDistance(comBez[0].p0, comBez[0].p)*0.005
+                    let ptQ = !isFlatBezier ? checkLineIntersection(comL0.p0, comL0.p, comL1.p0, comL1.p, false) : null
 
-                        /*
-                        // adjust curve start and end to meet original
-                        let t = 1
+                    if (!isFlatBezier && ptQ) {
 
-                        let p0_2 = pointAtT([ptQ, comL0.p], t)
-                        //renderPoint(markers, p0_2, 'cyan', '1%', '0.5')
-                        comL0.p = p0_2
-                        comL0.values = [p0_2.x, p0_2.y]
+                        // final check: mid point proximity
+                        let ptM = pointAtT([comL0.p, ptQ, comL1.p0], 0.5)
+                        //renderPoint(markers, ptM, 'red', '0.5%', '0.5')
 
-                        let p_2 = pointAtT([ptQ, comL1.p0], t)
-                        //renderPoint(markers, p_2, 'orange', '1%', '0.5')
-                        comL1.p0 = p_2
+                        let ptM_bez = comBez.length===1 ? pointAtT( [comBez[0].p0, comBez[0].cp1, comBez[0].cp2, comBez[0].p], 0.5 ) : comBez[0].p ;
 
-                        //renderPoint(markers, comL0.p, 'red', '1%', '0.5')
-                        //renderPoint(markers, ptQ, 'magenta')
-                        */
+                        let dist1 = getDistAv(ptM, ptM_bez)
 
+                        // not in tolerance – rturn original command
+                        if(dist1>len3){
+                            //renderPoint(markers, ptM_bez, 'cyan', '0.5%', '0.5')
+                            //renderPoint(markers, ptQ, 'magenta', '0.5%', '0.5')
+                            pathDataN.push(com);
+                        } 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;
+                            //renderPoint(markers, ptQ, 'magenta', '0.5%', '0.5')
+
+                            let comQ = { type: 'Q', values: [ptQ.x, ptQ.y, comL1.p0.x, comL1.p0.y] }
+                            comQ.p0 = comL0.p;
+                            comQ.cp1 = ptQ;
+                            comQ.p = comL1.p0;
+    
+                            // add quadratic command
+                            pathDataN.push(comL0, comQ);
+                            i += offset;
+                            continue;
+                        }
 
-                        // add quadratic command
-                        pathDataN.push(comL0, comQ);
-                        i += offset;
-                        continue;
                     }
                 }
             }
@@ -150,11 +165,16 @@ export function refineRoundedCorners(pathData, {
 
     }
 
+
+
     // revert close path normalization
-    if (normalizeClose) {
+    if (normalizeClose  || (isClosed && pathDataN[pathDataN.length-1].type!=='Z') ) {
         pathDataN.push({ type: 'Z', values: [] })
     }
 
+
+    //console.log(pathDataN);
+
     return pathDataN;
 
 }

package/src/svgii/svg_cleanup.js

@@ -1,54 +1,53 @@
 
 
-
 export function removeEmptySVGEls(svg) {
   let els = svg.querySelectorAll('g, defs');
   els.forEach(el => {
-      if (!el.children.length) el.remove()
+    if (!el.children.length) el.remove()
   })
 }
 
-
+//const DOMParserPoly = globalThis.DOMParser;
 
 export function cleanUpSVG(svgMarkup, {
-  returnDom=false, 
-  removeHidden=true,
-  removeUnused=true,
-}={}) {
+  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', 'fill', 'stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin'];
+  .parseFromString(svgMarkup, "text/html")
+  .querySelector("svg");
+
+
+  let allowed = ['viewBox', 'xmlns', 'width', 'height', 'id', 'class', 'fill', 'stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin'];
   removeExcludedAttribues(svg, allowed)
-  
+
   let removeEls = ['metadata', 'script']
-  
+
   let els = svg.querySelectorAll('*')
-  els.forEach(el=>{
-    let name = el.nodeName;    
+  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 )) {
+    if (name.includes(':') || removeEls.includes(name) || (removeHidden && isHidden)) {
       el.remove();
-    }else{
+    } else {
       // remove BS elements
       removeNameSpaceAtts(el)
     }
   })
 
-  if(returnDom) return svg
+  if (returnDom) return svg
 
   let markup = stringifySVG(svg)
-  console.log(markup);
+  //console.log(markup);
 
   return markup;
 }
@@ -67,7 +66,7 @@ function cleanSvgPrologue(svgString) {
   );
 }
 
-function removeExcludedAttribues(el, allowed=['viewBox', 'xmlns', 'width', 'height', 'id', 'class']){
+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)) {
@@ -86,13 +85,13 @@ function removeNameSpaceAtts(el) {
   });
 }
 
-export function stringifySVG(svg){
-    let markup = new XMLSerializer().serializeToString(svg);
+export 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, ' ')
+    .replace(/\t/g, "")
+    .replace(/[\n\r|]/g, "\n")
+    .replace(/\n\s*\n/g, '\n')
+    .replace(/ +/g, ' ')
 
   return markup
 }