@basemaps/landing 6.41.0 → 6.44.0

package/dist/lib/attribution-6.41.0-f0099e1099a7c0ac.js

@@ -1,2330 +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 __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-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(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// ../../node_modules/lineclip/index.js
-var require_lineclip = __commonJS({
-  "../../node_modules/lineclip/index.js"(exports, module2) {
-    "use strict";
-    module2.exports = lineclip2;
-    lineclip2.polyline = lineclip2;
-    lineclip2.polygon = polygonclip;
-    function lineclip2(points, bbox, result) {
-      var len = points.length, codeA = bitCode(points[0], bbox), part = [], i, a, b, codeB, lastCode;
-      if (!result)
-        result = [];
-      for (i = 1; i < len; i++) {
-        a = points[i - 1];
-        b = points[i];
-        codeB = lastCode = bitCode(b, bbox);
-        while (true) {
-          if (!(codeA | codeB)) {
-            part.push(a);
-            if (codeB !== lastCode) {
-              part.push(b);
-              if (i < len - 1) {
-                result.push(part);
-                part = [];
-              }
-            } else if (i === len - 1) {
-              part.push(b);
-            }
-            break;
-          } else if (codeA & codeB) {
-            break;
-          } else if (codeA) {
-            a = intersect(a, b, codeA, bbox);
-            codeA = bitCode(a, bbox);
-          } else {
-            b = intersect(a, b, codeB, bbox);
-            codeB = bitCode(b, bbox);
-          }
-        }
-        codeA = lastCode;
-      }
-      if (part.length)
-        result.push(part);
-      return result;
-    }
-    function polygonclip(points, bbox) {
-      var result, edge, prev, prevInside, i, p, inside;
-      for (edge = 1; edge <= 8; edge *= 2) {
-        result = [];
-        prev = points[points.length - 1];
-        prevInside = !(bitCode(prev, bbox) & edge);
-        for (i = 0; i < points.length; i++) {
-          p = points[i];
-          inside = !(bitCode(p, bbox) & edge);
-          if (inside !== prevInside)
-            result.push(intersect(prev, p, edge, bbox));
-          if (inside)
-            result.push(p);
-          prev = p;
-          prevInside = inside;
-        }
-        points = result;
-        if (!points.length)
-          break;
-      }
-      return result;
-    }
-    function intersect(a, b, edge, bbox) {
-      return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox[3] - a[1]) / (b[1] - a[1]), bbox[3]] : edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox[1] - a[1]) / (b[1] - a[1]), bbox[1]] : edge & 2 ? [bbox[2], a[1] + (b[1] - a[1]) * (bbox[2] - a[0]) / (b[0] - a[0])] : edge & 1 ? [bbox[0], a[1] + (b[1] - a[1]) * (bbox[0] - a[0]) / (b[0] - a[0])] : null;
-    }
-    function bitCode(p, bbox) {
-      var code = 0;
-      if (p[0] < bbox[0])
-        code |= 1;
-      else if (p[0] > bbox[2])
-        code |= 2;
-      if (p[1] < bbox[1])
-        code |= 4;
-      else if (p[1] > bbox[3])
-        code |= 8;
-      return code;
-    }
-  }
-});
-
-// ../../node_modules/polygon-clipping/dist/polygon-clipping.umd.js
-var require_polygon_clipping_umd = __commonJS({
-  "../../node_modules/polygon-clipping/dist/polygon-clipping.umd.js"(exports, module2) {
-    (function(global, factory) {
-      typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.polygonClipping = factory());
-    })(exports, function() {
-      "use strict";
-      function _classCallCheck(instance, Constructor) {
-        if (!(instance instanceof Constructor)) {
-          throw new TypeError("Cannot call a class as a function");
-        }
-      }
-      function _defineProperties(target, props) {
-        for (var i = 0; i < props.length; i++) {
-          var descriptor = props[i];
-          descriptor.enumerable = descriptor.enumerable || false;
-          descriptor.configurable = true;
-          if ("value" in descriptor)
-            descriptor.writable = true;
-          Object.defineProperty(target, descriptor.key, descriptor);
-        }
-      }
-      function _createClass(Constructor, protoProps, staticProps) {
-        if (protoProps)
-          _defineProperties(Constructor.prototype, protoProps);
-        if (staticProps)
-          _defineProperties(Constructor, staticProps);
-        return Constructor;
-      }
-      var Node = function() {
-        function Node2(key, data) {
-          this.next = null;
-          this.key = key;
-          this.data = data;
-          this.left = null;
-          this.right = null;
-        }
-        return Node2;
-      }();
-      function DEFAULT_COMPARE(a, b) {
-        return a > b ? 1 : a < b ? -1 : 0;
-      }
-      function splay(i, t, comparator) {
-        var N = new Node(null, null);
-        var l = N;
-        var r = N;
-        while (true) {
-          var cmp2 = comparator(i, t.key);
-          if (cmp2 < 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 (cmp2 > 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 cmp2 = comparator(i, t.key);
-        if (cmp2 < 0) {
-          node.left = t.left;
-          node.right = t;
-          t.left = null;
-        } else if (cmp2 >= 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 cmp2 = comparator(v.key, key);
-          if (cmp2 === 0) {
-            left = v.left;
-            right = v.right;
-          } else if (cmp2 < 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;
-      }
-      function printRow(root, prefix, isTail, out, printNode) {
-        if (root) {
-          out("" + prefix + (isTail ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ") + printNode(root) + "\n");
-          var indent = prefix + (isTail ? "    " : "\u2502   ");
-          if (root.left)
-            printRow(root.left, indent, false, out, printNode);
-          if (root.right)
-            printRow(root.right, indent, true, out, printNode);
-        }
-      }
-      var Tree = function() {
-        function Tree2(comparator) {
-          if (comparator === void 0) {
-            comparator = DEFAULT_COMPARE;
-          }
-          this._root = null;
-          this._size = 0;
-          this._comparator = comparator;
-        }
-        Tree2.prototype.insert = function(key, data) {
-          this._size++;
-          return this._root = insert(key, data, this._root, this._comparator);
-        };
-        Tree2.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 cmp2 = comparator(key, t.key);
-          if (cmp2 === 0)
-            this._root = t;
-          else {
-            if (cmp2 < 0) {
-              node.left = t.left;
-              node.right = t;
-              t.left = null;
-            } else if (cmp2 > 0) {
-              node.right = t.right;
-              node.left = t;
-              t.right = null;
-            }
-            this._size++;
-            this._root = node;
-          }
-          return this._root;
-        };
-        Tree2.prototype.remove = function(key) {
-          this._root = this._remove(key, this._root, this._comparator);
-        };
-        Tree2.prototype._remove = function(i, t, comparator) {
-          var x;
-          if (t === null)
-            return null;
-          t = splay(i, t, comparator);
-          var cmp2 = comparator(i, t.key);
-          if (cmp2 === 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;
-        };
-        Tree2.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;
-        };
-        Tree2.prototype.findStatic = function(key) {
-          var current = this._root;
-          var compare = this._comparator;
-          while (current) {
-            var cmp2 = compare(key, current.key);
-            if (cmp2 === 0)
-              return current;
-            else if (cmp2 < 0)
-              current = current.left;
-            else
-              current = current.right;
-          }
-          return null;
-        };
-        Tree2.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;
-        };
-        Tree2.prototype.contains = function(key) {
-          var current = this._root;
-          var compare = this._comparator;
-          while (current) {
-            var cmp2 = compare(key, current.key);
-            if (cmp2 === 0)
-              return true;
-            else if (cmp2 < 0)
-              current = current.left;
-            else
-              current = current.right;
-          }
-          return false;
-        };
-        Tree2.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;
-        };
-        Tree2.prototype.range = function(low, high, fn, ctx) {
-          var Q = [];
-          var compare = this._comparator;
-          var node = this._root;
-          var cmp2;
-          while (Q.length !== 0 || node) {
-            if (node) {
-              Q.push(node);
-              node = node.left;
-            } else {
-              node = Q.pop();
-              cmp2 = compare(node.key, high);
-              if (cmp2 > 0) {
-                break;
-              } else if (compare(node.key, low) >= 0) {
-                if (fn.call(ctx, node))
-                  return this;
-              }
-              node = node.right;
-            }
-          }
-          return this;
-        };
-        Tree2.prototype.keys = function() {
-          var keys = [];
-          this.forEach(function(_a) {
-            var key = _a.key;
-            return keys.push(key);
-          });
-          return keys;
-        };
-        Tree2.prototype.values = function() {
-          var values = [];
-          this.forEach(function(_a) {
-            var data = _a.data;
-            return values.push(data);
-          });
-          return values;
-        };
-        Tree2.prototype.min = function() {
-          if (this._root)
-            return this.minNode(this._root).key;
-          return null;
-        };
-        Tree2.prototype.max = function() {
-          if (this._root)
-            return this.maxNode(this._root).key;
-          return null;
-        };
-        Tree2.prototype.minNode = function(t) {
-          if (t === void 0) {
-            t = this._root;
-          }
-          if (t)
-            while (t.left) {
-              t = t.left;
-            }
-          return t;
-        };
-        Tree2.prototype.maxNode = function(t) {
-          if (t === void 0) {
-            t = this._root;
-          }
-          if (t)
-            while (t.right) {
-              t = t.right;
-            }
-          return t;
-        };
-        Tree2.prototype.at = function(index2) {
-          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 === index2)
-                  return current;
-                i++;
-                current = current.right;
-              } else
-                done = true;
-            }
-          }
-          return null;
-        };
-        Tree2.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 cmp2 = comparator(d.key, root.key);
-            if (cmp2 === 0)
-              break;
-            else if (cmp2 < 0) {
-              successor = root;
-              root = root.left;
-            } else
-              root = root.right;
-          }
-          return successor;
-        };
-        Tree2.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 cmp2 = comparator(d.key, root.key);
-            if (cmp2 === 0)
-              break;
-            else if (cmp2 < 0)
-              root = root.left;
-            else {
-              predecessor = root;
-              root = root.right;
-            }
-          }
-          return predecessor;
-        };
-        Tree2.prototype.clear = function() {
-          this._root = null;
-          this._size = 0;
-          return this;
-        };
-        Tree2.prototype.toList = function() {
-          return toList(this._root);
-        };
-        Tree2.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;
-        };
-        Tree2.prototype.isEmpty = function() {
-          return this._root === null;
-        };
-        Object.defineProperty(Tree2.prototype, "size", {
-          get: function get() {
-            return this._size;
-          },
-          enumerable: true,
-          configurable: true
-        });
-        Object.defineProperty(Tree2.prototype, "root", {
-          get: function get() {
-            return this._root;
-          },
-          enumerable: true,
-          configurable: true
-        });
-        Tree2.prototype.toString = function(printNode) {
-          if (printNode === void 0) {
-            printNode = function printNode2(n) {
-              return String(n.key);
-            };
-          }
-          var out = [];
-          printRow(this._root, "", true, function(v) {
-            return out.push(v);
-          }, printNode);
-          return out.join("");
-        };
-        Tree2.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);
-        };
-        Tree2.prototype.split = function(key) {
-          return split(key, this._root, this._comparator);
-        };
-        return Tree2;
-      }();
-      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);
-      }
-      var isInBbox = function isInBbox2(bbox, point) {
-        return bbox.ll.x <= point.x && point.x <= bbox.ur.x && bbox.ll.y <= point.y && point.y <= bbox.ur.y;
-      };
-      var getBboxOverlap = function getBboxOverlap2(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;
-        var lowerX = b1.ll.x < b2.ll.x ? b2.ll.x : b1.ll.x;
-        var upperX = b1.ur.x < b2.ur.x ? b1.ur.x : b2.ur.x;
-        var lowerY = b1.ll.y < b2.ll.y ? b2.ll.y : b1.ll.y;
-        var upperY = b1.ur.y < b2.ur.y ? b1.ur.y : b2.ur.y;
-        return {
-          ll: {
-            x: lowerX,
-            y: lowerY
-          },
-          ur: {
-            x: upperX,
-            y: upperY
-          }
-        };
-      };
-      var epsilon = Number.EPSILON;
-      if (epsilon === void 0)
-        epsilon = Math.pow(2, -52);
-      var EPSILON_SQ = epsilon * epsilon;
-      var cmp = function cmp2(a, b) {
-        if (-epsilon < a && a < epsilon) {
-          if (-epsilon < b && b < epsilon) {
-            return 0;
-          }
-        }
-        var ab = a - b;
-        if (ab * ab < EPSILON_SQ * a * b) {
-          return 0;
-        }
-        return a < b ? -1 : 1;
-      };
-      var PtRounder = /* @__PURE__ */ function() {
-        function PtRounder2() {
-          _classCallCheck(this, PtRounder2);
-          this.reset();
-        }
-        _createClass(PtRounder2, [{
-          key: "reset",
-          value: function reset() {
-            this.xRounder = new CoordRounder();
-            this.yRounder = new CoordRounder();
-          }
-        }, {
-          key: "round",
-          value: function round(x, y) {
-            return {
-              x: this.xRounder.round(x),
-              y: this.yRounder.round(y)
-            };
-          }
-        }]);
-        return PtRounder2;
-      }();
-      var CoordRounder = /* @__PURE__ */ function() {
-        function CoordRounder2() {
-          _classCallCheck(this, CoordRounder2);
-          this.tree = new Tree();
-          this.round(0);
-        }
-        _createClass(CoordRounder2, [{
-          key: "round",
-          value: function round(coord) {
-            var node = this.tree.add(coord);
-            var prevNode = this.tree.prev(node);
-            if (prevNode !== null && cmp(node.key, prevNode.key) === 0) {
-              this.tree.remove(coord);
-              return prevNode.key;
-            }
-            var nextNode = this.tree.next(node);
-            if (nextNode !== null && cmp(node.key, nextNode.key) === 0) {
-              this.tree.remove(coord);
-              return nextNode.key;
-            }
-            return coord;
-          }
-        }]);
-        return CoordRounder2;
-      }();
-      var rounder = new PtRounder();
-      var crossProduct = function crossProduct2(a, b) {
-        return a.x * b.y - a.y * b.x;
-      };
-      var dotProduct = function dotProduct2(a, b) {
-        return a.x * b.x + a.y * b.y;
-      };
-      var compareVectorAngles = function compareVectorAngles2(basePt, endPt1, endPt2) {
-        var v1 = {
-          x: endPt1.x - basePt.x,
-          y: endPt1.y - basePt.y
-        };
-        var v2 = {
-          x: endPt2.x - basePt.x,
-          y: endPt2.y - basePt.y
-        };
-        var kross = crossProduct(v1, v2);
-        return cmp(kross, 0);
-      };
-      var length = function length2(v) {
-        return Math.sqrt(dotProduct(v, v));
-      };
-      var sineOfAngle = function sineOfAngle2(pShared, pBase, pAngle) {
-        var vBase = {
-          x: pBase.x - pShared.x,
-          y: pBase.y - pShared.y
-        };
-        var vAngle = {
-          x: pAngle.x - pShared.x,
-          y: pAngle.y - pShared.y
-        };
-        return crossProduct(vAngle, vBase) / length(vAngle) / length(vBase);
-      };
-      var cosineOfAngle = function cosineOfAngle2(pShared, pBase, pAngle) {
-        var vBase = {
-          x: pBase.x - pShared.x,
-          y: pBase.y - pShared.y
-        };
-        var vAngle = {
-          x: pAngle.x - pShared.x,
-          y: pAngle.y - pShared.y
-        };
-        return dotProduct(vAngle, vBase) / length(vAngle) / length(vBase);
-      };
-      var horizontalIntersection = function horizontalIntersection2(pt, v, y) {
-        if (v.y === 0)
-          return null;
-        return {
-          x: pt.x + v.x / v.y * (y - pt.y),
-          y
-        };
-      };
-      var verticalIntersection = function verticalIntersection2(pt, v, x) {
-        if (v.x === 0)
-          return null;
-        return {
-          x,
-          y: pt.y + v.y / v.x * (x - pt.x)
-        };
-      };
-      var intersection2 = function intersection3(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);
-        var kross = crossProduct(v1, v2);
-        if (kross == 0)
-          return null;
-        var ve = {
-          x: pt2.x - pt1.x,
-          y: pt2.y - pt1.y
-        };
-        var d1 = crossProduct(ve, v1) / kross;
-        var d2 = crossProduct(ve, v2) / kross;
-        var x1 = pt1.x + d2 * v1.x, x2 = pt2.x + d1 * v2.x;
-        var y1 = pt1.y + d2 * v1.y, y2 = pt2.y + d1 * v2.y;
-        var x = (x1 + x2) / 2;
-        var y = (y1 + y2) / 2;
-        return {
-          x,
-          y
-        };
-      };
-      var SweepEvent = /* @__PURE__ */ function() {
-        _createClass(SweepEvent2, null, [{
-          key: "compare",
-          value: function compare(a, b) {
-            var ptCmp = SweepEvent2.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);
-          }
-        }, {
-          key: "comparePoints",
-          value: function 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;
-          }
-        }]);
-        function SweepEvent2(point, isLeft) {
-          _classCallCheck(this, SweepEvent2);
-          if (point.events === void 0)
-            point.events = [this];
-          else
-            point.events.push(this);
-          this.point = point;
-          this.isLeft = isLeft;
-        }
-        _createClass(SweepEvent2, [{
-          key: "link",
-          value: function link(other) {
-            if (other.point === this.point) {
-              throw new Error("Tried to link already linked events");
-            }
-            var otherEvents = other.point.events;
-            for (var i = 0, iMax = otherEvents.length; i < iMax; i++) {
-              var evt = otherEvents[i];
-              this.point.events.push(evt);
-              evt.point = this.point;
-            }
-            this.checkForConsuming();
-          }
-        }, {
-          key: "checkForConsuming",
-          value: function checkForConsuming() {
-            var numEvents = this.point.events.length;
-            for (var i = 0; i < numEvents; i++) {
-              var evt1 = this.point.events[i];
-              if (evt1.segment.consumedBy !== void 0)
-                continue;
-              for (var j = i + 1; j < numEvents; j++) {
-                var 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);
-              }
-            }
-          }
-        }, {
-          key: "getAvailableLinkedEvents",
-          value: function getAvailableLinkedEvents() {
-            var events = [];
-            for (var i = 0, iMax = this.point.events.length; i < iMax; i++) {
-              var evt = this.point.events[i];
-              if (evt !== this && !evt.segment.ringOut && evt.segment.isInResult()) {
-                events.push(evt);
-              }
-            }
-            return events;
-          }
-        }, {
-          key: "getLeftmostComparator",
-          value: function getLeftmostComparator(baseEvent) {
-            var _this = this;
-            var cache = /* @__PURE__ */ new Map();
-            var fillCache = function fillCache2(linkedEvent) {
-              var nextEvent = linkedEvent.otherSE;
-              cache.set(linkedEvent, {
-                sine: sineOfAngle(_this.point, baseEvent.point, nextEvent.point),
-                cosine: cosineOfAngle(_this.point, baseEvent.point, nextEvent.point)
-              });
-            };
-            return function(a, b) {
-              if (!cache.has(a))
-                fillCache(a);
-              if (!cache.has(b))
-                fillCache(b);
-              var _cache$get = cache.get(a), asine = _cache$get.sine, acosine = _cache$get.cosine;
-              var _cache$get2 = cache.get(b), bsine = _cache$get2.sine, bcosine = _cache$get2.cosine;
-              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;
-            };
-          }
-        }]);
-        return SweepEvent2;
-      }();
-      var segmentId = 0;
-      var Segment = /* @__PURE__ */ function() {
-        _createClass(Segment2, null, [{
-          key: "compare",
-          value: function compare(a, b) {
-            var alx = a.leftSE.point.x;
-            var blx = b.leftSE.point.x;
-            var arx = a.rightSE.point.x;
-            var brx = b.rightSE.point.x;
-            if (brx < alx)
-              return 1;
-            if (arx < blx)
-              return -1;
-            var aly = a.leftSE.point.y;
-            var bly = b.leftSE.point.y;
-            var ary = a.rightSE.point.y;
-            var bry = b.rightSE.point.y;
-            if (alx < blx) {
-              if (bly < aly && bly < ary)
-                return 1;
-              if (bly > aly && bly > ary)
-                return -1;
-              var aCmpBLeft = a.comparePoint(b.leftSE.point);
-              if (aCmpBLeft < 0)
-                return 1;
-              if (aCmpBLeft > 0)
-                return -1;
-              var 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;
-              var bCmpALeft = b.comparePoint(a.leftSE.point);
-              if (bCmpALeft !== 0)
-                return bCmpALeft;
-              var 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) {
-              var _bCmpARight = b.comparePoint(a.rightSE.point);
-              if (_bCmpARight !== 0)
-                return _bCmpARight;
-            }
-            if (arx > brx) {
-              var _aCmpBRight = a.comparePoint(b.rightSE.point);
-              if (_aCmpBRight < 0)
-                return 1;
-              if (_aCmpBRight > 0)
-                return -1;
-            }
-            if (arx !== brx) {
-              var ay = ary - aly;
-              var ax = arx - alx;
-              var by = bry - bly;
-              var 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;
-          }
-        }]);
-        function Segment2(leftSE, rightSE, rings, windings) {
-          _classCallCheck(this, Segment2);
-          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;
-        }
-        _createClass(Segment2, [{
-          key: "replaceRightSE",
-          value: function replaceRightSE(newRightSE) {
-            this.rightSE = newRightSE;
-            this.rightSE.segment = this;
-            this.rightSE.otherSE = this.leftSE;
-            this.leftSE.otherSE = this.rightSE;
-          }
-        }, {
-          key: "bbox",
-          value: function bbox() {
-            var y1 = this.leftSE.point.y;
-            var 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
-              }
-            };
-          }
-        }, {
-          key: "vector",
-          value: function vector() {
-            return {
-              x: this.rightSE.point.x - this.leftSE.point.x,
-              y: this.rightSE.point.y - this.leftSE.point.y
-            };
-          }
-        }, {
-          key: "isAnEndpoint",
-          value: function 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;
-          }
-        }, {
-          key: "comparePoint",
-          value: function comparePoint(point) {
-            if (this.isAnEndpoint(point))
-              return 0;
-            var lPt = this.leftSE.point;
-            var rPt = this.rightSE.point;
-            var v = this.vector();
-            if (lPt.x === rPt.x) {
-              if (point.x === lPt.x)
-                return 0;
-              return point.x < lPt.x ? 1 : -1;
-            }
-            var yDist = (point.y - lPt.y) / v.y;
-            var xFromYDist = lPt.x + yDist * v.x;
-            if (point.x === xFromYDist)
-              return 0;
-            var xDist = (point.x - lPt.x) / v.x;
-            var yFromXDist = lPt.y + xDist * v.y;
-            if (point.y === yFromXDist)
-              return 0;
-            return point.y < yFromXDist ? -1 : 1;
-          }
-        }, {
-          key: "getIntersection",
-          value: function getIntersection(other) {
-            var tBbox = this.bbox();
-            var oBbox = other.bbox();
-            var bboxOverlap = getBboxOverlap(tBbox, oBbox);
-            if (bboxOverlap === null)
-              return null;
-            var tlp = this.leftSE.point;
-            var trp = this.rightSE.point;
-            var olp = other.leftSE.point;
-            var orp = other.rightSE.point;
-            var touchesOtherLSE = isInBbox(tBbox, olp) && this.comparePoint(olp) === 0;
-            var touchesThisLSE = isInBbox(oBbox, tlp) && other.comparePoint(tlp) === 0;
-            var touchesOtherRSE = isInBbox(tBbox, orp) && this.comparePoint(orp) === 0;
-            var 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;
-            var pt = intersection2(tlp, this.vector(), olp, other.vector());
-            if (pt === null)
-              return null;
-            if (!isInBbox(bboxOverlap, pt))
-              return null;
-            return rounder.round(pt.x, pt.y);
-          }
-        }, {
-          key: "split",
-          value: function split2(point) {
-            var newEvents = [];
-            var alreadyLinked = point.events !== void 0;
-            var newLeftSE = new SweepEvent(point, true);
-            var newRightSE = new SweepEvent(point, false);
-            var oldRightSE = this.rightSE;
-            this.replaceRightSE(newRightSE);
-            newEvents.push(newRightSE);
-            newEvents.push(newLeftSE);
-            var newSeg = new Segment2(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;
-          }
-        }, {
-          key: "swapEvents",
-          value: function swapEvents() {
-            var tmpEvt = this.rightSE;
-            this.rightSE = this.leftSE;
-            this.leftSE = tmpEvt;
-            this.leftSE.isLeft = true;
-            this.rightSE.isLeft = false;
-            for (var i = 0, iMax = this.windings.length; i < iMax; i++) {
-              this.windings[i] *= -1;
-            }
-          }
-        }, {
-          key: "consume",
-          value: function consume(other) {
-            var consumer = this;
-            var consumee = other;
-            while (consumer.consumedBy) {
-              consumer = consumer.consumedBy;
-            }
-            while (consumee.consumedBy) {
-              consumee = consumee.consumedBy;
-            }
-            var cmp2 = Segment2.compare(consumer, consumee);
-            if (cmp2 === 0)
-              return;
-            if (cmp2 > 0) {
-              var tmp = consumer;
-              consumer = consumee;
-              consumee = tmp;
-            }
-            if (consumer.prev === consumee) {
-              var _tmp = consumer;
-              consumer = consumee;
-              consumee = _tmp;
-            }
-            for (var i = 0, iMax = consumee.rings.length; i < iMax; i++) {
-              var ring = consumee.rings[i];
-              var winding = consumee.windings[i];
-              var index2 = consumer.rings.indexOf(ring);
-              if (index2 === -1) {
-                consumer.rings.push(ring);
-                consumer.windings.push(winding);
-              } else
-                consumer.windings[index2] += winding;
-            }
-            consumee.rings = null;
-            consumee.windings = null;
-            consumee.consumedBy = consumer;
-            consumee.leftSE.consumedBy = consumer.leftSE;
-            consumee.rightSE.consumedBy = consumer.rightSE;
-          }
-        }, {
-          key: "prevInResult",
-          value: function 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;
-          }
-        }, {
-          key: "beforeState",
-          value: function beforeState() {
-            if (this._beforeState !== void 0)
-              return this._beforeState;
-            if (!this.prev)
-              this._beforeState = {
-                rings: [],
-                windings: [],
-                multiPolys: []
-              };
-            else {
-              var seg = this.prev.consumedBy || this.prev;
-              this._beforeState = seg.afterState();
-            }
-            return this._beforeState;
-          }
-        }, {
-          key: "afterState",
-          value: function afterState() {
-            if (this._afterState !== void 0)
-              return this._afterState;
-            var beforeState = this.beforeState();
-            this._afterState = {
-              rings: beforeState.rings.slice(0),
-              windings: beforeState.windings.slice(0),
-              multiPolys: []
-            };
-            var ringsAfter = this._afterState.rings;
-            var windingsAfter = this._afterState.windings;
-            var mpsAfter = this._afterState.multiPolys;
-            for (var i = 0, iMax = this.rings.length; i < iMax; i++) {
-              var ring = this.rings[i];
-              var winding = this.windings[i];
-              var index2 = ringsAfter.indexOf(ring);
-              if (index2 === -1) {
-                ringsAfter.push(ring);
-                windingsAfter.push(winding);
-              } else
-                windingsAfter[index2] += winding;
-            }
-            var polysAfter = [];
-            var polysExclude = [];
-            for (var _i = 0, _iMax = ringsAfter.length; _i < _iMax; _i++) {
-              if (windingsAfter[_i] === 0)
-                continue;
-              var _ring = ringsAfter[_i];
-              var poly = _ring.poly;
-              if (polysExclude.indexOf(poly) !== -1)
-                continue;
-              if (_ring.isExterior)
-                polysAfter.push(poly);
-              else {
-                if (polysExclude.indexOf(poly) === -1)
-                  polysExclude.push(poly);
-                var _index = polysAfter.indexOf(_ring.poly);
-                if (_index !== -1)
-                  polysAfter.splice(_index, 1);
-              }
-            }
-            for (var _i2 = 0, _iMax2 = polysAfter.length; _i2 < _iMax2; _i2++) {
-              var mp = polysAfter[_i2].multiPoly;
-              if (mpsAfter.indexOf(mp) === -1)
-                mpsAfter.push(mp);
-            }
-            return this._afterState;
-          }
-        }, {
-          key: "isInResult",
-          value: function isInResult() {
-            if (this.consumedBy)
-              return false;
-            if (this._isInResult !== void 0)
-              return this._isInResult;
-            var mpsBefore = this.beforeState().multiPolys;
-            var mpsAfter = this.afterState().multiPolys;
-            switch (operation.type) {
-              case "union": {
-                var noBefores = mpsBefore.length === 0;
-                var noAfters = mpsAfter.length === 0;
-                this._isInResult = noBefores !== noAfters;
-                break;
-              }
-              case "intersection": {
-                var least;
-                var 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": {
-                var diff = Math.abs(mpsBefore.length - mpsAfter.length);
-                this._isInResult = diff % 2 === 1;
-                break;
-              }
-              case "difference": {
-                var isJustSubject = function isJustSubject2(mps) {
-                  return mps.length === 1 && mps[0].isSubject;
-                };
-                this._isInResult = isJustSubject(mpsBefore) !== isJustSubject(mpsAfter);
-                break;
-              }
-              default:
-                throw new Error("Unrecognized operation type found ".concat(operation.type));
-            }
-            return this._isInResult;
-          }
-        }], [{
-          key: "fromRing",
-          value: function fromRing(pt1, pt2, ring) {
-            var leftPt, rightPt, winding;
-            var 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 [".concat(pt1.x, ", ").concat(pt1.y, "]"));
-            var leftSE = new SweepEvent(leftPt, true);
-            var rightSE = new SweepEvent(rightPt, false);
-            return new Segment2(leftSE, rightSE, [ring], [winding]);
-          }
-        }]);
-        return Segment2;
-      }();
-      var RingIn = /* @__PURE__ */ function() {
-        function RingIn2(geomRing, poly, isExterior) {
-          _classCallCheck(this, RingIn2);
-          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");
-          }
-          var 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
-            }
-          };
-          var prevPoint = firstPoint;
-          for (var 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");
-            }
-            var 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));
-          }
-        }
-        _createClass(RingIn2, [{
-          key: "getSweepEvents",
-          value: function getSweepEvents() {
-            var sweepEvents = [];
-            for (var i = 0, iMax = this.segments.length; i < iMax; i++) {
-              var segment = this.segments[i];
-              sweepEvents.push(segment.leftSE);
-              sweepEvents.push(segment.rightSE);
-            }
-            return sweepEvents;
-          }
-        }]);
-        return RingIn2;
-      }();
-      var PolyIn = /* @__PURE__ */ function() {
-        function PolyIn2(geomPoly, multiPoly) {
-          _classCallCheck(this, PolyIn2);
-          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 (var i = 1, iMax = geomPoly.length; i < iMax; i++) {
-            var 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;
-        }
-        _createClass(PolyIn2, [{
-          key: "getSweepEvents",
-          value: function getSweepEvents() {
-            var sweepEvents = this.exteriorRing.getSweepEvents();
-            for (var i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
-              var ringSweepEvents = this.interiorRings[i].getSweepEvents();
-              for (var j = 0, jMax = ringSweepEvents.length; j < jMax; j++) {
-                sweepEvents.push(ringSweepEvents[j]);
-              }
-            }
-            return sweepEvents;
-          }
-        }]);
-        return PolyIn2;
-      }();
-      var MultiPolyIn = /* @__PURE__ */ function() {
-        function MultiPolyIn2(geom, isSubject) {
-          _classCallCheck(this, MultiPolyIn2);
-          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 (var i = 0, iMax = geom.length; i < iMax; i++) {
-            var 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;
-        }
-        _createClass(MultiPolyIn2, [{
-          key: "getSweepEvents",
-          value: function getSweepEvents() {
-            var sweepEvents = [];
-            for (var i = 0, iMax = this.polys.length; i < iMax; i++) {
-              var polySweepEvents = this.polys[i].getSweepEvents();
-              for (var j = 0, jMax = polySweepEvents.length; j < jMax; j++) {
-                sweepEvents.push(polySweepEvents[j]);
-              }
-            }
-            return sweepEvents;
-          }
-        }]);
-        return MultiPolyIn2;
-      }();
-      var RingOut = /* @__PURE__ */ function() {
-        _createClass(RingOut2, null, [{
-          key: "factory",
-          value: function factory(allSegments) {
-            var ringsOut = [];
-            for (var i = 0, iMax = allSegments.length; i < iMax; i++) {
-              var segment = allSegments[i];
-              if (!segment.isInResult() || segment.ringOut)
-                continue;
-              var prevEvent = null;
-              var event = segment.leftSE;
-              var nextEvent = segment.rightSE;
-              var events = [event];
-              var startingPoint = event.point;
-              var intersectionLEs = [];
-              while (true) {
-                prevEvent = event;
-                event = nextEvent;
-                events.push(event);
-                if (event.point === startingPoint)
-                  break;
-                while (true) {
-                  var availableLEs = event.getAvailableLinkedEvents();
-                  if (availableLEs.length === 0) {
-                    var firstPt = events[0].point;
-                    var lastPt = events[events.length - 1].point;
-                    throw new Error("Unable to complete output ring starting at [".concat(firstPt.x, ",") + " ".concat(firstPt.y, "]. Last matching segment found ends at") + " [".concat(lastPt.x, ", ").concat(lastPt.y, "]."));
-                  }
-                  if (availableLEs.length === 1) {
-                    nextEvent = availableLEs[0].otherSE;
-                    break;
-                  }
-                  var indexLE = null;
-                  for (var j = 0, jMax = intersectionLEs.length; j < jMax; j++) {
-                    if (intersectionLEs[j].point === event.point) {
-                      indexLE = j;
-                      break;
-                    }
-                  }
-                  if (indexLE !== null) {
-                    var intersectionLE = intersectionLEs.splice(indexLE)[0];
-                    var ringEvents = events.splice(intersectionLE.index);
-                    ringEvents.unshift(ringEvents[0].otherSE);
-                    ringsOut.push(new RingOut2(ringEvents.reverse()));
-                    continue;
-                  }
-                  intersectionLEs.push({
-                    index: events.length,
-                    point: event.point
-                  });
-                  var comparator = event.getLeftmostComparator(prevEvent);
-                  nextEvent = availableLEs.sort(comparator)[0].otherSE;
-                  break;
-                }
-              }
-              ringsOut.push(new RingOut2(events));
-            }
-            return ringsOut;
-          }
-        }]);
-        function RingOut2(events) {
-          _classCallCheck(this, RingOut2);
-          this.events = events;
-          for (var i = 0, iMax = events.length; i < iMax; i++) {
-            events[i].segment.ringOut = this;
-          }
-          this.poly = null;
-        }
-        _createClass(RingOut2, [{
-          key: "getGeom",
-          value: function getGeom() {
-            var prevPt = this.events[0].point;
-            var points = [prevPt];
-            for (var i = 1, iMax = this.events.length - 1; i < iMax; i++) {
-              var _pt = this.events[i].point;
-              var _nextPt = this.events[i + 1].point;
-              if (compareVectorAngles(_pt, prevPt, _nextPt) === 0)
-                continue;
-              points.push(_pt);
-              prevPt = _pt;
-            }
-            if (points.length === 1)
-              return null;
-            var pt = points[0];
-            var nextPt = points[1];
-            if (compareVectorAngles(pt, prevPt, nextPt) === 0)
-              points.shift();
-            points.push(points[0]);
-            var step = this.isExteriorRing() ? 1 : -1;
-            var iStart = this.isExteriorRing() ? 0 : points.length - 1;
-            var iEnd = this.isExteriorRing() ? points.length : -1;
-            var orderedPoints = [];
-            for (var _i = iStart; _i != iEnd; _i += step) {
-              orderedPoints.push([points[_i].x, points[_i].y]);
-            }
-            return orderedPoints;
-          }
-        }, {
-          key: "isExteriorRing",
-          value: function isExteriorRing() {
-            if (this._isExteriorRing === void 0) {
-              var enclosing = this.enclosingRing();
-              this._isExteriorRing = enclosing ? !enclosing.isExteriorRing() : true;
-            }
-            return this._isExteriorRing;
-          }
-        }, {
-          key: "enclosingRing",
-          value: function enclosingRing() {
-            if (this._enclosingRing === void 0) {
-              this._enclosingRing = this._calcEnclosingRing();
-            }
-            return this._enclosingRing;
-          }
-        }, {
-          key: "_calcEnclosingRing",
-          value: function _calcEnclosingRing() {
-            var leftMostEvt = this.events[0];
-            for (var i = 1, iMax = this.events.length; i < iMax; i++) {
-              var evt = this.events[i];
-              if (SweepEvent.compare(leftMostEvt, evt) > 0)
-                leftMostEvt = evt;
-            }
-            var prevSeg = leftMostEvt.segment.prevInResult();
-            var 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;
-            }
-          }
-        }]);
-        return RingOut2;
-      }();
-      var PolyOut = /* @__PURE__ */ function() {
-        function PolyOut2(exteriorRing) {
-          _classCallCheck(this, PolyOut2);
-          this.exteriorRing = exteriorRing;
-          exteriorRing.poly = this;
-          this.interiorRings = [];
-        }
-        _createClass(PolyOut2, [{
-          key: "addInterior",
-          value: function addInterior(ring) {
-            this.interiorRings.push(ring);
-            ring.poly = this;
-          }
-        }, {
-          key: "getGeom",
-          value: function getGeom() {
-            var geom = [this.exteriorRing.getGeom()];
-            if (geom[0] === null)
-              return null;
-            for (var i = 0, iMax = this.interiorRings.length; i < iMax; i++) {
-              var ringGeom = this.interiorRings[i].getGeom();
-              if (ringGeom === null)
-                continue;
-              geom.push(ringGeom);
-            }
-            return geom;
-          }
-        }]);
-        return PolyOut2;
-      }();
-      var MultiPolyOut = /* @__PURE__ */ function() {
-        function MultiPolyOut2(rings) {
-          _classCallCheck(this, MultiPolyOut2);
-          this.rings = rings;
-          this.polys = this._composePolys(rings);
-        }
-        _createClass(MultiPolyOut2, [{
-          key: "getGeom",
-          value: function getGeom() {
-            var geom = [];
-            for (var i = 0, iMax = this.polys.length; i < iMax; i++) {
-              var polyGeom = this.polys[i].getGeom();
-              if (polyGeom === null)
-                continue;
-              geom.push(polyGeom);
-            }
-            return geom;
-          }
-        }, {
-          key: "_composePolys",
-          value: function _composePolys(rings) {
-            var polys = [];
-            for (var i = 0, iMax = rings.length; i < iMax; i++) {
-              var ring = rings[i];
-              if (ring.poly)
-                continue;
-              if (ring.isExteriorRing())
-                polys.push(new PolyOut(ring));
-              else {
-                var enclosingRing = ring.enclosingRing();
-                if (!enclosingRing.poly)
-                  polys.push(new PolyOut(enclosingRing));
-                enclosingRing.poly.addInterior(ring);
-              }
-            }
-            return polys;
-          }
-        }]);
-        return MultiPolyOut2;
-      }();
-      var SweepLine = /* @__PURE__ */ function() {
-        function SweepLine2(queue) {
-          var comparator = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Segment.compare;
-          _classCallCheck(this, SweepLine2);
-          this.queue = queue;
-          this.tree = new Tree(comparator);
-          this.segments = [];
-        }
-        _createClass(SweepLine2, [{
-          key: "process",
-          value: function process2(event) {
-            var segment = event.segment;
-            var newEvents = [];
-            if (event.consumedBy) {
-              if (event.isLeft)
-                this.queue.remove(event.otherSE);
-              else
-                this.tree.remove(segment);
-              return newEvents;
-            }
-            var node = event.isLeft ? this.tree.insert(segment) : this.tree.find(segment);
-            if (!node)
-              throw new Error("Unable to find segment #".concat(segment.id, " ") + "[".concat(segment.leftSE.point.x, ", ").concat(segment.leftSE.point.y, "] -> ") + "[".concat(segment.rightSE.point.x, ", ").concat(segment.rightSE.point.y, "] ") + "in SweepLine tree. Please submit a bug report.");
-            var prevNode = node;
-            var nextNode = node;
-            var prevSeg = void 0;
-            var 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) {
-              var prevMySplitter = null;
-              if (prevSeg) {
-                var prevInter = prevSeg.getIntersection(segment);
-                if (prevInter !== null) {
-                  if (!segment.isAnEndpoint(prevInter))
-                    prevMySplitter = prevInter;
-                  if (!prevSeg.isAnEndpoint(prevInter)) {
-                    var newEventsFromSplit = this._splitSafely(prevSeg, prevInter);
-                    for (var i = 0, iMax = newEventsFromSplit.length; i < iMax; i++) {
-                      newEvents.push(newEventsFromSplit[i]);
-                    }
-                  }
-                }
-              }
-              var nextMySplitter = null;
-              if (nextSeg) {
-                var nextInter = nextSeg.getIntersection(segment);
-                if (nextInter !== null) {
-                  if (!segment.isAnEndpoint(nextInter))
-                    nextMySplitter = nextInter;
-                  if (!nextSeg.isAnEndpoint(nextInter)) {
-                    var _newEventsFromSplit = this._splitSafely(nextSeg, nextInter);
-                    for (var _i = 0, _iMax = _newEventsFromSplit.length; _i < _iMax; _i++) {
-                      newEvents.push(_newEventsFromSplit[_i]);
-                    }
-                  }
-                }
-              }
-              if (prevMySplitter !== null || nextMySplitter !== null) {
-                var mySplitter = null;
-                if (prevMySplitter === null)
-                  mySplitter = nextMySplitter;
-                else if (nextMySplitter === null)
-                  mySplitter = prevMySplitter;
-                else {
-                  var cmpSplitters = SweepEvent.comparePoints(prevMySplitter, nextMySplitter);
-                  mySplitter = cmpSplitters <= 0 ? prevMySplitter : nextMySplitter;
-                }
-                this.queue.remove(segment.rightSE);
-                newEvents.push(segment.rightSE);
-                var _newEventsFromSplit2 = segment.split(mySplitter);
-                for (var _i2 = 0, _iMax2 = _newEventsFromSplit2.length; _i2 < _iMax2; _i2++) {
-                  newEvents.push(_newEventsFromSplit2[_i2]);
-                }
-              }
-              if (newEvents.length > 0) {
-                this.tree.remove(segment);
-                newEvents.push(event);
-              } else {
-                this.segments.push(segment);
-                segment.prev = prevSeg;
-              }
-            } else {
-              if (prevSeg && nextSeg) {
-                var inter = prevSeg.getIntersection(nextSeg);
-                if (inter !== null) {
-                  if (!prevSeg.isAnEndpoint(inter)) {
-                    var _newEventsFromSplit3 = this._splitSafely(prevSeg, inter);
-                    for (var _i3 = 0, _iMax3 = _newEventsFromSplit3.length; _i3 < _iMax3; _i3++) {
-                      newEvents.push(_newEventsFromSplit3[_i3]);
-                    }
-                  }
-                  if (!nextSeg.isAnEndpoint(inter)) {
-                    var _newEventsFromSplit4 = this._splitSafely(nextSeg, inter);
-                    for (var _i4 = 0, _iMax4 = _newEventsFromSplit4.length; _i4 < _iMax4; _i4++) {
-                      newEvents.push(_newEventsFromSplit4[_i4]);
-                    }
-                  }
-                }
-              }
-              this.tree.remove(segment);
-            }
-            return newEvents;
-          }
-        }, {
-          key: "_splitSafely",
-          value: function _splitSafely(seg, pt) {
-            this.tree.remove(seg);
-            var rightSE = seg.rightSE;
-            this.queue.remove(rightSE);
-            var newEvents = seg.split(pt);
-            newEvents.push(rightSE);
-            if (seg.consumedBy === void 0)
-              this.tree.insert(seg);
-            return newEvents;
-          }
-        }]);
-        return SweepLine2;
-      }();
-      var POLYGON_CLIPPING_MAX_QUEUE_SIZE = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_QUEUE_SIZE || 1e6;
-      var POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS = typeof process !== "undefined" && process.env.POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS || 1e6;
-      var Operation = /* @__PURE__ */ function() {
-        function Operation2() {
-          _classCallCheck(this, Operation2);
-        }
-        _createClass(Operation2, [{
-          key: "run",
-          value: function run(type, geom, moreGeoms) {
-            operation.type = type;
-            rounder.reset();
-            var multipolys = [new MultiPolyIn(geom, true)];
-            for (var i = 0, iMax = moreGeoms.length; i < iMax; i++) {
-              multipolys.push(new MultiPolyIn(moreGeoms[i], false));
-            }
-            operation.numMultiPolys = multipolys.length;
-            if (operation.type === "difference") {
-              var subject = multipolys[0];
-              var _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 (var _i2 = 0, _iMax = multipolys.length; _i2 < _iMax; _i2++) {
-                var mpA = multipolys[_i2];
-                for (var j = _i2 + 1, jMax = multipolys.length; j < jMax; j++) {
-                  if (getBboxOverlap(mpA.bbox, multipolys[j].bbox) === null)
-                    return [];
-                }
-              }
-            }
-            var queue = new Tree(SweepEvent.compare);
-            for (var _i3 = 0, _iMax2 = multipolys.length; _i3 < _iMax2; _i3++) {
-              var sweepEvents = multipolys[_i3].getSweepEvents();
-              for (var _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). Please file a bug report.");
-                }
-              }
-            }
-            var sweepLine = new SweepLine(queue);
-            var prevQueueSize = queue.size;
-            var node = queue.pop();
-            while (node) {
-              var evt = node.key;
-              if (queue.size === prevQueueSize) {
-                var seg = evt.segment;
-                throw new Error("Unable to pop() ".concat(evt.isLeft ? "left" : "right", " SweepEvent ") + "[".concat(evt.point.x, ", ").concat(evt.point.y, "] from segment #").concat(seg.id, " ") + "[".concat(seg.leftSE.point.x, ", ").concat(seg.leftSE.point.y, "] -> ") + "[".concat(seg.rightSE.point.x, ", ").concat(seg.rightSE.point.y, "] from queue. ") + "Please file a bug report.");
-              }
-              if (queue.size > POLYGON_CLIPPING_MAX_QUEUE_SIZE) {
-                throw new Error("Infinite loop when passing sweep line over endpoints (queue size too big). Please file a bug report.");
-              }
-              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). Please file a bug report.");
-              }
-              var newEvents = sweepLine.process(evt);
-              for (var _i4 = 0, _iMax3 = newEvents.length; _i4 < _iMax3; _i4++) {
-                var _evt = newEvents[_i4];
-                if (_evt.consumedBy === void 0)
-                  queue.insert(_evt);
-              }
-              prevQueueSize = queue.size;
-              node = queue.pop();
-            }
-            rounder.reset();
-            var ringsOut = RingOut.factory(sweepLine.segments);
-            var result = new MultiPolyOut(ringsOut);
-            return result.getGeom();
-          }
-        }]);
-        return Operation2;
-      }();
-      var operation = new Operation();
-      var union2 = function union3(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);
-      };
-      var intersection$1 = function intersection3(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);
-      };
-      var xor = function xor2(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);
-      };
-      var difference = function difference2(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);
-      };
-      var index = {
-        union: union2,
-        intersection: intersection$1,
-        xor,
-        difference
-      };
-      return index;
-    });
-  }
-});
-
-// ../linzjs-geojson/build/multipolygon/clipped.js
-var import_lineclip = __toESM(require_lineclip(), 1);
-var import_polygon_clipping = __toESM(require_polygon_clipping_umd(), 1);
-var { intersection, union } = import_polygon_clipping.default;
-
-// ../linzjs-geojson/build/wgs84.js
-var normLon = (lon) => {
-  if (lon < -360) {
-    lon = -(-lon % 360);
-  } else if (lon > 360) {
-    lon = lon % 360;
-  }
-  if (lon < -180) {
-    return 360 + lon;
-  } else if (lon > 180) {
-    return lon - 360;
-  }
-  return lon;
-};
-var delta = (a, b) => {
-  const d = b - a;
-  if (d > 180) {
-    return d - 360;
-  } else if (d < -180) {
-    return d + 360;
-  }
-  return d;
-};
-var calcMid = (a, b) => normLon(a + (b < a ? b + 360 - a : b - a));
-var Wgs84 = {
-  boxLonCenter(a) {
-    return normLon(a[0] + 0.5 * (a[2] < a[0] ? 360 + a[2] - a[0] : a[2] - a[0]));
-  },
-  delta,
-  crossesAM(a, b) {
-    return Math.sign(delta(a, b)) !== Math.sign(b - a);
-  },
-  normLon,
-  normExtent(extent) {
-    return [normLon(extent[0]), extent[1], normLon(extent[2]), extent[3]];
-  },
-  union(a, b) {
-    if (b == null) {
-      return a.slice();
-    }
-    const axCenter = Wgs84.boxLonCenter(a);
-    const bxCenter = Wgs84.boxLonCenter(b);
-    if (delta(axCenter, bxCenter) < 0) {
-      return this.union(b, a);
-    }
-    const ans = a.slice();
-    const mid = calcMid(axCenter, bxCenter);
-    if (delta(mid, b[0]) < delta(mid, a[0]))
-      ans[0] = b[0];
-    if (delta(mid, b[2]) > delta(mid, a[2]))
-      ans[2] = b[2];
-    if (b[1] < a[1])
-      ans[1] = b[1];
-    if (b[3] > a[3])
-      ans[3] = b[3];
-    return ans;
-  },
-  intersects(a, b) {
-    if (a[1] > b[3] || b[1] > a[3])
-      return false;
-    const a0 = a[0];
-    const b0 = b[0];
-    const a2 = a0 < a[2] ? a[2] : a[2] + 360;
-    const b2 = b0 < b[2] ? b[2] : b[2] + 360;
-    return a0 <= b2 && b0 <= a2 || a0 + 360 <= b2 && b0 <= a2 + 360 || a0 <= b2 + 360 && b0 + 360 <= a2;
-  },
-  ringToBbox(ring) {
-    if (ring.length < 3) {
-      throw new Error("Invalid ring");
-    }
-    let crossing = false;
-    const prev = ring[0];
-    let minX = prev[0];
-    let minY = prev[1];
-    let maxX = minX;
-    let maxY = minY;
-    let pLon = minX;
-    for (let i = 1; i < ring.length; ++i) {
-      const curr = ring[i];
-      let lon = curr[0];
-      const lineCrosses = Wgs84.crossesAM(pLon, lon);
-      if (lineCrosses) {
-        crossing = !crossing;
-      }
-      if (crossing) {
-        if (lon < 0) {
-          lon += 360;
-        } else {
-          pLon += 360;
-          if (i === 1) {
-            minX = maxX = pLon;
-          }
-        }
-      }
-      if (lon < minX)
-        minX = lon;
-      else if (lon > maxX)
-        maxX = lon;
-      const lat = curr[1];
-      if (lat < minY)
-        minY = lat;
-      else if (lat > maxY)
-        maxY = lat;
-      pLon = curr[0];
-    }
-    return [this.normLon(minX), minY, this.normLon(maxX), maxY];
-  },
-  multiPolygonToBbox(multipolygon) {
-    let ans = null;
-    for (const poly of multipolygon) {
-      if (poly.length === 0)
-        continue;
-      const ring = poly[0];
-      if (ring.length < 3)
-        continue;
-      const bbox = this.ringToBbox(ring);
-      ans = ans == null ? bbox : this.union(ans, bbox);
-    }
-    if (ans == null) {
-      throw new Error("Invalid multipolygon");
-    }
-    return ans;
-  },
-  bboxToMultiPolygon(bbox) {
-    const sw = [bbox[0], bbox[1]];
-    const se = [bbox[2], bbox[1]];
-    const nw = [bbox[0], bbox[3]];
-    const ne = [bbox[2], bbox[3]];
-    if (bbox[0] < bbox[2]) {
-      return [[[sw, nw, ne, se, sw]]];
-    }
-    return [[[sw, nw, [180, ne[1]], [180, se[1]], sw]], [[ne, se, [-180, sw[1]], [-180, nw[1]], ne]]];
-  }
-};
-
-// ../attribution/src/attribution.ts
-function escapeHtml(text) {
-  const elm = document.createElement("span");
-  elm.textContent = text;
-  return elm.innerHTML;
-}
-var AttributionBounds = class {
-  constructor(collection) {
-    this.boundaries = [];
-    this.collection = collection;
-    const zoom = collection.summaries["linz:zoom"];
-    this.minZoom = zoom.min;
-    this.maxZoom = zoom.max;
-    this.bbox = collection.extent.spatial.bbox[0];
-    this.startDate = collection.extent.temporal?.interval[0][0];
-    this.endDate = collection.extent.temporal?.interval[0][1];
-  }
-  intersects(params) {
-    if (params.zoom > this.maxZoom || params.zoom < this.minZoom)
-      return false;
-    if (params.dateAfter && params.dateBefore && params.dateAfter > params.dateBefore)
-      return false;
-    if (params.dateAfter && this.endDate && params.dateAfter > this.endDate)
-      return false;
-    if (params.dateBefore && this.startDate && params.dateBefore < this.startDate)
-      return false;
-    if (!Wgs84.intersects(params.extent, this.bbox))
-      return false;
-    return this.intersection(Wgs84.bboxToMultiPolygon(params.extent));
-  }
-  intersection(polygon) {
-    for (const boundary of this.boundaries) {
-      if (intersection(boundary, polygon).length > 0)
-        return true;
-    }
-    return false;
-  }
-  addBoundary(ring) {
-    assertRing(ring);
-    this.boundaries.push(ring);
-  }
-};
-function assertRing(ring) {
-  for (const outer of ring) {
-    for (const inner of outer) {
-      if (inner.length !== 2)
-        throw new Error("Invalid ring wrong length");
-    }
-  }
-}
-function convertToBounds(stac) {
-  const colMap = /* @__PURE__ */ new Map();
-  const result = [];
-  for (const collection of stac.collections) {
-    const attr = new AttributionBounds(collection);
-    result.push(attr);
-    colMap.set(collection.id, attr);
-  }
-  for (const f of stac.features) {
-    const col = colMap.get(f.collection ?? "");
-    if (col == null)
-      throw new Error("Could not match feature to collection: " + f.collection);
-    if (f.geometry.type === "Polygon") {
-      col.addBoundary(f.geometry.coordinates);
-    } else if (f.geometry.type === "MultiPolygon") {
-      for (const poly of f.geometry.coordinates)
-        col.addBoundary(poly);
-    }
-  }
-  return result;
-}
-function getYears(col) {
-  const interval = col.extent?.temporal?.interval;
-  if (interval == null || interval.length === 0)
-    return [-1, -1];
-  const range = interval[0];
-  const y1 = new Date(range[0]).getFullYear();
-  const y2 = (range.length < 2 ? y1 : new Date(range[1]).getFullYear()) - 1;
-  return [y1, y2 < y1 ? y1 : y2];
-}
-var Attribution = class {
-  constructor(attributions) {
-    this.attributions = attributions;
-  }
-  static async load(url) {
-    const resp = await fetch(url);
-    if (resp.ok) {
-      const attributionStac = await resp.json();
-      return Attribution.fromStac(attributionStac);
-    }
-    throw new Error(`fetch attribution failed [${resp.status}] ${resp.statusText}`);
-  }
-  static fromStac(json) {
-    return new Attribution(convertToBounds(json).reverse());
-  }
-  filter(params) {
-    params.zoom = Math.round(params.zoom);
-    const filtered = [];
-    const { attributions } = this;
-    if (attributions == null)
-      return filtered;
-    for (const attr of attributions) {
-      if (this.isIgnored != null && this.isIgnored(attr))
-        continue;
-      if (attr.intersects(params))
-        filtered.push(attr);
-    }
-    return filtered;
-  }
-  renderList(list) {
-    if (list.length === 0)
-      return "";
-    let result = escapeHtml(list[0].collection.title);
-    if (list.length > 1) {
-      if (list.length === 2) {
-        result += ` & ${escapeHtml(list[1].collection.title)}`;
-      } else {
-        let [minYear, maxYear] = getYears(list[1].collection);
-        for (let i = 1; i < list.length; ++i) {
-          const [a, b] = getYears(list[i].collection);
-          if (a !== -1 && (minYear === -1 || a < minYear))
-            minYear = a;
-          if (b !== -1 && (maxYear === -1 || b > maxYear))
-            maxYear = b;
-        }
-        if (minYear === -1)
-          minYear = maxYear;
-        if (maxYear !== -1) {
-          result += ` & others ${minYear}-${maxYear}`;
-        }
-      }
-    }
-    return result;
-  }
-};
-
-// ../attribution/src/attribution.index.ts
-window.BasemapsAttribution = Attribution;
-/**
- * splaytree v3.1.0
- * Fast Splay tree for Node and browser
- *
- * @author Alexander Milevski <info@w8r.name>
- * @license MIT
- * @preserve
- */