poly-extrude 0.18.1 → 0.20.0

package/dist/poly-extrude.mjs

@@ -1,62 +1,29 @@
 /*!
- * poly-extrude v0.18.1
+ * poly-extrude v0.20.0
   */
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
+var earcut$2 = {exports: {}};
 
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
-}
+earcut$2.exports = earcut;
 
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-
-  _setPrototypeOf(subClass, superClass);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
-}
+earcut$2.exports["default"] = earcut;
 
 function earcut(data, holeIndices, dim) {
-  if (dim === void 0) {
-    dim = 2;
-  }
-
-  var hasHoles = holeIndices && holeIndices.length;
-  var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-  var outerNode = linkedList(data, 0, outerLen, dim, true);
-  var triangles = [];
+  dim = dim || 2;
+  var hasHoles = holeIndices && holeIndices.length,
+      outerLen = hasHoles ? holeIndices[0] * dim : data.length,
+      outerNode = linkedList(data, 0, outerLen, dim, true),
+      triangles = [];
   if (!outerNode || outerNode.next === outerNode.prev) return triangles;
-  var minX, minY, invSize;
+  var minX, minY, maxX, maxY, x, y, invSize;
   if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim); // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
 
   if (data.length > 80 * dim) {
-    minX = Infinity;
-    minY = Infinity;
-    var maxX = -Infinity;
-    var maxY = -Infinity;
+    minX = maxX = data[0];
+    minY = maxY = data[1];
 
     for (var i = dim; i < outerLen; i += dim) {
-      var x = data[i];
-      var y = data[i + 1];
+      x = data[i];
+      y = data[i + 1];
       if (x < minX) minX = x;
       if (y < minY) minY = y;
       if (x > maxX) maxX = x;
@@ -72,16 +39,17 @@ function earcut(data, holeIndices, dim) {
   return triangles;
 } // create a circular doubly linked list from polygon points in the specified winding order
 
+
 function linkedList(data, start, end, dim, clockwise) {
-  var last;
+  var i, last;
 
   if (clockwise === signedArea(data, start, end, dim) > 0) {
-    for (var i = start; i < end; i += dim) {
-      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+    for (i = start; i < end; i += dim) {
+      last = insertNode(i, data[i], data[i + 1], last);
     }
   } else {
-    for (var _i = end - dim; _i >= start; _i -= dim) {
-      last = insertNode(_i / dim | 0, data[_i], data[_i + 1], last);
+    for (i = end - dim; i >= start; i -= dim) {
+      last = insertNode(i, data[i], data[i + 1], last);
     }
   }
 
@@ -121,15 +89,19 @@ function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
   if (!ear) return; // interlink polygon nodes in z-order
 
   if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
-  var stop = ear; // iterate through ears, slicing them one by one
+  var stop = ear,
+      prev,
+      next; // iterate through ears, slicing them one by one
 
   while (ear.prev !== ear.next) {
-    var prev = ear.prev;
-    var next = ear.next;
+    prev = ear.prev;
+    next = ear.next;
 
     if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-      triangles.push(prev.i, ear.i, next.i); // cut off the triangle
-
+      // cut off the triangle
+      triangles.push(prev.i / dim | 0);
+      triangles.push(ear.i / dim | 0);
+      triangles.push(next.i / dim | 0);
       removeNode(ear); // skipping the next vertex leads to less sliver triangles
 
       ear = next.next;
@@ -144,7 +116,7 @@ function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
       if (!pass) {
         earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1); // if this didn't work, try curing all small self-intersections locally
       } else if (pass === 1) {
-        ear = cureLocalIntersections(filterPoints(ear), triangles);
+        ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
         earcutLinked(ear, triangles, dim, minX, minY, invSize, 2); // as a last resort, try splitting the remaining polygon into two
       } else if (pass === 2) {
         splitEarcut(ear, triangles, dim, minX, minY, invSize);
@@ -168,16 +140,16 @@ function isEar(ear) {
       cx = c.x,
       ay = a.y,
       by = b.y,
-      cy = c.y; // triangle bbox
+      cy = c.y; // triangle bbox; min & max are calculated like this for speed
 
-  var x0 = Math.min(ax, bx, cx),
-      y0 = Math.min(ay, by, cy),
-      x1 = Math.max(ax, bx, cx),
-      y1 = Math.max(ay, by, cy);
+  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx,
+      y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy,
+      x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx,
+      y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
   var p = c.next;
 
   while (p !== a) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.next;
   }
 
@@ -195,12 +167,12 @@ function isEarHashed(ear, minX, minY, invSize) {
       cx = c.x,
       ay = a.y,
       by = b.y,
-      cy = c.y; // triangle bbox
+      cy = c.y; // triangle bbox; min & max are calculated like this for speed
 
-  var x0 = Math.min(ax, bx, cx),
-      y0 = Math.min(ay, by, cy),
-      x1 = Math.max(ax, bx, cx),
-      y1 = Math.max(ay, by, cy); // z-order range for the current triangle bbox;
+  var x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx,
+      y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy,
+      x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx,
+      y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy; // z-order range for the current triangle bbox;
 
   var minZ = zOrder(x0, y0, minX, minY, invSize),
       maxZ = zOrder(x1, y1, minX, minY, invSize);
@@ -208,21 +180,21 @@ function isEarHashed(ear, minX, minY, invSize) {
       n = ear.nextZ; // look for points inside the triangle in both directions
 
   while (p && p.z >= minZ && n && n.z <= maxZ) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.prevZ;
-    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
     n = n.nextZ;
   } // look for remaining points in decreasing z-order
 
 
   while (p && p.z >= minZ) {
-    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
     p = p.prevZ;
   } // look for remaining points in increasing z-order
 
 
   while (n && n.z <= maxZ) {
-    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
     n = n.nextZ;
   }
 
@@ -230,7 +202,7 @@ function isEarHashed(ear, minX, minY, invSize) {
 } // go through all polygon nodes and cure small local self-intersections
 
 
-function cureLocalIntersections(start, triangles) {
+function cureLocalIntersections(start, triangles, dim) {
   var p = start;
 
   do {
@@ -238,7 +210,9 @@ function cureLocalIntersections(start, triangles) {
         b = p.next.next;
 
     if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-      triangles.push(a.i, p.i, b.i); // remove two nodes involved
+      triangles.push(a.i / dim | 0);
+      triangles.push(p.i / dim | 0);
+      triangles.push(b.i / dim | 0); // remove two nodes involved
 
       removeNode(p);
       removeNode(p.next);
@@ -281,40 +255,32 @@ function splitEarcut(start, triangles, dim, minX, minY, invSize) {
 
 
 function eliminateHoles(data, holeIndices, outerNode, dim) {
-  var queue = [];
-
-  for (var i = 0, len = holeIndices.length; i < len; i++) {
-    var start = holeIndices[i] * dim;
-    var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-    var list = linkedList(data, start, end, dim, false);
+  var queue = [],
+      i,
+      len,
+      start,
+      end,
+      list;
+
+  for (i = 0, len = holeIndices.length; i < len; i++) {
+    start = holeIndices[i] * dim;
+    end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    list = linkedList(data, start, end, dim, false);
     if (list === list.next) list.steiner = true;
     queue.push(getLeftmost(list));
   }
 
-  queue.sort(compareXYSlope); // process holes from left to right
+  queue.sort(compareX); // process holes from left to right
 
-  for (var _i2 = 0; _i2 < queue.length; _i2++) {
-    outerNode = eliminateHole(queue[_i2], outerNode);
+  for (i = 0; i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode);
   }
 
   return outerNode;
 }
 
-function compareXYSlope(a, b) {
-  var result = a.x - b.x; // when the left-most point of 2 holes meet at a vertex, sort the holes counterclockwise so that when we find
-  // the bridge to the outer shell is always the point that they meet at.
-
-  if (result === 0) {
-    result = a.y - b.y;
-
-    if (result === 0) {
-      var aSlope = (a.next.y - a.y) / (a.next.x - a.x);
-      var bSlope = (b.next.y - b.y) / (b.next.x - b.x);
-      result = aSlope - bSlope;
-    }
-  }
-
-  return result;
+function compareX(a, b) {
+  return a.x - b.x;
 } // find a bridge between vertices that connects hole with an outer ring and and link it
 
 
@@ -333,18 +299,15 @@ function eliminateHole(hole, outerNode) {
 
 
 function findHoleBridge(hole, outerNode) {
-  var p = outerNode;
-  var hx = hole.x;
-  var hy = hole.y;
-  var qx = -Infinity;
-  var m; // find a segment intersected by a ray from the hole's leftmost point to the left;
+  var p = outerNode,
+      hx = hole.x,
+      hy = hole.y,
+      qx = -Infinity,
+      m; // find a segment intersected by a ray from the hole's leftmost point to the left;
   // segment's endpoint with lesser x will be potential connection point
-  // unless they intersect at a vertex, then choose the vertex
-
-  if (equals(hole, p)) return p;
 
   do {
-    if (equals(hole, p.next)) return p.next;else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+    if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
       var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
 
       if (x <= hx && x > qx) {
@@ -353,6 +316,7 @@ function findHoleBridge(hole, outerNode) {
         if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
       }
     }
+
     p = p.next;
   } while (p !== outerNode);
 
@@ -360,15 +324,16 @@ function findHoleBridge(hole, outerNode) {
   // if there are no points found, we have a valid connection;
   // otherwise choose the point of the minimum angle with the ray as connection point
 
-  var stop = m;
-  var mx = m.x;
-  var my = m.y;
-  var tanMin = Infinity;
+  var stop = m,
+      mx = m.x,
+      my = m.y,
+      tanMin = Infinity,
+      tan;
   p = m;
 
   do {
     if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
-      var tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
+      tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
 
       if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
         m = p;
@@ -406,28 +371,34 @@ function indexCurve(start, minX, minY, invSize) {
 
 
 function sortLinked(list) {
-  var numMerges;
-  var inSize = 1;
+  var i,
+      p,
+      q,
+      e,
+      tail,
+      numMerges,
+      pSize,
+      qSize,
+      inSize = 1;
 
   do {
-    var p = list;
-    var e = void 0;
+    p = list;
     list = null;
-    var tail = null;
+    tail = null;
     numMerges = 0;
 
     while (p) {
       numMerges++;
-      var q = p;
-      var pSize = 0;
+      q = p;
+      pSize = 0;
 
-      for (var i = 0; i < inSize; i++) {
+      for (i = 0; i < inSize; i++) {
         pSize++;
         q = q.nextZ;
         if (!q) break;
       }
 
-      var qSize = inSize;
+      qSize = inSize;
 
       while (pSize > 0 || qSize > 0 && q) {
         if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
@@ -487,11 +458,6 @@ function getLeftmost(start) {
 
 function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
   return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
-} // check if a point lies within a convex triangle but false if its equal to the first point of the triangle
-
-
-function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
-  return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
 } // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
 
 
@@ -559,10 +525,10 @@ function locallyInside(a, b) {
 
 
 function middleInside(a, b) {
-  var p = a;
-  var inside = false;
-  var px = (a.x + b.x) / 2;
-  var py = (a.y + b.y) / 2;
+  var p = a,
+      inside = false,
+      px = (a.x + b.x) / 2,
+      py = (a.y + b.y) / 2;
 
   do {
     if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x) inside = !inside;
@@ -575,8 +541,8 @@ function middleInside(a, b) {
 
 
 function splitPolygon(a, b) {
-  var a2 = createNode(a.i, a.x, a.y),
-      b2 = createNode(b.i, b.x, b.y),
+  var a2 = new Node(a.i, a.x, a.y),
+      b2 = new Node(b.i, b.x, b.y),
       an = a.next,
       bp = b.prev;
   a.next = b;
@@ -592,7 +558,7 @@ function splitPolygon(a, b) {
 
 
 function insertNode(i, x, y, last) {
-  var p = createNode(i, x, y);
+  var p = new Node(i, x, y);
 
   if (!last) {
     p.prev = p;
@@ -614,25 +580,50 @@ function removeNode(p) {
   if (p.nextZ) p.nextZ.prevZ = p.prevZ;
 }
 
-function createNode(i, x, y) {
-  return {
-    i: i,
-    // vertex index in coordinates array
-    x: x,
-    y: y,
-    // vertex coordinates
-    prev: null,
-    // previous and next vertex nodes in a polygon ring
-    next: null,
-    z: 0,
-    // z-order curve value
-    prevZ: null,
-    // previous and next nodes in z-order
-    nextZ: null,
-    steiner: false // indicates whether this is a steiner point
+function Node(i, x, y) {
+  // vertex index in coordinates array
+  this.i = i; // vertex coordinates
 
-  };
+  this.x = x;
+  this.y = y; // previous and next vertex nodes in a polygon ring
+
+  this.prev = null;
+  this.next = null; // z-order curve value
+
+  this.z = 0; // previous and next nodes in z-order
+
+  this.prevZ = null;
+  this.nextZ = null; // indicates whether this is a steiner point
+
+  this.steiner = false;
 } // return a percentage difference between the polygon area and its triangulation area;
+// used to verify correctness of triangulation
+
+
+earcut.deviation = function (data, holeIndices, dim, triangles) {
+  var hasHoles = holeIndices && holeIndices.length;
+  var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+
+  if (hasHoles) {
+    for (var i = 0, len = holeIndices.length; i < len; i++) {
+      var start = holeIndices[i] * dim;
+      var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+      polygonArea -= Math.abs(signedArea(data, start, end, dim));
+    }
+  }
+
+  var trianglesArea = 0;
+
+  for (i = 0; i < triangles.length; i += 3) {
+    var a = triangles[i] * dim;
+    var b = triangles[i + 1] * dim;
+    var c = triangles[i + 2] * dim;
+    trianglesArea += Math.abs((data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
+  }
+
+  return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
+};
 
 function signedArea(data, start, end, dim) {
   var sum = 0;
@@ -645,6 +636,68 @@ function signedArea(data, start, end, dim) {
   return sum;
 } // turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
 
+
+earcut.flatten = function (data) {
+  var dim = data[0][0].length,
+      result = {
+    vertices: [],
+    holes: [],
+    dimensions: dim
+  },
+      holeIndex = 0;
+
+  for (var i = 0; i < data.length; i++) {
+    for (var j = 0; j < data[i].length; j++) {
+      for (var d = 0; d < dim; d++) {
+        result.vertices.push(data[i][j][d]);
+      }
+    }
+
+    if (i > 0) {
+      holeIndex += data[i - 1].length;
+      result.holes.push(holeIndex);
+    }
+  }
+
+  return result;
+};
+
+var earcut$1 = earcut$2.exports;
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
 // code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Quaternion.js
 // import { clamp } from './MathUtils.js';
 var Quaternion = /*#__PURE__*/function () {
@@ -1980,7 +2033,7 @@ function extrudePolygons(polygons, opts) {
         validatePolygon(polygon, true);
         const result = flatVertices(polygon, options);
         result.polygon = polygon;
-        const triangles = earcut(result.flatVertices, result.holes, 2);
+        const triangles = earcut$1(result.flatVertices, result.holes, 2);
         generateTopAndBottom$1(result, triangles, options);
         generateSides$1(result, options);
         result.position = new Float32Array(result.points);
@@ -2126,7 +2179,7 @@ function simplePolygon(polygon, options = {}) {
             uv[++uvIndex] = c[1];
         }
     }
-    const triangles = earcut(flatVertices, holes, 2);
+    const triangles = earcut$1(flatVertices, holes, 2);
     const normal = generateNormal(triangles, points);
     return {
         normal,
@@ -2223,10 +2276,15 @@ function generateTopAndBottom(result, options) {
     const { leftPoints, rightPoints } = result;
     const line = result.line;
     const pathUV = options.pathUV;
+    let uvCalPath = line;
+    // let needCalUV = false;
+    if (leftPoints.length > uvCalPath.length) {
+        uvCalPath = leftPoints;
+    }
     if (pathUV) {
-        calLineDistance(line);
-        for (let i = 0, len = line.length; i < len; i++) {
-            leftPoints[i].distance = rightPoints[i].distance = line[i].distance;
+        calLineDistance(uvCalPath);
+        for (let i = 0, len = uvCalPath.length; i < len; i++) {
+            leftPoints[i].distance = rightPoints[i].distance = uvCalPath[i].distance;
         }
     }
     let i = 0, len = leftPoints.length;
@@ -2238,12 +2296,14 @@ function generateTopAndBottom(result, options) {
         points[idx0] = x1;
         points[idx0 + 1] = y1;
         points[idx0 + 2] = lz + z1;
+        // const p1 = leftPoints[i];
         // top right
         const [x2, y2, z2] = rightPoints[i];
         const idx1 = len * 3 + idx0;
         points[idx1] = x2;
         points[idx1 + 1] = y2;
         points[idx1 + 2] = rz + z2;
+        // const p2 = rightPoints[i];
         // bottom left
         const idx2 = (len * 2) * 3 + idx0;
         points[idx2] = x1;
@@ -2262,8 +2322,8 @@ function generateTopAndBottom(result, options) {
         }
         // generate path uv
         if (pathUV) {
-            const p = line[i];
-            const uvx = p.distance;
+            const p = uvCalPath[i];
+            let uvx = p.distance;
             const uIndex0 = i * 2;
             uv[uIndex0] = uvx;
             uv[uIndex0 + 1] = 1;
@@ -2413,38 +2473,94 @@ function generateSides(result, options) {
 }
 const TEMPV1 = { x: 0, y: 0 }, TEMPV2 = { x: 0, y: 0 };
 function expandLine(line, options) {
-    // let preAngle = 0;
+    options = Object.assign({}, { lineWidth: 1, cutCorner: false }, options);
     let radius = options.lineWidth / 2;
     if (options.isSlope) {
         radius *= 2;
     }
+    const { cutCorner } = options;
     const points = [], leftPoints = [], rightPoints = [];
     const len = line.length;
+    const repeatVertex = () => {
+        const len1 = leftPoints.length;
+        if (len1) {
+            leftPoints.push(leftPoints[len1 - 1]);
+            rightPoints.push(rightPoints[len1 - 1]);
+            const len2 = points.length;
+            points.push(points[len2 - 2], points[len2 - 1]);
+        }
+    };
+    const equal = (p1, p2) => {
+        return p1[0] === p2[0] && p1[1] === p2[1];
+    };
     let i = 0;
+    let preleftline, prerightline;
     while (i < len) {
+        let p0;
         let p1 = line[i], p2 = line[i + 1];
-        const currentp = line[i];
+        const currentp = p1;
         // last vertex
         if (i === len - 1) {
             p1 = line[len - 2];
             p2 = line[len - 1];
+            if (equal(p1, p2)) {
+                for (let j = line.indexOf(p1); j >= 0; j--) {
+                    const p = line[j];
+                    if (!equal(p, currentp)) {
+                        p1 = p;
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            if (equal(p1, p2)) {
+                for (let j = line.indexOf(p2); j < len; j++) {
+                    const p = line[j];
+                    if (!equal(p, currentp)) {
+                        p2 = p;
+                        break;
+                    }
+                }
+            }
+        }
+        if (equal(p1, p2)) {
+            repeatVertex();
+            i++;
+            continue;
         }
-        const dy = p2[1] - p1[1], dx = p2[0] - p1[0];
+        let dy = p2[1] - p1[1], dx = p2[0] - p1[0];
         let rAngle = 0;
-        const rad = Math.atan(dy / dx);
+        const rad = Math.atan2(dy, dx);
         const angle = radToDeg(rad);
-        // preAngle = angle;
         if (i === 0 || i === len - 1) {
             rAngle = angle;
             rAngle -= 90;
         }
         else {
             // 至少3个顶点才会触发
-            const p0 = line[i - 1];
+            p0 = line[i - 1];
+            if (equal(p0, p2) || equal(p0, p1)) {
+                for (let j = line.indexOf(p2); j >= 0; j--) {
+                    const p = line[j];
+                    if (!equal(p, p2) && (!equal(p, p1))) {
+                        p0 = p;
+                        break;
+                    }
+                }
+            }
+            if (equal(p0, p2) || equal(p0, p1) || equal(p1, p2)) {
+                repeatVertex();
+                i++;
+                continue;
+            }
             TEMPV1.x = p0[0] - p1[0];
             TEMPV1.y = p0[1] - p1[1];
             TEMPV2.x = p2[0] - p1[0];
             TEMPV2.y = p2[1] - p1[1];
+            if ((TEMPV1.x === 0 && TEMPV1.y === 0) || (TEMPV2.x === 0 && TEMPV2.y === 0)) {
+                console.error('has repeat vertex,the index:', i);
+            }
             const vAngle = getAngle$1(TEMPV1, TEMPV2);
             rAngle = angle - vAngle / 2;
         }
@@ -2452,15 +2568,16 @@ function expandLine(line, options) {
         const p3 = currentp;
         const x = Math.cos(rRad) + p3[0], y = Math.sin(rRad) + p3[1];
         const p4 = [x, y];
-        const [line1, line2] = translateLine(p1, p2, radius);
-        let op1 = lineIntersection(line1[0], line1[1], p3, p4);
-        let op2 = lineIntersection(line2[0], line2[1], p3, p4);
+        const [leftline, rightline] = translateLine(p1, p2, radius);
+        let op1 = lineIntersection(leftline[0], leftline[1], p3, p4);
+        let op2 = lineIntersection(rightline[0], rightline[1], p3, p4);
         // 平行，回头路
         if (!op1 || !op2) {
             const len1 = points.length;
             const point1 = points[len1 - 2];
             const point2 = points[len1 - 1];
             if (!point1 || !point2) {
+                i++;
                 continue;
             }
             op1 = [point1[0], point1[1]];
@@ -2470,14 +2587,60 @@ function expandLine(line, options) {
         op2[2] = currentp[2] || 0;
         // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
         points.push(op1, op2);
-        if (leftOnLine(op1, p1, p2)) {
-            leftPoints.push(op1);
-            rightPoints.push(op2);
+        let needCut = false;
+        if (cutCorner) {
+            const bufferRadius = radius * 2;
+            if (distance(currentp, op1) > bufferRadius || distance(currentp, op2) > bufferRadius) {
+                needCut = true;
+            }
+        }
+        if (needCut && p0 && preleftline && prerightline) {
+            let cutPoint = op1;
+            if (distance(op1, p0) < distance(op2, p0)) {
+                cutPoint = op2;
+            }
+            const dy = cutPoint[1] - currentp[1], dx = cutPoint[0] - currentp[0];
+            const cutAngle = Math.atan2(dy, dx) / Math.PI * 180;
+            const cutRad = degToRad(cutAngle);
+            const x1 = Math.cos(cutRad) * radius + currentp[0];
+            const y1 = Math.sin(cutRad) * radius + currentp[1];
+            const v1 = [x1, y1];
+            const hcutangle = cutAngle + 90;
+            // console.log(i, cutAngle, hcutangle);
+            const hcutRad = degToRad(hcutangle);
+            const x2 = Math.cos(hcutRad) + x1;
+            const y2 = Math.sin(hcutRad) + y1;
+            const v2 = [x2, y2];
+            let preline = preleftline;
+            let currentLine = leftline;
+            let appendArray = leftPoints;
+            let repeatArray = rightPoints;
+            if (!leftOnLine(cutPoint, p1, p2)) {
+                preline = prerightline;
+                currentLine = rightline;
+                appendArray = rightPoints;
+                repeatArray = leftPoints;
+            }
+            let cross1 = lineIntersection(preline[0], preline[1], v1, v2);
+            let cross2 = lineIntersection(currentLine[0], currentLine[1], v1, v2);
+            cross1[2] = currentp[2] || 0;
+            cross2[2] = currentp[2] || 0;
+            const repeatPoint = cutPoint === op1 ? op2 : op1;
+            appendArray.push(cross1, cross2);
+            repeatArray.push(repeatPoint, [...repeatPoint]);
         }
         else {
-            leftPoints.push(op2);
-            rightPoints.push(op1);
+            if (leftOnLine(op1, p1, p2)) {
+                leftPoints.push(op1);
+                rightPoints.push(op2);
+            }
+            else {
+                leftPoints.push(op2);
+                rightPoints.push(op1);
+            }
         }
+        preleftline = leftline;
+        prerightline = rightline;
         i++;
     }
     return { offsetPoints: points, leftPoints, rightPoints, line };
@@ -2486,8 +2649,13 @@ const getAngle$1 = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
     const dot = x1 * x2 + y1 * y2;
     const det = x1 * y2 - y1 * x2;
     const angle = Math.atan2(det, dot) / Math.PI * 180;
-    return (angle + 360) % 360;
+    return (angle);
+    // return (angle + 360) % 360;
 };
+function distance(p1, p2) {
+    const dx = p2[0] - p1[0], dy = p2[1] - p1[1];
+    return Math.sqrt(dx * dx + dy * dy);
+}
 function leftOnLine(p, p1, p2) {
     const [x1, y1] = p1;
     const [x2, y2] = p2;
@@ -2503,6 +2671,9 @@ function leftOnLine(p, p1, p2) {
  */
 function translateLine(p1, p2, distance) {
     const dy = p2[1] - p1[1], dx = p2[0] - p1[0];
+    if (dy === 0 && dx === 0) {
+        return null;
+    }
     const rad = Math.atan2(dy, dx);
     const rad1 = rad + Math.PI / 2;
     let offsetX = Math.cos(rad1) * distance, offsetY = Math.sin(rad1) * distance;
@@ -2526,9 +2697,11 @@ function translateLine(p1, p2, distance) {
 function lineIntersection(p1, p2, p3, p4) {
     const dx1 = p2[0] - p1[0], dy1 = p2[1] - p1[1];
     const dx2 = p4[0] - p3[0], dy2 = p4[1] - p3[1];
+    //vertical 
     if (dx1 === 0 && dx2 === 0) {
         return null;
     }
+    //horizontal
     if (dy1 === 0 && dy2 === 0) {
         return null;
     }
@@ -4657,7 +4830,7 @@ function generateStartAndEnd(result, polygon, options) {
             flatVertices[++pIndex] = c[1];
         }
     }
-    const triangles = earcut(flatVertices, holes, 2);
+    const triangles = earcut$1(flatVertices, holes, 2);
     const { points, normal, uv, indices, startPoints, endPoints, polygonLen } = result;
     pIndex = 0;
     let uIndex = 0;