poly-extrude 0.15.0 → 0.17.0

package/dist/poly-extrude.mjs

@@ -1,29 +1,62 @@
 /*!
- * poly-extrude v0.15.0
+ * poly-extrude v0.17.0
   */
-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;
+}
 
-earcut$2.exports["default"] = 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);
+}
 
 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
+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.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;
@@ -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 () {
@@ -1746,6 +1693,12 @@ var Vector3 = /*#__PURE__*/function () {
   return Vector3;
 }();
 
+function mergeArray(array1, array2) {
+    let index = array1.length - 1;
+    for (let i = 0, len = array2.length; i < len; i++) {
+        array1[++index] = array2[i];
+    }
+}
 /**
  * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
  * @param {*} ring
@@ -1765,6 +1718,63 @@ function isClockwise(ring) {
     }
     return sum > 0;
 }
+function validateRing(ring) {
+    if (!isClosedRing(ring)) {
+        ring.push(ring[0]);
+    }
+}
+function isClosedRing(ring) {
+    const len = ring.length;
+    const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
+    return (x1 === x2 && y1 === y2);
+}
+function calPolygonPointsCount(polygon) {
+    let count = 0;
+    let i = 0;
+    const len = polygon.length;
+    while (i < len) {
+        count += (polygon[i].length);
+        i++;
+    }
+    return count;
+}
+function getPolygonsBBOX(polygons, bbox) {
+    bbox = bbox || [Infinity, Infinity, -Infinity, -Infinity];
+    for (let i = 0, len = polygons.length; i < len; i++) {
+        const p = polygons[i];
+        if (Array.isArray(p[0][0])) {
+            getPolygonsBBOX(p, bbox);
+        }
+        else {
+            for (let j = 0, len1 = p.length; j < len1; j++) {
+                const c = p[j];
+                const [x, y] = c;
+                bbox[0] = Math.min(bbox[0], x);
+                bbox[1] = Math.min(bbox[1], y);
+                bbox[2] = Math.max(bbox[2], x);
+                bbox[3] = Math.max(bbox[3], y);
+            }
+        }
+    }
+    return bbox;
+}
+function validatePolygon(polygon) {
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        validateRing(ring);
+        if (i === 0) {
+            if (!isClockwise(ring)) {
+                polygon[i] = ring.reverse();
+            }
+        }
+        else if (isClockwise(ring)) {
+            polygon[i] = ring.reverse();
+        }
+        if (isClosedRing(ring)) {
+            ring.splice(ring.length - 1, 1);
+        }
+    }
+}
 function v3Sub(out, v1, v2) {
     out[0] = v1[0] - v2[0];
     out[1] = v1[1] - v2[1];
@@ -1963,27 +1973,13 @@ function calLineDistance(line) {
 }
 
 function extrudePolygons(polygons, options) {
-    options = Object.assign({}, { depth: 2 }, options);
+    options = Object.assign({}, { depth: 2, top: true }, options);
     const results = polygons.map(polygon => {
-        for (let i = 0, len = polygon.length; i < len; i++) {
-            const ring = polygon[i];
-            validateRing(ring);
-            if (i === 0) {
-                if (!isClockwise(ring)) {
-                    polygon[i] = ring.reverse();
-                }
-            }
-            else if (isClockwise(ring)) {
-                polygon[i] = ring.reverse();
-            }
-            if (isClosedRing(ring)) {
-                ring.splice(ring.length - 1, 1);
-            }
-        }
+        validatePolygon(polygon);
         const result = flatVertices(polygon, options);
         result.polygon = polygon;
-        const triangles = earcut$1(result.flatVertices, result.holes, 2);
-        generateTopAndBottom$1(result, triangles);
+        const triangles = earcut(result.flatVertices, result.holes, 2);
+        generateTopAndBottom$1(result, triangles, options);
         generateSides$1(result, options);
         result.position = new Float32Array(result.points);
         result.indices = new Uint32Array(result.indices);
@@ -1995,18 +1991,24 @@ function extrudePolygons(polygons, options) {
     result.polygons = polygons;
     return result;
 }
-function generateTopAndBottom$1(result, triangles) {
+function generateTopAndBottom$1(result, triangles, options) {
     const indices = [];
     const { count } = result;
+    const top = options.top;
     for (let i = 0, len = triangles.length; i < len; i += 3) {
         // top
         const a = triangles[i], b = triangles[i + 1], c = triangles[i + 2];
-        indices[i] = a;
-        indices[i + 1] = b;
-        indices[i + 2] = c;
+        if (top) {
+            indices[i] = a;
+            indices[i + 1] = b;
+            indices[i + 2] = c;
+        }
         // bottom
-        const idx = len + i;
+        let idx = len + i;
         const a1 = count + a, b1 = count + b, c1 = count + c;
+        if (!top) {
+            idx = i;
+        }
         indices[idx] = a1;
         indices[idx + 1] = b1;
         indices[idx + 2] = c1;
@@ -2058,16 +2060,6 @@ function generateSides$1(result, options) {
         }
     }
 }
-function calPolygonPointsCount(polygon) {
-    let count = 0;
-    let i = 0;
-    const len = polygon.length;
-    while (i < len) {
-        count += (polygon[i].length);
-        i++;
-    }
-    return count;
-}
 function flatVertices(polygon, options) {
     const count = calPolygonPointsCount(polygon);
     const len = polygon.length;
@@ -2112,15 +2104,49 @@ function flatVertices(polygon, options) {
         uv
     };
 }
-function validateRing(ring) {
-    if (!isClosedRing(ring)) {
-        ring.push(ring[0]);
+function simplePolygon(polygon, options = {}) {
+    const flatVertices = [], holes = [];
+    let pIndex = -1, aIndex = -1, uvIndex = -1;
+    const points = [], uv = [];
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        if (i > 0) {
+            holes.push(flatVertices.length / 2);
+        }
+        for (let j = 0, len1 = ring.length; j < len1; j++) {
+            const c = ring[j];
+            flatVertices[++pIndex] = c[0];
+            flatVertices[++pIndex] = c[1];
+            points[++aIndex] = c[0];
+            points[++aIndex] = c[1];
+            points[++aIndex] = c[2] || 0;
+            uv[++uvIndex] = c[0];
+            uv[++uvIndex] = c[1];
+        }
     }
+    const triangles = earcut(flatVertices, holes, 2);
+    const normal = generateNormal(triangles, points);
+    return {
+        normal,
+        uv,
+        points,
+        indices: triangles
+    };
 }
-function isClosedRing(ring) {
-    const len = ring.length;
-    const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
-    return (x1 === x2 && y1 === y2);
+function polygons(polygons, options = {}) {
+    const results = polygons.map(polygon => {
+        validatePolygon(polygon);
+        const result = simplePolygon(polygon, options);
+        result.polygon = polygon;
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = new Float32Array(result.normal);
+        return result;
+    });
+    const result = merge(results);
+    result.polygons = polygons;
+    return result;
 }
 
 function checkOptions(options) {
@@ -2416,7 +2442,7 @@ function expandLine(line, options) {
             TEMPV1.y = p0[1] - p1[1];
             TEMPV2.x = p2[0] - p1[0];
             TEMPV2.y = p2[1] - p1[1];
-            const vAngle = getAngle(TEMPV1, TEMPV2);
+            const vAngle = getAngle$1(TEMPV1, TEMPV2);
             rAngle = angle - vAngle / 2;
         }
         const rRad = degToRad(rAngle);
@@ -2453,7 +2479,7 @@ function expandLine(line, options) {
     }
     return { offsetPoints: points, leftPoints, rightPoints, line };
 }
-const getAngle = ({ x: x1, y: y1 }, { x: x2, y: y2 }) => {
+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;
@@ -3930,7 +3956,7 @@ var PathPointList = /*#__PURE__*/function () {
   return PathPointList;
 }();
 
-const UP$1 = new Vector3(0, 0, 1);
+const UP$2 = new Vector3(0, 0, 1);
 const right = new Vector3();
 const left = new Vector3();
 // for sharp corners
@@ -3944,7 +3970,7 @@ function expandPaths(lines, options) {
         const points = line2Vectors(line);
         const pathPointList = new PathPointList();
         //@ts-ignore
-        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$1);
+        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$2);
         const params = generatePathVertexData(pathPointList, options);
         const result = {
             position: new Float32Array(params.position),
@@ -4253,15 +4279,15 @@ function generatePathVertexData(pathPointList, options) {
     };
 }
 
