tess-extrude 0.1.0

package/dist/tess-extrude.cjs.js

@@ -0,0 +1,1726 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const SVGLoader_js = require("three/examples/jsm/loaders/SVGLoader.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const THREE__namespace = /* @__PURE__ */ _interopNamespaceDefault(THREE);
+function validatePoints(points) {
+  if (!Array.isArray(points) || points.length < 3) return null;
+  for (const p of points) {
+    if (typeof p.x !== "number" || typeof p.y !== "number" || !isFinite(p.x) || !isFinite(p.y)) {
+      return null;
+    }
+  }
+  return points;
+}
+function fromSVG(data) {
+  let svgString;
+  if (data.startsWith("data:")) {
+    const commaIdx = data.indexOf(",");
+    svgString = atob(commaIdx >= 0 ? data.slice(commaIdx + 1) : data);
+  } else {
+    svgString = atob(data);
+  }
+  const loader = new SVGLoader_js.SVGLoader();
+  const svgData = loader.parse(svgString);
+  const contours = [];
+  for (const path of svgData.paths) {
+    const shapes = SVGLoader_js.SVGLoader.createShapes(path);
+    for (const shape of shapes) {
+      const pts = shape.getPoints();
+      if (pts.length >= 3) {
+        contours.push(pts.map((p) => ({ x: p.x, y: p.y })));
+      }
+    }
+  }
+  return contours;
+}
+function deduplicatePoints(points, eps = 0.5) {
+  if (points.length === 0) return [];
+  const epsSq = eps * eps;
+  const result = [points[0]];
+  for (let i = 1; i < points.length; i++) {
+    const prev = result[result.length - 1];
+    const cur = points[i];
+    const dx = cur.x - prev.x;
+    const dy = cur.y - prev.y;
+    if (dx * dx + dy * dy > epsSq) {
+      result.push(cur);
+    }
+  }
+  if (result.length > 1) {
+    const first = result[0];
+    const last = result[result.length - 1];
+    const dx = last.x - first.x;
+    const dy = last.y - first.y;
+    if (dx * dx + dy * dy <= epsSq) {
+      result.pop();
+    }
+  }
+  return result;
+}
+function ensureCCW(points) {
+  let area = 0;
+  for (let i = 0; i < points.length; i++) {
+    const j = (i + 1) % points.length;
+    area += points[i].x * points[j].y;
+    area -= points[j].x * points[i].y;
+  }
+  if (area < 0) {
+    return [...points].reverse();
+  }
+  return points;
+}
+function centerPoints(points) {
+  let cx = 0;
+  let cy = 0;
+  for (const p of points) {
+    cx += p.x;
+    cy += p.y;
+  }
+  cx /= points.length;
+  cy /= points.length;
+  return points.map((p) => ({ x: p.x - cx, y: p.y - cy }));
+}
+function subdivideBoundary(points, subdivisions) {
+  if (subdivisions <= 1) return [...points];
+  const n = points.length;
+  const result = new Array(n * subdivisions);
+  for (let i = 0; i < n; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % n];
+    for (let s = 0; s < subdivisions; s++) {
+      const t = s / subdivisions;
+      result[i * subdivisions + s] = {
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t
+      };
+    }
+  }
+  return result;
+}
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var poly2tri = {};
+const version = "1.5.0";
+const require$$0 = {
+  version
+};
+function toStringBase(p) {
+  return "(" + p.x + ";" + p.y + ")";
+}
+function toString(p) {
+  var s = p.toString();
+  return s === "[object Object]" ? toStringBase(p) : s;
+}
+function compare(a, b) {
+  if (a.y === b.y) {
+    return a.x - b.x;
+  } else {
+    return a.y - b.y;
+  }
+}
+function equals(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+var xy$3 = {
+  toString,
+  toStringBase,
+  compare,
+  equals
+};
+var xy$2 = xy$3;
+var PointError$2 = function(message, points) {
+  this.name = "PointError";
+  this.points = points = points || [];
+  this.message = message || "Invalid Points!";
+  for (var i = 0; i < points.length; i++) {
+    this.message += " " + xy$2.toString(points[i]);
+  }
+};
+PointError$2.prototype = new Error();
+PointError$2.prototype.constructor = PointError$2;
+var pointerror = PointError$2;
+var xy$1 = xy$3;
+var Point$1 = function(x, y) {
+  this.x = +x || 0;
+  this.y = +y || 0;
+  this._p2t_edge_list = null;
+};
+Point$1.prototype.toString = function() {
+  return xy$1.toStringBase(this);
+};
+Point$1.prototype.toJSON = function() {
+  return { x: this.x, y: this.y };
+};
+Point$1.prototype.clone = function() {
+  return new Point$1(this.x, this.y);
+};
+Point$1.prototype.set_zero = function() {
+  this.x = 0;
+  this.y = 0;
+  return this;
+};
+Point$1.prototype.set = function(x, y) {
+  this.x = +x || 0;
+  this.y = +y || 0;
+  return this;
+};
+Point$1.prototype.negate = function() {
+  this.x = -this.x;
+  this.y = -this.y;
+  return this;
+};
+Point$1.prototype.add = function(n) {
+  this.x += n.x;
+  this.y += n.y;
+  return this;
+};
+Point$1.prototype.sub = function(n) {
+  this.x -= n.x;
+  this.y -= n.y;
+  return this;
+};
+Point$1.prototype.mul = function(s) {
+  this.x *= s;
+  this.y *= s;
+  return this;
+};
+Point$1.prototype.length = function() {
+  return Math.sqrt(this.x * this.x + this.y * this.y);
+};
+Point$1.prototype.normalize = function() {
+  var len = this.length();
+  this.x /= len;
+  this.y /= len;
+  return len;
+};
+Point$1.prototype.equals = function(p) {
+  return this.x === p.x && this.y === p.y;
+};
+Point$1.negate = function(p) {
+  return new Point$1(-p.x, -p.y);
+};
+Point$1.add = function(a, b) {
+  return new Point$1(a.x + b.x, a.y + b.y);
+};
+Point$1.sub = function(a, b) {
+  return new Point$1(a.x - b.x, a.y - b.y);
+};
+Point$1.mul = function(s, p) {
+  return new Point$1(s * p.x, s * p.y);
+};
+Point$1.cross = function(a, b) {
+  if (typeof a === "number") {
+    if (typeof b === "number") {
+      return a * b;
+    } else {
+      return new Point$1(-a * b.y, a * b.x);
+    }
+  } else {
+    if (typeof b === "number") {
+      return new Point$1(b * a.y, -b * a.x);
+    } else {
+      return a.x * b.y - a.y * b.x;
+    }
+  }
+};
+Point$1.toString = xy$1.toString;
+Point$1.compare = xy$1.compare;
+Point$1.cmp = xy$1.compare;
+Point$1.equals = xy$1.equals;
+Point$1.dot = function(a, b) {
+  return a.x * b.x + a.y * b.y;
+};
+var point = Point$1;
+var xy = xy$3;
+var Triangle$2 = function(a, b, c) {
+  this.points_ = [a, b, c];
+  this.neighbors_ = [null, null, null];
+  this.interior_ = false;
+  this.constrained_edge = [false, false, false];
+  this.delaunay_edge = [false, false, false];
+};
+var p2s = xy.toString;
+Triangle$2.prototype.toString = function() {
+  return "[" + p2s(this.points_[0]) + p2s(this.points_[1]) + p2s(this.points_[2]) + "]";
+};
+Triangle$2.prototype.getPoint = function(index) {
+  return this.points_[index];
+};
+Triangle$2.prototype.GetPoint = Triangle$2.prototype.getPoint;
+Triangle$2.prototype.getPoints = function() {
+  return this.points_;
+};
+Triangle$2.prototype.getNeighbor = function(index) {
+  return this.neighbors_[index];
+};
+Triangle$2.prototype.containsPoint = function(point2) {
+  var points = this.points_;
+  return point2 === points[0] || point2 === points[1] || point2 === points[2];
+};
+Triangle$2.prototype.containsEdge = function(edge) {
+  return this.containsPoint(edge.p) && this.containsPoint(edge.q);
+};
+Triangle$2.prototype.containsPoints = function(p1, p2) {
+  return this.containsPoint(p1) && this.containsPoint(p2);
+};
+Triangle$2.prototype.isInterior = function() {
+  return this.interior_;
+};
+Triangle$2.prototype.setInterior = function(interior) {
+  this.interior_ = interior;
+  return this;
+};
+Triangle$2.prototype.markNeighborPointers = function(p1, p2, t) {
+  var points = this.points_;
+  if (p1 === points[2] && p2 === points[1] || p1 === points[1] && p2 === points[2]) {
+    this.neighbors_[0] = t;
+  } else if (p1 === points[0] && p2 === points[2] || p1 === points[2] && p2 === points[0]) {
+    this.neighbors_[1] = t;
+  } else if (p1 === points[0] && p2 === points[1] || p1 === points[1] && p2 === points[0]) {
+    this.neighbors_[2] = t;
+  } else {
+    throw new Error("poly2tri Invalid Triangle.markNeighborPointers() call");
+  }
+};
+Triangle$2.prototype.markNeighbor = function(t) {
+  var points = this.points_;
+  if (t.containsPoints(points[1], points[2])) {
+    this.neighbors_[0] = t;
+    t.markNeighborPointers(points[1], points[2], this);
+  } else if (t.containsPoints(points[0], points[2])) {
+    this.neighbors_[1] = t;
+    t.markNeighborPointers(points[0], points[2], this);
+  } else if (t.containsPoints(points[0], points[1])) {
+    this.neighbors_[2] = t;
+    t.markNeighborPointers(points[0], points[1], this);
+  }
+};
+Triangle$2.prototype.clearNeighbors = function() {
+  this.neighbors_[0] = null;
+  this.neighbors_[1] = null;
+  this.neighbors_[2] = null;
+};
+Triangle$2.prototype.clearDelaunayEdges = function() {
+  this.delaunay_edge[0] = false;
+  this.delaunay_edge[1] = false;
+  this.delaunay_edge[2] = false;
+};
+Triangle$2.prototype.pointCW = function(p) {
+  var points = this.points_;
+  if (p === points[0]) {
+    return points[2];
+  } else if (p === points[1]) {
+    return points[0];
+  } else if (p === points[2]) {
+    return points[1];
+  } else {
+    return null;
+  }
+};
+Triangle$2.prototype.pointCCW = function(p) {
+  var points = this.points_;
+  if (p === points[0]) {
+    return points[1];
+  } else if (p === points[1]) {
+    return points[2];
+  } else if (p === points[2]) {
+    return points[0];
+  } else {
+    return null;
+  }
+};
+Triangle$2.prototype.neighborCW = function(p) {
+  if (p === this.points_[0]) {
+    return this.neighbors_[1];
+  } else if (p === this.points_[1]) {
+    return this.neighbors_[2];
+  } else {
+    return this.neighbors_[0];
+  }
+};
+Triangle$2.prototype.neighborCCW = function(p) {
+  if (p === this.points_[0]) {
+    return this.neighbors_[2];
+  } else if (p === this.points_[1]) {
+    return this.neighbors_[0];
+  } else {
+    return this.neighbors_[1];
+  }
+};
+Triangle$2.prototype.getConstrainedEdgeCW = function(p) {
+  if (p === this.points_[0]) {
+    return this.constrained_edge[1];
+  } else if (p === this.points_[1]) {
+    return this.constrained_edge[2];
+  } else {
+    return this.constrained_edge[0];
+  }
+};
+Triangle$2.prototype.getConstrainedEdgeCCW = function(p) {
+  if (p === this.points_[0]) {
+    return this.constrained_edge[2];
+  } else if (p === this.points_[1]) {
+    return this.constrained_edge[0];
+  } else {
+    return this.constrained_edge[1];
+  }
+};
+Triangle$2.prototype.getConstrainedEdgeAcross = function(p) {
+  if (p === this.points_[0]) {
+    return this.constrained_edge[0];
+  } else if (p === this.points_[1]) {
+    return this.constrained_edge[1];
+  } else {
+    return this.constrained_edge[2];
+  }
+};
+Triangle$2.prototype.setConstrainedEdgeCW = function(p, ce) {
+  if (p === this.points_[0]) {
+    this.constrained_edge[1] = ce;
+  } else if (p === this.points_[1]) {
+    this.constrained_edge[2] = ce;
+  } else {
+    this.constrained_edge[0] = ce;
+  }
+};
+Triangle$2.prototype.setConstrainedEdgeCCW = function(p, ce) {
+  if (p === this.points_[0]) {
+    this.constrained_edge[2] = ce;
+  } else if (p === this.points_[1]) {
+    this.constrained_edge[0] = ce;
+  } else {
+    this.constrained_edge[1] = ce;
+  }
+};
+Triangle$2.prototype.getDelaunayEdgeCW = function(p) {
+  if (p === this.points_[0]) {
+    return this.delaunay_edge[1];
+  } else if (p === this.points_[1]) {
+    return this.delaunay_edge[2];
+  } else {
+    return this.delaunay_edge[0];
+  }
+};
+Triangle$2.prototype.getDelaunayEdgeCCW = function(p) {
+  if (p === this.points_[0]) {
+    return this.delaunay_edge[2];
+  } else if (p === this.points_[1]) {
+    return this.delaunay_edge[0];
+  } else {
+    return this.delaunay_edge[1];
+  }
+};
+Triangle$2.prototype.setDelaunayEdgeCW = function(p, e) {
+  if (p === this.points_[0]) {
+    this.delaunay_edge[1] = e;
+  } else if (p === this.points_[1]) {
+    this.delaunay_edge[2] = e;
+  } else {
+    this.delaunay_edge[0] = e;
+  }
+};
+Triangle$2.prototype.setDelaunayEdgeCCW = function(p, e) {
+  if (p === this.points_[0]) {
+    this.delaunay_edge[2] = e;
+  } else if (p === this.points_[1]) {
+    this.delaunay_edge[0] = e;
+  } else {
+    this.delaunay_edge[1] = e;
+  }
+};
+Triangle$2.prototype.neighborAcross = function(p) {
+  if (p === this.points_[0]) {
+    return this.neighbors_[0];
+  } else if (p === this.points_[1]) {
+    return this.neighbors_[1];
+  } else {
+    return this.neighbors_[2];
+  }
+};
+Triangle$2.prototype.oppositePoint = function(t, p) {
+  var cw = t.pointCW(p);
+  return this.pointCW(cw);
+};
+Triangle$2.prototype.legalize = function(opoint, npoint) {
+  var points = this.points_;
+  if (opoint === points[0]) {
+    points[1] = points[0];
+    points[0] = points[2];
+    points[2] = npoint;
+  } else if (opoint === points[1]) {
+    points[2] = points[1];
+    points[1] = points[0];
+    points[0] = npoint;
+  } else if (opoint === points[2]) {
+    points[0] = points[2];
+    points[2] = points[1];
+    points[1] = npoint;
+  } else {
+    throw new Error("poly2tri Invalid Triangle.legalize() call");
+  }
+};
+Triangle$2.prototype.index = function(p) {
+  var points = this.points_;
+  if (p === points[0]) {
+    return 0;
+  } else if (p === points[1]) {
+    return 1;
+  } else if (p === points[2]) {
+    return 2;
+  } else {
+    throw new Error("poly2tri Invalid Triangle.index() call");
+  }
+};
+Triangle$2.prototype.edgeIndex = function(p1, p2) {
+  var points = this.points_;
+  if (p1 === points[0]) {
+    if (p2 === points[1]) {
+      return 2;
+    } else if (p2 === points[2]) {
+      return 1;
+    }
+  } else if (p1 === points[1]) {
+    if (p2 === points[2]) {
+      return 0;
+    } else if (p2 === points[0]) {
+      return 2;
+    }
+  } else if (p1 === points[2]) {
+    if (p2 === points[0]) {
+      return 1;
+    } else if (p2 === points[1]) {
+      return 0;
+    }
+  }
+  return -1;
+};
+Triangle$2.prototype.markConstrainedEdgeByIndex = function(index) {
+  this.constrained_edge[index] = true;
+};
+Triangle$2.prototype.markConstrainedEdgeByEdge = function(edge) {
+  this.markConstrainedEdgeByPoints(edge.p, edge.q);
+};
+Triangle$2.prototype.markConstrainedEdgeByPoints = function(p, q) {
+  var points = this.points_;
+  if (q === points[0] && p === points[1] || q === points[1] && p === points[0]) {
+    this.constrained_edge[2] = true;
+  } else if (q === points[0] && p === points[2] || q === points[2] && p === points[0]) {
+    this.constrained_edge[1] = true;
+  } else if (q === points[1] && p === points[2] || q === points[2] && p === points[1]) {
+    this.constrained_edge[0] = true;
+  }
+};
+var triangle = Triangle$2;
+var sweep$1 = {};
+function assert$1(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assert Failed");
+  }
+}
+var assert_1 = assert$1;
+var advancingfront = { exports: {} };
+var Node$2 = function(p, t) {
+  this.point = p;
+  this.triangle = t || null;
+  this.next = null;
+  this.prev = null;
+  this.value = p.x;
+};
+var AdvancingFront$1 = function(head, tail) {
+  this.head_ = head;
+  this.tail_ = tail;
+  this.search_node_ = head;
+};
+AdvancingFront$1.prototype.head = function() {
+  return this.head_;
+};
+AdvancingFront$1.prototype.setHead = function(node) {
+  this.head_ = node;
+};
+AdvancingFront$1.prototype.tail = function() {
+  return this.tail_;
+};
+AdvancingFront$1.prototype.setTail = function(node) {
+  this.tail_ = node;
+};
+AdvancingFront$1.prototype.search = function() {
+  return this.search_node_;
+};
+AdvancingFront$1.prototype.setSearch = function(node) {
+  this.search_node_ = node;
+};
+AdvancingFront$1.prototype.findSearchNode = function() {
+  return this.search_node_;
+};
+AdvancingFront$1.prototype.locateNode = function(x) {
+  var node = this.search_node_;
+  if (x < node.value) {
+    while (node = node.prev) {
+      if (x >= node.value) {
+        this.search_node_ = node;
+        return node;
+      }
+    }
+  } else {
+    while (node = node.next) {
+      if (x < node.value) {
+        this.search_node_ = node.prev;
+        return node.prev;
+      }
+    }
+  }
+  return null;
+};
+AdvancingFront$1.prototype.locatePoint = function(point2) {
+  var px = point2.x;
+  var node = this.findSearchNode(px);
+  var nx = node.point.x;
+  if (px === nx) {
+    if (point2 !== node.point) {
+      if (point2 === node.prev.point) {
+        node = node.prev;
+      } else if (point2 === node.next.point) {
+        node = node.next;
+      } else {
+        throw new Error("poly2tri Invalid AdvancingFront.locatePoint() call");
+      }
+    }
+  } else if (px < nx) {
+    while (node = node.prev) {
+      if (point2 === node.point) {
+        break;
+      }
+    }
+  } else {
+    while (node = node.next) {
+      if (point2 === node.point) {
+        break;
+      }
+    }
+  }
+  if (node) {
+    this.search_node_ = node;
+  }
+  return node;
+};
+advancingfront.exports = AdvancingFront$1;
+advancingfront.exports.Node = Node$2;
+var advancingfrontExports = advancingfront.exports;
+var utils$1 = {};
+var EPSILON$1 = 1e-12;
+utils$1.EPSILON = EPSILON$1;
+var Orientation$1 = {
+  "CW": 1,
+  "CCW": -1,
+  "COLLINEAR": 0
+};
+utils$1.Orientation = Orientation$1;
+function orient2d$1(pa, pb, pc) {
+  var detleft = (pa.x - pc.x) * (pb.y - pc.y);
+  var detright = (pa.y - pc.y) * (pb.x - pc.x);
+  var val = detleft - detright;
+  if (val > -EPSILON$1 && val < EPSILON$1) {
+    return Orientation$1.COLLINEAR;
+  } else if (val > 0) {
+    return Orientation$1.CCW;
+  } else {
+    return Orientation$1.CW;
+  }
+}
+utils$1.orient2d = orient2d$1;
+function inScanArea$1(pa, pb, pc, pd) {
+  var oadb = (pa.x - pb.x) * (pd.y - pb.y) - (pd.x - pb.x) * (pa.y - pb.y);
+  if (oadb >= -EPSILON$1) {
+    return false;
+  }
+  var oadc = (pa.x - pc.x) * (pd.y - pc.y) - (pd.x - pc.x) * (pa.y - pc.y);
+  if (oadc <= EPSILON$1) {
+    return false;
+  }
+  return true;
+}
+utils$1.inScanArea = inScanArea$1;
+function isAngleObtuse$1(pa, pb, pc) {
+  var ax = pb.x - pa.x;
+  var ay = pb.y - pa.y;
+  var bx = pc.x - pa.x;
+  var by = pc.y - pa.y;
+  return ax * bx + ay * by < 0;
+}
+utils$1.isAngleObtuse = isAngleObtuse$1;
+var assert = assert_1;
+var PointError$1 = pointerror;
+var Triangle$1 = triangle;
+var Node$1 = advancingfrontExports.Node;
+var utils = utils$1;
+var EPSILON = utils.EPSILON;
+var Orientation = utils.Orientation;
+var orient2d = utils.orient2d;
+var inScanArea = utils.inScanArea;
+var isAngleObtuse = utils.isAngleObtuse;
+function triangulate(tcx) {
+  tcx.initTriangulation();
+  tcx.createAdvancingFront();
+  sweepPoints(tcx);
+  finalizationPolygon(tcx);
+}
+function sweepPoints(tcx) {
+  var i, len = tcx.pointCount();
+  for (i = 1; i < len; ++i) {
+    var point2 = tcx.getPoint(i);
+    var node = pointEvent(tcx, point2);
+    var edges = point2._p2t_edge_list;
+    for (var j = 0; edges && j < edges.length; ++j) {
+      edgeEventByEdge(tcx, edges[j], node);
+    }
+  }
+}
+function finalizationPolygon(tcx) {
+  var t = tcx.front().head().next.triangle;
+  var p = tcx.front().head().next.point;
+  while (!t.getConstrainedEdgeCW(p)) {
+    t = t.neighborCCW(p);
+  }
+  tcx.meshClean(t);
+}
+function pointEvent(tcx, point2) {
+  var node = tcx.locateNode(point2);
+  var new_node = newFrontTriangle(tcx, point2, node);
+  if (point2.x <= node.point.x + EPSILON) {
+    fill(tcx, node);
+  }
+  fillAdvancingFront(tcx, new_node);
+  return new_node;
+}
+function edgeEventByEdge(tcx, edge, node) {
+  tcx.edge_event.constrained_edge = edge;
+  tcx.edge_event.right = edge.p.x > edge.q.x;
+  if (isEdgeSideOfTriangle(node.triangle, edge.p, edge.q)) {
+    return;
+  }
+  fillEdgeEvent(tcx, edge, node);
+  edgeEventByPoints(tcx, edge.p, edge.q, node.triangle, edge.q);
+}
+function edgeEventByPoints(tcx, ep, eq, triangle2, point2) {
+  if (isEdgeSideOfTriangle(triangle2, ep, eq)) {
+    return;
+  }
+  var p1 = triangle2.pointCCW(point2);
+  var o1 = orient2d(eq, p1, ep);
+  if (o1 === Orientation.COLLINEAR) {
+    throw new PointError$1("poly2tri EdgeEvent: Collinear not supported!", [eq, p1, ep]);
+  }
+  var p2 = triangle2.pointCW(point2);
+  var o2 = orient2d(eq, p2, ep);
+  if (o2 === Orientation.COLLINEAR) {
+    throw new PointError$1("poly2tri EdgeEvent: Collinear not supported!", [eq, p2, ep]);
+  }
+  if (o1 === o2) {
+    if (o1 === Orientation.CW) {
+      triangle2 = triangle2.neighborCCW(point2);
+    } else {
+      triangle2 = triangle2.neighborCW(point2);
+    }
+    edgeEventByPoints(tcx, ep, eq, triangle2, point2);
+  } else {
+    flipEdgeEvent(tcx, ep, eq, triangle2, point2);
+  }
+}
+function isEdgeSideOfTriangle(triangle2, ep, eq) {
+  var index = triangle2.edgeIndex(ep, eq);
+  if (index !== -1) {
+    triangle2.markConstrainedEdgeByIndex(index);
+    var t = triangle2.getNeighbor(index);
+    if (t) {
+      t.markConstrainedEdgeByPoints(ep, eq);
+    }
+    return true;
+  }
+  return false;
+}
+function newFrontTriangle(tcx, point2, node) {
+  var triangle2 = new Triangle$1(point2, node.point, node.next.point);
+  triangle2.markNeighbor(node.triangle);
+  tcx.addToMap(triangle2);
+  var new_node = new Node$1(point2);
+  new_node.next = node.next;
+  new_node.prev = node;
+  node.next.prev = new_node;
+  node.next = new_node;
+  if (!legalize(tcx, triangle2)) {
+    tcx.mapTriangleToNodes(triangle2);
+  }
+  return new_node;
+}
+function fill(tcx, node) {
+  var triangle2 = new Triangle$1(node.prev.point, node.point, node.next.point);
+  triangle2.markNeighbor(node.prev.triangle);
+  triangle2.markNeighbor(node.triangle);
+  tcx.addToMap(triangle2);
+  node.prev.next = node.next;
+  node.next.prev = node.prev;
+  if (!legalize(tcx, triangle2)) {
+    tcx.mapTriangleToNodes(triangle2);
+  }
+}
+function fillAdvancingFront(tcx, n) {
+  var node = n.next;
+  while (node.next) {
+    if (isAngleObtuse(node.point, node.next.point, node.prev.point)) {
+      break;
+    }
+    fill(tcx, node);
+    node = node.next;
+  }
+  node = n.prev;
+  while (node.prev) {
+    if (isAngleObtuse(node.point, node.next.point, node.prev.point)) {
+      break;
+    }
+    fill(tcx, node);
+    node = node.prev;
+  }
+  if (n.next && n.next.next) {
+    if (isBasinAngleRight(n)) {
+      fillBasin(tcx, n);
+    }
+  }
+}
+function isBasinAngleRight(node) {
+  var ax = node.point.x - node.next.next.point.x;
+  var ay = node.point.y - node.next.next.point.y;
+  assert(ay >= 0, "unordered y");
+  return ax >= 0 || Math.abs(ax) < ay;
+}
+function legalize(tcx, t) {
+  for (var i = 0; i < 3; ++i) {
+    if (t.delaunay_edge[i]) {
+      continue;
+    }
+    var ot = t.getNeighbor(i);
+    if (ot) {
+      var p = t.getPoint(i);
+      var op = ot.oppositePoint(t, p);
+      var oi = ot.index(op);
+      if (ot.constrained_edge[oi] || ot.delaunay_edge[oi]) {
+        t.constrained_edge[i] = ot.constrained_edge[oi];
+        continue;
+      }
+      var inside = inCircle(p, t.pointCCW(p), t.pointCW(p), op);
+      if (inside) {
+        t.delaunay_edge[i] = true;
+        ot.delaunay_edge[oi] = true;
+        rotateTrianglePair(t, p, ot, op);
+        var not_legalized = !legalize(tcx, t);
+        if (not_legalized) {
+          tcx.mapTriangleToNodes(t);
+        }
+        not_legalized = !legalize(tcx, ot);
+        if (not_legalized) {
+          tcx.mapTriangleToNodes(ot);
+        }
+        t.delaunay_edge[i] = false;
+        ot.delaunay_edge[oi] = false;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function inCircle(pa, pb, pc, pd) {
+  var adx = pa.x - pd.x;
+  var ady = pa.y - pd.y;
+  var bdx = pb.x - pd.x;
+  var bdy = pb.y - pd.y;
+  var adxbdy = adx * bdy;
+  var bdxady = bdx * ady;
+  var oabd = adxbdy - bdxady;
+  if (oabd <= 0) {
+    return false;
+  }
+  var cdx = pc.x - pd.x;
+  var cdy = pc.y - pd.y;
+  var cdxady = cdx * ady;
+  var adxcdy = adx * cdy;
+  var ocad = cdxady - adxcdy;
+  if (ocad <= 0) {
+    return false;
+  }
+  var bdxcdy = bdx * cdy;
+  var cdxbdy = cdx * bdy;
+  var alift = adx * adx + ady * ady;
+  var blift = bdx * bdx + bdy * bdy;
+  var clift = cdx * cdx + cdy * cdy;
+  var det = alift * (bdxcdy - cdxbdy) + blift * ocad + clift * oabd;
+  return det > 0;
+}
+function rotateTrianglePair(t, p, ot, op) {
+  var n1, n2, n3, n4;
+  n1 = t.neighborCCW(p);
+  n2 = t.neighborCW(p);
+  n3 = ot.neighborCCW(op);
+  n4 = ot.neighborCW(op);
+  var ce1, ce2, ce3, ce4;
+  ce1 = t.getConstrainedEdgeCCW(p);
+  ce2 = t.getConstrainedEdgeCW(p);
+  ce3 = ot.getConstrainedEdgeCCW(op);
+  ce4 = ot.getConstrainedEdgeCW(op);
+  var de1, de2, de3, de4;
+  de1 = t.getDelaunayEdgeCCW(p);
+  de2 = t.getDelaunayEdgeCW(p);
+  de3 = ot.getDelaunayEdgeCCW(op);
+  de4 = ot.getDelaunayEdgeCW(op);
+  t.legalize(p, op);
+  ot.legalize(op, p);
+  ot.setDelaunayEdgeCCW(p, de1);
+  t.setDelaunayEdgeCW(p, de2);
+  t.setDelaunayEdgeCCW(op, de3);
+  ot.setDelaunayEdgeCW(op, de4);
+  ot.setConstrainedEdgeCCW(p, ce1);
+  t.setConstrainedEdgeCW(p, ce2);
+  t.setConstrainedEdgeCCW(op, ce3);
+  ot.setConstrainedEdgeCW(op, ce4);
+  t.clearNeighbors();
+  ot.clearNeighbors();
+  if (n1) {
+    ot.markNeighbor(n1);
+  }
+  if (n2) {
+    t.markNeighbor(n2);
+  }
+  if (n3) {
+    t.markNeighbor(n3);
+  }
+  if (n4) {
+    ot.markNeighbor(n4);
+  }
+  t.markNeighbor(ot);
+}
+function fillBasin(tcx, node) {
+  if (orient2d(node.point, node.next.point, node.next.next.point) === Orientation.CCW) {
+    tcx.basin.left_node = node.next.next;
+  } else {
+    tcx.basin.left_node = node.next;
+  }
+  tcx.basin.bottom_node = tcx.basin.left_node;
+  while (tcx.basin.bottom_node.next && tcx.basin.bottom_node.point.y >= tcx.basin.bottom_node.next.point.y) {
+    tcx.basin.bottom_node = tcx.basin.bottom_node.next;
+  }
+  if (tcx.basin.bottom_node === tcx.basin.left_node) {
+    return;
+  }
+  tcx.basin.right_node = tcx.basin.bottom_node;
+  while (tcx.basin.right_node.next && tcx.basin.right_node.point.y < tcx.basin.right_node.next.point.y) {
+    tcx.basin.right_node = tcx.basin.right_node.next;
+  }
+  if (tcx.basin.right_node === tcx.basin.bottom_node) {
+    return;
+  }
+  tcx.basin.width = tcx.basin.right_node.point.x - tcx.basin.left_node.point.x;
+  tcx.basin.left_highest = tcx.basin.left_node.point.y > tcx.basin.right_node.point.y;
+  fillBasinReq(tcx, tcx.basin.bottom_node);
+}
+function fillBasinReq(tcx, node) {
+  if (isShallow(tcx, node)) {
+    return;
+  }
+  fill(tcx, node);
+  var o;
+  if (node.prev === tcx.basin.left_node && node.next === tcx.basin.right_node) {
+    return;
+  } else if (node.prev === tcx.basin.left_node) {
+    o = orient2d(node.point, node.next.point, node.next.next.point);
+    if (o === Orientation.CW) {
+      return;
+    }
+    node = node.next;
+  } else if (node.next === tcx.basin.right_node) {
+    o = orient2d(node.point, node.prev.point, node.prev.prev.point);
+    if (o === Orientation.CCW) {
+      return;
+    }
+    node = node.prev;
+  } else {
+    if (node.prev.point.y < node.next.point.y) {
+      node = node.prev;
+    } else {
+      node = node.next;
+    }
+  }
+  fillBasinReq(tcx, node);
+}
+function isShallow(tcx, node) {
+  var height;
+  if (tcx.basin.left_highest) {
+    height = tcx.basin.left_node.point.y - node.point.y;
+  } else {
+    height = tcx.basin.right_node.point.y - node.point.y;
+  }
+  if (tcx.basin.width > height) {
+    return true;
+  }
+  return false;
+}
+function fillEdgeEvent(tcx, edge, node) {
+  if (tcx.edge_event.right) {
+    fillRightAboveEdgeEvent(tcx, edge, node);
+  } else {
+    fillLeftAboveEdgeEvent(tcx, edge, node);
+  }
+}
+function fillRightAboveEdgeEvent(tcx, edge, node) {
+  while (node.next.point.x < edge.p.x) {
+    if (orient2d(edge.q, node.next.point, edge.p) === Orientation.CCW) {
+      fillRightBelowEdgeEvent(tcx, edge, node);
+    } else {
+      node = node.next;
+    }
+  }
+}
+function fillRightBelowEdgeEvent(tcx, edge, node) {
+  if (node.point.x < edge.p.x) {
+    if (orient2d(node.point, node.next.point, node.next.next.point) === Orientation.CCW) {
+      fillRightConcaveEdgeEvent(tcx, edge, node);
+    } else {
+      fillRightConvexEdgeEvent(tcx, edge, node);
+      fillRightBelowEdgeEvent(tcx, edge, node);
+    }
+  }
+}
+function fillRightConcaveEdgeEvent(tcx, edge, node) {
+  fill(tcx, node.next);
+  if (node.next.point !== edge.p) {
+    if (orient2d(edge.q, node.next.point, edge.p) === Orientation.CCW) {
+      if (orient2d(node.point, node.next.point, node.next.next.point) === Orientation.CCW) {
+        fillRightConcaveEdgeEvent(tcx, edge, node);
+      }
+    }
+  }
+}
+function fillRightConvexEdgeEvent(tcx, edge, node) {
+  if (orient2d(node.next.point, node.next.next.point, node.next.next.next.point) === Orientation.CCW) {
+    fillRightConcaveEdgeEvent(tcx, edge, node.next);
+  } else {
+    if (orient2d(edge.q, node.next.next.point, edge.p) === Orientation.CCW) {
+      fillRightConvexEdgeEvent(tcx, edge, node.next);
+    }
+  }
+}
+function fillLeftAboveEdgeEvent(tcx, edge, node) {
+  while (node.prev.point.x > edge.p.x) {
+    if (orient2d(edge.q, node.prev.point, edge.p) === Orientation.CW) {
+      fillLeftBelowEdgeEvent(tcx, edge, node);
+    } else {
+      node = node.prev;
+    }
+  }
+}
+function fillLeftBelowEdgeEvent(tcx, edge, node) {
+  if (node.point.x > edge.p.x) {
+    if (orient2d(node.point, node.prev.point, node.prev.prev.point) === Orientation.CW) {
+      fillLeftConcaveEdgeEvent(tcx, edge, node);
+    } else {
+      fillLeftConvexEdgeEvent(tcx, edge, node);
+      fillLeftBelowEdgeEvent(tcx, edge, node);
+    }
+  }
+}
+function fillLeftConvexEdgeEvent(tcx, edge, node) {
+  if (orient2d(node.prev.point, node.prev.prev.point, node.prev.prev.prev.point) === Orientation.CW) {
+    fillLeftConcaveEdgeEvent(tcx, edge, node.prev);
+  } else {
+    if (orient2d(edge.q, node.prev.prev.point, edge.p) === Orientation.CW) {
+      fillLeftConvexEdgeEvent(tcx, edge, node.prev);
+    }
+  }
+}
+function fillLeftConcaveEdgeEvent(tcx, edge, node) {
+  fill(tcx, node.prev);
+  if (node.prev.point !== edge.p) {
+    if (orient2d(edge.q, node.prev.point, edge.p) === Orientation.CW) {
+      if (orient2d(node.point, node.prev.point, node.prev.prev.point) === Orientation.CW) {
+        fillLeftConcaveEdgeEvent(tcx, edge, node);
+      }
+    }
+  }
+}
+function flipEdgeEvent(tcx, ep, eq, t, p) {
+  var ot = t.neighborAcross(p);
+  assert(ot, "FLIP failed due to missing triangle!");
+  var op = ot.oppositePoint(t, p);
+  if (t.getConstrainedEdgeAcross(p)) {
+    var index = t.index(p);
+    throw new PointError$1(
+      "poly2tri Intersecting Constraints",
+      [p, op, t.getPoint((index + 1) % 3), t.getPoint((index + 2) % 3)]
+    );
+  }
+  if (inScanArea(p, t.pointCCW(p), t.pointCW(p), op)) {
+    rotateTrianglePair(t, p, ot, op);
+    tcx.mapTriangleToNodes(t);
+    tcx.mapTriangleToNodes(ot);
+    if (p === eq && op === ep) {
+      if (eq === tcx.edge_event.constrained_edge.q && ep === tcx.edge_event.constrained_edge.p) {
+        t.markConstrainedEdgeByPoints(ep, eq);
+        ot.markConstrainedEdgeByPoints(ep, eq);
+        legalize(tcx, t);
+        legalize(tcx, ot);
+      }
+    } else {
+      var o = orient2d(eq, op, ep);
+      t = nextFlipTriangle(tcx, o, t, ot, p, op);
+      flipEdgeEvent(tcx, ep, eq, t, p);
+    }
+  } else {
+    var newP = nextFlipPoint(ep, eq, ot, op);
+    flipScanEdgeEvent(tcx, ep, eq, t, ot, newP);
+    edgeEventByPoints(tcx, ep, eq, t, p);
+  }
+}
+function nextFlipTriangle(tcx, o, t, ot, p, op) {
+  var edge_index;
+  if (o === Orientation.CCW) {
+    edge_index = ot.edgeIndex(p, op);
+    ot.delaunay_edge[edge_index] = true;
+    legalize(tcx, ot);
+    ot.clearDelaunayEdges();
+    return t;
+  }
+  edge_index = t.edgeIndex(p, op);
+  t.delaunay_edge[edge_index] = true;
+  legalize(tcx, t);
+  t.clearDelaunayEdges();
+  return ot;
+}
+function nextFlipPoint(ep, eq, ot, op) {
+  var o2d = orient2d(eq, op, ep);
+  if (o2d === Orientation.CW) {
+    return ot.pointCCW(op);
+  } else if (o2d === Orientation.CCW) {
+    return ot.pointCW(op);
+  } else {
+    throw new PointError$1("poly2tri [Unsupported] nextFlipPoint: opposing point on constrained edge!", [eq, op, ep]);
+  }
+}
+function flipScanEdgeEvent(tcx, ep, eq, flip_triangle, t, p) {
+  var ot = t.neighborAcross(p);
+  assert(ot, "FLIP failed due to missing triangle");
+  var op = ot.oppositePoint(t, p);
+  if (inScanArea(eq, flip_triangle.pointCCW(eq), flip_triangle.pointCW(eq), op)) {
+    flipEdgeEvent(tcx, eq, op, ot, op);
+  } else {
+    var newP = nextFlipPoint(ep, eq, ot, op);
+    flipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP);
+  }
+}
+sweep$1.triangulate = triangulate;
+var PointError = pointerror;
+var Point = point;
+var Triangle = triangle;
+var sweep = sweep$1;
+var AdvancingFront = advancingfrontExports;
+var Node = AdvancingFront.Node;
+var kAlpha = 0.3;
+var Edge = function(p1, p2) {
+  this.p = p1;
+  this.q = p2;
+  if (p1.y > p2.y) {
+    this.q = p1;
+    this.p = p2;
+  } else if (p1.y === p2.y) {
+    if (p1.x > p2.x) {
+      this.q = p1;
+      this.p = p2;
+    } else if (p1.x === p2.x) {
+      throw new PointError("poly2tri Invalid Edge constructor: repeated points!", [p1]);
+    }
+  }
+  if (!this.q._p2t_edge_list) {
+    this.q._p2t_edge_list = [];
+  }
+  this.q._p2t_edge_list.push(this);
+};
+var Basin = function() {
+  this.left_node = null;
+  this.bottom_node = null;
+  this.right_node = null;
+  this.width = 0;
+  this.left_highest = false;
+};
+Basin.prototype.clear = function() {
+  this.left_node = null;
+  this.bottom_node = null;
+  this.right_node = null;
+  this.width = 0;
+  this.left_highest = false;
+};
+var EdgeEvent = function() {
+  this.constrained_edge = null;
+  this.right = false;
+};
+var SweepContext = function(contour, options) {
+  options = options || {};
+  this.triangles_ = [];
+  this.map_ = [];
+  this.points_ = options.cloneArrays ? contour.slice(0) : contour;
+  this.edge_list = [];
+  this.pmin_ = this.pmax_ = null;
+  this.front_ = null;
+  this.head_ = null;
+  this.tail_ = null;
+  this.af_head_ = null;
+  this.af_middle_ = null;
+  this.af_tail_ = null;
+  this.basin = new Basin();
+  this.edge_event = new EdgeEvent();
+  this.initEdges(this.points_);
+};
+SweepContext.prototype.addHole = function(polyline) {
+  this.initEdges(polyline);
+  var i, len = polyline.length;
+  for (i = 0; i < len; i++) {
+    this.points_.push(polyline[i]);
+  }
+  return this;
+};
+SweepContext.prototype.AddHole = SweepContext.prototype.addHole;
+SweepContext.prototype.addHoles = function(holes) {
+  var i, len = holes.length;
+  for (i = 0; i < len; i++) {
+    this.initEdges(holes[i]);
+  }
+  this.points_ = this.points_.concat.apply(this.points_, holes);
+  return this;
+};
+SweepContext.prototype.addPoint = function(point2) {
+  this.points_.push(point2);
+  return this;
+};
+SweepContext.prototype.AddPoint = SweepContext.prototype.addPoint;
+SweepContext.prototype.addPoints = function(points) {
+  this.points_ = this.points_.concat(points);
+  return this;
+};
+SweepContext.prototype.triangulate = function() {
+  sweep.triangulate(this);
+  return this;
+};
+SweepContext.prototype.getBoundingBox = function() {
+  return { min: this.pmin_, max: this.pmax_ };
+};
+SweepContext.prototype.getTriangles = function() {
+  return this.triangles_;
+};
+SweepContext.prototype.GetTriangles = SweepContext.prototype.getTriangles;
+SweepContext.prototype.front = function() {
+  return this.front_;
+};
+SweepContext.prototype.pointCount = function() {
+  return this.points_.length;
+};
+SweepContext.prototype.head = function() {
+  return this.head_;
+};
+SweepContext.prototype.setHead = function(p1) {
+  this.head_ = p1;
+};
+SweepContext.prototype.tail = function() {
+  return this.tail_;
+};
+SweepContext.prototype.setTail = function(p1) {
+  this.tail_ = p1;
+};
+SweepContext.prototype.getMap = function() {
+  return this.map_;
+};
+SweepContext.prototype.initTriangulation = function() {
+  var xmax = this.points_[0].x;
+  var xmin = this.points_[0].x;
+  var ymax = this.points_[0].y;
+  var ymin = this.points_[0].y;
+  var i, len = this.points_.length;
+  for (i = 1; i < len; i++) {
+    var p = this.points_[i];
+    p.x > xmax && (xmax = p.x);
+    p.x < xmin && (xmin = p.x);
+    p.y > ymax && (ymax = p.y);
+    p.y < ymin && (ymin = p.y);
+  }
+  this.pmin_ = new Point(xmin, ymin);
+  this.pmax_ = new Point(xmax, ymax);
+  var dx = kAlpha * (xmax - xmin);
+  var dy = kAlpha * (ymax - ymin);
+  this.head_ = new Point(xmax + dx, ymin - dy);
+  this.tail_ = new Point(xmin - dx, ymin - dy);
+  this.points_.sort(Point.compare);
+};
+SweepContext.prototype.initEdges = function(polyline) {
+  var i, len = polyline.length;
+  for (i = 0; i < len; ++i) {
+    this.edge_list.push(new Edge(polyline[i], polyline[(i + 1) % len]));
+  }
+};
+SweepContext.prototype.getPoint = function(index) {
+  return this.points_[index];
+};
+SweepContext.prototype.addToMap = function(triangle2) {
+  this.map_.push(triangle2);
+};
+SweepContext.prototype.locateNode = function(point2) {
+  return this.front_.locateNode(point2.x);
+};
+SweepContext.prototype.createAdvancingFront = function() {
+  var head;
+  var middle;
+  var tail;
+  var triangle2 = new Triangle(this.points_[0], this.tail_, this.head_);
+  this.map_.push(triangle2);
+  head = new Node(triangle2.getPoint(1), triangle2);
+  middle = new Node(triangle2.getPoint(0), triangle2);
+  tail = new Node(triangle2.getPoint(2));
+  this.front_ = new AdvancingFront(head, tail);
+  head.next = middle;
+  middle.next = tail;
+  middle.prev = head;
+  tail.prev = middle;
+};
+SweepContext.prototype.removeNode = function(node) {
+};
+SweepContext.prototype.mapTriangleToNodes = function(t) {
+  for (var i = 0; i < 3; ++i) {
+    if (!t.getNeighbor(i)) {
+      var n = this.front_.locatePoint(t.pointCW(t.getPoint(i)));
+      if (n) {
+        n.triangle = t;
+      }
+    }
+  }
+};
+SweepContext.prototype.removeFromMap = function(triangle2) {
+  var i, map = this.map_, len = map.length;
+  for (i = 0; i < len; i++) {
+    if (map[i] === triangle2) {
+      map.splice(i, 1);
+      break;
+    }
+  }
+};
+SweepContext.prototype.meshClean = function(triangle2) {
+  var triangles = [triangle2], t, i;
+  while (t = triangles.pop()) {
+    if (!t.isInterior()) {
+      t.setInterior(true);
+      this.triangles_.push(t);
+      for (i = 0; i < 3; i++) {
+        if (!t.constrained_edge[i]) {
+          triangles.push(t.getNeighbor(i));
+        }
+      }
+    }
+  }
+};
+var sweepcontext = SweepContext;
+(function(exports$1) {
+  var previousPoly2tri = commonjsGlobal.poly2tri;
+  exports$1.noConflict = function() {
+    commonjsGlobal.poly2tri = previousPoly2tri;
+    return exports$1;
+  };
+  exports$1.VERSION = require$$0.version;
+  exports$1.PointError = pointerror;
+  exports$1.Point = point;
+  exports$1.Triangle = triangle;
+  exports$1.SweepContext = sweepcontext;
+  var sweep2 = sweep$1;
+  exports$1.triangulate = sweep2.triangulate;
+  exports$1.sweep = { Triangulate: sweep2.triangulate };
+})(poly2tri);
+function pointInPolygon(px, py, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x;
+    const yi = polygon[i].y;
+    const xj = polygon[j].x;
+    const yj = polygon[j].y;
+    if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function distToSegment(px, py, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) return Math.hypot(px - a.x, py - a.y);
+  const t = Math.max(0, Math.min(1, ((px - a.x) * dx + (py - a.y) * dy) / lenSq));
+  return Math.hypot(px - (a.x + t * dx), py - (a.y + t * dy));
+}
+function generateSteinerPoints(polygon, density, bounds, rand) {
+  const { minX, minY, maxX, maxY } = bounds;
+  const maxDim = Math.max(maxX - minX, maxY - minY);
+  const spacing = maxDim / (density + 1);
+  const margin = spacing * 0.5;
+  const steiners = [];
+  for (let x = minX + margin; x < maxX - margin * 0.5; x += spacing) {
+    for (let y = minY + margin; y < maxY - margin * 0.5; y += spacing) {
+      if (!pointInPolygon(x, y, polygon)) continue;
+      let tooClose = false;
+      for (let i = 0; i < polygon.length; i++) {
+        const j = (i + 1) % polygon.length;
+        if (distToSegment(x, y, polygon[i], polygon[j]) < spacing * 0.15) {
+          tooClose = true;
+          break;
+        }
+      }
+      if (!tooClose) {
+        const jx = (rand() - 0.5) * spacing * 0.05;
+        const jy = (rand() - 0.5) * spacing * 0.05;
+        steiners.push({ x: x + jx, y: y + jy });
+      }
+    }
+  }
+  return steiners;
+}
+function mulberry32(seed) {
+  let s = seed | 0;
+  return function() {
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function triangulateCap(boundaryPoints, density, bounds) {
+  const seed = Math.round(
+    Math.abs(bounds.maxX - bounds.minX) * 1e3 + Math.abs(bounds.maxY - bounds.minY) * 1e3
+  );
+  const rand = mulberry32(seed);
+  const attempt = (withSteiners) => {
+    try {
+      const contour = boundaryPoints.map((p) => new poly2tri.Point(p.x, p.y));
+      const swctx = new poly2tri.SweepContext(contour);
+      if (withSteiners && density > 1) {
+        const steiners = generateSteinerPoints(boundaryPoints, density, bounds, rand);
+        for (const s of steiners) {
+          swctx.addPoint(new poly2tri.Point(s.x, s.y));
+        }
+      }
+      swctx.triangulate();
+      const tris2 = swctx.getTriangles();
+      return tris2;
+    } catch {
+      return null;
+    }
+  };
+  let tris = attempt(true);
+  if (tris === null) {
+    console.warn("poly2tri: triangulation failed, retrying without Steiner points");
+    tris = attempt(false);
+    if (tris === null) {
+      console.error("poly2tri: triangulation failed completely");
+    }
+  }
+  return tris;
+}
+function writeCap(positions, normals, indices, vertOffset, idxOffset, capTriangles, z, normalZ, reverseWinding) {
+  const vertMap = /* @__PURE__ */ new Map();
+  let localVert = 0;
+  let ii = idxOffset;
+  for (const tri of capTriangles) {
+    const pts = tri.getPoints();
+    const vi0 = getOrAdd(pts[0], z, normalZ, positions, normals, vertOffset, vertMap, () => localVert++);
+    const vi1 = getOrAdd(pts[1], z, normalZ, positions, normals, vertOffset, vertMap, () => localVert++);
+    const vi2 = getOrAdd(pts[2], z, normalZ, positions, normals, vertOffset, vertMap, () => localVert++);
+    if (reverseWinding) {
+      indices[ii++] = vi0;
+      indices[ii++] = vi2;
+      indices[ii++] = vi1;
+    } else {
+      indices[ii++] = vi0;
+      indices[ii++] = vi1;
+      indices[ii++] = vi2;
+    }
+  }
+  return localVert;
+}
+function getOrAdd(pt, z, normalZ, positions, normals, vertOffset, map, nextIdx) {
+  let idx = map.get(pt);
+  if (idx !== void 0) return idx;
+  idx = vertOffset + nextIdx();
+  const base = idx * 3;
+  positions[base] = pt.x;
+  positions[base + 1] = pt.y;
+  positions[base + 2] = z;
+  normals[base] = 0;
+  normals[base + 1] = 0;
+  normals[base + 2] = normalZ;
+  map.set(pt, idx);
+  return idx;
+}
+function writeSides(positions, normals, indices, vertOffset, idxOffset, boundaryPoints, frontZ, backZ, depthSegs) {
+  const n = boundaryPoints.length;
+  let vi = vertOffset;
+  let ii = idxOffset;
+  for (let i = 0; i < n; i++) {
+    const a = boundaryPoints[i];
+    const b = boundaryPoints[(i + 1) % n];
+    const edgeDx = b.x - a.x;
+    const edgeDy = b.y - a.y;
+    const edgeLen = Math.hypot(edgeDx, edgeDy);
+    const nx = edgeLen > 0 ? edgeDy / edgeLen : 0;
+    const ny = edgeLen > 0 ? -edgeDx / edgeLen : 0;
+    for (let j = 0; j < depthSegs; j++) {
+      const z0 = frontZ + (backZ - frontZ) * (j / depthSegs);
+      const z1 = frontZ + (backZ - frontZ) * ((j + 1) / depthSegs);
+      const v0 = vi++;
+      positions[v0 * 3] = a.x;
+      positions[v0 * 3 + 1] = a.y;
+      positions[v0 * 3 + 2] = z0;
+      normals[v0 * 3] = nx;
+      normals[v0 * 3 + 1] = ny;
+      normals[v0 * 3 + 2] = 0;
+      const v1 = vi++;
+      positions[v1 * 3] = b.x;
+      positions[v1 * 3 + 1] = b.y;
+      positions[v1 * 3 + 2] = z0;
+      normals[v1 * 3] = nx;
+      normals[v1 * 3 + 1] = ny;
+      normals[v1 * 3 + 2] = 0;
+      const v2 = vi++;
+      positions[v2 * 3] = b.x;
+      positions[v2 * 3 + 1] = b.y;
+      positions[v2 * 3 + 2] = z1;
+      normals[v2 * 3] = nx;
+      normals[v2 * 3 + 1] = ny;
+      normals[v2 * 3 + 2] = 0;
+      const v3 = vi++;
+      positions[v3 * 3] = a.x;
+      positions[v3 * 3 + 1] = a.y;
+      positions[v3 * 3 + 2] = z1;
+      normals[v3 * 3] = nx;
+      normals[v3 * 3 + 1] = ny;
+      normals[v3 * 3 + 2] = 0;
+      indices[ii++] = v0;
+      indices[ii++] = v1;
+      indices[ii++] = v2;
+      indices[ii++] = v0;
+      indices[ii++] = v2;
+      indices[ii++] = v3;
+    }
+  }
+}
+function computeBounds(points) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of points) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function buildGeometry(subdividedPts, capTriangles, depth, depthSegs) {
+  const nCapTris = capTriangles.length;
+  const nBoundary = subdividedPts.length;
+  const uniqueCapPoints = /* @__PURE__ */ new Set();
+  for (const tri of capTriangles) {
+    const pts = tri.getPoints();
+    uniqueCapPoints.add(pts[0]);
+    uniqueCapPoints.add(pts[1]);
+    uniqueCapPoints.add(pts[2]);
+  }
+  const nUniqueCapVerts = uniqueCapPoints.size;
+  uniqueCapPoints.clear();
+  const nSideVerts = nBoundary * depthSegs * 4;
+  const totalVerts = nUniqueCapVerts * 2 + nSideVerts;
+  const totalIndices = nCapTris * 6 + nBoundary * depthSegs * 6;
+  const positions = new Float32Array(totalVerts * 3);
+  const normals = new Float32Array(totalVerts * 3);
+  const indices = totalVerts <= 65535 ? new Uint16Array(totalIndices) : new Uint32Array(totalIndices);
+  const frontZ = -depth / 2;
+  const backZ = depth / 2;
+  const frontVertsWritten = writeCap(
+    positions,
+    normals,
+    indices,
+    0,
+    0,
+    capTriangles,
+    frontZ,
+    -1,
+    true
+  );
+  writeCap(
+    positions,
+    normals,
+    indices,
+    frontVertsWritten,
+    nCapTris * 3,
+    capTriangles,
+    backZ,
+    1,
+    false
+  );
+  writeSides(
+    positions,
+    normals,
+    indices,
+    nUniqueCapVerts * 2,
+    nCapTris * 6,
+    subdividedPts,
+    frontZ,
+    backZ,
+    depthSegs
+  );
+  const geo = new THREE__namespace.BufferGeometry();
+  geo.setAttribute("position", new THREE__namespace.BufferAttribute(positions, 3));
+  geo.setAttribute("normal", new THREE__namespace.BufferAttribute(normals, 3));
+  geo.setIndex(new THREE__namespace.BufferAttribute(indices, 1));
+  return geo;
+}
+const DEFAULTS = {
+  depth: 20,
+  depthSegments: 4,
+  capDensity: 5,
+  edgeSubdivisions: 2
+};
+function buildExtrudedGeometry(rawPoints, opts) {
+  const { depth, depthSegments, capDensity, edgeSubdivisions } = opts;
+  let pts = deduplicatePoints(rawPoints, 0.5);
+  if (pts.length < 3) return null;
+  pts = ensureCCW(pts);
+  pts = centerPoints(pts);
+  const subdividedPts = subdivideBoundary(pts, edgeSubdivisions);
+  const bounds = computeBounds(subdividedPts);
+  const capTriangles = triangulateCap(subdividedPts, capDensity, bounds);
+  if (!capTriangles || capTriangles.length === 0) return null;
+  return buildGeometry(subdividedPts, capTriangles, depth, depthSegments);
+}
+function extrude(input, options) {
+  const opts = { ...DEFAULTS, ...options };
+  if (input.type === "points") {
+    const pts = validatePoints(input.points);
+    if (!pts) return null;
+    return buildExtrudedGeometry(pts, opts);
+  }
+  let contours;
+  try {
+    contours = fromSVG(input.data);
+  } catch (e) {
+    console.error("tess-extrude: SVG parsing failed", e);
+    return null;
+  }
+  if (contours.length === 0) return null;
+  const geometries = [];
+  for (const contour of contours) {
+    const geo = buildExtrudedGeometry(contour, opts);
+    if (geo) geometries.push(geo);
+  }
+  if (geometries.length === 0) return null;
+  if (geometries.length === 1) return geometries[0];
+  return mergeGeometries(geometries);
+}
+function mergeGeometries(geos) {
+  let totalVerts = 0;
+  let totalIndices = 0;
+  for (const g of geos) {
+    const pos = g.getAttribute("position");
+    totalVerts += pos.count;
+    const idx = g.index;
+    if (idx) totalIndices += idx.count;
+  }
+  const positions = new Float32Array(totalVerts * 3);
+  const normals = new Float32Array(totalVerts * 3);
+  const indices = totalVerts <= 65535 ? new Uint16Array(totalIndices) : new Uint32Array(totalIndices);
+  let vOff = 0;
+  let iOff = 0;
+  for (const g of geos) {
+    const pos = g.getAttribute("position").array;
+    const nor = g.getAttribute("normal").array;
+    const idx = g.index;
+    positions.set(pos, vOff * 3);
+    normals.set(nor, vOff * 3);
+    if (idx) {
+      const idxArr = idx.array;
+      for (let i = 0; i < idxArr.length; i++) {
+        indices[iOff + i] = idxArr[i] + vOff;
+      }
+      iOff += idxArr.length;
+    }
+    vOff += pos.length / 3;
+    g.dispose();
+  }
+  const merged = new THREE__namespace.BufferGeometry();
+  merged.setAttribute("position", new THREE__namespace.BufferAttribute(positions, 3));
+  merged.setAttribute("normal", new THREE__namespace.BufferAttribute(normals, 3));
+  merged.setIndex(new THREE__namespace.BufferAttribute(indices, 1));
+  return merged;
+}
+function perpendicularDist(p, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) return Math.hypot(p.x - a.x, p.y - a.y);
+  const t = Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lenSq));
+  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+function simplifyPath(points, tolerance) {
+  if (points.length <= 2) return points.slice();
+  const keep = new Uint8Array(points.length);
+  keep[0] = 1;
+  keep[points.length - 1] = 1;
+  const stack = [[0, points.length - 1]];
+  while (stack.length > 0) {
+    const range = stack.pop();
+    const start = range[0];
+    const end = range[1];
+    if (end - start <= 1) continue;
+    const first = points[start];
+    const last = points[end];
+    let maxDist = 0;
+    let maxIdx = start;
+    for (let i = start + 1; i < end; i++) {
+      const d = perpendicularDist(points[i], first, last);
+      if (d > maxDist) {
+        maxDist = d;
+        maxIdx = i;
+      }
+    }
+    if (maxDist > tolerance) {
+      keep[maxIdx] = 1;
+      stack.push([start, maxIdx]);
+      stack.push([maxIdx, end]);
+    }
+  }
+  const result = [];
+  for (let i = 0; i < points.length; i++) {
+    if (keep[i]) result.push(points[i]);
+  }
+  return result;
+}
+exports.deduplicatePoints = deduplicatePoints;
+exports.ensureCCW = ensureCCW;
+exports.extrude = extrude;
+exports.simplifyPath = simplifyPath;
+exports.subdivideBoundary = subdivideBoundary;
+//# sourceMappingURL=tess-extrude.cjs.js.map