@mce/bigesj 0.23.0 → 0.24.1

package/dist/index.js

@@ -4,6 +4,29 @@ import { clearUndef, idGenerator, isGradient, isGradientFill, normalizeCRLF, nor
 import { OoxmlNode, parsePresetShapeDefinition } from "modern-openxml";
 import { assets } from "modern-canvas";
 import { gunzipSync } from "fflate";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
 //#region src/composables/useFonts.ts
 var bigeFonts = ref([]);
 function levenshteinDistance(a, b) {
@@ -1657,8 +1680,1953 @@ function signedArea(data, start, end, dim) {
 	}
 	return sum;
 }
+/**
+* splaytree v3.1.2
+* Fast Splay tree for Node and browser
+*
+* @author Alexander Milevski <info@w8r.name>
+* @license MIT
+* @preserve
+*/
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
 //#endregion
-//#region ../../node_modules/.pnpm/modern-path2d@1.7.0/node_modules/modern-path2d/dist/index.mjs
+//#region ../../node_modules/.pnpm/modern-path2d@1.8.5/node_modules/modern-path2d/dist/index.mjs
+var import_polygon_clipping_umd = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(global, factory) {
+		typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.polygonClipping = factory());
+	})(exports, (function() {
+		"use strict";
+		function __generator(thisArg, body) {
+			var _ = {
+				label: 0,
+				sent: function() {
+					if (t[0] & 1) throw t[1];
+					return t[1];
+				},
+				trys: [],
+				ops: []
+			}, f, y, t, g;
+			return g = {
+				next: verb(0),
+				"throw": verb(1),
+				"return": verb(2)
+			}, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+				return this;
+			}), g;
+			function verb(n) {
+				return function(v) {
+					return step([n, v]);
+				};
+			}
+			function step(op) {
+				if (f) throw new TypeError("Generator is already executing.");
+				while (_) try {
+					if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+					if (y = 0, t) op = [op[0] & 2, t.value];
+					switch (op[0]) {
+						case 0:
+						case 1:
+							t = op;
+							break;
+						case 4:
+							_.label++;
+							return {
+								value: op[1],
+								done: false
+							};
+						case 5:
+							_.label++;
+							y = op[1];
+							op = [0];
+							continue;
+						case 7:
+							op = _.ops.pop();
+							_.trys.pop();
+							continue;
+						default:
+							if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+								_ = 0;
+								continue;
+							}
+							if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+								_.label = op[1];
+								break;
+							}
+							if (op[0] === 6 && _.label < t[1]) {
+								_.label = t[1];
+								t = op;
+								break;
+							}
+							if (t && _.label < t[2]) {
+								_.label = t[2];
+								_.ops.push(op);
+								break;
+							}
+							if (t[2]) _.ops.pop();
+							_.trys.pop();
+							continue;
+					}
+					op = body.call(thisArg, _);
+				} catch (e) {
+					op = [6, e];
+					y = 0;
+				} finally {
+					f = t = 0;
+				}
+				if (op[0] & 5) throw op[1];
+				return {
+					value: op[0] ? op[1] : void 0,
+					done: true
+				};
+			}
+		}
+		var Node = function() {
+			function Node(key, data) {
+				this.next = null;
+				this.key = key;
+				this.data = data;
+				this.left = null;
+				this.right = null;
+			}
+			return Node;
+		}();
+		function DEFAULT_COMPARE(a, b) {
+			return a > b ? 1 : a < b ? -1 : 0;
+		}
+		/**
+		* Simple top down splay, not requiring i to be in the tree t.
+		*/
+		function splay(i, t, comparator) {
+			var N = new Node(null, null);
+			var l = N;
+			var r = N;
+			while (true) {
+				var cmp = comparator(i, t.key);
+				if (cmp < 0) {
+					if (t.left === null) break;
+					if (comparator(i, t.left.key) < 0) {
+						var y = t.left;
+						t.left = y.right;
+						y.right = t;
+						t = y;
+						if (t.left === null) break;
+					}
+					r.left = t;
+					r = t;
+					t = t.left;
+				} else if (cmp > 0) {
+					if (t.right === null) break;
+					if (comparator(i, t.right.key) > 0) {
+						var y = t.right;
+						t.right = y.left;
+						y.left = t;
+						t = y;
+						if (t.right === null) break;
+					}
+					l.right = t;
+					l = t;
+					t = t.right;
+				} else break;
+			}
+			l.right = t.left;
+			r.left = t.right;
+			t.left = N.right;
+			t.right = N.left;
+			return t;
+		}
+		function insert(i, data, t, comparator) {
+			var node = new Node(i, data);
+			if (t === null) {
+				node.left = node.right = null;
+				return node;
+			}
+			t = splay(i, t, comparator);
+			var cmp = comparator(i, t.key);
+			if (cmp < 0) {
+				node.left = t.left;
+				node.right = t;
+				t.left = null;
+			} else if (cmp >= 0) {
+				node.right = t.right;
+				node.left = t;
+				t.right = null;
+			}
+			return node;
+		}
+		function split(key, v, comparator) {
+			var left = null;
+			var right = null;
+			if (v) {
+				v = splay(key, v, comparator);
+				var cmp = comparator(v.key, key);
+				if (cmp === 0) {
+					left = v.left;
+					right = v.right;
+				} else if (cmp < 0) {
+					right = v.right;
+					v.right = null;
+					left = v;
+				} else {
+					left = v.left;
+					v.left = null;
+					right = v;
+				}
+			}
+			return {
+				left,
+				right
+			};
+		}
+		function merge(left, right, comparator) {
+			if (right === null) return left;
+			if (left === null) return right;
+			right = splay(left.key, right, comparator);
+			right.left = left;
+			return right;
+		}
+		/**
+		* Prints level of the tree
+		*/
+		function printRow(root, prefix, isTail, out, printNode) {
+			if (root) {
+				out("" + prefix + (isTail ? "└── " : "├── ") + printNode(root) + "\n");
+				var indent = prefix + (isTail ? "    " : "│   ");
+				if (root.left) printRow(root.left, indent, false, out, printNode);
+				if (root.right) printRow(root.right, indent, true, out, printNode);
+			}
+		}
+		var Tree = function() {
+			function Tree(comparator) {
+				if (comparator === void 0) comparator = DEFAULT_COMPARE;
+				this._root = null;
+				this._size = 0;
+				this._comparator = comparator;
+			}
+			/**
+			* Inserts a key, allows duplicates
+			*/
+			Tree.prototype.insert = function(key, data) {
+				this._size++;
+				return this._root = insert(key, data, this._root, this._comparator);
+			};
+			/**
+			* Adds a key, if it is not present in the tree
+			*/
+			Tree.prototype.add = function(key, data) {
+				var node = new Node(key, data);
+				if (this._root === null) {
+					node.left = node.right = null;
+					this._size++;
+					this._root = node;
+				}
+				var comparator = this._comparator;
+				var t = splay(key, this._root, comparator);
+				var cmp = comparator(key, t.key);
+				if (cmp === 0) this._root = t;
+				else {
+					if (cmp < 0) {
+						node.left = t.left;
+						node.right = t;
+						t.left = null;
+					} else if (cmp > 0) {
+						node.right = t.right;
+						node.left = t;
+						t.right = null;
+					}
+					this._size++;
+					this._root = node;
+				}
+				return this._root;
+			};
+			/**
+			* @param  {Key} key
+			* @return {Node|null}
+			*/
+			Tree.prototype.remove = function(key) {
+				this._root = this._remove(key, this._root, this._comparator);
+			};
+			/**
+			* Deletes i from the tree if it's there
+			*/
+			Tree.prototype._remove = function(i, t, comparator) {
+				var x;
+				if (t === null) return null;
+				t = splay(i, t, comparator);
+				if (comparator(i, t.key) === 0) {
+					if (t.left === null) x = t.right;
+					else {
+						x = splay(i, t.left, comparator);
+						x.right = t.right;
+					}
+					this._size--;
+					return x;
+				}
+				return t;
+			};
+			/**
+			* Removes and returns the node with smallest key
+			*/
+			Tree.prototype.pop = function() {
+				var node = this._root;
+				if (node) {
+					while (node.left) node = node.left;
+					this._root = splay(node.key, this._root, this._comparator);
+					this._root = this._remove(node.key, this._root, this._comparator);
+					return {
+						key: node.key,
+						data: node.data
+					};
+				}
+				return null;
+			};
+			/**
+			* Find without splaying
+			*/
+			Tree.prototype.findStatic = function(key) {
+				var current = this._root;
+				var compare = this._comparator;
+				while (current) {
+					var cmp = compare(key, current.key);
+					if (cmp === 0) return current;
+					else if (cmp < 0) current = current.left;
+					else current = current.right;
+				}
+				return null;
+			};
+			Tree.prototype.find = function(key) {
+				if (this._root) {
+					this._root = splay(key, this._root, this._comparator);
+					if (this._comparator(key, this._root.key) !== 0) return null;
+				}
+				return this._root;
+			};
+			Tree.prototype.contains = function(key) {
+				var current = this._root;
+				var compare = this._comparator;
+				while (current) {
+					var cmp = compare(key, current.key);
+					if (cmp === 0) return true;
+					else if (cmp < 0) current = current.left;
+					else current = current.right;
+				}
+				return false;
+			};
+			Tree.prototype.forEach = function(visitor, ctx) {
+				var current = this._root;
+				var Q = [];
+				var done = false;
+				while (!done) if (current !== null) {
+					Q.push(current);
+					current = current.left;
+				} else if (Q.length !== 0) {
+					current = Q.pop();
+					visitor.call(ctx, current);
+					current = current.right;
+				} else done = true;
+				return this;
+			};
+			/**
+			* Walk key range from `low` to `high`. Stops if `fn` returns a value.
+			*/
+			Tree.prototype.range = function(low, high, fn, ctx) {
+				var Q = [];
+				var compare = this._comparator;
+				var node = this._root;
+				var cmp;
+				while (Q.length !== 0 || node) if (node) {
+					Q.push(node);
+					node = node.left;
+				} else {
+					node = Q.pop();
+					cmp = compare(node.key, high);
+					if (cmp > 0) break;
+					else if (compare(node.key, low) >= 0) {
+						if (fn.call(ctx, node)) return this;
+					}
+					node = node.right;
+				}
+				return this;
+			};
+			/**
+			* Returns array of keys
+			*/
+			Tree.prototype.keys = function() {
+				var keys = [];
+				this.forEach(function(_a) {
+					var key = _a.key;
+					return keys.push(key);
+				});
+				return keys;
+			};
+			/**
+			* Returns array of all the data in the nodes
+			*/
+			Tree.prototype.values = function() {
+				var values = [];
+				this.forEach(function(_a) {
+					var data = _a.data;
+					return values.push(data);
+				});
+				return values;
+			};
+			Tree.prototype.min = function() {
+				if (this._root) return this.minNode(this._root).key;
+				return null;
+			};
+			Tree.prototype.max = function() {
+				if (this._root) return this.maxNode(this._root).key;
+				return null;
+			};
+			Tree.prototype.minNode = function(t) {
+				if (t === void 0) t = this._root;
+				if (t) while (t.left) t = t.left;
+				return t;
+			};
+			Tree.prototype.maxNode = function(t) {
+				if (t === void 0) t = this._root;
+				if (t) while (t.right) t = t.right;
+				return t;
+			};
+			/**
+			* Returns node at given index
+			*/
+			Tree.prototype.at = function(index) {
+				var current = this._root;
+				var done = false;
+				var i = 0;
+				var Q = [];
+				while (!done) if (current) {
+					Q.push(current);
+					current = current.left;
+				} else if (Q.length > 0) {
+					current = Q.pop();
+					if (i === index) return current;
+					i++;
+					current = current.right;
+				} else done = true;
+				return null;
+			};
+			Tree.prototype.next = function(d) {
+				var root = this._root;
+				var successor = null;
+				if (d.right) {
+					successor = d.right;
+					while (successor.left) successor = successor.left;
+					return successor;
+				}
+				var comparator = this._comparator;
+				while (root) {
+					var cmp = comparator(d.key, root.key);
+					if (cmp === 0) break;
+					else if (cmp < 0) {
+						successor = root;
+						root = root.left;
+					} else root = root.right;
+				}
+				return successor;
+			};
+			Tree.prototype.prev = function(d) {
+				var root = this._root;
+				var predecessor = null;
+				if (d.left !== null) {
+					predecessor = d.left;
+					while (predecessor.right) predecessor = predecessor.right;
+					return predecessor;
+				}
+				var comparator = this._comparator;
+				while (root) {
+					var cmp = comparator(d.key, root.key);
+					if (cmp === 0) break;
+					else if (cmp < 0) root = root.left;
+					else {
+						predecessor = root;
+						root = root.right;
+					}
+				}
+				return predecessor;
+			};
+			Tree.prototype.clear = function() {
+				this._root = null;
+				this._size = 0;
+				return this;
+			};
+			Tree.prototype.toList = function() {
+				return toList(this._root);
+			};
+			/**
+			* Bulk-load items. Both array have to be same size
+			*/
+			Tree.prototype.load = function(keys, values, presort) {
+				if (values === void 0) values = [];
+				if (presort === void 0) presort = false;
+				var size = keys.length;
+				var comparator = this._comparator;
+				if (presort) sort(keys, values, 0, size - 1, comparator);
+				if (this._root === null) {
+					this._root = loadRecursive(keys, values, 0, size);
+					this._size = size;
+				} else {
+					var mergedList = mergeLists(this.toList(), createList(keys, values), comparator);
+					size = this._size + size;
+					this._root = sortedListToBST({ head: mergedList }, 0, size);
+				}
+				return this;
+			};
+			Tree.prototype.isEmpty = function() {
+				return this._root === null;
+			};
+			Object.defineProperty(Tree.prototype, "size", {
+				get: function() {
+					return this._size;
+				},
+				enumerable: true,
+				configurable: true
+			});
+			Object.defineProperty(Tree.prototype, "root", {
+				get: function() {
+					return this._root;
+				},
+				enumerable: true,
+				configurable: true
+			});
+			Tree.prototype.toString = function(printNode) {
+				if (printNode === void 0) printNode = function(n) {
+					return String(n.key);
+				};
+				var out = [];
+				printRow(this._root, "", true, function(v) {
+					return out.push(v);
+				}, printNode);
+				return out.join("");
+			};
+			Tree.prototype.update = function(key, newKey, newData) {
+				var comparator = this._comparator;
+				var _a = split(key, this._root, comparator), left = _a.left, right = _a.right;
+				if (comparator(key, newKey) < 0) right = insert(newKey, newData, right, comparator);
+				else left = insert(newKey, newData, left, comparator);
+				this._root = merge(left, right, comparator);
+			};
+			Tree.prototype.split = function(key) {
+				return split(key, this._root, this._comparator);
+			};
+			Tree.prototype[Symbol.iterator] = function() {
+				var current, Q, done;
+				return __generator(this, function(_a) {
+					switch (_a.label) {
+						case 0:
+							current = this._root;
+							Q = [];
+							done = false;
+							_a.label = 1;
+						case 1:
+							if (!!done) return [3, 6];
+							if (!(current !== null)) return [3, 2];
+							Q.push(current);
+							current = current.left;
+							return [3, 5];
+						case 2:
+							if (!(Q.length !== 0)) return [3, 4];
+							current = Q.pop();
+							return [4, current];
+						case 3:
+							_a.sent();
+							current = current.right;
+							return [3, 5];
+						case 4:
+							done = true;
+							_a.label = 5;
+						case 5: return [3, 1];
+						case 6: return [2];
+					}
+				});
+			};
+			return Tree;
+		}();
+		function loadRecursive(keys, values, start, end) {
+			var size = end - start;
+			if (size > 0) {
+				var middle = start + Math.floor(size / 2);
+				var key = keys[middle];
+				var data = values[middle];
+				var node = new Node(key, data);
+				node.left = loadRecursive(keys, values, start, middle);
+				node.right = loadRecursive(keys, values, middle + 1, end);
+				return node;
+			}
+			return null;
+		}
+		function createList(keys, values) {
+			var head = new Node(null, null);
+			var p = head;
+			for (var i = 0; i < keys.length; i++) p = p.next = new Node(keys[i], values[i]);
+			p.next = null;
+			return head.next;
+		}
+		function toList(root) {
+			var current = root;
+			var Q = [];
+			var done = false;
+			var head = new Node(null, null);
+			var p = head;
+			while (!done) if (current) {
+				Q.push(current);
+				current = current.left;
+			} else if (Q.length > 0) {
+				current = p = p.next = Q.pop();
+				current = current.right;
+			} else done = true;
+			p.next = null;
+			return head.next;
+		}
+		function sortedListToBST(list, start, end) {
+			var size = end - start;
+			if (size > 0) {
+				var middle = start + Math.floor(size / 2);
+				var left = sortedListToBST(list, start, middle);
+				var root = list.head;
+				root.left = left;
+				list.head = list.head.next;
+				root.right = sortedListToBST(list, middle + 1, end);
+				return root;
+			}
+			return null;
+		}
+		function mergeLists(l1, l2, compare) {
+			var head = new Node(null, null);
+			var p = head;
+			var p1 = l1;
+			var p2 = l2;
+			while (p1 !== null && p2 !== null) {
+				if (compare(p1.key, p2.key) < 0) {
+					p.next = p1;
+					p1 = p1.next;
+				} else {
+					p.next = p2;
+					p2 = p2.next;
+				}
+				p = p.next;
+			}
+			if (p1 !== null) p.next = p1;
+			else if (p2 !== null) p.next = p2;
+			return head.next;
+		}
+		function sort(keys, values, left, right, compare) {
+			if (left >= right) return;
+			var pivot = keys[left + right >> 1];
+			var i = left - 1;
+			var j = right + 1;
+			while (true) {
+				do
+					i++;
+				while (compare(keys[i], pivot) < 0);
+				do
+					j--;
+				while (compare(keys[j], pivot) > 0);
+				if (i >= j) break;
+				var tmp = keys[i];
+				keys[i] = keys[j];
+				keys[j] = tmp;
+				tmp = values[i];
+				values[i] = values[j];
+				values[j] = tmp;
+			}
+			sort(keys, values, left, j, compare);
+			sort(keys, values, j + 1, right, compare);
+		}
+		/**
+		* A bounding box has the format:
+		*
+		*  { ll: { x: xmin, y: ymin }, ur: { x: xmax, y: ymax } }
+		*
+		*/
+		const isInBbox = (bbox, point) => {
+			return bbox.ll.x <= point.x && point.x <= bbox.ur.x && bbox.ll.y <= point.y && point.y <= bbox.ur.y;
+		};
+		const getBboxOverlap = (b1, b2) => {
+			if (b2.ur.x < b1.ll.x || b1.ur.x < b2.ll.x || b2.ur.y < b1.ll.y || b1.ur.y < b2.ll.y) return null;
+			const lowerX = b1.ll.x < b2.ll.x ? b2.ll.x : b1.ll.x;
+			const upperX = b1.ur.x < b2.ur.x ? b1.ur.x : b2.ur.x;
+			const lowerY = b1.ll.y < b2.ll.y ? b2.ll.y : b1.ll.y;
+			const upperY = b1.ur.y < b2.ur.y ? b1.ur.y : b2.ur.y;
+			return {
+				ll: {
+					x: lowerX,
+					y: lowerY
+				},
+				ur: {
+					x: upperX,
+					y: upperY
+				}
+			};
+		};
+		let epsilon$1 = Number.EPSILON;
+		if (epsilon$1 === void 0) epsilon$1 = Math.pow(2, -52);
+		const EPSILON_SQ = epsilon$1 * epsilon$1;
+		const cmp = (a, b) => {
+			if (-epsilon$1 < a && a < epsilon$1) {
+				if (-epsilon$1 < b && b < epsilon$1) return 0;
+			}
+			const ab = a - b;
+			if (ab * ab < EPSILON_SQ * a * b) return 0;
+			return a < b ? -1 : 1;
+		};
+		/**
+		* This class rounds incoming values sufficiently so that
+		* floating points problems are, for the most part, avoided.
+		*
+		* Incoming points are have their x & y values tested against
+		* all previously seen x & y values. If either is 'too close'
+		* to a previously seen value, it's value is 'snapped' to the
+		* previously seen value.
+		*
+		* All points should be rounded by this class before being
+		* stored in any data structures in the rest of this algorithm.
+		*/
+		class PtRounder {
+			constructor() {
+				this.reset();
+			}
+			reset() {
+				this.xRounder = new CoordRounder();
+				this.yRounder = new CoordRounder();
+			}
+			round(x, y) {
+				return {
+					x: this.xRounder.round(x),
+					y: this.yRounder.round(y)
+				};
+			}
+		}
+		class CoordRounder {
+			constructor() {
+				this.tree = new Tree();
+				this.round(0);
+			}
+			round(coord) {
+				const node = this.tree.add(coord);
+				const prevNode = this.tree.prev(node);
+				if (prevNode !== null && cmp(node.key, prevNode.key) === 0) {
+					this.tree.remove(coord);
+					return prevNode.key;
+				}
+				const nextNode = this.tree.next(node);
+				if (nextNode !== null && cmp(node.key, nextNode.key) === 0) {
+					this.tree.remove(coord);
+					return nextNode.key;
+				}
+				return coord;
+			}
+		}
+		const rounder = new PtRounder();
+		const epsilon = 11102230246251565e-32;
+		const splitter = 134217729;
+		const resulterrbound = 3.000000000000001 * epsilon;
+		function sum(elen, e, flen, f, h) {
+			let Q, Qnew, hh, bvirt;
+			let enow = e[0];
+			let fnow = f[0];
+			let eindex = 0;
+			let findex = 0;
+			if (fnow > enow === fnow > -enow) {
+				Q = enow;
+				enow = e[++eindex];
+			} else {
+				Q = fnow;
+				fnow = f[++findex];
+			}
+			let hindex = 0;
+			if (eindex < elen && findex < flen) {
+				if (fnow > enow === fnow > -enow) {
+					Qnew = enow + Q;
+					hh = Q - (Qnew - enow);
+					enow = e[++eindex];
+				} else {
+					Qnew = fnow + Q;
+					hh = Q - (Qnew - fnow);
+					fnow = f[++findex];
+				}
+				Q = Qnew;
+				if (hh !== 0) h[hindex++] = hh;
+				while (eindex < elen && findex < flen) {
+					if (fnow > enow === fnow > -enow) {
+						Qnew = Q + enow;
+						bvirt = Qnew - Q;
+						hh = Q - (Qnew - bvirt) + (enow - bvirt);
+						enow = e[++eindex];
+					} else {
+						Qnew = Q + fnow;
+						bvirt = Qnew - Q;
+						hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+						fnow = f[++findex];
+					}
+					Q = Qnew;
+					if (hh !== 0) h[hindex++] = hh;
+				}
+			}
+			while (eindex < elen) {
+				Qnew = Q + enow;
+				bvirt = Qnew - Q;
+				hh = Q - (Qnew - bvirt) + (enow - bvirt);
+				enow = e[++eindex];
+				Q = Qnew;
+				if (hh !== 0) h[hindex++] = hh;
+			}
+			while (findex < flen) {
+				Qnew = Q + fnow;
+				bvirt = Qnew - Q;
+				hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+				fnow = f[++findex];
+				Q = Qnew;
+				if (hh !== 0) h[hindex++] = hh;
+			}
+			if (Q !== 0 || hindex === 0) h[hindex++] = Q;
+			return hindex;
+		}
+		function estimate(elen, e) {
+			let Q = e[0];
+			for (let i = 1; i < elen; i++) Q += e[i];
+			return Q;
+		}
+		function vec(n) {
+			return new Float64Array(n);
+		}
+		const ccwerrboundA = 3.0000000000000018 * epsilon;
+		const ccwerrboundB = 2.0000000000000013 * epsilon;
+		const ccwerrboundC = 9.000000000000007 * epsilon * epsilon;
+		const B = vec(4);
+		const C1 = vec(8);
+		const C2 = vec(12);
+		const D = vec(16);
+		const u = vec(4);
+		function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+			let acxtail, acytail, bcxtail, bcytail;
+			let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+			const acx = ax - cx;
+			const bcx = bx - cx;
+			const acy = ay - cy;
+			const bcy = by - cy;
+			s1 = acx * bcy;
+			c = splitter * acx;
+			ahi = c - (c - acx);
+			alo = acx - ahi;
+			c = splitter * bcy;
+			bhi = c - (c - bcy);
+			blo = bcy - bhi;
+			s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+			t1 = acy * bcx;
+			c = splitter * acy;
+			ahi = c - (c - acy);
+			alo = acy - ahi;
+			c = splitter * bcx;
+			bhi = c - (c - bcx);
+			blo = bcx - bhi;
+			t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+			_i = s0 - t0;
+			bvirt = s0 - _i;
+			B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+			_j = s1 + _i;
+			bvirt = _j - s1;
+			_0 = s1 - (_j - bvirt) + (_i - bvirt);
+			_i = _0 - t1;
+			bvirt = _0 - _i;
+			B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+			u3 = _j + _i;
+			bvirt = u3 - _j;
+			B[2] = _j - (u3 - bvirt) + (_i - bvirt);
+			B[3] = u3;
+			let det = estimate(4, B);
+			let errbound = ccwerrboundB * detsum;
+			if (det >= errbound || -det >= errbound) return det;
+			bvirt = ax - acx;
+			acxtail = ax - (acx + bvirt) + (bvirt - cx);
+			bvirt = bx - bcx;
+			bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+			bvirt = ay - acy;
+			acytail = ay - (acy + bvirt) + (bvirt - cy);
+			bvirt = by - bcy;
+			bcytail = by - (bcy + bvirt) + (bvirt - cy);
+			if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) return det;
+			errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+			det += acx * bcytail + bcy * acxtail - (acy * bcxtail + bcx * acytail);
+			if (det >= errbound || -det >= errbound) return det;
+			s1 = acxtail * bcy;
+			c = splitter * acxtail;
+			ahi = c - (c - acxtail);
+			alo = acxtail - ahi;
+			c = splitter * bcy;
+			bhi = c - (c - bcy);
+			blo = bcy - bhi;
+			s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+			t1 = acytail * bcx;
+			c = splitter * acytail;
+			ahi = c - (c - acytail);
+			alo = acytail - ahi;
+			c = splitter * bcx;
+			bhi = c - (c - bcx);
+			blo = bcx - bhi;
+			t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+			_i = s0 - t0;
+			bvirt = s0 - _i;
+			u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+			_j = s1 + _i;
+			bvirt = _j - s1;
+			_0 = s1 - (_j - bvirt) + (_i - bvirt);
+			_i = _0 - t1;
+			bvirt = _0 - _i;
+			u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+			u3 = _j + _i;
+			bvirt = u3 - _j;
+			u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+			u[3] = u3;
+			const C1len = sum(4, B, 4, u, C1);
+			s1 = acx * bcytail;
+			c = splitter * acx;
+			ahi = c - (c - acx);
+			alo = acx - ahi;
+			c = splitter * bcytail;
+			bhi = c - (c - bcytail);
+			blo = bcytail - bhi;
+			s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+			t1 = acy * bcxtail;
+			c = splitter * acy;
+			ahi = c - (c - acy);
+			alo = acy - ahi;
+			c = splitter * bcxtail;
+			bhi = c - (c - bcxtail);
+			blo = bcxtail - bhi;
+			t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+			_i = s0 - t0;
+			bvirt = s0 - _i;
+			u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+			_j = s1 + _i;
+			bvirt = _j - s1;
+			_0 = s1 - (_j - bvirt) + (_i - bvirt);
+			_i = _0 - t1;
+			bvirt = _0 - _i;
+			u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+			u3 = _j + _i;
+			bvirt = u3 - _j;
+			u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+			u[3] = u3;
+			const C2len = sum(C1len, C1, 4, u, C2);
+			s1 = acxtail * bcytail;
+			c = splitter * acxtail;
+			ahi = c - (c - acxtail);
+			alo = acxtail - ahi;
+			c = splitter * bcytail;
+			bhi = c - (c - bcytail);
+			blo = bcytail - bhi;
+			s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+			t1 = acytail * bcxtail;
+			c = splitter * acytail;
+			ahi = c - (c - acytail);
+			alo = acytail - ahi;
+			c = splitter * bcxtail;
+			bhi = c - (c - bcxtail);
+			blo = bcxtail - bhi;
+			t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+			_i = s0 - t0;
+			bvirt = s0 - _i;
+			u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+			_j = s1 + _i;
+			bvirt = _j - s1;
+			_0 = s1 - (_j - bvirt) + (_i - bvirt);
+			_i = _0 - t1;
+			bvirt = _0 - _i;
+			u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+			u3 = _j + _i;
+			bvirt = u3 - _j;
+			u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+			u[3] = u3;
+			return D[sum(C2len, C2, 4, u, D) - 1];
+		}
+		function orient2d(ax, ay, bx, by, cx, cy) {
+			const detleft = (ay - cy) * (bx - cx);
+			const detright = (ax - cx) * (by - cy);
+			const det = detleft - detright;
+			const detsum = Math.abs(detleft + detright);
+			if (Math.abs(det) >= ccwerrboundA * detsum) return det;
+			return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+		}
+		const crossProduct = (a, b) => a.x * b.y - a.y * b.x;
+		const dotProduct = (a, b) => a.x * b.x + a.y * b.y;
+		const compareVectorAngles = (basePt, endPt1, endPt2) => {
+			const res = orient2d(basePt.x, basePt.y, endPt1.x, endPt1.y, endPt2.x, endPt2.y);
+			if (res > 0) return -1;
+			if (res < 0) return 1;
+			return 0;
+		};
+		const length = (v) => Math.sqrt(dotProduct(v, v));
+		const sineOfAngle = (pShared, pBase, pAngle) => {
+			const vBase = {
+				x: pBase.x - pShared.x,
+				y: pBase.y - pShared.y
+			};
+			const vAngle = {
+				x: pAngle.x - pShared.x,
+				y: pAngle.y - pShared.y
+			};
+			return crossProduct(vAngle, vBase) / length(vAngle) / length(vBase);
+		};
+		const cosineOfAngle = (pShared, pBase, pAngle) => {
+			const vBase = {
+				x: pBase.x - pShared.x,
+				y: pBase.y - pShared.y
+			};
+			const vAngle = {
+				x: pAngle.x - pShared.x,
+				y: pAngle.y - pShared.y
+			};
+			return dotProduct(vAngle, vBase) / length(vAngle) / length(vBase);
+		};
+		const horizontalIntersection = (pt, v, y) => {
+			if (v.y === 0) return null;
+			return {
+				x: pt.x + v.x / v.y * (y - pt.y),
+				y
+			};
+		};
+		const verticalIntersection = (pt, v, x) => {
+			if (v.x === 0) return null;
+			return {
+				x,
+				y: pt.y + v.y / v.x * (x - pt.x)
+			};
+		};
+		const intersection$1 = (pt1, v1, pt2, v2) => {
+			if (v1.x === 0) return verticalIntersection(pt2, v2, pt1.x);
+			if (v2.x === 0) return verticalIntersection(pt1, v1, pt2.x);
+			if (v1.y === 0) return horizontalIntersection(pt2, v2, pt1.y);
+			if (v2.y === 0) return horizontalIntersection(pt1, v1, pt2.y);
+			const kross = crossProduct(v1, v2);
+			if (kross == 0) return null;
+			const ve = {
+				x: pt2.x - pt1.x,
+				y: pt2.y - pt1.y
+			};
+			const d1 = crossProduct(ve, v1) / kross;
+			const d2 = crossProduct(ve, v2) / kross;
+			const x1 = pt1.x + d2 * v1.x, x2 = pt2.x + d1 * v2.x;
+			const y1 = pt1.y + d2 * v1.y, y2 = pt2.y + d1 * v2.y;
+			return {
+				x: (x1 + x2) / 2,
+				y: (y1 + y2) / 2
+			};
+		};
+		class SweepEvent {
+			static compare(a, b) {
+				const ptCmp = SweepEvent.comparePoints(a.point, b.point);
+				if (ptCmp !== 0) return ptCmp;
+				if (a.point !== b.point) a.link(b);
+				if (a.isLeft !== b.isLeft) return a.isLeft ? 1 : -1;
+				return Segment.compare(a.segment, b.segment);
+			}
+			static comparePoints(aPt, bPt) {
+				if (aPt.x < bPt.x) return -1;
+				if (aPt.x > bPt.x) return 1;
+				if (aPt.y < bPt.y) return -1;
+				if (aPt.y > bPt.y) return 1;
+				return 0;
+			}
+			constructor(point, isLeft) {
+				if (point.events === void 0) point.events = [this];
+				else point.events.push(this);
+				this.point = point;
+				this.isLeft = isLeft;
+			}
+			link(other) {
+				if (other.point === this.point) throw new Error("Tried to link already linked events");
+				const otherEvents = other.point.events;
+				for (let i = 0, iMax = otherEvents.length; i < iMax; i++) {
+					const evt = otherEvents[i];
+					this.point.events.push(evt);
+					evt.point = this.point;
+				}
+				this.checkForConsuming();
+			}
+			checkForConsuming() {
+				const numEvents = this.point.events.length;
+				for (let i = 0; i < numEvents; i++) {
+					const evt1 = this.point.events[i];
+					if (evt1.segment.consumedBy !== void 0) continue;
+					for (let j = i + 1; j < numEvents; j++) {
+						const evt2 = this.point.events[j];
+						if (evt2.consumedBy !== void 0) continue;
+						if (evt1.otherSE.point.events !== evt2.otherSE.point.events) continue;
+						evt1.segment.consume(evt2.segment);
+					}
+				}
+			}
+			getAvailableLinkedEvents() {
+				const events = [];
+				for (let i = 0, iMax = this.point.events.length; i < iMax; i++) {
+					const evt = this.point.events[i];
+					if (evt !== this && !evt.segment.ringOut && evt.segment.isInResult()) events.push(evt);
+				}
+				return events;
+			}
+			/**
+			* Returns a comparator function for sorting linked events that will
+			* favor the event that will give us the smallest left-side angle.
+			* All ring construction starts as low as possible heading to the right,
+			* so by always turning left as sharp as possible we'll get polygons
+			* without uncessary loops & holes.
+			*
+			* The comparator function has a compute cache such that it avoids
+			* re-computing already-computed values.
+			*/
+			getLeftmostComparator(baseEvent) {
+				const cache = /* @__PURE__ */ new Map();
+				const fillCache = (linkedEvent) => {
+					const nextEvent = linkedEvent.otherSE;
+					cache.set(linkedEvent, {
+						sine: sineOfAngle(this.point, baseEvent.point, nextEvent.point),
+						cosine: cosineOfAngle(this.point, baseEvent.point, nextEvent.point)
+					});
+				};
+				return (a, b) => {
+					if (!cache.has(a)) fillCache(a);
+					if (!cache.has(b)) fillCache(b);
+					const { sine: asine, cosine: acosine } = cache.get(a);
+					const { sine: bsine, cosine: bcosine } = cache.get(b);
+					if (asine >= 0 && bsine >= 0) {
+						if (acosine < bcosine) return 1;
+						if (acosine > bcosine) return -1;
+						return 0;
+					}
+					if (asine < 0 && bsine < 0) {
+						if (acosine < bcosine) return -1;
+						if (acosine > bcosine) return 1;
+						return 0;
+					}
+					if (bsine < asine) return -1;
+					if (bsine > asine) return 1;
+					return 0;
+				};
+			}
+		}
+		let segmentId = 0;
+		class Segment {
+			static compare(a, b) {
+				const alx = a.leftSE.point.x;
+				const blx = b.leftSE.point.x;
+				const arx = a.rightSE.point.x;
+				const brx = b.rightSE.point.x;
+				if (brx < alx) return 1;
+				if (arx < blx) return -1;
+				const aly = a.leftSE.point.y;
+				const bly = b.leftSE.point.y;
+				const ary = a.rightSE.point.y;
+				const bry = b.rightSE.point.y;
+				if (alx < blx) {
+					if (bly < aly && bly < ary) return 1;
+					if (bly > aly && bly > ary) return -1;
+					const aCmpBLeft = a.comparePoint(b.leftSE.point);
+					if (aCmpBLeft < 0) return 1;
+					if (aCmpBLeft > 0) return -1;
+					const bCmpARight = b.comparePoint(a.rightSE.point);
+					if (bCmpARight !== 0) return bCmpARight;
+					return -1;
+				}
+				if (alx > blx) {
+					if (aly < bly && aly < bry) return -1;
+					if (aly > bly && aly > bry) return 1;
+					const bCmpALeft = b.comparePoint(a.leftSE.point);
+					if (bCmpALeft !== 0) return bCmpALeft;
+					const aCmpBRight = a.comparePoint(b.rightSE.point);
+					if (aCmpBRight < 0) return 1;
+					if (aCmpBRight > 0) return -1;
+					return 1;
+				}
+				if (aly < bly) return -1;
+				if (aly > bly) return 1;
+				if (arx < brx) {
+					const bCmpARight = b.comparePoint(a.rightSE.point);
+					if (bCmpARight !== 0) return bCmpARight;
+				}
+				if (arx > brx) {
+					const aCmpBRight = a.comparePoint(b.rightSE.point);
+					if (aCmpBRight < 0) return 1;
+					if (aCmpBRight > 0) return -1;
+				}
+				if (arx !== brx) {
+					const ay = ary - aly;
+					const ax = arx - alx;
+					const by = bry - bly;
+					const bx = brx - blx;
+					if (ay > ax && by < bx) return 1;
+					if (ay < ax && by > bx) return -1;
+				}
+				if (arx > brx) return 1;
+				if (arx < brx) return -1;
+				if (ary < bry) return -1;
+				if (ary > bry) return 1;
+				if (a.id < b.id) return -1;
+				if (a.id > b.id) return 1;
+				return 0;
+			}
+			constructor(leftSE, rightSE, rings, windings) {
+				this.id = ++segmentId;
+				this.leftSE = leftSE;
+				leftSE.segment = this;
+				leftSE.otherSE = rightSE;
+				this.rightSE = rightSE;
+				rightSE.segment = this;
+				rightSE.otherSE = leftSE;
+				this.rings = rings;
+				this.windings = windings;
+			}
+			static fromRing(pt1, pt2, ring) {
+				let leftPt, rightPt, winding;
+				const cmpPts = SweepEvent.comparePoints(pt1, pt2);
+				if (cmpPts < 0) {
+					leftPt = pt1;
+					rightPt = pt2;
+					winding = 1;
+				} else if (cmpPts > 0) {
+					leftPt = pt2;
+					rightPt = pt1;
+					winding = -1;
+				} else throw new Error(`Tried to create degenerate segment at [${pt1.x}, ${pt1.y}]`);
+				return new Segment(new SweepEvent(leftPt, true), new SweepEvent(rightPt, false), [ring], [winding]);
+			}
+			replaceRightSE(newRightSE) {
+				this.rightSE = newRightSE;
+				this.rightSE.segment = this;
+				this.rightSE.otherSE = this.leftSE;
+				this.leftSE.otherSE = this.rightSE;
+			}
+			bbox() {
+				const y1 = this.leftSE.point.y;
+				const y2 = this.rightSE.point.y;
+				return {
+					ll: {
+						x: this.leftSE.point.x,
+						y: y1 < y2 ? y1 : y2
+					},
+					ur: {
+						x: this.rightSE.point.x,
+						y: y1 > y2 ? y1 : y2
+					}
+				};
+			}
+			vector() {
+				return {
+					x: this.rightSE.point.x - this.leftSE.point.x,
+					y: this.rightSE.point.y - this.leftSE.point.y
+				};
+			}
+			isAnEndpoint(pt) {
+				return pt.x === this.leftSE.point.x && pt.y === this.leftSE.point.y || pt.x === this.rightSE.point.x && pt.y === this.rightSE.point.y;
+			}
+			comparePoint(point) {
+				if (this.isAnEndpoint(point)) return 0;
+				const lPt = this.leftSE.point;
+				const rPt = this.rightSE.point;
+				const v = this.vector();
+				if (lPt.x === rPt.x) {
+					if (point.x === lPt.x) return 0;
+					return point.x < lPt.x ? 1 : -1;
+				}
+				const yDist = (point.y - lPt.y) / v.y;
+				const xFromYDist = lPt.x + yDist * v.x;
+				if (point.x === xFromYDist) return 0;
+				const xDist = (point.x - lPt.x) / v.x;
+				const yFromXDist = lPt.y + xDist * v.y;
+				if (point.y === yFromXDist) return 0;
+				return point.y < yFromXDist ? -1 : 1;
+			}
+			/**
+			* Given another segment, returns the first non-trivial intersection
+			* between the two segments (in terms of sweep line ordering), if it exists.
+			*
+			* A 'non-trivial' intersection is one that will cause one or both of the
+			* segments to be split(). As such, 'trivial' vs. 'non-trivial' intersection:
+			*
+			*   * endpoint of segA with endpoint of segB --> trivial
+			*   * endpoint of segA with point along segB --> non-trivial
+			*   * endpoint of segB with point along segA --> non-trivial
+			*   * point along segA with point along segB --> non-trivial
+			*
+			* If no non-trivial intersection exists, return null
+			* Else, return null.
+			*/
+			getIntersection(other) {
+				const tBbox = this.bbox();
+				const oBbox = other.bbox();
+				const bboxOverlap = getBboxOverlap(tBbox, oBbox);
+				if (bboxOverlap === null) return null;
+				const tlp = this.leftSE.point;
+				const trp = this.rightSE.point;
+				const olp = other.leftSE.point;
+				const orp = other.rightSE.point;
+				const touchesOtherLSE = isInBbox(tBbox, olp) && this.comparePoint(olp) === 0;
+				const touchesThisLSE = isInBbox(oBbox, tlp) && other.comparePoint(tlp) === 0;
+				const touchesOtherRSE = isInBbox(tBbox, orp) && this.comparePoint(orp) === 0;
+				const touchesThisRSE = isInBbox(oBbox, trp) && other.comparePoint(trp) === 0;
+				if (touchesThisLSE && touchesOtherLSE) {
+					if (touchesThisRSE && !touchesOtherRSE) return trp;
+					if (!touchesThisRSE && touchesOtherRSE) return orp;
+					return null;
+				}
+				if (touchesThisLSE) {
+					if (touchesOtherRSE) {
+						if (tlp.x === orp.x && tlp.y === orp.y) return null;
+					}
+					return tlp;
+				}
+				if (touchesOtherLSE) {
+					if (touchesThisRSE) {
+						if (trp.x === olp.x && trp.y === olp.y) return null;
+					}
+					return olp;
+				}
+				if (touchesThisRSE && touchesOtherRSE) return null;
+				if (touchesThisRSE) return trp;
+				if (touchesOtherRSE) return orp;
+				const pt = intersection$1(tlp, this.vector(), olp, other.vector());
+				if (pt === null) return null;
+				if (!isInBbox(bboxOverlap, pt)) return null;
+				return rounder.round(pt.x, pt.y);
+			}
+			/**
+			* Split the given segment into multiple segments on the given points.
+			*  * Each existing segment will retain its leftSE and a new rightSE will be
+			*    generated for it.
+			*  * A new segment will be generated which will adopt the original segment's
+			*    rightSE, and a new leftSE will be generated for it.
+			*  * If there are more than two points given to split on, new segments
+			*    in the middle will be generated with new leftSE and rightSE's.
+			*  * An array of the newly generated SweepEvents will be returned.
+			*
+			* Warning: input array of points is modified
+			*/
+			split(point) {
+				const newEvents = [];
+				const alreadyLinked = point.events !== void 0;
+				const newLeftSE = new SweepEvent(point, true);
+				const newRightSE = new SweepEvent(point, false);
+				const oldRightSE = this.rightSE;
+				this.replaceRightSE(newRightSE);
+				newEvents.push(newRightSE);
+				newEvents.push(newLeftSE);
+				const newSeg = new Segment(newLeftSE, oldRightSE, this.rings.slice(), this.windings.slice());
+				if (SweepEvent.comparePoints(newSeg.leftSE.point, newSeg.rightSE.point) > 0) newSeg.swapEvents();
+				if (SweepEvent.comparePoints(this.leftSE.point, this.rightSE.point) > 0) this.swapEvents();
+				if (alreadyLinked) {
+					newLeftSE.checkForConsuming();
+					newRightSE.checkForConsuming();
+				}
+				return newEvents;
+			}
+			swapEvents() {
+				const tmpEvt = this.rightSE;
+				this.rightSE = this.leftSE;
+				this.leftSE = tmpEvt;
+				this.leftSE.isLeft = true;
+				this.rightSE.isLeft = false;
+				for (let i = 0, iMax = this.windings.length; i < iMax; i++) this.windings[i] *= -1;
+			}
+			consume(other) {
+				let consumer = this;
+				let consumee = other;
+				while (consumer.consumedBy) consumer = consumer.consumedBy;
+				while (consumee.consumedBy) consumee = consumee.consumedBy;
+				const cmp = Segment.compare(consumer, consumee);
+				if (cmp === 0) return;
+				if (cmp > 0) {
+					const tmp = consumer;
+					consumer = consumee;
+					consumee = tmp;
+				}
+				if (consumer.prev === consumee) {
+					const tmp = consumer;
+					consumer = consumee;
+					consumee = tmp;
+				}
+				for (let i = 0, iMax = consumee.rings.length; i < iMax; i++) {
+					const ring = consumee.rings[i];
+					const winding = consumee.windings[i];
+					const index = consumer.rings.indexOf(ring);
+					if (index === -1) {
+						consumer.rings.push(ring);
+						consumer.windings.push(winding);
+					} else consumer.windings[index] += winding;
+				}
+				consumee.rings = null;
+				consumee.windings = null;
+				consumee.consumedBy = consumer;
+				consumee.leftSE.consumedBy = consumer.leftSE;
+				consumee.rightSE.consumedBy = consumer.rightSE;
+			}
+			prevInResult() {
+				if (this._prevInResult !== void 0) return this._prevInResult;
+				if (!this.prev) this._prevInResult = null;
+				else if (this.prev.isInResult()) this._prevInResult = this.prev;
+				else this._prevInResult = this.prev.prevInResult();
+				return this._prevInResult;
+			}
+			beforeState() {
+				if (this._beforeState !== void 0) return this._beforeState;
+				if (!this.prev) this._beforeState = {
+					rings: [],
+					windings: [],
+					multiPolys: []
+				};
+				else {
+					const seg = this.prev.consumedBy || this.prev;
+					this._beforeState = seg.afterState();
+				}
+				return this._beforeState;
+			}
+			afterState() {
+				if (this._afterState !== void 0) return this._afterState;
+				const beforeState = this.beforeState();
+				this._afterState = {
+					rings: beforeState.rings.slice(0),
+					windings: beforeState.windings.slice(0),
+					multiPolys: []
+				};
+				const ringsAfter = this._afterState.rings;
+				const windingsAfter = this._afterState.windings;
+				const mpsAfter = this._afterState.multiPolys;
+				for (let i = 0, iMax = this.rings.length; i < iMax; i++) {
+					const ring = this.rings[i];
+					const winding = this.windings[i];
+					const index = ringsAfter.indexOf(ring);
+					if (index === -1) {
+						ringsAfter.push(ring);
+						windingsAfter.push(winding);
+					} else windingsAfter[index] += winding;
+				}
+				const polysAfter = [];
+				const polysExclude = [];
+				for (let i = 0, iMax = ringsAfter.length; i < iMax; i++) {
+					if (windingsAfter[i] === 0) continue;
+					const ring = ringsAfter[i];
+					const poly = ring.poly;
+					if (polysExclude.indexOf(poly) !== -1) continue;
+					if (ring.isExterior) polysAfter.push(poly);
+					else {
+						if (polysExclude.indexOf(poly) === -1) polysExclude.push(poly);
+						const index = polysAfter.indexOf(ring.poly);
+						if (index !== -1) polysAfter.splice(index, 1);
+					}
+				}
+				for (let i = 0, iMax = polysAfter.length; i < iMax; i++) {
+					const mp = polysAfter[i].multiPoly;
+					if (mpsAfter.indexOf(mp) === -1) mpsAfter.push(mp);
+				}
+				return this._afterState;
+			}
+			isInResult() {
+				if (this.consumedBy) return false;
+				if (this._isInResult !== void 0) return this._isInResult;
+				const mpsBefore = this.beforeState().multiPolys;
+				const mpsAfter = this.afterState().multiPolys;
+				switch (operation.type) {
+					case "union": {
+						const noBefores = mpsBefore.length === 0;
+						const noAfters = mpsAfter.length === 0;
+						this._isInResult = noBefores !== noAfters;
+						break;
+					}
+					case "intersection": {
+						let least;
+						let most;
+						if (mpsBefore.length < mpsAfter.length) {
+							least = mpsBefore.length;
+							most = mpsAfter.length;
+						} else {
+							least = mpsAfter.length;
+							most = mpsBefore.length;
+						}
+						this._isInResult = most === operation.numMultiPolys && least < most;
+						break;
+					}
+					case "xor": {
+						const diff = Math.abs(mpsBefore.length - mpsAfter.length);
+						this._isInResult = diff % 2 === 1;
+						break;
+					}
+					case "difference": {
+						const isJustSubject = (mps) => mps.length === 1 && mps[0].isSubject;
+						this._isInResult = isJustSubject(mpsBefore) !== isJustSubject(mpsAfter);
+						break;
+					}
+					default: throw new Error(`Unrecognized operation type found ${operation.type}`);
+				}
+				return this._isInResult;
+			}
+		}
+		class RingIn {
+			constructor(geomRing, poly, isExterior) {
+				if (!Array.isArray(geomRing) || geomRing.length === 0) throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+				this.poly = poly;
+				this.isExterior = isExterior;
+				this.segments = [];
+				if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+				const firstPoint = rounder.round(geomRing[0][0], geomRing[0][1]);
+				this.bbox = {
+					ll: {
+						x: firstPoint.x,
+						y: firstPoint.y
+					},
+					ur: {
+						x: firstPoint.x,
+						y: firstPoint.y
+					}
+				};
+				let prevPoint = firstPoint;
+				for (let i = 1, iMax = geomRing.length; i < iMax; i++) {
+					if (typeof geomRing[i][0] !== "number" || typeof geomRing[i][1] !== "number") throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+					let point = rounder.round(geomRing[i][0], geomRing[i][1]);
+					if (point.x === prevPoint.x && point.y === prevPoint.y) continue;
+					this.segments.push(Segment.fromRing(prevPoint, point, this));
+					if (point.x < this.bbox.ll.x) this.bbox.ll.x = point.x;
+					if (point.y < this.bbox.ll.y) this.bbox.ll.y = point.y;
+					if (point.x > this.bbox.ur.x) this.bbox.ur.x = point.x;
+					if (point.y > this.bbox.ur.y) this.bbox.ur.y = point.y;
+					prevPoint = point;
+				}
+				if (firstPoint.x !== prevPoint.x || firstPoint.y !== prevPoint.y) this.segments.push(Segment.fromRing(prevPoint, firstPoint, this));
+			}
+			getSweepEvents() {
+				const sweepEvents = [];
+				for (let i = 0, iMax = this.segments.length; i < iMax; i++) {
+					const segment = this.segments[i];
+					sweepEvents.push(segment.leftSE);
+					sweepEvents.push(segment.rightSE);
+				}
+				return sweepEvents;
+			}
+		}
+		class PolyIn {
+			constructor(geomPoly, multiPoly) {
+				if (!Array.isArray(geomPoly)) throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+				this.exteriorRing = new RingIn(geomPoly[0], this, true);
+				this.bbox = {
+					ll: {
+						x: this.exteriorRing.bbox.ll.x,
+						y: this.exteriorRing.bbox.ll.y
+					},
+					ur: {
+						x: this.exteriorRing.bbox.ur.x,
+						y: this.exteriorRing.bbox.ur.y
+					}
+				};
+				this.interiorRings = [];
+				for (let i = 1, iMax = geomPoly.length; i < iMax; i++) {
+					const ring = new RingIn(geomPoly[i], this, false);
+					if (ring.bbox.ll.x < this.bbox.ll.x) this.bbox.ll.x = ring.bbox.ll.x;
+					if (ring.bbox.ll.y < this.bbox.ll.y) this.bbox.ll.y = ring.bbox.ll.y;
+					if (ring.bbox.ur.x > this.bbox.ur.x) this.bbox.ur.x = ring.bbox.ur.x;
+					if (ring.bbox.ur.y > this.bbox.ur.y) this.bbox.ur.y = ring.bbox.ur.y;
+					this.interiorRings.push(ring);
+				}
+				this.multiPoly = multiPoly;
+			}
+			getSweepEvents() {
+				const sweepEvents = this.exteriorRing.getSweepEvents();
+				for (let i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
+					const ringSweepEvents = this.interiorRings[i].getSweepEvents();
+					for (let j = 0, jMax = ringSweepEvents.length; j < jMax; j++) sweepEvents.push(ringSweepEvents[j]);
+				}
+				return sweepEvents;
+			}
+		}
+		class MultiPolyIn {
+			constructor(geom, isSubject) {
+				if (!Array.isArray(geom)) throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+				try {
+					if (typeof geom[0][0][0] === "number") geom = [geom];
+				} catch (ex) {}
+				this.polys = [];
+				this.bbox = {
+					ll: {
+						x: Number.POSITIVE_INFINITY,
+						y: Number.POSITIVE_INFINITY
+					},
+					ur: {
+						x: Number.NEGATIVE_INFINITY,
+						y: Number.NEGATIVE_INFINITY
+					}
+				};
+				for (let i = 0, iMax = geom.length; i < iMax; i++) {
+					const poly = new PolyIn(geom[i], this);
+					if (poly.bbox.ll.x < this.bbox.ll.x) this.bbox.ll.x = poly.bbox.ll.x;
+					if (poly.bbox.ll.y < this.bbox.ll.y) this.bbox.ll.y = poly.bbox.ll.y;
+					if (poly.bbox.ur.x > this.bbox.ur.x) this.bbox.ur.x = poly.bbox.ur.x;
+					if (poly.bbox.ur.y > this.bbox.ur.y) this.bbox.ur.y = poly.bbox.ur.y;
+					this.polys.push(poly);
+				}
+				this.isSubject = isSubject;
+			}
+			getSweepEvents() {
+				const sweepEvents = [];
+				for (let i = 0, iMax = this.polys.length; i < iMax; i++) {
+					const polySweepEvents = this.polys[i].getSweepEvents();
+					for (let j = 0, jMax = polySweepEvents.length; j < jMax; j++) sweepEvents.push(polySweepEvents[j]);
+				}
+				return sweepEvents;
+			}
+		}
+		class RingOut {
+			static factory(allSegments) {
+				const ringsOut = [];
+				for (let i = 0, iMax = allSegments.length; i < iMax; i++) {
+					const segment = allSegments[i];
+					if (!segment.isInResult() || segment.ringOut) continue;
+					let prevEvent = null;
+					let event = segment.leftSE;
+					let nextEvent = segment.rightSE;
+					const events = [event];
+					const startingPoint = event.point;
+					const intersectionLEs = [];
+					while (true) {
+						prevEvent = event;
+						event = nextEvent;
+						events.push(event);
+						if (event.point === startingPoint) break;
+						while (true) {
+							const availableLEs = event.getAvailableLinkedEvents();
+							if (availableLEs.length === 0) {
+								const firstPt = events[0].point;
+								const lastPt = events[events.length - 1].point;
+								throw new Error(`Unable to complete output ring starting at [${firstPt.x}, ${firstPt.y}]. Last matching segment found ends at [${lastPt.x}, ${lastPt.y}].`);
+							}
+							if (availableLEs.length === 1) {
+								nextEvent = availableLEs[0].otherSE;
+								break;
+							}
+							let indexLE = null;
+							for (let j = 0, jMax = intersectionLEs.length; j < jMax; j++) if (intersectionLEs[j].point === event.point) {
+								indexLE = j;
+								break;
+							}
+							if (indexLE !== null) {
+								const intersectionLE = intersectionLEs.splice(indexLE)[0];
+								const ringEvents = events.splice(intersectionLE.index);
+								ringEvents.unshift(ringEvents[0].otherSE);
+								ringsOut.push(new RingOut(ringEvents.reverse()));
+								continue;
+							}
+							intersectionLEs.push({
+								index: events.length,
+								point: event.point
+							});
+							const comparator = event.getLeftmostComparator(prevEvent);
+							nextEvent = availableLEs.sort(comparator)[0].otherSE;
+							break;
+						}
+					}
+					ringsOut.push(new RingOut(events));
+				}
+				return ringsOut;
+			}
+			constructor(events) {
+				this.events = events;
+				for (let i = 0, iMax = events.length; i < iMax; i++) events[i].segment.ringOut = this;
+				this.poly = null;
+			}
+			getGeom() {
+				let prevPt = this.events[0].point;
+				const points = [prevPt];
+				for (let i = 1, iMax = this.events.length - 1; i < iMax; i++) {
+					const pt = this.events[i].point;
+					const nextPt = this.events[i + 1].point;
+					if (compareVectorAngles(pt, prevPt, nextPt) === 0) continue;
+					points.push(pt);
+					prevPt = pt;
+				}
+				if (points.length === 1) return null;
+				const pt = points[0];
+				const nextPt = points[1];
+				if (compareVectorAngles(pt, prevPt, nextPt) === 0) points.shift();
+				points.push(points[0]);
+				const step = this.isExteriorRing() ? 1 : -1;
+				const iStart = this.isExteriorRing() ? 0 : points.length - 1;
+				const iEnd = this.isExteriorRing() ? points.length : -1;
+				const orderedPoints = [];
+				for (let i = iStart; i != iEnd; i += step) orderedPoints.push([points[i].x, points[i].y]);
+				return orderedPoints;
+			}
+			isExteriorRing() {
+				if (this._isExteriorRing === void 0) {
+					const enclosing = this.enclosingRing();
+					this._isExteriorRing = enclosing ? !enclosing.isExteriorRing() : true;
+				}
+				return this._isExteriorRing;
+			}
+			enclosingRing() {
+				if (this._enclosingRing === void 0) this._enclosingRing = this._calcEnclosingRing();
+				return this._enclosingRing;
+			}
+			_calcEnclosingRing() {
+				let leftMostEvt = this.events[0];
+				for (let i = 1, iMax = this.events.length; i < iMax; i++) {
+					const evt = this.events[i];
+					if (SweepEvent.compare(leftMostEvt, evt) > 0) leftMostEvt = evt;
+				}
+				let prevSeg = leftMostEvt.segment.prevInResult();
+				let prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null;
+				while (true) {
+					if (!prevSeg) return null;
+					if (!prevPrevSeg) return prevSeg.ringOut;
+					if (prevPrevSeg.ringOut !== prevSeg.ringOut) if (prevPrevSeg.ringOut.enclosingRing() !== prevSeg.ringOut) return prevSeg.ringOut;
+					else return prevSeg.ringOut.enclosingRing();
+					prevSeg = prevPrevSeg.prevInResult();
+					prevPrevSeg = prevSeg ? prevSeg.prevInResult() : null;
+				}
+			}
+		}
+		class PolyOut {
+			constructor(exteriorRing) {
+				this.exteriorRing = exteriorRing;
+				exteriorRing.poly = this;
+				this.interiorRings = [];
+			}
+			addInterior(ring) {
+				this.interiorRings.push(ring);
+				ring.poly = this;
+			}
+			getGeom() {
+				const geom = [this.exteriorRing.getGeom()];
+				if (geom[0] === null) return null;
+				for (let i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
+					const ringGeom = this.interiorRings[i].getGeom();
+					if (ringGeom === null) continue;
+					geom.push(ringGeom);
+				}
+				return geom;
+			}
+		}
+		class MultiPolyOut {
+			constructor(rings) {
+				this.rings = rings;
+				this.polys = this._composePolys(rings);
+			}
+			getGeom() {
+				const geom = [];
+				for (let i = 0, iMax = this.polys.length; i < iMax; i++) {
+					const polyGeom = this.polys[i].getGeom();
+					if (polyGeom === null) continue;
+					geom.push(polyGeom);
+				}
+				return geom;
+			}
+			_composePolys(rings) {
+				const polys = [];
+				for (let i = 0, iMax = rings.length; i < iMax; i++) {
+					const ring = rings[i];
+					if (ring.poly) continue;
+					if (ring.isExteriorRing()) polys.push(new PolyOut(ring));
+					else {
+						const enclosingRing = ring.enclosingRing();
+						if (!enclosingRing.poly) polys.push(new PolyOut(enclosingRing));
+						enclosingRing.poly.addInterior(ring);
+					}
+				}
+				return polys;
+			}
+		}
+		/**
+		* NOTE:  We must be careful not to change any segments while
+		*        they are in the SplayTree. AFAIK, there's no way to tell
+		*        the tree to rebalance itself - thus before splitting
+		*        a segment that's in the tree, we remove it from the tree,
+		*        do the split, then re-insert it. (Even though splitting a
+		*        segment *shouldn't* change its correct position in the
+		*        sweep line tree, the reality is because of rounding errors,
+		*        it sometimes does.)
+		*/
+		class SweepLine {
+			constructor(queue) {
+				let comparator = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Segment.compare;
+				this.queue = queue;
+				this.tree = new Tree(comparator);
+				this.segments = [];
+			}
+			process(event) {
+				const segment = event.segment;
+				const newEvents = [];
+				if (event.consumedBy) {
+					if (event.isLeft) this.queue.remove(event.otherSE);
+					else this.tree.remove(segment);
+					return newEvents;
+				}
+				const node = event.isLeft ? this.tree.add(segment) : this.tree.find(segment);
+				if (!node) throw new Error(`Unable to find segment #${segment.id} [${segment.leftSE.point.x}, ${segment.leftSE.point.y}] -> [${segment.rightSE.point.x}, ${segment.rightSE.point.y}] in SweepLine tree.`);
+				let prevNode = node;
+				let nextNode = node;
+				let prevSeg = void 0;
+				let nextSeg = void 0;
+				while (prevSeg === void 0) {
+					prevNode = this.tree.prev(prevNode);
+					if (prevNode === null) prevSeg = null;
+					else if (prevNode.key.consumedBy === void 0) prevSeg = prevNode.key;
+				}
+				while (nextSeg === void 0) {
+					nextNode = this.tree.next(nextNode);
+					if (nextNode === null) nextSeg = null;
+					else if (nextNode.key.consumedBy === void 0) nextSeg = nextNode.key;
+				}
+				if (event.isLeft) {
+					let prevMySplitter = null;
+					if (prevSeg) {
+						const prevInter = prevSeg.getIntersection(segment);
+						if (prevInter !== null) {
+							if (!segment.isAnEndpoint(prevInter)) prevMySplitter = prevInter;
+							if (!prevSeg.isAnEndpoint(prevInter)) {
+								const newEventsFromSplit = this._splitSafely(prevSeg, prevInter);
+								for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) newEvents.push(newEventsFromSplit[i]);
+							}
+						}
+					}
+					let nextMySplitter = null;
+					if (nextSeg) {
+						const nextInter = nextSeg.getIntersection(segment);
+						if (nextInter !== null) {
+							if (!segment.isAnEndpoint(nextInter)) nextMySplitter = nextInter;
+							if (!nextSeg.isAnEndpoint(nextInter)) {
+								const newEventsFromSplit = this._splitSafely(nextSeg, nextInter);
+								for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) newEvents.push(newEventsFromSplit[i]);
+							}
+						}
+					}
+					if (prevMySplitter !== null || nextMySplitter !== null) {
+						let mySplitter = null;
+						if (prevMySplitter === null) mySplitter = nextMySplitter;
+						else if (nextMySplitter === null) mySplitter = prevMySplitter;
+						else mySplitter = SweepEvent.comparePoints(prevMySplitter, nextMySplitter) <= 0 ? prevMySplitter : nextMySplitter;
+						this.queue.remove(segment.rightSE);
+						newEvents.push(segment.rightSE);
+						const newEventsFromSplit = segment.split(mySplitter);
+						for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) newEvents.push(newEventsFromSplit[i]);
+					}
+					if (newEvents.length > 0) {
+						this.tree.remove(segment);
+						newEvents.push(event);
+					} else {
+						this.segments.push(segment);
+						segment.prev = prevSeg;
+					}
+				} else {
+					if (prevSeg && nextSeg) {
+						const inter = prevSeg.getIntersection(nextSeg);
+						if (inter !== null) {
+							if (!prevSeg.isAnEndpoint(inter)) {
+								const newEventsFromSplit = this._splitSafely(prevSeg, inter);
+								for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) newEvents.push(newEventsFromSplit[i]);
+							}
+							if (!nextSeg.isAnEndpoint(inter)) {
+								const newEventsFromSplit = this._splitSafely(nextSeg, inter);
+								for (let i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) newEvents.push(newEventsFromSplit[i]);
+							}
+						}
+					}
+					this.tree.remove(segment);
+				}
+				return newEvents;
+			}
+			_splitSafely(seg, pt) {
+				this.tree.remove(seg);
+				const rightSE = seg.rightSE;
+				this.queue.remove(rightSE);
+				const newEvents = seg.split(pt);
+				newEvents.push(rightSE);
+				if (seg.consumedBy === void 0) this.tree.add(seg);
+				return newEvents;
+			}
+		}
+		const POLYGON_CLIPPING_MAX_QUEUE_SIZE = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_QUEUE_SIZE || 1e6;
+		const POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS || 1e6;
+		class Operation {
+			run(type, geom, moreGeoms) {
+				operation.type = type;
+				rounder.reset();
+				const multipolys = [new MultiPolyIn(geom, true)];
+				for (let i = 0, iMax = moreGeoms.length; i < iMax; i++) multipolys.push(new MultiPolyIn(moreGeoms[i], false));
+				operation.numMultiPolys = multipolys.length;
+				if (operation.type === "difference") {
+					const subject = multipolys[0];
+					let i = 1;
+					while (i < multipolys.length) if (getBboxOverlap(multipolys[i].bbox, subject.bbox) !== null) i++;
+					else multipolys.splice(i, 1);
+				}
+				if (operation.type === "intersection") for (let i = 0, iMax = multipolys.length; i < iMax; i++) {
+					const mpA = multipolys[i];
+					for (let j = i + 1, jMax = multipolys.length; j < jMax; j++) if (getBboxOverlap(mpA.bbox, multipolys[j].bbox) === null) return [];
+				}
+				const queue = new Tree(SweepEvent.compare);
+				for (let i = 0, iMax = multipolys.length; i < iMax; i++) {
+					const sweepEvents = multipolys[i].getSweepEvents();
+					for (let j = 0, jMax = sweepEvents.length; j < jMax; j++) {
+						queue.insert(sweepEvents[j]);
+						if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) throw new Error("Infinite loop when putting segment endpoints in a priority queue (queue size too big).");
+					}
+				}
+				const sweepLine = new SweepLine(queue);
+				let prevQueueSize = queue.size;
+				let node = queue.pop();
+				while (node) {
+					const evt = node.key;
+					if (queue.size === prevQueueSize) {
+						const seg = evt.segment;
+						throw new Error(`Unable to pop() ${evt.isLeft ? "left" : "right"} SweepEvent [${evt.point.x}, ${evt.point.y}] from segment #${seg.id} [${seg.leftSE.point.x}, ${seg.leftSE.point.y}] -> [${seg.rightSE.point.x}, ${seg.rightSE.point.y}] from queue.`);
+					}
+					if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) throw new Error("Infinite loop when passing sweep line over endpoints (queue size too big).");
+					if (sweepLine.segments.length > POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS) throw new Error("Infinite loop when passing sweep line over endpoints (too many sweep line segments).");
+					const newEvents = sweepLine.process(evt);
+					for (let i = 0, iMax = newEvents.length; i < iMax; i++) {
+						const evt = newEvents[i];
+						if (evt.consumedBy === void 0) queue.insert(evt);
+					}
+					prevQueueSize = queue.size;
+					node = queue.pop();
+				}
+				rounder.reset();
+				return new MultiPolyOut(RingOut.factory(sweepLine.segments)).getGeom();
+			}
+		}
+		const operation = new Operation();
+		const union = function(geom) {
+			for (var _len = arguments.length, moreGeoms = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) moreGeoms[_key - 1] = arguments[_key];
+			return operation.run("union", geom, moreGeoms);
+		};
+		const intersection = function(geom) {
+			for (var _len2 = arguments.length, moreGeoms = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) moreGeoms[_key2 - 1] = arguments[_key2];
+			return operation.run("intersection", geom, moreGeoms);
+		};
+		const xor = function(geom) {
+			for (var _len3 = arguments.length, moreGeoms = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) moreGeoms[_key3 - 1] = arguments[_key3];
+			return operation.run("xor", geom, moreGeoms);
+		};
+		const difference = function(subjectGeom) {
+			for (var _len4 = arguments.length, clippingGeoms = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) clippingGeoms[_key4 - 1] = arguments[_key4];
+			return operation.run("difference", subjectGeom, clippingGeoms);
+		};
+		return {
+			union,
+			intersection,
+			xor,
+			difference
+		};
+	}));
+})))(), 1);
 function drawPoint(ctx, x, y, options = {}) {
 	const { radius = 1 } = options;
 	ctx.moveTo(x, y);
@@ -1926,6 +3894,50 @@ var BoundingBox = class BoundingBox {
 		return new BoundingBox(this.left, this.top, this.width, this.height);
 	}
 };
