modern-path2d 1.7.0 → 1.8.1

package/dist/index.cjs

@@ -1,10 +1,12 @@
 'use strict';
 
 const earcut = require('earcut');
+const polygonClipping = require('polygon-clipping');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const earcut__default = /*#__PURE__*/_interopDefaultCompat(earcut);
+const polygonClipping__default = /*#__PURE__*/_interopDefaultCompat(polygonClipping);
 
 function drawPoint(ctx, x, y, options = {}) {
   const { radius = 1 } = options;
@@ -303,6 +305,63 @@ class BoundingBox {
   }
 }
 
+function flatRingToPairs(r) {
+  const ring = [];
+  for (let i = 0; i < r.length; i += 2) {
+    ring.push([r[i], r[i + 1]]);
+  }
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first && last && (first[0] !== last[0] || first[1] !== last[1])) {
+    ring.push([first[0], first[1]]);
+  }
+  return ring;
+}
+function ringsToGeom(rings) {
+  const valid = rings.filter((r) => r.length >= 6).map(flatRingToPairs);
+  if (!valid.length) {
+    return [];
+  }
+  let geom = [[valid[0]]];
+  for (let i = 1; i < valid.length; i++) {
+    geom = polygonClipping__default.xor(geom, [[valid[i]]]);
+  }
+  return geom;
+}
+function geomToRings(geom) {
+  const out = [];
+  for (const poly of geom) {
+    for (const ring of poly) {
+      const flat = [];
+      for (const [x, y] of ring) {
+        flat.push(x, y);
+      }
+      out.push(flat);
+    }
+  }
+  return out;
+}
+function polygonBoolean(op, ringsA, ringsB) {
+  const a = ringsToGeom(ringsA);
+  const b = ringsToGeom(ringsB);
+  let res;
+  switch (op) {
+    case "union":
+      res = polygonClipping__default.union(a, b);
+      break;
+    case "intersection":
+      res = polygonClipping__default.intersection(a, b);
+      break;
+    case "difference":
+      res = polygonClipping__default.difference(a, b);
+      break;
+    case "xor":
+      res = polygonClipping__default.xor(a, b);
+      break;
+  }
+  return geomToRings(res);
+}
+
 function catmullRom(t, p0, p1, p2, p3) {
   const v0 = (p2 - p0) * 0.5;
   const v1 = (p3 - p1) * 0.5;
@@ -433,6 +492,195 @@ function cubicBezier(t, p0, p1, p2, p3) {
   return cubicBezierP0(t, p0) + cubicBezierP1(t, p1) + cubicBezierP2(t, p2) + cubicBezierP3(t, p3);
 }
 
+function isLeft(ax, ay, bx, by, px, py) {
+  return (bx - ax) * (py - ay) - (px - ax) * (by - ay);
+}
+function windingNumber$1(px, py, vertices) {
+  const len = vertices.length;
+  let wn = 0;
+  for (let i = 0; i < len; i += 2) {
+    const ax = vertices[i];
+    const ay = vertices[i + 1];
+    const k = (i + 2) % len;
+    const bx = vertices[k];
+    const by = vertices[k + 1];
+    if (ay <= py) {
+      if (by > py && isLeft(ax, ay, bx, by, px, py) > 0) {
+        wn++;
+      }
+    } else {
+      if (by <= py && isLeft(ax, ay, bx, by, px, py) < 0) {
+        wn--;
+      }
+    }
+  }
+  return wn;
+}
+function crossingNumber(px, py, vertices) {
+  const len = vertices.length;
+  let cn = 0;
+  for (let i = 0; i < len; i += 2) {
+    const ax = vertices[i];
+    const ay = vertices[i + 1];
+    const k = (i + 2) % len;
+    const bx = vertices[k];
+    const by = vertices[k + 1];
+    if (ay <= py && by > py || ay > py && by <= py) {
+      const t = (py - ay) / (by - ay);
+      if (px < ax + t * (bx - ax)) {
+        cn++;
+      }
+    }
+  }
+  return cn;
+}
+function segmentDistance(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const lenSq = dx * dx + dy * dy;
+  let t = lenSq === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / lenSq;
+  if (t < 0) {
+    t = 0;
+  } else if (t > 1) {
+    t = 1;
+  }
+  const cx = ax + t * dx;
+  const cy = ay + t * dy;
+  return Math.hypot(px - cx, py - cy);
+}
+function pointInPolygon(point, vertices, fillRule = "nonzero") {
+  if (vertices.length < 6) {
+    return false;
+  }
+  if (fillRule === "evenodd") {
+    return (crossingNumber(point.x, point.y, vertices) & 1) === 1;
+  }
+  return windingNumber$1(point.x, point.y, vertices) !== 0;
+}
+function pointInPolygons(point, polygons, fillRule = "nonzero") {
+  const { x, y } = point;
+  if (fillRule === "evenodd") {
+    let cn = 0;
+    for (let i = 0, len = polygons.length; i < len; i++) {
+      const ring = polygons[i];
+      if (ring.length >= 6) {
+        cn += crossingNumber(x, y, ring);
+      }
+    }
+    return (cn & 1) === 1;
+  }
+  let wn = 0;
+  for (let i = 0, len = polygons.length; i < len; i++) {
+    const ring = polygons[i];
+    if (ring.length >= 6) {
+      wn += windingNumber$1(x, y, ring);
+    }
+  }
+  return wn !== 0;
+}
+function pointToSegmentDistance(point, a, b) {
+  return segmentDistance(point.x, point.y, a.x, a.y, b.x, b.y);
+}
+function pointToPolylineDistance(point, vertices, closed = false) {
+  const len = vertices.length;
+  if (len < 2) {
+    return Infinity;
+  }
+  const { x: px, y: py } = point;
+  if (len === 2) {
+    return Math.hypot(px - vertices[0], py - vertices[1]);
+  }
+  let min = Infinity;
+  for (let i = 0; i < len - 2; i += 2) {
+    const d = segmentDistance(px, py, vertices[i], vertices[i + 1], vertices[i + 2], vertices[i + 3]);
+    if (d < min) {
+      min = d;
+    }
+  }
+  if (closed && len >= 6) {
+    const d = segmentDistance(px, py, vertices[len - 2], vertices[len - 1], vertices[0], vertices[1]);
+    if (d < min) {
+      min = d;
+    }
+  }
+  return min;
+}
+
+function boundsOf(ring) {
+  if (ring.length < 6) {
+    return null;
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let i = 0; i < ring.length; i += 2) {
+    const x = ring[i];
+    const y = ring[i + 1];
+    if (x < minX)
+      minX = x;
+    if (y < minY)
+      minY = y;
+    if (x > maxX)
+      maxX = x;
+    if (y > maxY)
+      maxY = y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function bboxInside(inner, outer) {
+  return inner.minX >= outer.minX && inner.maxX <= outer.maxX && inner.minY >= outer.minY && inner.maxY <= outer.maxY;
+}
+function ringInsideRing(inner, outer) {
+  const n = inner.length / 2;
+  const step = Math.max(1, Math.floor(n / 9));
+  let tested = 0;
+  let inside = 0;
+  for (let i = 0; i < n; i += step) {
+    tested++;
+    if (pointInPolygon({ x: inner[i * 2], y: inner[i * 2 + 1] }, outer, "evenodd")) {
+      inside++;
+    }
+  }
+  return tested > 0 && inside * 2 > tested;
+}
+function evenoddFillRule(paths) {
+  const len = paths.length;
+  const bboxes = paths.map(boundsOf);
+  const depth = Array.from({ length: len }).fill(0);
+  const containers = paths.map(() => []);
+  for (let i = 0; i < len; i++) {
+    const bi = bboxes[i];
+    if (!bi) {
+      continue;
+    }
+    for (let j = 0; j < len; j++) {
+      if (i === j) {
+        continue;
+      }
+      const bj = bboxes[j];
+      if (!bj || !bboxInside(bi, bj)) {
+        continue;
+      }
+      if (ringInsideRing(paths[i], paths[j])) {
+        depth[i]++;
+        containers[i].push(j);
+      }
+    }
+  }
+  return paths.map((_, i) => {
+    let parentIndex = -1;
+    let bestDepth = -1;
+    for (const j of containers[i]) {
+      if (depth[j] > bestDepth) {
+        bestDepth = depth[j];
+        parentIndex = j;
+      }
+    }
+    return { index: i, depth: depth[i], parentIndex };
+  });
+}
+
 function fillTriangulate(pointArray, options = {}) {
   let {
     vertices = [],
@@ -595,7 +843,7 @@ function getDirectedArea(vertices) {
 function cross(ax, ay, bx, by, cx, cy) {
   return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
 }
-function windingNumber$1(px, py, polygon) {
+function windingNumber(px, py, polygon) {
   const polygonLen = polygon.length;
   let wn = 0;
   for (let i = 0, j = polygonLen - 2; i < polygonLen; j = i, i += 2) {
@@ -716,7 +964,7 @@ function nonzeroFillRule(paths) {
       const wnList = [];
       for (let p = 0, pLen = testPoints.length; p < pLen; p++) {
         const [x, y] = testPoints[p];
-        const winding = windingNumber$1(x, y, paths[j]);
+        const winding = windingNumber(x, y, paths[j]);
         wnMap[winding] = (wnMap[winding] ?? 0) + 1;
         wnList.push(winding);
       }
@@ -739,120 +987,6 @@ function nonzeroFillRule(paths) {
   return results;
 }
 
-function isLeft(ax, ay, bx, by, px, py) {
-  return (bx - ax) * (py - ay) - (px - ax) * (by - ay);
-}
-function windingNumber(px, py, vertices) {
-  const len = vertices.length;
-  let wn = 0;
-  for (let i = 0; i < len; i += 2) {
-    const ax = vertices[i];
-    const ay = vertices[i + 1];
-    const k = (i + 2) % len;
-    const bx = vertices[k];
-    const by = vertices[k + 1];
-    if (ay <= py) {
-      if (by > py && isLeft(ax, ay, bx, by, px, py) > 0) {
-        wn++;
-      }
-    } else {
-      if (by <= py && isLeft(ax, ay, bx, by, px, py) < 0) {
-        wn--;
-      }
-    }
-  }
-  return wn;
-}
-function crossingNumber(px, py, vertices) {
-  const len = vertices.length;
-  let cn = 0;
-  for (let i = 0; i < len; i += 2) {
-    const ax = vertices[i];
-    const ay = vertices[i + 1];
-    const k = (i + 2) % len;
-    const bx = vertices[k];
-    const by = vertices[k + 1];
-    if (ay <= py && by > py || ay > py && by <= py) {
-      const t = (py - ay) / (by - ay);
-      if (px < ax + t * (bx - ax)) {
-        cn++;
-      }
-    }
-  }
-  return cn;
-}
-function segmentDistance(px, py, ax, ay, bx, by) {
-  const dx = bx - ax;
-  const dy = by - ay;
-  const lenSq = dx * dx + dy * dy;
-  let t = lenSq === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / lenSq;
-  if (t < 0) {
-    t = 0;
-  } else if (t > 1) {
-    t = 1;
-  }
-  const cx = ax + t * dx;
-  const cy = ay + t * dy;
-  return Math.hypot(px - cx, py - cy);
-}
-function pointInPolygon(point, vertices, fillRule = "nonzero") {
-  if (vertices.length < 6) {
-    return false;
-  }
-  if (fillRule === "evenodd") {
-    return (crossingNumber(point.x, point.y, vertices) & 1) === 1;
-  }
-  return windingNumber(point.x, point.y, vertices) !== 0;
-}
-function pointInPolygons(point, polygons, fillRule = "nonzero") {
-  const { x, y } = point;
-  if (fillRule === "evenodd") {
-    let cn = 0;
-    for (let i = 0, len = polygons.length; i < len; i++) {
-      const ring = polygons[i];
-      if (ring.length >= 6) {
-        cn += crossingNumber(x, y, ring);
-      }
-    }
-    return (cn & 1) === 1;
-  }
-  let wn = 0;
-  for (let i = 0, len = polygons.length; i < len; i++) {
-    const ring = polygons[i];
-    if (ring.length >= 6) {
-      wn += windingNumber(x, y, ring);
-    }
-  }
-  return wn !== 0;
-}
-function pointToSegmentDistance(point, a, b) {
-  return segmentDistance(point.x, point.y, a.x, a.y, b.x, b.y);
-}
-function pointToPolylineDistance(point, vertices, closed = false) {
-  const len = vertices.length;
-  if (len < 2) {
-    return Infinity;
-  }
-  const { x: px, y: py } = point;
-  if (len === 2) {
-    return Math.hypot(px - vertices[0], py - vertices[1]);
-  }
-  let min = Infinity;
-  for (let i = 0; i < len - 2; i += 2) {
-    const d = segmentDistance(px, py, vertices[i], vertices[i + 1], vertices[i + 2], vertices[i + 3]);
-    if (d < min) {
-      min = d;
-    }
-  }
-  if (closed && len >= 6) {
-    const d = segmentDistance(px, py, vertices[len - 2], vertices[len - 1], vertices[0], vertices[1]);
-    if (d < min) {
-      min = d;
-    }
-  }
-  return min;
-}
-
 function quadraticBezierP0(t, p) {
   const k = 1 - t;
   return k * k * p;
@@ -867,22 +1001,35 @@ function quadraticBezier(t, p0, p1, p2) {
   return quadraticBezierP0(t, p0) + quadraticBezierP1(t, p1) + quadraticBezierP2(t, p2);
 }
 
+function resolveLineJoin(join) {
+  switch (join) {
+    case "round":
+    case "bevel":
+    case "miter":
+      return join;
+    default:
+      return "miter";
+  }
+}
+function resolveLineStyle(style) {
+  return {
+    width: style?.strokeWidth ?? 1,
+    alignment: 0.5,
+    join: resolveLineJoin(style?.strokeLinejoin),
+    cap: style?.strokeLinecap ?? "butt",
+    miterLimit: style?.strokeMiterlimit ?? 10
+  };
+}
 const closePointEps = 1e-4;
 const curveEps = 1e-4;
 function strokeTriangulate(points, options = {}) {
   const {
     vertices = [],
     indices = [],
-    lineStyle = {
-      alignment: 0.5,
-      cap: "butt",
-      join: "miter",
-      width: 1,
-      miterLimit: 10
-    },
     flipAlignment = false,
     closed = true
   } = options;
+  const lineStyle = options.lineStyle ?? resolveLineStyle(options.style);
   const eps = closePointEps;
   if (points.length === 0) {
     return { vertices, indices };
@@ -2710,6 +2857,22 @@ class Curve {
   getControlPointRefs() {
     return [];
   }
+  /**
+   * Reverse the traversal direction in place (start ↔ end, same geometry). The base
+   * implementation reverses the order of the control-point *values*, which is correct for
+   * line / Bézier / spline primitives whose {@link getControlPointRefs} order matches their
+   * parametric order. {@link RoundCurve} (angle-based) and composites (child order) override it.
+   */
+  reverse() {
+    const refs = this.getControlPointRefs();
+    const n = refs.length;
+    const snapshot = refs.map((p) => p.clone());
+    for (let i = 0; i < n; i++) {
+      refs[i].copyFrom(snapshot[n - 1 - i]);
+    }
+    this.invalidate();
+    return this;
+  }
   applyTransform(transform) {
     const isFunction = typeof transform === "function";
     this.getControlPointRefs().forEach((p) => {
@@ -2837,6 +3000,22 @@ class Curve {
   getTangentAt(u, output) {
     return this.getTangent(this.getUToTMapping(u), output);
   }
+  /**
+   * PathKit-style sample at an absolute arc-length `distance` along the curve: the point, the unit
+   * tangent, and the tangent `angle` in radians. `distance` is clamped to `[0, getLength()]`, so
+   * passing `0`/`getLength()` always yields the endpoints. See {@link PathMeasure} for a wrapper.
+   */
+  getPosTan(distance) {
+    const length = this.getLength();
+    const u = length > 0 ? Math.min(Math.max(distance / length, 0), 1) : 0;
+    const t = this.getUToTMapping(u);
+    const tangent = this.getTangent(t);
+    return {
+      position: this.getPoint(t),
+      tangent,
+      angle: Math.atan2(tangent.y, tangent.x)
+    };
+  }
   getNormal(t, output = new Vector2()) {
     this.getTangent(t, output);
     return output.set(-output.y, output.x).normalize();
@@ -2932,10 +3111,28 @@ class Curve {
       options
     );
   }
+  /**
+   * Whether this curve forms a closed loop (its outline should be stroked without end caps,
+   * stitching the last vertex back to the first). The base test is purely geometric — the first
+   * sampled vertex coincides with the last. Curves that close without a duplicated endpoint
+   * (a full-revolution {@link RoundCurve}, rectangles, polygons) override this.
+   */
+  isClosed() {
+    const v = this._getCachedAdaptiveVertices();
+    const len = v.length;
+    if (len < 6) {
+      return false;
+    }
+    const eps = 1e-4;
+    return Math.abs(v[0] - v[len - 2]) < eps && Math.abs(v[1] - v[len - 1]) < eps;
+  }
   strokeTriangulate(options) {
     return strokeTriangulate(
       this.getAdaptiveVertices(),
-      options
+      {
+        ...options,
+        closed: options?.closed ?? this.isClosed()
+      }
     );
   }
   toCommands() {
@@ -3030,6 +3227,22 @@ class RoundCurve extends Curve {
   isClockwise() {
     return this.clockwise;
   }
+  /**
+   * A circle/ellipse arc is closed when it sweeps (at least) a full revolution — the sampled
+   * outline does not duplicate the start vertex, so the geometric first==last test in the base
+   * class would wrongly report a full circle as open and leave a seam gap in the stroke.
+   */
+  isClosed() {
+    return Math.abs(this.endAngle - this.startAngle) >= Math.PI * 2 - 1e-9 || super.isClosed();
+  }
+  reverse() {
+    const { startAngle, endAngle } = this;
+    this.startAngle = endAngle;
+    this.endAngle = startAngle;
+    this.clockwise = !this.clockwise;
+    this.invalidate();
+    return this;
+  }
   _getDeltaAngle() {
     const PI_2 = Math.PI * 2;
     let deltaAngle = this.endAngle - this.startAngle;
@@ -3286,9 +3499,25 @@ class RoundCurve extends Curve {
     return output;
   }
   getAdaptiveVertices(output = []) {
-    if (this.startAngle === 0 && this.endAngle === Math.PI * 2) {
+    const PI2 = Math.PI * 2;
+    if (this.startAngle === 0 && this.endAngle === PI2) {
       return this._getAdaptiveVerticesByCircle(output);
     }
+    if (Math.abs(this.endAngle - this.startAngle) >= PI2 - 1e-9) {
+      const tmp = this._getAdaptiveVerticesByCircle([]);
+      const n = tmp.length / 2;
+      if (this.endAngle > this.startAngle) {
+        for (let i = 0; i < tmp.length; i++) {
+          output.push(tmp[i]);
+        }
+      } else {
+        output.push(tmp[0], tmp[1]);
+        for (let i = n - 1; i >= 1; i--) {
+          output.push(tmp[i * 2], tmp[i * 2 + 1]);
+        }
+      }
+      return output;
+    }
     return this._getAdaptiveVerticesByArc(output);
   }
   copyFrom(source) {
@@ -3498,6 +3727,15 @@ class LineCurve extends Curve {
   getControlPointRefs() {
     return [this.p1, this.p2];
   }
+  // Swap endpoint *references* (not values) so corner Vector2s shared with adjacent
+  // segments stay intact and simply re-associate with the reversed segment.
+  reverse() {
+    const { p1, p2 } = this;
+    this.p1 = p2;
+    this.p2 = p1;
+    this.invalidate();
+    return this;
+  }
   getAdaptiveVertices(output = []) {
     output.push(
       this.p1.x,
@@ -3661,6 +3899,16 @@ class CompositeCurve extends Curve {
     });
     return output;
   }
+  /**
+   * A composite is closed when its single child is closed (e.g. a lone full-circle arc), or when
+   * its assembled outline returns to its start (rectangles, polygons, multi-segment loops).
+   */
+  isClosed() {
+    if (this.curves.length === 1) {
+      return this.curves[0].isClosed();
+    }
+    return super.isClosed();
+  }
   strokeTriangulate(options) {
     if (this.curves.length === 1) {
       return this.curves[0].strokeTriangulate(options);
@@ -3668,6 +3916,13 @@ class CompositeCurve extends Curve {
       return super.strokeTriangulate(options);
     }
   }
+  /** Reverse the sub-curve order and reverse each sub-curve, so the whole outline runs backwards. */
+  reverse() {
+    this.curves.reverse();
+    this.curves.forEach((curve) => curve.reverse());
+    this.invalidate();
+    return this;
+  }
   getFillVertices(options) {
     if (this.curves.length === 1) {
       return this.curves[0].getFillVertices(options);
@@ -3763,6 +4018,16 @@ class CubicBezierCurve extends Curve {
   getControlPointRefs() {
     return [this.p1, this.cp1, this.cp2, this.p2];
   }
+  // Swap endpoint and control-point references; keeps shared corner Vector2s intact.
+  reverse() {
+    const { p1, cp1, cp2, p2 } = this;
+    this.p1 = p2;
+    this.cp1 = cp2;
+    this.cp2 = cp1;
+    this.p2 = p1;
+    this.invalidate();
+    return this;
+  }
   _solveQuadratic(a, b, c) {
     if (Math.abs(a) < 1e-12) {
       if (Math.abs(b) < 1e-12)
@@ -3923,6 +4188,14 @@ class QuadraticBezierCurve extends Curve {
   getControlPointRefs() {
     return [this.p1, this.cp, this.p2];
   }
+  // Swap endpoint references (cp is symmetric); keeps shared corner Vector2s intact.
+  reverse() {
+    const { p1, p2 } = this;
+    this.p1 = p2;
+    this.p2 = p1;
+    this.invalidate();
+    return this;
+  }
   getAdaptiveVertices(output = []) {
     return getAdaptiveQuadraticBezierCurvePoints(
       this.p1.x,
@@ -4124,6 +4397,11 @@ class SplineCurve extends Curve {
   getControlPointRefs() {
     return this.points;
   }
+  reverse() {
+    this.points.reverse();
+    this.invalidate();
+    return this;
+  }
   copyFrom(source) {
     super.copyFrom(source);
     this.points = [];
@@ -4160,6 +4438,22 @@ class CurvePath extends CompositeCurve {
     this.addCommands(svgPathDataToCommands(data));
     return this;
   }
+  /**
+   * A sub-path is closed if it was explicitly closed (`autoClose`, i.e. a `Z`/`closePath`), or if
+   * it forms a geometric loop / wraps a single closed primitive (handled by the base class).
+   */
+  isClosed() {
+    return this.autoClose || super.isClosed();
+  }
+  /** Reverse direction, then refresh the {@link startPoint}/{@link currentPoint} cursors. */
+  reverse() {
+    super.reverse();
+    if (this.curves.length) {
+      this.startPoint = this.getPoint(0);
+      this.currentPoint = this.getPoint(1);
+    }
+    return this;
+  }
   _closeVertices(output) {
     if (this.autoClose && output.length >= 4 && (output[0] !== output[output.length - 2] && output[1] !== output[output.length - 1])) {
       output.push(output[0], output[1]);
@@ -4596,6 +4890,51 @@ class Path2D extends CompositeCurve {
     const fillRule = options.fillRule ?? this.style.fillRule ?? "nonzero";
     return pointInPolygons(point, this._getRings(), fillRule);
   }
+  /** Build a `Path2D` from flat rings (`[x0,y0,…]` per sub-path); closed-and-filled as sub-paths. */
+  static fromRings(rings, style = {}) {
+    const path = new Path2D(void 0, style);
+    for (const ring of rings) {
+      if (ring.length < 6) {
+        continue;
+      }
+      let end = ring.length;
+      if (ring[0] === ring[end - 2] && ring[1] === ring[end - 1]) {
+        end -= 2;
+      }
+      path.moveTo(ring[0], ring[1]);
+      for (let i = 2; i < end; i += 2) {
+        path.lineTo(ring[i], ring[i + 1]);
+      }
+      path.closePath();
+    }
+    return path;
+  }
+  /**
+   * Boolean (path) operation against another path, returning a NEW `Path2D` whose outline is the
+   * polygonal result. Curves are sampled before clipping, so the result is a polygonal
+   * approximation (see {@link polygonBoolean}). The result inherits this path's `style` unless
+   * overridden via `style`. Holes are emitted as oppositely-wound sub-paths (nonzero fill).
+   */
+  booleanOp(op, other, style) {
+    const rings = polygonBoolean(op, this._getRings(), other._getRings());
+    return Path2D.fromRings(rings, { ...this.style, ...style });
+  }
+  /** `this ∪ other` — the combined filled area. */
+  union(other, style) {
+    return this.booleanOp("union", other, style);
+  }
+  /** `this ∩ other` — only the overlapping area. */
+  intersection(other, style) {
+    return this.booleanOp("intersection", other, style);
+  }
+  /** `this − other` — this path with `other` cut away. */
+  difference(other, style) {
+    return this.booleanOp("difference", other, style);
+  }
+  /** `this ⊕ other` — areas covered by exactly one of the two paths. */
+  xor(other, style) {
+    return this.booleanOp("xor", other, style);
+  }
   /**
    * Test whether a point lies on this path's stroke. A hit on any sub-path counts.
    *
@@ -4678,14 +5017,30 @@ class Path2D extends CompositeCurve {
         });
       }
     } else {
-      this.curves.forEach((curve) => {
-        curve.fillTriangulate({
+      const paths = this.curves.map((curve) => curve.getFillVertices(_options));
+      const groups = evenoddFillRule(paths);
+      const groupsLen = groups.length;
+      for (let i = 0; i < groupsLen; i++) {
+        const pointArray = paths[i];
+        if ((groups[i].depth & 1) === 1 || !pointArray.length) {
+          continue;
+        }
+        const _pointArray = pointArray.slice();
+        const holes = [];
+        for (let j = 0; j < groupsLen; j++) {
+          if (groups[j].parentIndex === i && (groups[j].depth & 1) === 1) {
+            holes.push(_pointArray.length / 2);
+            _pointArray.push(...paths[j]);
+          }
+        }
+        fillTriangulate(_pointArray, {
           ...options,
           indices,
           vertices,
+          holes,
           style: { ...this.style }
         });
-      });
+      }
     }
     return { indices, vertices };
   }
@@ -4695,7 +5050,7 @@ class Path2D extends CompositeCurve {
   }
   drawTo(ctx, style = {}) {
     style = { ...this.style, ...style };
-    const { fill = "#000", stroke = "none" } = style;
+    const { fill = "#000", stroke = "none", fillRule = "nonzero" } = style;
     ctx.beginPath();
     ctx.save();
     setCanvasContext(ctx, style);
@@ -4703,7 +5058,7 @@ class Path2D extends CompositeCurve {
       path.drawTo(ctx);
     });
     if (fill !== "none") {
-      ctx.fill();
+      ctx.fill(fillRule);
     }
     if (stroke !== "none") {
       ctx.stroke();
@@ -4909,6 +5264,44 @@ ${content}
   }
 }
 
+class PathMeasure {
+  constructor(curve) {
+    this.curve = curve;
+  }
+  /** Total arc length of the path. */
+  getLength() {
+    return this.curve.getLength();
+  }
+  /** Whether the path forms a closed loop (see {@link Curve.isClosed}). */
+  isClosed() {
+    return this.curve.isClosed();
+  }
+  /** Point + unit tangent + tangent angle at an absolute arc-length `distance` (clamped). */
+  getPosTan(distance) {
+    return this.curve.getPosTan(distance);
+  }
+  /** Point at an absolute arc-length `distance` (clamped to `[0, getLength()]`). */
+  getPosition(distance) {
+    return this.curve.getPosTan(distance).position;
+  }
+  /** Point + tangent at a normalized progress `t ∈ [0, 1]` along the path. */
+  getPosTanAtProgress(t) {
+    return this.curve.getPosTan(this.getLength() * t);
+  }
+  /**
+   * Evenly sample the path into `count + 1` {@link PosTan} entries (arc-length spaced), e.g. to
+   * lay glyphs along a path or drive an `animate(progress)`-style traversal.
+   */
+  sample(count = 100) {
+    const length = this.getLength();
+    const out = [];
+    for (let i = 0; i <= count; i++) {
+      out.push(this.curve.getPosTan(length * i / count));
+    }
+    return out;
+  }
+}
+
 class FFDControlGrid {
   constructor(rows, cols, width = 1, height = 1) {
     this.rows = rows;
@@ -4978,6 +5371,7 @@ exports.PI = PI;
 exports.PI_2 = PI_2;
 exports.Path2D = Path2D;
 exports.Path2DSet = Path2DSet;
+exports.PathMeasure = PathMeasure;
 exports.PolygonCurve = PolygonCurve;
 exports.QuadraticBezierCurve = QuadraticBezierCurve;
 exports.RectangleCurve = RectangleCurve;
@@ -4989,6 +5383,7 @@ exports.applyFFD = applyFFD;
 exports.catmullRom = catmullRom;
 exports.cubicBezier = cubicBezier;
 exports.drawPoint = drawPoint;
+exports.evenoddFillRule = evenoddFillRule;
 exports.fillTriangulate = fillTriangulate;
 exports.getAdaptiveCubicBezierCurvePoints = getAdaptiveCubicBezierCurvePoints;
 exports.getAdaptiveQuadraticBezierCurvePoints = getAdaptiveQuadraticBezierCurvePoints;
@@ -5004,7 +5399,9 @@ exports.pointInPolygon = pointInPolygon;
 exports.pointInPolygons = pointInPolygons;
 exports.pointToPolylineDistance = pointToPolylineDistance;
 exports.pointToSegmentDistance = pointToSegmentDistance;
+exports.polygonBoolean = polygonBoolean;
 exports.quadraticBezier = quadraticBezier;
+exports.resolveLineStyle = resolveLineStyle;
 exports.setCanvasContext = setCanvasContext;
 exports.strokeTriangulate = strokeTriangulate;
 exports.svgPathCommandsAddToPath2D = svgPathCommandsAddToPath2D;