all these changes

frontend/node_modules/@turf/kinks/dist/es/index.js

@@ -0,0 +1,136 @@
+import { point } from "@turf/helpers";
+/**
+ * Takes a {@link LineString|linestring}, {@link MultiLineString|multi-linestring},
+ * {@link MultiPolygon|multi-polygon} or {@link Polygon|polygon} and
+ * returns {@link Point|points} at all self-intersections.
+ *
+ * @name kinks
+ * @param {Feature<LineString|MultiLineString|MultiPolygon|Polygon>} featureIn input feature
+ * @returns {FeatureCollection<Point>} self-intersections
+ * @example
+ * var poly = turf.polygon([[
+ *   [-12.034835, 8.901183],
+ *   [-12.060413, 8.899826],
+ *   [-12.03638, 8.873199],
+ *   [-12.059383, 8.871418],
+ *   [-12.034835, 8.901183]
+ * ]]);
+ *
+ * var kinks = turf.kinks(poly);
+ *
+ * //addToMap
+ * var addToMap = [poly, kinks]
+ */
+export default function kinks(featureIn) {
+    var coordinates;
+    var feature;
+    var results = {
+        type: "FeatureCollection",
+        features: [],
+    };
+    if (featureIn.type === "Feature") {
+        feature = featureIn.geometry;
+    }
+    else {
+        feature = featureIn;
+    }
+    if (feature.type === "LineString") {
+        coordinates = [feature.coordinates];
+    }
+    else if (feature.type === "MultiLineString") {
+        coordinates = feature.coordinates;
+    }
+    else if (feature.type === "MultiPolygon") {
+        coordinates = [].concat.apply([], feature.coordinates);
+    }
+    else if (feature.type === "Polygon") {
+        coordinates = feature.coordinates;
+    }
+    else {
+        throw new Error("Input must be a LineString, MultiLineString, " +
+            "Polygon, or MultiPolygon Feature or Geometry");
+    }
+    coordinates.forEach(function (line1) {
+        coordinates.forEach(function (line2) {
+            for (var i = 0; i < line1.length - 1; i++) {
+                // start iteration at i, intersections for k < i have already
+                // been checked in previous outer loop iterations
+                for (var k = i; k < line2.length - 1; k++) {
+                    if (line1 === line2) {
+                        // segments are adjacent and always share a vertex, not a kink
+                        if (Math.abs(i - k) === 1) {
+                            continue;
+                        }
+                        // first and last segment in a closed lineString or ring always share a vertex, not a kink
+                        if (
+                        // segments are first and last segment of lineString
+                        i === 0 &&
+                            k === line1.length - 2 &&
+                            // lineString is closed
+                            line1[i][0] === line1[line1.length - 1][0] &&
+                            line1[i][1] === line1[line1.length - 1][1]) {
+                            continue;
+                        }
+                    }
+                    var intersection = lineIntersects(line1[i][0], line1[i][1], line1[i + 1][0], line1[i + 1][1], line2[k][0], line2[k][1], line2[k + 1][0], line2[k + 1][1]);
+                    if (intersection) {
+                        results.features.push(point([intersection[0], intersection[1]]));
+                    }
+                }
+            }
+        });
+    });
+    return results;
+}
+// modified from http://jsfiddle.net/justin_c_rounds/Gd2S2/light/
+function lineIntersects(line1StartX, line1StartY, line1EndX, line1EndY, line2StartX, line2StartY, line2EndX, line2EndY) {
+    // if the lines intersect, the result contains the x and y of the
+    // intersection (treating the lines as infinite) and booleans for whether
+    // line segment 1 or line segment 2 contain the point
+    var denominator;
+    var a;
+    var b;
+    var numerator1;
+    var numerator2;
+    var result = {
+        x: null,
+        y: null,
+        onLine1: false,
+        onLine2: false,
+    };
+    denominator =
+        (line2EndY - line2StartY) * (line1EndX - line1StartX) -
+            (line2EndX - line2StartX) * (line1EndY - line1StartY);
+    if (denominator === 0) {
+        if (result.x !== null && result.y !== null) {
+            return result;
+        }
+        else {
+            return false;
+        }
+    }
+    a = line1StartY - line2StartY;
+    b = line1StartX - line2StartX;
+    numerator1 = (line2EndX - line2StartX) * a - (line2EndY - line2StartY) * b;
+    numerator2 = (line1EndX - line1StartX) * a - (line1EndY - line1StartY) * b;
+    a = numerator1 / denominator;
+    b = numerator2 / denominator;
+    // if we cast these lines infinitely in both directions, they intersect here:
+    result.x = line1StartX + a * (line1EndX - line1StartX);
+    result.y = line1StartY + a * (line1EndY - line1StartY);
+    // if line1 is a segment and line2 is infinite, they intersect if:
+    if (a >= 0 && a <= 1) {
+        result.onLine1 = true;
+    }
+    // if line2 is a segment and line1 is infinite, they intersect if:
+    if (b >= 0 && b <= 1) {
+        result.onLine2 = true;
+    }
+    // if line1 and line2 are segments, they intersect if both of the above are true
+    if (result.onLine1 && result.onLine2) {
+        return [result.x, result.y];
+    }
+    else {
+        return false;
+    }
+}