+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 = import_polygon_clipping_umd.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 = import_polygon_clipping_umd.default.union(a, b);
+			break;
+		case "intersection":
+			res = import_polygon_clipping_umd.default.intersection(a, b);
+			break;
+		case "difference":
+			res = import_polygon_clipping_umd.default.difference(a, b);
+			break;
+		case "xor":
+			res = import_polygon_clipping_umd.default.xor(a, b);
+			break;
+	}
+	return geomToRings(res);
+}
 function catmullRom(t, p0, p1, p2, p3) {
 	const v0 = (p2 - p0) * .5;
 	const v1 = (p3 - p1) * .5;
@@ -2014,27 +4026,209 @@ function parseCssArg(name, value, context = {}) {
 			result.normalizedIntValue = result.intValue;
 			break;
 	}
-	return result;
+	return result;
+}
+function cubicBezierP0(t, p) {
+	const k = 1 - t;
+	return k * k * k * p;
+}
+function cubicBezierP1(t, p) {
+	const k = 1 - t;
+	return 3 * k * k * t * p;
+}
+function cubicBezierP2(t, p) {
+	return 3 * (1 - t) * t * t * p;
+}
+function cubicBezierP3(t, p) {
+	return t * t * t * p;
+}
+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) {
+			if (px < ax + (py - ay) / (by - ay) * (bx - ax)) cn++;
+		}
+	}
+	return cn;
 }
