node-red-contrib-tak-registration 0.16.1 → 0.16.5

package/node_modules/polyclip-ts/dist/cjs/index.cjs

@@ -1,1179 +0,0 @@
-"use strict";
-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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  difference: () => difference,
-  intersection: () => intersection2,
-  setPrecision: () => setPrecision,
-  union: () => union,
-  xor: () => xor
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/geom-in.ts
-var import_bignumber2 = __toESM(require("bignumber.js"), 1);
-
-// src/constant.ts
-var constant_default = (x) => {
-  return () => {
-    return x;
-  };
-};
-
-// src/compare.ts
-var compare_default = (eps) => {
-  const almostEqual = eps ? (a, b) => b.minus(a).abs().isLessThanOrEqualTo(eps) : constant_default(false);
-  return (a, b) => {
-    if (almostEqual(a, b)) return 0;
-    return a.comparedTo(b);
-  };
-};
-
-// src/orient.ts
-function orient_default(eps) {
-  const almostCollinear = eps ? (area2, ax, ay, cx, cy) => area2.exponentiatedBy(2).isLessThanOrEqualTo(
-    cx.minus(ax).exponentiatedBy(2).plus(cy.minus(ay).exponentiatedBy(2)).times(eps)
-  ) : constant_default(false);
-  return (a, b, c) => {
-    const ax = a.x, ay = a.y, cx = c.x, cy = c.y;
-    const area2 = ay.minus(cy).times(b.x.minus(cx)).minus(ax.minus(cx).times(b.y.minus(cy)));
-    if (almostCollinear(area2, ax, ay, cx, cy)) return 0;
-    return area2.comparedTo(0);
-  };
-}
-
-// src/snap.ts
-var import_bignumber = __toESM(require("bignumber.js"), 1);
-var import_splaytree_ts = require("splaytree-ts");
-
-// src/identity.ts
-var identity_default = (x) => {
-  return x;
-};
-
-// src/snap.ts
-var snap_default = (eps) => {
-  if (eps) {
-    const xTree = new import_splaytree_ts.SplayTreeSet(compare_default(eps));
-    const yTree = new import_splaytree_ts.SplayTreeSet(compare_default(eps));
-    const snapCoord = (coord, tree) => {
-      return tree.addAndReturn(coord);
-    };
-    const snap = (v) => {
-      return {
-        x: snapCoord(v.x, xTree),
-        y: snapCoord(v.y, yTree)
-      };
-    };
-    snap({ x: new import_bignumber.default(0), y: new import_bignumber.default(0) });
-    return snap;
-  }
-  return identity_default;
-};
-
-// src/precision.ts
-var set = (eps) => {
-  return {
-    set: (eps2) => {
-      precision = set(eps2);
-    },
-    reset: () => set(eps),
-    compare: compare_default(eps),
-    snap: snap_default(eps),
-    orient: orient_default(eps)
-  };
-};
-var precision = set();
-
-// src/bbox.ts
-var isInBbox = (bbox, point) => {
-  return bbox.ll.x.isLessThanOrEqualTo(point.x) && point.x.isLessThanOrEqualTo(bbox.ur.x) && bbox.ll.y.isLessThanOrEqualTo(point.y) && point.y.isLessThanOrEqualTo(bbox.ur.y);
-};
-var getBboxOverlap = (b1, b2) => {
-  if (b2.ur.x.isLessThan(b1.ll.x) || b1.ur.x.isLessThan(b2.ll.x) || b2.ur.y.isLessThan(b1.ll.y) || b1.ur.y.isLessThan(b2.ll.y))
-    return null;
-  const lowerX = b1.ll.x.isLessThan(b2.ll.x) ? b2.ll.x : b1.ll.x;
-  const upperX = b1.ur.x.isLessThan(b2.ur.x) ? b1.ur.x : b2.ur.x;
-  const lowerY = b1.ll.y.isLessThan(b2.ll.y) ? b2.ll.y : b1.ll.y;
-  const upperY = b1.ur.y.isLessThan(b2.ur.y) ? b1.ur.y : b2.ur.y;
-  return { ll: { x: lowerX, y: lowerY }, ur: { x: upperX, y: upperY } };
-};
-
-// src/operation.ts
-var import_splaytree_ts3 = require("splaytree-ts");
-
-// src/vector.ts
-var crossProduct = (a, b) => a.x.times(b.y).minus(a.y.times(b.x));
-var dotProduct = (a, b) => a.x.times(b.x).plus(a.y.times(b.y));
-var length = (v) => dotProduct(v, v).sqrt();
-var sineOfAngle = (pShared, pBase, pAngle) => {
-  const vBase = { x: pBase.x.minus(pShared.x), y: pBase.y.minus(pShared.y) };
-  const vAngle = { x: pAngle.x.minus(pShared.x), y: pAngle.y.minus(pShared.y) };
-  return crossProduct(vAngle, vBase).div(length(vAngle)).div(length(vBase));
-};
-var cosineOfAngle = (pShared, pBase, pAngle) => {
-  const vBase = { x: pBase.x.minus(pShared.x), y: pBase.y.minus(pShared.y) };
-  const vAngle = { x: pAngle.x.minus(pShared.x), y: pAngle.y.minus(pShared.y) };
-  return dotProduct(vAngle, vBase).div(length(vAngle)).div(length(vBase));
-};
-var horizontalIntersection = (pt, v, y) => {
-  if (v.y.isZero()) return null;
-  return { x: pt.x.plus(v.x.div(v.y).times(y.minus(pt.y))), y };
-};
-var verticalIntersection = (pt, v, x) => {
-  if (v.x.isZero()) return null;
-  return { x, y: pt.y.plus(v.y.div(v.x).times(x.minus(pt.x))) };
-};
-var intersection = (pt1, v1, pt2, v2) => {
-  if (v1.x.isZero()) return verticalIntersection(pt2, v2, pt1.x);
-  if (v2.x.isZero()) return verticalIntersection(pt1, v1, pt2.x);
-  if (v1.y.isZero()) return horizontalIntersection(pt2, v2, pt1.y);
-  if (v2.y.isZero()) return horizontalIntersection(pt1, v1, pt2.y);
-  const kross = crossProduct(v1, v2);
-  if (kross.isZero()) return null;
-  const ve = { x: pt2.x.minus(pt1.x), y: pt2.y.minus(pt1.y) };
-  const d1 = crossProduct(ve, v1).div(kross);
-  const d2 = crossProduct(ve, v2).div(kross);
-  const x1 = pt1.x.plus(d2.times(v1.x)), x2 = pt2.x.plus(d1.times(v2.x));
-  const y1 = pt1.y.plus(d2.times(v1.y)), y2 = pt2.y.plus(d1.times(v2.y));
-  const x = x1.plus(x2).div(2);
-  const y = y1.plus(y2).div(2);
-  return { x, y };
-};
-
-// src/sweep-event.ts
-var SweepEvent = class _SweepEvent {
-  point;
-  isLeft;
-  segment;
-  otherSE;
-  consumedBy;
-  // for ordering sweep events in the sweep event queue
-  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);
-  }
-  // for ordering points in sweep line order
-  static comparePoints(aPt, bPt) {
-    if (aPt.x.isLessThan(bPt.x)) return -1;
-    if (aPt.x.isGreaterThan(bPt.x)) return 1;
-    if (aPt.y.isLessThan(bPt.y)) return -1;
-    if (aPt.y.isGreaterThan(bPt.y)) return 1;
-    return 0;
-  }
-  // Warning: 'point' input will be modified and re-used (for performance)
-  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();
-  }
-  /* Do a pass over our linked events and check to see if any pair
-   * of segments match, and should be consumed. */
-  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.isGreaterThanOrEqualTo(0) && bsine.isGreaterThanOrEqualTo(0)) {
-        if (acosine.isLessThan(bcosine)) return 1;
-        if (acosine.isGreaterThan(bcosine)) return -1;
-        return 0;
-      }
-      if (asine.isLessThan(0) && bsine.isLessThan(0)) {
-        if (acosine.isLessThan(bcosine)) return -1;
-        if (acosine.isGreaterThan(bcosine)) return 1;
-        return 0;
-      }
-      if (bsine.isLessThan(asine)) return -1;
-      if (bsine.isGreaterThan(asine)) return 1;
-      return 0;
-    };
-  }
-};
-
-// src/geom-out.ts
-var RingOut = class _RingOut {
-  events;
-  poly;
-  _isExteriorRing;
-  _enclosingRing;
-  /* Given the segments from the sweep line pass, compute & return a series
-   * of closed rings from all the segments marked to be part of the result */
-  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 pt2 = this.events[i].point;
-      const nextPt2 = this.events[i + 1].point;
-      if (precision.orient(pt2, prevPt, nextPt2) === 0) continue;
-      points.push(pt2);
-      prevPt = pt2;
-    }
-    if (points.length === 1) return null;
-    const pt = points[0];
-    const nextPt = points[1];
-    if (precision.orient(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.toNumber(), points[i].y.toNumber()]);
-    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;
-  }
-  /* Returns the ring that encloses this one, if any */
-  _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;
-    }
-  }
-};
-var PolyOut = class {
-  exteriorRing;
-  interiorRings;
-  constructor(exteriorRing) {
-    this.exteriorRing = exteriorRing;
-    exteriorRing.poly = this;
-    this.interiorRings = [];
-  }
-  addInterior(ring) {
-    this.interiorRings.push(ring);
-    ring.poly = this;
-  }
-  getGeom() {
-    const geom0 = this.exteriorRing.getGeom();
-    if (geom0 === null) return null;
-    const geom = [geom0];
-    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;
-  }
-};
-var MultiPolyOut = class {
-  rings;
-  polys;
-  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;
-  }
-};
-
-// src/sweep-line.ts
-var import_splaytree_ts2 = require("splaytree-ts");
-var SweepLine = class {
-  queue;
-  tree;
-  segments;
-  constructor(queue, comparator = Segment.compare) {
-    this.queue = queue;
-    this.tree = new import_splaytree_ts2.SplayTreeSet(comparator);
-    this.segments = [];
-  }
-  process(event) {
-    const segment = event.segment;
-    const newEvents = [];
-    if (event.consumedBy) {
-      if (event.isLeft) this.queue.delete(event.otherSE);
-      else this.tree.delete(segment);
-      return newEvents;
-    }
-    if (event.isLeft) this.tree.add(segment);
-    let prevSeg = segment;
-    let nextSeg = segment;
-    do {
-      prevSeg = this.tree.lastBefore(prevSeg);
-    } while (prevSeg != null && prevSeg.consumedBy != void 0);
-    do {
-      nextSeg = this.tree.firstAfter(nextSeg);
-    } while (nextSeg != null && nextSeg.consumedBy != void 0);
-    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 {
-          const cmpSplitters = SweepEvent.comparePoints(
-            prevMySplitter,
-            nextMySplitter
-          );
-          mySplitter = cmpSplitters <= 0 ? prevMySplitter : nextMySplitter;
-        }
-        this.queue.delete(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.delete(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.delete(segment);
-    }
-    return newEvents;
-  }
-  /* Safely split a segment that is currently in the datastructures
-   * IE - a segment other than the one that is currently being processed. */
-  _splitSafely(seg, pt) {
-    this.tree.delete(seg);
-    const rightSE = seg.rightSE;
-    this.queue.delete(rightSE);
-    const newEvents = seg.split(pt);
-    newEvents.push(rightSE);
-    if (seg.consumedBy === void 0) this.tree.add(seg);
-    return newEvents;
-  }
-};
-
-// src/operation.ts
-var Operation = class {
-  type;
-  numMultiPolys;
-  run(type, geom, moreGeoms) {
-    operation.type = type;
-    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 import_splaytree_ts3.SplayTreeSet(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.add(sweepEvents[j]);
-      }
-    }
-    const sweepLine = new SweepLine(queue);
-    let evt = null;
-    if (queue.size != 0) {
-      evt = queue.first();
-      queue.delete(evt);
-    }
-    while (evt) {
-      const newEvents = sweepLine.process(evt);
-      for (let i = 0, iMax = newEvents.length; i < iMax; i++) {
-        const evt2 = newEvents[i];
-        if (evt2.consumedBy === void 0) queue.add(evt2);
-      }
-      if (queue.size != 0) {
-        evt = queue.first();
-        queue.delete(evt);
-      } else {
-        evt = null;
-      }
-    }
-    precision.reset();
-    const ringsOut = RingOut.factory(sweepLine.segments);
-    const result = new MultiPolyOut(ringsOut);
-    return result.getGeom();
-  }
-};
-var operation = new Operation();
-var operation_default = operation;
-
-// src/segment.ts
-var segmentId = 0;
-var Segment = class _Segment {
-  id;
-  leftSE;
-  rightSE;
-  rings;
-  windings;
-  ringOut;
-  consumedBy;
-  prev;
-  _prevInResult;
-  _beforeState;
-  _afterState;
-  _isInResult;
-  /* This compare() function is for ordering segments in the sweep
-   * line tree, and does so according to the following criteria:
-   *
-   * Consider the vertical line that lies an infinestimal step to the
-   * right of the right-more of the two left endpoints of the input
-   * segments. Imagine slowly moving a point up from negative infinity
-   * in the increasing y direction. Which of the two segments will that
-   * point intersect first? That segment comes 'before' the other one.
-   *
-   * If neither segment would be intersected by such a line, (if one
-   * or more of the segments are vertical) then the line to be considered
-   * is directly on the right-more of the two left inputs.
-   */
-  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.isLessThan(alx)) return 1;
-    if (arx.isLessThan(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.isLessThan(blx)) {
-      if (bly.isLessThan(aly) && bly.isLessThan(ary)) return 1;
-      if (bly.isGreaterThan(aly) && bly.isGreaterThan(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.isGreaterThan(blx)) {
-      if (aly.isLessThan(bly) && aly.isLessThan(bry)) return -1;
-      if (aly.isGreaterThan(bly) && aly.isGreaterThan(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.isLessThan(bly)) return -1;
-    if (aly.isGreaterThan(bly)) return 1;
-    if (arx.isLessThan(brx)) {
-      const bCmpARight = b.comparePoint(a.rightSE.point);
-      if (bCmpARight !== 0) return bCmpARight;
-    }
-    if (arx.isGreaterThan(brx)) {
-      const aCmpBRight = a.comparePoint(b.rightSE.point);
-      if (aCmpBRight < 0) return 1;
-      if (aCmpBRight > 0) return -1;
-    }
-    if (!arx.eq(brx)) {
-      const ay = ary.minus(aly);
-      const ax = arx.minus(alx);
-      const by = bry.minus(bly);
-      const bx = brx.minus(blx);
-      if (ay.isGreaterThan(ax) && by.isLessThan(bx)) return 1;
-      if (ay.isLessThan(ax) && by.isGreaterThan(bx)) return -1;
-    }
-    if (arx.isGreaterThan(brx)) return 1;
-    if (arx.isLessThan(brx)) return -1;
-    if (ary.isLessThan(bry)) return -1;
-    if (ary.isGreaterThan(bry)) return 1;
-    if (a.id < b.id) return -1;
-    if (a.id > b.id) return 1;
-    return 0;
-  }
-  /* Warning: a reference to ringWindings input will be stored,
-   *  and possibly will be later modified */
-  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}]`
-      );
-    const leftSE = new SweepEvent(leftPt, true);
-    const rightSE = new SweepEvent(rightPt, false);
-    return new _Segment(leftSE, rightSE, [ring], [winding]);
-  }
-  /* When a segment is split, the rightSE is replaced with a new sweep event */
-  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.isLessThan(y2) ? y1 : y2 },
-      ur: { x: this.rightSE.point.x, y: y1.isGreaterThan(y2) ? y1 : y2 }
-    };
-  }
-  /* A vector from the left point to the right */
-  vector() {
-    return {
-      x: this.rightSE.point.x.minus(this.leftSE.point.x),
-      y: this.rightSE.point.y.minus(this.leftSE.point.y)
-    };
-  }
-  isAnEndpoint(pt) {
-    return pt.x.eq(this.leftSE.point.x) && pt.y.eq(this.leftSE.point.y) || pt.x.eq(this.rightSE.point.x) && pt.y.eq(this.rightSE.point.y);
-  }
-  /* Compare this segment with a point.
-   *
-   * A point P is considered to be colinear to a segment if there
-   * exists a distance D such that if we travel along the segment
-   * from one * endpoint towards the other a distance D, we find
-   * ourselves at point P.
-   *
-   * Return value indicates:
-   *
-   *   1: point lies above the segment (to the left of vertical)
-   *   0: point is colinear to segment
-   *  -1: point lies below the segment (to the right of vertical)
-   */
-  comparePoint(point) {
-    return precision.orient(this.leftSE.point, point, this.rightSE.point);
-  }
-  /**
-   * 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.eq(orp.x) && tlp.y.eq(orp.y)) return null;
-      }
-      return tlp;
-    }
-    if (touchesOtherLSE) {
-      if (touchesThisRSE) {
-        if (trp.x.eq(olp.x) && trp.y.eq(olp.y)) return null;
-      }
-      return olp;
-    }
-    if (touchesThisRSE && touchesOtherRSE) return null;
-    if (touchesThisRSE) return trp;
-    if (touchesOtherRSE) return orp;
-    const pt = intersection(tlp, this.vector(), olp, other.vector());
-    if (pt === null) return null;
-    if (!isInBbox(bboxOverlap, pt)) return null;
-    return precision.snap(pt);
-  }
-  /**
-   * 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;
-  }
-  /* Swap which event is left and right */
-  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 another segment. We take their rings under our wing
-   * and mark them as consumed. Use for perfectly overlapping segments */
-  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;
-  }
-  /* The first segment previous segment chain that is in the result */
-  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;
-  }
-  /* Is this segment part of the final result? */
-  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_default.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_default.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;
-      }
-    }
-    return this._isInResult;
-  }
-};
-
-// src/geom-in.ts
-var RingIn = class {
-  poly;
-  isExterior;
-  segments;
-  bbox;
-  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 = precision.snap({ x: new import_bignumber2.default(geomRing[0][0]), y: new import_bignumber2.default(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");
-      }
-      const point = precision.snap({ x: new import_bignumber2.default(geomRing[i][0]), y: new import_bignumber2.default(geomRing[i][1]) });
-      if (point.x.eq(prevPoint.x) && point.y.eq(prevPoint.y)) continue;
-      this.segments.push(Segment.fromRing(prevPoint, point, this));
-      if (point.x.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = point.x;
-      if (point.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = point.y;
-      if (point.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = point.x;
-      if (point.y.isGreaterThan(this.bbox.ur.y)) this.bbox.ur.y = point.y;
-      prevPoint = point;
-    }
-    if (!firstPoint.x.eq(prevPoint.x) || !firstPoint.y.eq(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;
-  }
-};
-var PolyIn = class {
-  multiPoly;
-  exteriorRing;
-  interiorRings;
-  bbox;
-  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.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = ring.bbox.ll.x;
-      if (ring.bbox.ll.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = ring.bbox.ll.y;
-      if (ring.bbox.ur.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = ring.bbox.ur.x;
-      if (ring.bbox.ur.y.isGreaterThan(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;
-  }
-};
-var MultiPolyIn = class {
-  isSubject;
-  polys;
-  bbox;
-  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: new import_bignumber2.default(Number.POSITIVE_INFINITY), y: new import_bignumber2.default(Number.POSITIVE_INFINITY) },
-      ur: { x: new import_bignumber2.default(Number.NEGATIVE_INFINITY), y: new import_bignumber2.default(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.isLessThan(this.bbox.ll.x)) this.bbox.ll.x = poly.bbox.ll.x;
-      if (poly.bbox.ll.y.isLessThan(this.bbox.ll.y)) this.bbox.ll.y = poly.bbox.ll.y;
-      if (poly.bbox.ur.x.isGreaterThan(this.bbox.ur.x)) this.bbox.ur.x = poly.bbox.ur.x;
-      if (poly.bbox.ur.y.isGreaterThan(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;
-  }
-};
-
-// src/index.ts
-var union = (geom, ...moreGeoms) => operation_default.run("union", geom, moreGeoms);
-var intersection2 = (geom, ...moreGeoms) => operation_default.run("intersection", geom, moreGeoms);
-var xor = (geom, ...moreGeoms) => operation_default.run("xor", geom, moreGeoms);
-var difference = (geom, ...moreGeoms) => operation_default.run("difference", geom, moreGeoms);
-var setPrecision = precision.set;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  difference,
-  intersection,
-  setPrecision,
-  union,
-  xor
-});
-//# sourceMappingURL=index.cjs.map