-const UP = new Vector3(0, 0, 1);
-const normalDir = new Vector3();
+const UP$1 = new Vector3(0, 0, 1);
+const normalDir$1 = new Vector3();
 function expandTubes(lines, options) {
     options = Object.assign({}, { radius: 1, cornerSplit: 0, radialSegments: 8, startRad: -Math.PI / 4 }, options);
     const results = lines.map(line => {
         const points = line2Vectors(line);
         const pathPointList = new PathPointList();
         //@ts-ignore
-        pathPointList.set(points, 0, options.cornerSplit, UP);
+        pathPointList.set(points, 0, options.cornerSplit, UP$1);
         const result = generateTubeVertexData(pathPointList, options);
         result.line = line;
         result.position = new Float32Array(result.points);
@@ -4308,14 +4334,14 @@ function generateTubeVertexData(pathPointList, options) {
             if (r === radialSegments) {
                 r = 0;
             }
-            normalDir.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, startRad + Math.PI * 2 * r / radialSegments).normalize();
+            normalDir$1.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, startRad + Math.PI * 2 * r / radialSegments).normalize();
             const scale = radius * pathPoint.widthScale;
-            points[++pIndex] = pathPoint.pos.x + normalDir.x * scale;
-            points[++pIndex] = pathPoint.pos.y + normalDir.y * scale;
-            points[++pIndex] = pathPoint.pos.z + normalDir.z * scale;
-            normal[++nIndex] = normalDir.x;
-            normal[++nIndex] = normalDir.y;
-            normal[++nIndex] = normalDir.z;
+            points[++pIndex] = pathPoint.pos.x + normalDir$1.x * scale;
+            points[++pIndex] = pathPoint.pos.y + normalDir$1.y * scale;
+            points[++pIndex] = pathPoint.pos.z + normalDir$1.z * scale;
+            normal[++nIndex] = normalDir$1.x;
+            normal[++nIndex] = normalDir$1.y;
+            normal[++nIndex] = normalDir$1.z;
             uv[++uIndex] = uvDist;
             uv[++uIndex] = i / radialSegments;
             // uvs.push(uvDist, r / radialSegments);
@@ -4430,5 +4456,263 @@ function plane(width, height, devideW, devideH) {
     };
 }
 
-export { cylinder, expandLine, expandPaths, expandTubes, extrudePolygons, extrudePolylines, extrudeSlopes, isClockwise, leftOnLine, merge, plane };
+const UP = new Vector3(0, 0, 1);
+const normalDir = new Vector3();
+function extrudePolygonsOnPath(polygons, options) {
+    options = Object.assign({}, { openEnd: false, openEndUV: true }, options);
+    const { extrudePath, openEnd } = options;
+    if (!extrudePath || !Array.isArray(extrudePath) || extrudePath.length < 2) {
+        console.error('extrudePath is error:', extrudePath);
+        return null;
+    }
+    const bbox = getPolygonsBBOX(polygons);
+    const [minx, miny, maxx, maxy] = bbox;
+    const center = [(minx + maxx) / 2, (miny + maxy) / 2];
+    const points = line2Vectors(extrudePath);
+    const pathPointList = new PathPointList();
+    //@ts-ignore
+    pathPointList.set(points, 0, options.cornerSplit, UP);
+    const results = polygons.map(polygon => {
+        for (let i = 0, len = polygon.length; i < len; i++) {
+            const ring = polygon[i];
+            validateRing(ring);
+            if (i === 0) {
+                if (isClockwise(ring)) {
+                    polygon[i] = ring.reverse();
+                }
+            }
+            else if (!isClockwise(ring)) {
+                polygon[i] = ring.reverse();
+            }
+        }
+        const result = generatePolygonOnPathVertexData(pathPointList, polygon, center);
+        if (!openEnd) {
+            generateStartAndEnd(result, polygon, options);
+        }
+        result.polygon = polygon;
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = new Float32Array(result.normal);
+        return result;
+    });
+    const result = merge(results);
+    result.polygons = polygons;
+    return result;
+}
+function getAngle(c1, c2) {
+    const [x1, y1] = c1;
+    const [x2, y2] = c2;
+    const dy = y2 - y1;
+    const dx = x2 - x1;
+    return Math.atan2(dy, dx);
+}
+function transformPolygon(polygon, center) {
+    const [cx, cy] = center;
+    const list = [];
+    polygon.forEach((ring, rIndex) => {
+        const data = [];
+        let totalDistance = 0;
+        let tempPoint;
+        for (let i = 0, len = ring.length; i < len; i++) {
+            const p = ring[i];
+            const x1 = p[0], y1 = p[1];
+            const offsetx = x1 - cx, offsety = y1 - cy;
+            let distance = 0;
+            if (i > 0) {
+                const x2 = tempPoint[0], y2 = tempPoint[1];
+                const dx = x2 - x1, dy = y2 - y1;
+                distance = Math.sqrt(dx * dx + dy * dy) + totalDistance;
+                totalDistance = distance;
+            }
+            data[i] = {
+                // dx,
+                // dy,
+                // dz: 0,
+                distance,
+                radius: Math.sqrt(offsetx * offsetx + offsety * offsety),
+                angle: getAngle(center, p)
+            };
+            tempPoint = p;
+        }
+        list[rIndex] = {
+            ring: data,
+            ringLen: totalDistance
+        };
+    });
+    return list;
+}
+const TEMP_VECTOR3 = new Vector3(0, 0, 0);
+// Vertex Data Generate Functions
+// code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
+function generatePolygonOnPathVertexData(pathPointList, polygon, center) {
+    const tpolygon = transformPolygon(polygon, center);
+    // let count = 0;
+    // modify data
+    const points = [];
+    const normal = [];
+    const uv = [];
+    // const uv2 = [];
+    const indices = [];
+    let verticesCount = 0;
+    let pIndex = -1;
+    let nIndex = -1;
+    let uIndex = -1;
+    let iIndex = -1;
+    const startPoints = [], endPoints = [];
+    function addVertices(pathPoint, ring, ringLen, first, end) {
+        const uvDist = pathPoint.dist / ringLen;
+        const radialSegments = ring.length;
+        // const startRad = ring[0].angle;
+        for (let i = 0; i < radialSegments; i++) {
+            const item = ring[i];
+            if (!item) {
+                continue;
+            }
+            const isLast = i === radialSegments - 1;
+            const angle = item.angle;
+            const radius = item.radius;
+            const distance = item.distance;
+            normalDir.copy(pathPoint.up).applyAxisAngle(pathPoint.dir, angle).normalize();
+            const v = TEMP_VECTOR3.copy(pathPoint.up);
+            v.applyAxisAngle(pathPoint.dir, angle);
+            v.x *= radius;
+            v.y *= radius;
+            v.z *= radius;
+            points[++pIndex] = pathPoint.pos.x + v.x;
+            points[++pIndex] = pathPoint.pos.y + v.y;
+            points[++pIndex] = pathPoint.pos.z + v.z;
+            // if (i === 0 || i === radialSegments - 1) {
+            //     console.log(i, radialSegments, v.x, v.y, v.z);
+            // }
+            normal[++nIndex] = normalDir.x;
+            normal[++nIndex] = normalDir.y;
+            normal[++nIndex] = normalDir.z;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = distance / ringLen;
+            verticesCount++;
+            if (first && !isLast) {
+                let index = startPoints.length - 1;
+                startPoints[++index] = pathPoint.pos.x + v.x;
+                startPoints[++index] = pathPoint.pos.y + v.y;
+                startPoints[++index] = pathPoint.pos.z + v.z;
+            }
+            if (end && !isLast) {
+                let index = endPoints.length - 1;
+                endPoints[++index] = pathPoint.pos.x + v.x;
+                endPoints[++index] = pathPoint.pos.y + v.y;
+                endPoints[++index] = pathPoint.pos.z + v.z;
+            }
+        }
+        if (!first) {
+            const begin1 = verticesCount - (radialSegments) * 2;
+            const begin2 = verticesCount - (radialSegments);
+            for (let i = 0; i < radialSegments; i++) {
+                indices[++iIndex] = begin2 + i;
+                indices[++iIndex] = begin1 + i;
+                indices[++iIndex] = begin1 + i + 1;
+                indices[++iIndex] = begin2 + i;
+                indices[++iIndex] = begin1 + i + 1;
+                indices[++iIndex] = begin2 + i + 1;
+            }
+        }
+    }
+    const polygonLen = tpolygon[0].ringLen;
+    tpolygon.forEach(item => {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+            const { ring, ringLen } = item;
+            addVertices(pathPoint, ring, ringLen, i === 0, i === pathPointList.count - 1);
+        }
+    });
+    return {
+        points,
+        normal,
+        uv,
+        // uv2,
+        indices,
+        startPoints,
+        endPoints,
+        polygonLen
+        // count
+    };
+}
+function generateStartAndEnd(result, polygon, options) {
+    const { openEndUV } = options;
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        if (isClosedRing(ring)) {
+            ring.splice(ring.length - 1, 1);
+        }
+    }
+    const pointCount = calPolygonPointsCount(polygon);
+    const flatVertices = [], holes = [];
+    let pIndex = -1;
+    for (let i = 0, len = polygon.length; i < len; i++) {
+        const ring = polygon[i];
+        if (i > 0) {
+            holes.push(flatVertices.length / 2);
+        }
+        for (let j = 0, len1 = ring.length; j < len1; j++) {
+            const c = ring[j];
+            flatVertices[++pIndex] = c[0];
+            flatVertices[++pIndex] = c[1];
+        }
+    }
+    const triangles = earcut(flatVertices, holes, 2);
+    const { points, normal, uv, indices, startPoints, endPoints, polygonLen } = result;
+    pIndex = 0;
+    let uIndex = 0;
+    const aPoints1 = [], auv1 = [], aPoints2 = [], auv2 = [];
+    for (let i = 0; i < pointCount; i++) {
+        const idx = i * 3;
+        const x = startPoints[idx];
+        const y = startPoints[idx + 1];
+        const z = startPoints[idx + 2];
+        aPoints1[pIndex] = x;
+        aPoints1[pIndex + 1] = y;
+        aPoints1[pIndex + 2] = z;
+        if (openEndUV) {
+            auv1[uIndex] = y / polygonLen;
+            auv1[uIndex + 1] = z / polygonLen;
+        }
+        else {
+            auv1[uIndex] = 0;
+            auv1[uIndex + 1] = 0;
+        }
+        const x1 = endPoints[idx];
+        const y1 = endPoints[idx + 1];
+        const z1 = endPoints[idx + 2];
+        aPoints2[pIndex] = x1;
+        aPoints2[pIndex + 1] = y1;
+        aPoints2[pIndex + 2] = z1;
+        if (openEndUV) {
+            auv2[uIndex] = y1 / polygonLen;
+            auv2[uIndex + 1] = z1 / polygonLen;
+        }
+        else {
+            auv2[uIndex] = 0;
+            auv2[uIndex + 1] = 0;
+        }
+        pIndex += 3;
+        uIndex += 2;
+    }
+    const indexOffset = points.length / 3;
+    const indexs = [];
+    for (let i = 0, len = triangles.length; i < len; i++) {
+        indexs[i] = triangles[i] + indexOffset;
+        indexs[i + len] = triangles[i] + indexOffset + pointCount;
+    }
+    const anormal1 = generateNormal(triangles, aPoints1);
+    const anormal2 = generateNormal(triangles, aPoints2);
+    mergeArray(points, aPoints1);
+    mergeArray(points, aPoints2);
+    mergeArray(uv, auv1);
+    mergeArray(uv, auv2);
+    mergeArray(normal, anormal1);
+    mergeArray(normal, anormal2);
+    mergeArray(indices, indexs);
+}
+
+export { cylinder, expandLine, expandPaths, expandTubes, extrudePolygons, extrudePolygonsOnPath, extrudePolylines, extrudeSlopes, isClockwise, leftOnLine, merge, plane, polygons };
 //# sourceMappingURL=poly-extrude.mjs.map