frontend/node_modules/@turf/kinks/dist/es/lib/sweepline-intersections.js

@@ -0,0 +1,288 @@
+// Inlined from
+// https://github.com/rowanwins/sweepline-intersections
+// Needed to go through babel to transform ES6 classes
+var commonjsGlobal = typeof globalThis !== "undefined"
+    ? globalThis
+    : typeof window !== "undefined"
+        ? window
+        : typeof global !== "undefined"
+            ? global
+            : typeof self !== "undefined"
+                ? self
+                : {};
+function createCommonjsModule(fn, module) {
+    return (module = { exports: {} }), fn(module, module.exports), module.exports;
+}
+var tinyqueue = createCommonjsModule(function (module) {
+    (function (global, factory) {
+        module.exports = factory();
+    })(commonjsGlobal, function () {
+        var TinyQueue = function TinyQueue(data, compare) {
+            if (data === void 0)
+                data = [];
+            if (compare === void 0)
+                compare = defaultCompare;
+            this.data = data;
+            this.length = this.data.length;
+            this.compare = compare;
+            if (this.length > 0) {
+                for (var i = (this.length >> 1) - 1; i >= 0; i--) {
+                    this._down(i);
+                }
+            }
+        };
+        TinyQueue.prototype.push = function push(item) {
+            this.data.push(item);
+            this.length++;
+            this._up(this.length - 1);
+        };
+        TinyQueue.prototype.pop = function pop() {
+            if (this.length === 0) {
+                return undefined;
+            }
+            var top = this.data[0];
+            var bottom = this.data.pop();
+            this.length--;
+            if (this.length > 0) {
+                this.data[0] = bottom;
+                this._down(0);
+            }
+            return top;
+        };
+        TinyQueue.prototype.peek = function peek() {
+            return this.data[0];
+        };
+        TinyQueue.prototype._up = function _up(pos) {
+            var ref = this;
+            var data = ref.data;
+            var compare = ref.compare;
+            var item = data[pos];
+            while (pos > 0) {
+                var parent = (pos - 1) >> 1;
+                var current = data[parent];
+                if (compare(item, current) >= 0) {
+                    break;
+                }
+                data[pos] = current;
+                pos = parent;
+            }
+            data[pos] = item;
+        };
+        TinyQueue.prototype._down = function _down(pos) {
+            var ref = this;
+            var data = ref.data;
+            var compare = ref.compare;
+            var halfLength = this.length >> 1;
+            var item = data[pos];
+            while (pos < halfLength) {
+                var left = (pos << 1) + 1;
+                var best = data[left];
+                var right = left + 1;
+                if (right < this.length && compare(data[right], best) < 0) {
+                    left = right;
+                    best = data[right];
+                }
+                if (compare(best, item) >= 0) {
+                    break;
+                }
+                data[pos] = best;
+                pos = left;
+            }
+            data[pos] = item;
+        };
+        function defaultCompare(a, b) {
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
+        return TinyQueue;
+    });
+});
+function checkWhichEventIsLeft(e1, e2) {
+    if (e1.p.x > e2.p.x)
+        return 1;
+    if (e1.p.x < e2.p.x)
+        return -1;
+    if (e1.p.y !== e2.p.y)
+        return e1.p.y > e2.p.y ? 1 : -1;
+    return 1;
+}
+function checkWhichSegmentHasRightEndpointFirst(seg1, seg2) {
+    if (seg1.rightSweepEvent.p.x > seg2.rightSweepEvent.p.x)
+        return 1;
+    if (seg1.rightSweepEvent.p.x < seg2.rightSweepEvent.p.x)
+        return -1;
+    if (seg1.rightSweepEvent.p.y !== seg2.rightSweepEvent.p.y)
+        return seg1.rightSweepEvent.p.y < seg2.rightSweepEvent.p.y ? 1 : -1;
+    return 1;
+}
+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 Event = /*#__PURE__*/ (function () {
+    function Event(p, featureId, ringId, eventId) {
+        _classCallCheck(this, Event);
+        this.p = {
+            x: p[0],
+            y: p[1],
+        };
+        this.featureId = featureId;
+        this.ringId = ringId;
+        this.eventId = eventId;
+        this.otherEvent = null;
+        this.isLeftEndpoint = null;
+    }
+    _createClass(Event, [
+        {
+            key: "isSamePoint",
+            value: function isSamePoint(eventToCheck) {
+                return this.p.x === eventToCheck.p.x && this.p.y === eventToCheck.p.y;
+            },
+        },
+    ]);
+    return Event;
+})();
+function fillEventQueue(geojson, eventQueue) {
+    if (geojson.type === "FeatureCollection") {
+        var features = geojson.features;
+        for (var i = 0; i < features.length; i++) {
+            processFeature(features[i], eventQueue);
+        }
+    }
+    else {
+        processFeature(geojson, eventQueue);
+    }
+}
+var featureId = 0;
+var ringId = 0;
+var eventId = 0;
+function processFeature(featureOrGeometry, eventQueue) {
+    var geom = featureOrGeometry.type === "Feature"
+        ? featureOrGeometry.geometry
+        : featureOrGeometry;
+    var coords = geom.coordinates; // standardise the input
+    if (geom.type === "Polygon" || geom.type === "MultiLineString")
+        coords = [coords];
+    if (geom.type === "LineString")
+        coords = [[coords]];
+    for (var i = 0; i < coords.length; i++) {
+        for (var ii = 0; ii < coords[i].length; ii++) {
+            var currentP = coords[i][ii][0];
+            var nextP = null;
+            ringId = ringId + 1;
+            for (var iii = 0; iii < coords[i][ii].length - 1; iii++) {
+                nextP = coords[i][ii][iii + 1];
+                var e1 = new Event(currentP, featureId, ringId, eventId);
+                var e2 = new Event(nextP, featureId, ringId, eventId + 1);
+                e1.otherEvent = e2;
+                e2.otherEvent = e1;
+                if (checkWhichEventIsLeft(e1, e2) > 0) {
+                    e2.isLeftEndpoint = true;
+                    e1.isLeftEndpoint = false;
+                }
+                else {
+                    e1.isLeftEndpoint = true;
+                    e2.isLeftEndpoint = false;
+                }
+                eventQueue.push(e1);
+                eventQueue.push(e2);
+                currentP = nextP;
+                eventId = eventId + 1;
+            }
+        }
+    }
+    featureId = featureId + 1;
+}
+var Segment = function Segment(event) {
+    _classCallCheck(this, Segment);
+    this.leftSweepEvent = event;
+    this.rightSweepEvent = event.otherEvent;
+};
+function testSegmentIntersect(seg1, seg2) {
+    if (seg1 === null || seg2 === null)
+        return false;
+    if (seg1.leftSweepEvent.ringId === seg2.leftSweepEvent.ringId &&
+        (seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+            seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+            seg1.rightSweepEvent.isSamePoint(seg2.rightSweepEvent) ||
+            seg1.leftSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+            seg1.leftSweepEvent.isSamePoint(seg2.rightSweepEvent)))
+        return false;
+    var x1 = seg1.leftSweepEvent.p.x;
+    var y1 = seg1.leftSweepEvent.p.y;
+    var x2 = seg1.rightSweepEvent.p.x;
+    var y2 = seg1.rightSweepEvent.p.y;
+    var x3 = seg2.leftSweepEvent.p.x;
+    var y3 = seg2.leftSweepEvent.p.y;
+    var x4 = seg2.rightSweepEvent.p.x;
+    var y4 = seg2.rightSweepEvent.p.y;
+    var denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+    var numeA = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+    var numeB = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+    if (denom === 0) {
+        if (numeA === 0 && numeB === 0)
+            return false;
+        return false;
+    }
+    var uA = numeA / denom;
+    var uB = numeB / denom;
+    if (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) {
+        var x = x1 + uA * (x2 - x1);
+        var y = y1 + uA * (y2 - y1);
+        return [x, y];
+    }
+    return false;
+}
+function runCheck(eventQueue, ignoreSelfIntersections) {
+    ignoreSelfIntersections = ignoreSelfIntersections
+        ? ignoreSelfIntersections
+        : false;
+    var intersectionPoints = [];
+    var outQueue = new tinyqueue([], checkWhichSegmentHasRightEndpointFirst);
+    while (eventQueue.length) {
+        var event = eventQueue.pop();
+        if (event.isLeftEndpoint) {
+            // debugEventAndSegments(event.p, outQueue.data)
+            var segment = new Segment(event);
+            for (var i = 0; i < outQueue.data.length; i++) {
+                var otherSeg = outQueue.data[i];
+                if (ignoreSelfIntersections) {
+                    if (otherSeg.leftSweepEvent.featureId === event.featureId)
+                        continue;
+                }
+                var intersection = testSegmentIntersect(segment, otherSeg);
+                if (intersection !== false)
+                    intersectionPoints.push(intersection);
+            }
+            outQueue.push(segment);
+        }
+        else if (event.isLeftEndpoint === false) {
+            outQueue.pop(); // const seg = outQueue.pop()
+            // debugRemovingSegment(event.p, seg)
+        }
+    }
+    return intersectionPoints;
+}
+function sweeplineIntersections(geojson, ignoreSelfIntersections) {
+    var eventQueue = new tinyqueue([], checkWhichEventIsLeft);
+    fillEventQueue(geojson, eventQueue);
+    return runCheck(eventQueue, ignoreSelfIntersections);
+}
+export default sweeplineIntersections;

frontend/node_modules/@turf/kinks/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

frontend/node_modules/@turf/kinks/dist/js/index.d.ts

@@ -0,0 +1,24 @@
+import { Feature, FeatureCollection, LineString, MultiLineString, MultiPolygon, Point, Polygon } from "@turf/helpers";
+/**
+ * Takes a {@link LineString|linestring}, {@link MultiLineString|multi-linestring},
+ * {@link MultiPolygon|multi-polygon} or {@link Polygon|polygon} and
+ * returns {@link Point|points} at all self-intersections.
+ *
+ * @name kinks
+ * @param {Feature<LineString|MultiLineString|MultiPolygon|Polygon>} featureIn input feature
+ * @returns {FeatureCollection<Point>} self-intersections
+ * @example
+ * var poly = turf.polygon([[
+ *   [-12.034835, 8.901183],
+ *   [-12.060413, 8.899826],
+ *   [-12.03638, 8.873199],
+ *   [-12.059383, 8.871418],
+ *   [-12.034835, 8.901183]
+ * ]]);
+ *
+ * var kinks = turf.kinks(poly);
+ *
+ * //addToMap
+ * var addToMap = [poly, kinks]
+ */
+export default function kinks<T extends LineString | MultiLineString | Polygon | MultiPolygon>(featureIn: Feature<T> | T): FeatureCollection<Point>;

frontend/node_modules/@turf/kinks/dist/js/index.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var helpers_1 = require("@turf/helpers");
+/**
+ * Takes a {@link LineString|linestring}, {@link MultiLineString|multi-linestring},
+ * {@link MultiPolygon|multi-polygon} or {@link Polygon|polygon} and
+ * returns {@link Point|points} at all self-intersections.
+ *
+ * @name kinks
+ * @param {Feature<LineString|MultiLineString|MultiPolygon|Polygon>} featureIn input feature
+ * @returns {FeatureCollection<Point>} self-intersections
+ * @example
+ * var poly = turf.polygon([[
+ *   [-12.034835, 8.901183],
+ *   [-12.060413, 8.899826],
+ *   [-12.03638, 8.873199],
+ *   [-12.059383, 8.871418],
+ *   [-12.034835, 8.901183]
+ * ]]);
+ *
+ * var kinks = turf.kinks(poly);
+ *
+ * //addToMap
+ * var addToMap = [poly, kinks]
+ */
+function kinks(featureIn) {
+    var coordinates;
+    var feature;
+    var results = {
+        type: "FeatureCollection",
+        features: [],
+    };
+    if (featureIn.type === "Feature") {
+        feature = featureIn.geometry;
+    }
+    else {
+        feature = featureIn;
+    }
+    if (feature.type === "LineString") {
+        coordinates = [feature.coordinates];
+    }
+    else if (feature.type === "MultiLineString") {
+        coordinates = feature.coordinates;
+    }
+    else if (feature.type === "MultiPolygon") {
+        coordinates = [].concat.apply([], feature.coordinates);
+    }
+    else if (feature.type === "Polygon") {
+        coordinates = feature.coordinates;
+    }
+    else {
+        throw new Error("Input must be a LineString, MultiLineString, " +
+            "Polygon, or MultiPolygon Feature or Geometry");
+    }
+    coordinates.forEach(function (line1) {
+        coordinates.forEach(function (line2) {
+            for (var i = 0; i < line1.length - 1; i++) {
+                // start iteration at i, intersections for k < i have already
+                // been checked in previous outer loop iterations
+                for (var k = i; k < line2.length - 1; k++) {
+                    if (line1 === line2) {
+                        // segments are adjacent and always share a vertex, not a kink
+                        if (Math.abs(i - k) === 1) {
+                            continue;
+                        }
+                        // first and last segment in a closed lineString or ring always share a vertex, not a kink
+                        if (
+                        // segments are first and last segment of lineString
+                        i === 0 &&
+                            k === line1.length - 2 &&
+                            // lineString is closed
+                            line1[i][0] === line1[line1.length - 1][0] &&
+                            line1[i][1] === line1[line1.length - 1][1]) {
+                            continue;
+                        }
+                    }
+                    var intersection = lineIntersects(line1[i][0], line1[i][1], line1[i + 1][0], line1[i + 1][1], line2[k][0], line2[k][1], line2[k + 1][0], line2[k + 1][1]);
+                    if (intersection) {
+                        results.features.push(helpers_1.point([intersection[0], intersection[1]]));
+                    }
+                }
+            }
+        });
+    });
+    return results;
+}
+exports.default = kinks;
+// modified from http://jsfiddle.net/justin_c_rounds/Gd2S2/light/
+function lineIntersects(line1StartX, line1StartY, line1EndX, line1EndY, line2StartX, line2StartY, line2EndX, line2EndY) {
+    // if the lines intersect, the result contains the x and y of the
+    // intersection (treating the lines as infinite) and booleans for whether
+    // line segment 1 or line segment 2 contain the point
+    var denominator;
+    var a;
+    var b;
+    var numerator1;
+    var numerator2;
+    var result = {
+        x: null,
+        y: null,
+        onLine1: false,
+        onLine2: false,
+    };
+    denominator =
+        (line2EndY - line2StartY) * (line1EndX - line1StartX) -
+            (line2EndX - line2StartX) * (line1EndY - line1StartY);
+    if (denominator === 0) {
+        if (result.x !== null && result.y !== null) {
+            return result;
+        }
+        else {
+            return false;
+        }
+    }
+    a = line1StartY - line2StartY;
+    b = line1StartX - line2StartX;
+    numerator1 = (line2EndX - line2StartX) * a - (line2EndY - line2StartY) * b;
+    numerator2 = (line1EndX - line1StartX) * a - (line1EndY - line1StartY) * b;
+    a = numerator1 / denominator;
+    b = numerator2 / denominator;
+    // if we cast these lines infinitely in both directions, they intersect here:
+    result.x = line1StartX + a * (line1EndX - line1StartX);
+    result.y = line1StartY + a * (line1EndY - line1StartY);
+    // if line1 is a segment and line2 is infinite, they intersect if:
+    if (a >= 0 && a <= 1) {
+        result.onLine1 = true;
+    }
+    // if line2 is a segment and line1 is infinite, they intersect if:
+    if (b >= 0 && b <= 1) {
+        result.onLine2 = true;
+    }
+    // if line1 and line2 are segments, they intersect if both of the above are true
+    if (result.onLine1 && result.onLine2) {
+        return [result.x, result.y];
+    }
+    else {
+        return false;
+    }
+}

frontend/node_modules/@turf/kinks/dist/js/lib/sweepline-intersections.d.ts

@@ -0,0 +1,2 @@
+export default sweeplineIntersections;
+declare function sweeplineIntersections(geojson: any, ignoreSelfIntersections: any): any[][];

frontend/node_modules/@turf/kinks/dist/js/lib/sweepline-intersections.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Inlined from
+// https://github.com/rowanwins/sweepline-intersections
+// Needed to go through babel to transform ES6 classes
+var commonjsGlobal = typeof globalThis !== "undefined"
+    ? globalThis
+    : typeof window !== "undefined"
+        ? window
+        : typeof global !== "undefined"
+            ? global
+            : typeof self !== "undefined"
+                ? self
+                : {};
+function createCommonjsModule(fn, module) {
+    return (module = { exports: {} }), fn(module, module.exports), module.exports;
+}
+var tinyqueue = createCommonjsModule(function (module) {
+    (function (global, factory) {
+        module.exports = factory();
+    })(commonjsGlobal, function () {
+        var TinyQueue = function TinyQueue(data, compare) {
+            if (data === void 0)
+                data = [];
+            if (compare === void 0)
+                compare = defaultCompare;
+            this.data = data;
+            this.length = this.data.length;
+            this.compare = compare;
+            if (this.length > 0) {
+                for (var i = (this.length >> 1) - 1; i >= 0; i--) {
+                    this._down(i);
+                }
+            }
+        };
+        TinyQueue.prototype.push = function push(item) {
+            this.data.push(item);
+            this.length++;
+            this._up(this.length - 1);
+        };
+        TinyQueue.prototype.pop = function pop() {
+            if (this.length === 0) {
+                return undefined;
+            }
+            var top = this.data[0];
+            var bottom = this.data.pop();
+            this.length--;
+            if (this.length > 0) {
+                this.data[0] = bottom;
+                this._down(0);
+            }
+            return top;
+        };
+        TinyQueue.prototype.peek = function peek() {
+            return this.data[0];
+        };
+        TinyQueue.prototype._up = function _up(pos) {
+            var ref = this;
+            var data = ref.data;
+            var compare = ref.compare;
+            var item = data[pos];
+            while (pos > 0) {
+                var parent = (pos - 1) >> 1;
+                var current = data[parent];
+                if (compare(item, current) >= 0) {
+                    break;
+                }
+                data[pos] = current;
+                pos = parent;
+            }
+            data[pos] = item;
+        };
+        TinyQueue.prototype._down = function _down(pos) {
+            var ref = this;
+            var data = ref.data;
+            var compare = ref.compare;
+            var halfLength = this.length >> 1;
+            var item = data[pos];
+            while (pos < halfLength) {
+                var left = (pos << 1) + 1;
+                var best = data[left];
+                var right = left + 1;
+                if (right < this.length && compare(data[right], best) < 0) {
+                    left = right;
+                    best = data[right];
+                }
+                if (compare(best, item) >= 0) {
+                    break;
+                }
+                data[pos] = best;
+                pos = left;
+            }
+            data[pos] = item;
+        };
+        function defaultCompare(a, b) {
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
+        return TinyQueue;
+    });
+});
+function checkWhichEventIsLeft(e1, e2) {
+    if (e1.p.x > e2.p.x)
+        return 1;
+    if (e1.p.x < e2.p.x)
+        return -1;
+    if (e1.p.y !== e2.p.y)
+        return e1.p.y > e2.p.y ? 1 : -1;
+    return 1;
+}
+function checkWhichSegmentHasRightEndpointFirst(seg1, seg2) {
+    if (seg1.rightSweepEvent.p.x > seg2.rightSweepEvent.p.x)
+        return 1;
+    if (seg1.rightSweepEvent.p.x < seg2.rightSweepEvent.p.x)
+        return -1;
+    if (seg1.rightSweepEvent.p.y !== seg2.rightSweepEvent.p.y)
+        return seg1.rightSweepEvent.p.y < seg2.rightSweepEvent.p.y ? 1 : -1;
+    return 1;
+}
+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 Event = /*#__PURE__*/ (function () {
+    function Event(p, featureId, ringId, eventId) {
+        _classCallCheck(this, Event);
+        this.p = {
+            x: p[0],
+            y: p[1],
+        };
+        this.featureId = featureId;
+        this.ringId = ringId;
+        this.eventId = eventId;
+        this.otherEvent = null;
+        this.isLeftEndpoint = null;
+    }
+    _createClass(Event, [
+        {
+            key: "isSamePoint",
+            value: function isSamePoint(eventToCheck) {
+                return this.p.x === eventToCheck.p.x && this.p.y === eventToCheck.p.y;
+            },
+        },
+    ]);
+    return Event;
+})();
+function fillEventQueue(geojson, eventQueue) {
+    if (geojson.type === "FeatureCollection") {
+        var features = geojson.features;
+        for (var i = 0; i < features.length; i++) {
+            processFeature(features[i], eventQueue);
+        }
+    }
+    else {
+        processFeature(geojson, eventQueue);
+    }
+}
+var featureId = 0;
+var ringId = 0;
+var eventId = 0;
+function processFeature(featureOrGeometry, eventQueue) {
+    var geom = featureOrGeometry.type === "Feature"
+        ? featureOrGeometry.geometry
+        : featureOrGeometry;
+    var coords = geom.coordinates; // standardise the input
+    if (geom.type === "Polygon" || geom.type === "MultiLineString")
+        coords = [coords];
+    if (geom.type === "LineString")
+        coords = [[coords]];
+    for (var i = 0; i < coords.length; i++) {
+        for (var ii = 0; ii < coords[i].length; ii++) {
+            var currentP = coords[i][ii][0];
+            var nextP = null;
+            ringId = ringId + 1;
+            for (var iii = 0; iii < coords[i][ii].length - 1; iii++) {
+                nextP = coords[i][ii][iii + 1];
+                var e1 = new Event(currentP, featureId, ringId, eventId);
+                var e2 = new Event(nextP, featureId, ringId, eventId + 1);
+                e1.otherEvent = e2;
+                e2.otherEvent = e1;
+                if (checkWhichEventIsLeft(e1, e2) > 0) {
+                    e2.isLeftEndpoint = true;
+                    e1.isLeftEndpoint = false;
+                }
+                else {
+                    e1.isLeftEndpoint = true;
+                    e2.isLeftEndpoint = false;
+                }
+                eventQueue.push(e1);
+                eventQueue.push(e2);
+                currentP = nextP;
+                eventId = eventId + 1;
+            }
+        }
+    }
+    featureId = featureId + 1;
+}
+var Segment = function Segment(event) {
+    _classCallCheck(this, Segment);
+    this.leftSweepEvent = event;
+    this.rightSweepEvent = event.otherEvent;
+};
+function testSegmentIntersect(seg1, seg2) {
+    if (seg1 === null || seg2 === null)
+        return false;
+    if (seg1.leftSweepEvent.ringId === seg2.leftSweepEvent.ringId &&
+        (seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+            seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+            seg1.rightSweepEvent.isSamePoint(seg2.rightSweepEvent) ||
+            seg1.leftSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+            seg1.leftSweepEvent.isSamePoint(seg2.rightSweepEvent)))
+        return false;
+    var x1 = seg1.leftSweepEvent.p.x;
+    var y1 = seg1.leftSweepEvent.p.y;
+    var x2 = seg1.rightSweepEvent.p.x;
+    var y2 = seg1.rightSweepEvent.p.y;
+    var x3 = seg2.leftSweepEvent.p.x;
+    var y3 = seg2.leftSweepEvent.p.y;
+    var x4 = seg2.rightSweepEvent.p.x;
+    var y4 = seg2.rightSweepEvent.p.y;
+    var denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+    var numeA = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+    var numeB = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+    if (denom === 0) {
+        if (numeA === 0 && numeB === 0)
+            return false;
+        return false;
+    }
+    var uA = numeA / denom;
+    var uB = numeB / denom;
+    if (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) {
+        var x = x1 + uA * (x2 - x1);
+        var y = y1 + uA * (y2 - y1);
+        return [x, y];
+    }
+    return false;
+}
+function runCheck(eventQueue, ignoreSelfIntersections) {
+    ignoreSelfIntersections = ignoreSelfIntersections
+        ? ignoreSelfIntersections
+        : false;
+    var intersectionPoints = [];
+    var outQueue = new tinyqueue([], checkWhichSegmentHasRightEndpointFirst);
+    while (eventQueue.length) {
+        var event = eventQueue.pop();
+        if (event.isLeftEndpoint) {
+            // debugEventAndSegments(event.p, outQueue.data)
+            var segment = new Segment(event);
+            for (var i = 0; i < outQueue.data.length; i++) {
+                var otherSeg = outQueue.data[i];
+                if (ignoreSelfIntersections) {
+                    if (otherSeg.leftSweepEvent.featureId === event.featureId)
+                        continue;
+                }
+                var intersection = testSegmentIntersect(segment, otherSeg);
+                if (intersection !== false)
+                    intersectionPoints.push(intersection);
+            }
+            outQueue.push(segment);
+        }
+        else if (event.isLeftEndpoint === false) {
+            outQueue.pop(); // const seg = outQueue.pop()
+            // debugRemovingSegment(event.p, seg)
+        }
+    }
+    return intersectionPoints;
+}
+function sweeplineIntersections(geojson, ignoreSelfIntersections) {
+    var eventQueue = new tinyqueue([], checkWhichEventIsLeft);
+    fillEventQueue(geojson, eventQueue);
+    return runCheck(eventQueue, ignoreSelfIntersections);
+}
+exports.default = sweeplineIntersections;