poly-extrude 0.20.3 → 0.20.5

package/dist/poly-extrude.mjs

@@ -1,29 +1,62 @@
 /*!
- * poly-extrude v0.20.3
+ * poly-extrude v0.20.5
   */
-var 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);
+  }
+}
 
-earcut$2.exports = earcut;
+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);
+}
 
-earcut$2.exports["default"] = earcut;
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
 
 function earcut(data, holeIndices, dim) {
-  dim = dim || 2;
-  var hasHoles = holeIndices && holeIndices.length,
-      outerLen = hasHoles ? holeIndices[0] * dim : data.length,
-      outerNode = linkedList(data, 0, outerLen, dim, true),
-      triangles = [];
+  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 = [];
   if (!outerNode || outerNode.next === outerNode.prev) return triangles;
-  var minX, minY, maxX, maxY, x, y, invSize;
+  var minX, minY, 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 = maxX = data[0];
-    minY = maxY = data[1];
+    minX = Infinity;
+    minY = Infinity;
+    var maxX = -Infinity;
+    var maxY = -Infinity;
 
     for (var i = dim; i < outerLen; i += dim) {
-      x = data[i];
-      y = data[i + 1];
+      var x = data[i];
+      var y = data[i + 1];
       if (x < minX) minX = x;
       if (y < minY) minY = y;
       if (x > maxX) maxX = x;
@@ -39,17 +72,16 @@ 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 i, last;
+  var last;
 
   if (clockwise === signedArea(data, start, end, dim) > 0) {
-    for (i = start; i < end; i += dim) {
-      last = insertNode(i, data[i], data[i + 1], last);
+    for (var i = start; i < end; i += dim) {
+      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
     }
   } else {
-    for (i = end - dim; i >= start; i -= dim) {
-      last = insertNode(i, data[i], data[i + 1], last);
+    for (var _i = end - dim; _i >= start; _i -= dim) {
+      last = insertNode(_i / dim | 0, data[_i], data[_i + 1], last);
     }
   }
 
@@ -89,19 +121,15 @@ 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,
-      prev,
-      next; // iterate through ears, slicing them one by one
+  var stop = ear; // iterate through ears, slicing them one by one
 
   while (ear.prev !== ear.next) {
-    prev = ear.prev;
-    next = ear.next;
+    var prev = ear.prev;
+    var next = ear.next;
 
     if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-      // cut off the triangle
-      triangles.push(prev.i / dim | 0);
-      triangles.push(ear.i / dim | 0);
-      triangles.push(next.i / dim | 0);
+      triangles.push(prev.i, ear.i, next.i); // cut off the triangle
+
       removeNode(ear); // skipping the next vertex leads to less sliver triangles
 
       ear = next.next;
@@ -116,7 +144,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, dim);
+        ear = cureLocalIntersections(filterPoints(ear), triangles);
         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);
@@ -140,16 +168,16 @@ function isEar(ear) {
       cx = c.x,
       ay = a.y,
       by = b.y,
-      cy = c.y; // triangle bbox; min & max are calculated like this for speed
+      cy = c.y; // 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;
+  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 p = c.next;
 
   while (p !== a) {
-    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;
+    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;
     p = p.next;
   }
 
@@ -167,12 +195,12 @@ function isEarHashed(ear, minX, minY, invSize) {
       cx = c.x,
       ay = a.y,
       by = b.y,
-      cy = c.y; // triangle bbox; min & max are calculated like this for speed
+      cy = c.y; // 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 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 minZ = zOrder(x0, y0, minX, minY, invSize),
       maxZ = zOrder(x1, y1, minX, minY, invSize);
@@ -180,21 +208,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 && pointInTriangle(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 && pointInTriangleExceptFirst(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 && pointInTriangle(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 && pointInTriangleExceptFirst(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 && pointInTriangle(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 && pointInTriangleExceptFirst(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 && pointInTriangle(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 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
     n = n.nextZ;
   }
 
@@ -202,7 +230,7 @@ function isEarHashed(ear, minX, minY, invSize) {
 } // go through all polygon nodes and cure small local self-intersections
 
 
-function cureLocalIntersections(start, triangles, dim) {
+function cureLocalIntersections(start, triangles) {
   var p = start;
 
   do {
@@ -210,9 +238,7 @@ function cureLocalIntersections(start, triangles, dim) {
         b = p.next.next;
 
     if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-      triangles.push(a.i / dim | 0);
-      triangles.push(p.i / dim | 0);
-      triangles.push(b.i / dim | 0); // remove two nodes involved
+      triangles.push(a.i, p.i, b.i); // remove two nodes involved
 
       removeNode(p);
       removeNode(p.next);
@@ -255,32 +281,40 @@ function splitEarcut(start, triangles, dim, minX, minY, invSize) {
 
 
 function eliminateHoles(data, holeIndices, outerNode, dim) {
-  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);
+  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);
     if (list === list.next) list.steiner = true;
     queue.push(getLeftmost(list));
   }
 
-  queue.sort(compareX); // process holes from left to right
+  queue.sort(compareXYSlope); // process holes from left to right
 
-  for (i = 0; i < queue.length; i++) {
-    outerNode = eliminateHole(queue[i], outerNode);
+  for (var _i2 = 0; _i2 < queue.length; _i2++) {
+    outerNode = eliminateHole(queue[_i2], outerNode);
   }
 
   return outerNode;
 }
 
-function compareX(a, b) {
-  return a.x - b.x;
+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;
 } // find a bridge between vertices that connects hole with an outer ring and and link it
 
 
@@ -299,15 +333,18 @@ function eliminateHole(hole, outerNode) {
 
 
 function findHoleBridge(hole, outerNode) {
-  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;
+  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;
   // 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 (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+    if (equals(hole, p.next)) return p.next;else 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) {
@@ -316,7 +353,6 @@ function findHoleBridge(hole, outerNode) {
         if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
       }
     }
-
     p = p.next;
   } while (p !== outerNode);
 
@@ -324,16 +360,15 @@ 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,
-      mx = m.x,
-      my = m.y,
-      tanMin = Infinity,
-      tan;
+  var stop = m;
+  var mx = m.x;
+  var my = m.y;
+  var tanMin = Infinity;
   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)) {
-      tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
+      var 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;
@@ -371,34 +406,28 @@ function indexCurve(start, minX, minY, invSize) {
 
 
 function sortLinked(list) {
-  var i,
-      p,
-      q,
-      e,
-      tail,
-      numMerges,
-      pSize,
-      qSize,
-      inSize = 1;
+  var numMerges;
+  var inSize = 1;
 
   do {
-    p = list;
+    var p = list;
+    var e = void 0;
     list = null;
-    tail = null;
+    var tail = null;
     numMerges = 0;
 
     while (p) {
       numMerges++;
-      q = p;
-      pSize = 0;
+      var q = p;
+      var pSize = 0;
 
-      for (i = 0; i < inSize; i++) {
+      for (var i = 0; i < inSize; i++) {
         pSize++;
         q = q.nextZ;
         if (!q) break;
       }
 
-      qSize = inSize;
+      var qSize = inSize;
 
       while (pSize > 0 || qSize > 0 && q) {
         if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
@@ -458,6 +487,11 @@ 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)
 
 
@@ -525,10 +559,10 @@ function locallyInside(a, b) {
 
 
 function middleInside(a, b) {
-  var p = a,
-      inside = false,
-      px = (a.x + b.x) / 2,
-      py = (a.y + b.y) / 2;
+  var p = a;
+  var inside = false;
+  var px = (a.x + b.x) / 2;
+  var 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;
@@ -541,8 +575,8 @@ function middleInside(a, b) {
 
 
 function splitPolygon(a, b) {
-  var a2 = new Node(a.i, a.x, a.y),
-      b2 = new Node(b.i, b.x, b.y),
+  var a2 = createNode(a.i, a.x, a.y),
+      b2 = createNode(b.i, b.x, b.y),
       an = a.next,
       bp = b.prev;
   a.next = b;
@@ -558,7 +592,7 @@ function splitPolygon(a, b) {
 
 
 function insertNode(i, x, y, last) {
-  var p = new Node(i, x, y);
+  var p = createNode(i, x, y);
 
   if (!last) {
     p.prev = p;
@@ -580,50 +614,25 @@ function removeNode(p) {
   if (p.nextZ) p.nextZ.prevZ = p.prevZ;
 }
 
-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
+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
 
-  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;
@@ -636,68 +645,6 @@ 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 () {
@@ -2033,7 +1980,7 @@ function extrudePolygons(polygons, opts) {
         validatePolygon(polygon, true);
         const result = flatVertices(polygon, options);
         result.polygon = polygon;
-        const triangles = earcut$1(result.flatVertices, result.holes, 2);
+        const triangles = earcut(result.flatVertices, result.holes, 2);
         generateTopAndBottom$1(result, triangles, options);
         generateSides$1(result, options);
         result.position = new Float32Array(result.points);
@@ -2179,7 +2126,7 @@ function simplePolygon(polygon, options = {}) {
             uv[++uvIndex] = c[1];
         }
     }
-    const triangles = earcut$1(flatVertices, holes, 2);
+    const triangles = earcut(flatVertices, holes, 2);
     const normal = generateNormal(triangles, points);
     return {
         normal,
@@ -2490,15 +2437,17 @@ function expandLine(line, options) {
             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;
+    let pre, preleftline, prerightline;
     while (i < len) {
         let p0;
         let p1 = line[i], p2 = line[i + 1];
-        const currentp = p1;
+        const current = p1;
+        if (pre && equal(pre, current)) {
+            repeatVertex();
+            i++;
+            continue;
+        }
         // last vertex
         if (i === len - 1) {
             p1 = line[len - 2];
@@ -2506,7 +2455,7 @@ function expandLine(line, options) {
             if (equal(p1, p2)) {
                 for (let j = line.indexOf(p1); j >= 0; j--) {
                     const p = line[j];
-                    if (!equal(p, currentp)) {
+                    if (!equal(p, current)) {
                         p1 = p;
                         break;
                     }
@@ -2517,7 +2466,7 @@ function expandLine(line, options) {
             if (equal(p1, p2)) {
                 for (let j = line.indexOf(p2); j < len; j++) {
                     const p = line[j];
-                    if (!equal(p, currentp)) {
+                    if (!equal(p, current)) {
                         p2 = p;
                         break;
                     }
@@ -2525,17 +2474,17 @@ function expandLine(line, options) {
             }
         }
         if (equal(p1, p2)) {
+            console.error('not find next vertex:index:', i, line);
             repeatVertex();
             i++;
             continue;
         }
         let dy = p2[1] - p1[1], dx = p2[0] - p1[0];
-        let rAngle = 0;
+        let rangle = 0;
         const rad = Math.atan2(dy, dx);
         const angle = radToDeg(rad);
         if (i === 0 || i === len - 1) {
-            rAngle = angle;
-            rAngle -= 90;
+            rangle = angle - 90;
         }
         else {
             // 至少3个顶点才会触发
@@ -2550,6 +2499,7 @@ function expandLine(line, options) {
                 }
             }
             if (equal(p0, p2) || equal(p0, p1) || equal(p1, p2)) {
+                console.error('not find pre vertex:index:', i, line);
                 repeatVertex();
                 i++;
                 continue;
@@ -2559,8 +2509,7 @@ function expandLine(line, options) {
             const angle1 = radToDeg(rad1);
             // 平行，回头路
             if (Math.abs(Math.abs(angle1 - angle) - 180) <= 0.0001) {
-                rAngle = angle;
-                rAngle -= 90;
+                rangle = angle - 90;
             }
             else {
                 TEMPV1.x = p0[0] - p1[0];
@@ -2571,18 +2520,29 @@ function expandLine(line, options) {
                     console.error('has repeat vertex,the index:', i);
                 }
                 const vAngle = getAngle$1(TEMPV1, TEMPV2);
-                rAngle = angle - vAngle / 2;
+                if (Math.abs(vAngle) <= 1) {
+                    rangle = angle - 90;
+                }
+                else {
+                    rangle = angle - vAngle / 2;
+                }
             }
         }
-        const rRad = degToRad(rAngle);
-        const p3 = currentp;
+        const rRad = degToRad(rangle);
+        const p3 = current;
         const x = Math.cos(rRad) + p3[0], y = Math.sin(rRad) + p3[1];
         const p4 = [x, y];
         const [leftline, rightline] = translateLine(p1, p2, radius);
+        if (!leftline || !rightline) {
+            console.error('translateLine line eror,the index:', i, line);
+            i++;
+            continue;
+        }
         let op1 = lineIntersection(leftline[0], leftline[1], p3, p4);
         let op2 = lineIntersection(rightline[0], rightline[1], p3, p4);
         // 平行，回头路
         if (!op1 || !op2) {
+            console.error('not find Intersection,the index:', i, line);
             const len1 = points.length;
             const point1 = points[len1 - 2];
             const point2 = points[len1 - 1];
@@ -2593,14 +2553,14 @@ function expandLine(line, options) {
             op1 = [point1[0], point1[1]];
             op2 = [point2[0], point2[1]];
         }
-        op1[2] = currentp[2] || 0;
-        op2[2] = currentp[2] || 0;
+        op1[2] = current[2] || 0;
+        op2[2] = current[2] || 0;
         // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
         points.push(op1, op2);
         let needCut = false;
         if (cutCorner) {
             const bufferRadius = radius * 2;
-            if (distance(currentp, op1) > bufferRadius || distance(currentp, op2) > bufferRadius) {
+            if (distance(current, op1) > bufferRadius || distance(current, op2) > bufferRadius) {
                 needCut = true;
             }
         }
@@ -2609,11 +2569,11 @@ function expandLine(line, options) {
             if (distance(op1, p0) < distance(op2, p0)) {
                 cutPoint = op2;
             }
-            const dy = cutPoint[1] - currentp[1], dx = cutPoint[0] - currentp[0];
+            const dy = cutPoint[1] - current[1], dx = cutPoint[0] - current[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 x1 = Math.cos(cutRad) * radius + current[0];
+            const y1 = Math.sin(cutRad) * radius + current[1];
             const v1 = [x1, y1];
             const hcutangle = cutAngle + 90;
             // console.log(i, cutAngle, hcutangle);
@@ -2633,8 +2593,8 @@ function expandLine(line, options) {
             }
             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;
+            cross1[2] = current[2] || 0;
+            cross2[2] = current[2] || 0;
             const repeatPoint = cutPoint === op1 ? op2 : op1;
             appendArray.push(cross1, cross2);
             repeatArray.push(repeatPoint, [...repeatPoint]);
@@ -2651,10 +2611,14 @@ function expandLine(line, options) {
         }
         preleftline = leftline;
         prerightline = rightline;
+        pre = current;
         i++;
     }
     return { offsetPoints: points, leftPoints, rightPoints, line };
 }
+function equal(p1, p2) {
+    return p1[0] === p2[0] && p1[1] === p2[1];
+}
 const getAngle$1 = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
     const dot = x1 * x2 + y1 * y2;
     const det = x1 * y2 - y1 * x2;
@@ -4840,7 +4804,7 @@ function generateStartAndEnd(result, polygon, options) {
             flatVertices[++pIndex] = c[1];
         }
     }
-    const triangles = earcut$1(flatVertices, holes, 2);
+    const triangles = earcut(flatVertices, holes, 2);
     const { points, normal, uv, indices, startPoints, endPoints, polygonLen } = result;
     pIndex = 0;
     let uIndex = 0;