-function cubicBezierP0(t, p) {
-	const k = 1 - t;
-	return k * k * k * p;
+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 cubicBezierP1(t, p) {
-	const k = 1 - t;
-	return 3 * k * k * t * p;
+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 cubicBezierP2(t, p) {
-	return 3 * (1 - t) * t * t * p;
+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 cubicBezierP3(t, p) {
-	return t * t * t * p;
+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 cubicBezier(t, p0, p1, p2, p3) {
-	return cubicBezierP0(t, p0) + cubicBezierP1(t, p1) + cubicBezierP2(t, p2) + cubicBezierP3(t, p3);
+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
+		};
+	});
+}
+var fillDedupeEps = 1e-7;
+function dedupeContours(points, holeIndices, eps) {
+	const total = points.length / 2;
+	const bounds = [
+		0,
+		...holeIndices,
+		total
+	];
+	const out = [];
+	const newHoles = [];
+	for (let s = 0; s < bounds.length - 1; s++) {
+		const start = bounds[s];
+		const end = bounds[s + 1];
+		if (s > 0) newHoles.push(out.length / 2);
+		const segStart = out.length;
+		for (let vi = start; vi < end; vi++) {
+			const x = points[vi * 2];
+			const y = points[vi * 2 + 1];
+			const m = out.length;
+			if (m > segStart && Math.abs(x - out[m - 2]) < eps && Math.abs(y - out[m - 1]) < eps) continue;
+			out.push(x, y);
+		}
+		if (out.length - segStart >= 4 && Math.abs(out[out.length - 2] - out[segStart]) < eps && Math.abs(out[out.length - 1] - out[segStart + 1]) < eps) out.length -= 2;
+	}
+	return {
+		points: out,
+		holes: newHoles
+	};
 }
 function fillTriangulate(pointArray, options = {}) {
 	let { vertices = [], indices = [], holes = [], verticesStride = 2, verticesOffset = vertices.length / verticesStride, indicesOffset = indices.length } = options;
+	({points: pointArray, holes} = dedupeContours(pointArray, holes, fillDedupeEps));
 	const triangles = earcut(pointArray, holes, 2);
 	if (triangles.length) {
 		for (let i = 0; i < triangles.length; i += 3) {
@@ -2150,7 +4344,7 @@ function recursive(points, x1, y1, x2, y2, x3, y3, distanceTolerance, level) {
 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) {
@@ -2169,6 +4363,12 @@ function distance(p1, p2) {
 	const dy = p2[1] - p1[1];
 	return Math.sqrt(dx * dx + dy * dy);
 }
+function selfWindingSign(ring) {
+	let a = 0;
+	const n = ring.length;
+	for (let i = 0, j = n - 2; i < n; j = i, i += 2) a += ring[j] * ring[i + 1] - ring[i] * ring[j + 1];
+	return Math.sign(a);
+}
 function aabbIntersects(a, b) {
 	return a.minX <= b.maxX && a.maxX >= b.minX && a.minY <= b.maxY && a.maxY >= b.minY;
 }
@@ -2253,7 +4453,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);
 			}
@@ -2264,95 +4464,14 @@ function nonzeroFillRule(paths) {
 				dist: distance(testPointsGroups[i][0], testPointsGroups[j][0])
 			});
 		}
-		if (_results.reduce((total, item) => total + item.winding, 0) !== 0) {
+		const containerWinding = _results.reduce((total, item) => total + item.winding, 0);
+		if (_results.length && containerWinding + selfWindingSign(paths[i]) === 0) {
 			_results.sort((a, b) => a.dist - b.dist);
 			results[i] = _results[0];
 		}
 	}
 	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) {
-			if (px < ax + (py - ay) / (by - ay) * (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 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;
@@ -2366,21 +4485,38 @@ function quadraticBezierP2(t, p) {
 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: .5,
+		join: resolveLineJoin(style?.strokeLinejoin),
+		cap: style?.strokeLinecap ?? "butt",
+		miterLimit: style?.strokeMiterlimit ?? 10
+	};
+}
 var closePointEps = 1e-4;
 var curveEps = 1e-4;
 function strokeTriangulate(points, options = {}) {
-	const { vertices = [], indices = [], lineStyle = {
-		alignment: .5,
-		cap: "butt",
-		join: "miter",
-		width: 1,
-		miterLimit: 10
-	}, flipAlignment = false, closed = true } = options;
+	const { vertices = [], indices = [], flipAlignment = false, closed = true } = options;
+	const lineStyle = options.lineStyle ?? resolveLineStyle(options.style);
 	const eps = closePointEps;
 	if (points.length === 0) return {
 		vertices,
 		indices
 	};
+	points = dedupeConsecutivePoints(points, eps);
+	if (points.length < 4) return {
+		vertices,
+		indices
+	};
 	const style = lineStyle;
 	let alignment = style.alignment;
 	if (lineStyle.alignment !== .5) {
@@ -2575,6 +4711,15 @@ function strokeTriangulate(points, options = {}) {
 		indices
 	};
 }
+function dedupeConsecutivePoints(points, eps) {
+	const out = [points[0], points[1]];
+	for (let i = 2; i < points.length; i += 2) {
+		const x = points[i];
+		const y = points[i + 1];
+		if (Math.abs(x - out[out.length - 2]) >= eps || Math.abs(y - out[out.length - 1]) >= eps) out.push(x, y);
+	}
+	return out;
+}
 function getOrientationOfPoints(points) {
 	const m = points.length;
 	if (m < 6) return 1;
@@ -3900,6 +6045,20 @@ var Curve = class {
 	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) => {
@@ -4012,6 +6171,22 @@ var Curve = class {
 	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();
@@ -4099,8 +6274,24 @@ var Curve = class {
 	fillTriangulate(options) {
 		return fillTriangulate(this.getFillVertices(options), 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);
+		return strokeTriangulate(this.getAdaptiveVertices(), {
+			...options,
+			closed: options?.closed ?? this.isClosed()
+		});
 	}
 	toCommands() {
 		const comds = [];
@@ -4198,6 +6389,22 @@ var RoundCurve = class 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;
@@ -4462,7 +6669,18 @@ var RoundCurve = class extends Curve {
 		return output;
 	}
 	getAdaptiveVertices(output = []) {
-		if (this.startAngle === 0 && this.endAngle === Math.PI * 2) return this._getAdaptiveVerticesByCircle(output);
+		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) {
@@ -4627,6 +6845,13 @@ var LineCurve = class LineCurve extends Curve {
 	getControlPointRefs() {
 		return [this.p1, this.p2];
 	}
+	reverse() {
+		const { p1, p2 } = this;
+		this.p1 = p2;
+		this.p2 = p1;
+		this.invalidate();
+		return this;
+	}
 	getAdaptiveVertices(output = []) {
 		output.push(this.p1.x, this.p1.y, this.p2.x, this.p2.y);
 		return output;
@@ -4775,10 +7000,25 @@ var CompositeCurve = 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);
 		else 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);
 		else {
@@ -4854,6 +7094,15 @@ var CubicBezierCurve = class CubicBezierCurve extends Curve {
 			this.p2
 		];
 	}
+	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) return [];
@@ -4950,6 +7199,13 @@ var QuadraticBezierCurve = class QuadraticBezierCurve extends Curve {
 			this.p2
 		];
 	}
+	reverse() {
+		const { p1, p2 } = this;
+		this.p1 = p2;
+		this.p2 = p1;
+		this.invalidate();
+		return this;
+	}
 	getAdaptiveVertices(output = []) {
 		return getAdaptiveQuadraticBezierCurvePoints(this.p1.x, this.p1.y, this.cp.x, this.cp.y, this.p2.x, this.p2.y, .5, output);
 	}
@@ -5134,6 +7390,11 @@ var SplineCurve = class extends Curve {
 	getControlPointRefs() {
 		return this.points;
 	}
+	reverse() {
+		this.points.reverse();
+		this.invalidate();
+		return this;
+	}
 	copyFrom(source) {
 		super.copyFrom(source);
 		this.points = [];
@@ -5165,6 +7426,22 @@ var CurvePath = class 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]);
 		return output;
@@ -5540,6 +7817,48 @@ var Path2D = 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.
 	*
@@ -5599,7 +7918,7 @@ var Path2D = class Path2D extends CompositeCurve {
 		};
 		const indices = _options.indices ?? [];
 		const vertices = _options.vertices ?? [];
-		if ((_options.style.fillRule ?? "nonzero") === "nonzero") {
+		if ((options?.fillRule ?? _options.style.fillRule ?? "nonzero") === "nonzero") {
 			const paths = this.curves.map((curve) => curve.getFillVertices(_options));
 			const groups = nonzeroFillRule(paths);
 			const groupsLen = groups.length;
@@ -5624,14 +7943,28 @@ var Path2D = class Path2D extends CompositeCurve {
 					style: { ...this.style }
 				});
 			}
-		} else this.curves.forEach((curve) => {
-			curve.fillTriangulate({
-				...options,
-				indices,
-				vertices,
-				style: { ...this.style }
-			});
-		});
+		} else {
+			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
@@ -5646,14 +7979,14 @@ var Path2D = class Path2D extends CompositeCurve {
 			...this.style,
 			...style
 		};
-		const { fill = "#000", stroke = "none" } = style;
+		const { fill = "#000", stroke = "none", fillRule = "nonzero" } = style;
 		ctx.beginPath();
 		ctx.save();
 		setCanvasContext(ctx, style);
 		this.curves.forEach((path) => {
 			path.drawTo(ctx);
 		});
-		if (fill !== "none") ctx.fill();
+		if (fill !== "none") ctx.fill(fillRule);
 		if (stroke !== "none") ctx.stroke();
 		ctx.restore();
 		return this;