geojson-polygon-self-intersections 1.2.1 → 2.0.0

package/README.md

@@ -1,34 +1,52 @@
 # geojson-polygon-self-intersections
 
-A very simple script to compute all self-intersections in a GeoJSON polygon.
+A very simple module to compute all self-intersections in coordinates of a polygon.
 
-According to the [Simple Features standard](https://en.wikipedia.org/wiki/Simple_Features), polygons may not self-intersect. GeoJSON, however, doesn't care about this. You can use this tool to check for self-intersections, list them or use them in some way.
+According to the [Simple Features standard](https://en.wikipedia.org/wiki/Simple_Features), polygons may not self-intersect. GeoJSON, however, doesn't care about this. You can use this tool to check for and/or retrieve self-intersections.
 
-This tool uses the [rbush](https://github.com/mourner/rbush) spatial index by default to speed up the detection of intersections. This is especially useful when are many edges but only few intersections. If you prefer, you can opt-out using an input parameter (see below) and it will perform a brute-force search for intersections instead. This might be preferable in case of few edges, as it allows you to avoid some overhead.
+## Installation
 
-# Usage
+This package works in browsers and in Node.js as an ESM module.
 
-Get Node.js, then
+Install Node.js or any compatible JavaScript runtime, then install this package with your favorite package manager.
 
-```bash
+```sh
 npm install geojson-polygon-self-intersections
 ```
 
-and use it like so:
+You can optionally build this package locally by running:
 
-```javascript
-var gpsi = require('geojson-polygon-self-intersections');
+```sh
+npm run build
+```
+
+## Usage
+
+```js
+import gpsi from 'geojson-polygon-self-intersections'
 
-// poly = {type: "Feature", geometry: {type: "Polygon", coordinates: [[[1, 10], [11, 13], ...]]}}
+// feature = {type: "Feature", geometry: {type: "Polygon", coordinates: [[[1, 10], [11, 13], ...]]}}
 
-var isects = gpsi(poly);
+const isects = gpsi(feature.geometry.coordinates);
 
-// isects = {type: "Feature", geometry: {type: "MultiPoint", coordinates: [[5, 8], [7, 3], ...]}}
+// isects = [[5, 8], [7, 3], ...]
 ```
 
-Where `poly` is a GeoJSON Polygon, and `isects` is a GeoJSON MultiPoint.
+Where `feature` is a GeoJSON Feature of Polygon *geometry*, who's coordinates are an Array of Array of Positions, where each position has at least two coordinates. Only the first two coordinates (typically *X* and *Y* or *lon* and *lat*) are taken into account.
+
+### Options
+
+The following options can be passed as a second argument to control the behaviour of the algorithm.
+
+| Option                 | Description                                                                                                                                                                                                                                                                                                                            |
+|------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `useSpatialIndex`      | Whether a spatial index should be used to filter for possible intersections. Default: `true`                                                                                                                                                                                                                                           |
+| `reportVertexOnVertex` | If the same vertex (or almost the same vertex) appears more than once in the input, should this be reported as an intersection? Default: `false`                                                                                                                                                                                       |
+| `reportVertexOnEdge`   | If a vertex lies (almost) exactly on an edge segment, should this be reported as an intersection? Default: `false`                                                                                                                                                                                                                     |
+| `epsilon`              | It is almost never a good idea to compare floating point numbers for identity. Therefor, if we say "the same vertex" or "exactly on an edge segment", we need to define how "close" is "close enough". Note that the value is *not* used as an euclidian distance but always relative to the length of some edge segment. Default: `0` |
+| `callbackFunction`              | A callback function can be specified to process the output. See below. Default: `{ isect } => isect` |
 
-Alternatively, you can use a filter function to specify the output. You have access to the following data per point:
+For the callback function, you have access to the following data per intersection point:
 
 - [x,y] intersection coordinates: `isect`
 - ring index of the first edge: `ring0`
@@ -39,25 +57,28 @@ Alternatively, you can use a filter function to specify the output. You have acc
 - idem for the second edge: `ring1`, `edge1`, `start1`, `end1`, `frac1`
 - boolean indicating if the intersection is unique: `unique`
 
-Finally, you can pass an option object to control the behaviour of the algorithm.
-The following options are supported:
-
-|Option|Description|
-|------|-----------|
-| `useSpatialIndex` | Whether a spatial index should be used to filter for possible intersections. Default: `true` |
-| `reportVertexOnVertex` | If the same vertex (or almost the same vertex) appears more than once in the input, should this be reported as an intersection? Default: `false`|
-| `reportVertexOnEdge` | If a vertex lies (almost) exactly on an edge segment, should this be reported as an intersection? Default: `false` |
-| `epsilon` | It is almost never a good idea to compare floating point numbers for identity. Therefor, if we say "the same vertex" or "exactly on an edge segment", we need to define how "close" is "close enough". Note that the value is *not* used as an euclidian distance but always relative to the length of some edge segment. Default: `0`|
 
 Together, this may look like so:
 
-```javascript
-var options = {
-  useSpatialIndex:false
-};
-var isects = gpsi(poly, function filterFn(isect, ring0, edge0, start0, end0, frac0, ring1, edge1, start1, end1, frac1, unique){return [isect, frac0, frac1];}, options);
+```js
+const options = {
+  useSpatialIndex: false,
+  callbackFunction: ({ isect, frac0, frac1 }) => { return [isect, frac0, frac1] }
+}
+const isects = gpsi(feature.geometry.coordinates, options);
 
 // isects = [[[5, 8], 0.4856, 0.1865]], [[[7, 3], 0.3985, 0.9658]], ...]
 ```
-For backwards compatibility, if you pass anything other than an object, it will be interpreted as the value of the
-`useSpatialIndex`-option.
+
+## Speed
+
+This tool uses the [rbush](https://github.com/mourner/rbush) spatial index by default to speed up the detection of intersections. This is especially useful when are many edges but only few intersections. If you prefer, you can opt-out using an options parameter (see below) and it will perform a brute-force search for intersections instead. This might be preferable in case of few edges, as it allows you to avoid some overhead.
+
+## Changelog
+
+### 2.0.0 - 2025-12-22
+
+- This is now an ESM module written in TypeScript
+- Inputs and outputs are now bare polygon coordinates and no longer GeoJSON Features with a polygon geometry. The package name is kept for continuity, and because it relates to GeoJSON not being as strict as the Simple Feature standard w.r.t. self-intersection.
+- *Filter function* is now called *callback function* and part of the options
+- Options must always be an object, only passing a boolean for `useSpatialIndex` is no longer supported

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { Position } from 'geojson';
+type CallbackFunctionInput = {
+    isect: Position;
+    ring0: number;
+    edge0: number;
+    start0: Position;
+    end0: Position;
+    frac0: number;
+    ring1: number;
+    edge1: number;
+    start1: Position;
+    end1: Position;
+    frac1: number;
+    unique: boolean;
+};
+type Options = {
+    useSpatialIndex: boolean;
+    epsilon: number;
+    reportVertexOnVertex: boolean;
+    reportVertexOnEdge: boolean;
+    callbackFunction: (callbackFunctionInput: CallbackFunctionInput) => any;
+};
+/**
+ * Return a polygon's self-intersections
+ *
+ * @export
+ * @param {Position[][]} polygon
+ * @param {?(Partial<Options>)} [partialOptions] Option
+ * @returns {any[]} Array of self-intersection points (or any type produced by the callback function)
+ */
+export default function gpsi(polygon: Position[][], partialOptions?: Partial<Options>): any[];
+/**
+ * Compute where two lines intersect.
+ *
+ * From https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
+ *
+ * @param {Position} start0
+ * @param {Position} end0
+ * @param {Position} start1
+ * @param {Position} end1
+ * @returns {(Position | undefined)} The point of intersection, or undefined if no intersection
+ */
+export declare function intersect(start0: Position, end0: Position, start1: Position, end1: Position): Position | undefined;
+export declare function equalArrays(array1: any[], array2: any[]): boolean;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAGlC,KAAK,qBAAqB,GAAG;IAC3B,KAAK,EAAE,QAAQ,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,QAAQ,CAAA;IAChB,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,QAAQ,CAAA;IAChB,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AACD,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,oBAAoB,EAAE,OAAO,CAAA;IAC7B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,gBAAgB,EAAE,CAAC,qBAAqB,EAAE,qBAAqB,KAAK,GAAG,CAAA;CACxE,CAAA;AAkBD;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,OAAO,EAAE,QAAQ,EAAE,EAAE,EACrB,cAAc,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,GAChC,GAAG,EAAE,CAsHP;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,QAAQ,GACb,QAAQ,GAAG,SAAS,CAyBtB;AAGD,wBAAgB,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAkBjE"}

package/dist/index.js

@@ -0,0 +1,210 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import RBush from 'rbush';
+const defaultOptions = {
+    useSpatialIndex: true,
+    epsilon: 0,
+    reportVertexOnVertex: false,
+    reportVertexOnEdge: false,
+    callbackFunction: ({ isect }) => isect
+};
+/**
+ * Return a polygon's self-intersections
+ *
+ * @export
+ * @param {Position[][]} polygon
+ * @param {?(Partial<Options>)} [partialOptions] Option
+ * @returns {any[]} Array of self-intersection points (or any type produced by the callback function)
+ */
+export default function gpsi(polygon, partialOptions) {
+    const options = mergeOptions(defaultOptions, partialOptions);
+    const output = [];
+    const seen = {};
+    let tree;
+    if (options.useSpatialIndex) {
+        const allEdgesAsRbushTreeItems = [];
+        for (let ring0 = 0; ring0 < polygon.length; ring0++) {
+            for (let edge0 = 0; edge0 < polygon[ring0].length - 1; edge0++) {
+                allEdgesAsRbushTreeItems.push(rbushTreeItem(polygon, ring0, edge0));
+            }
+        }
+        tree = new RBush();
+        tree.load(allEdgesAsRbushTreeItems);
+    }
+    for (let ring0 = 0; ring0 < polygon.length; ring0++) {
+        for (let edge0 = 0; edge0 < polygon[ring0].length - 1; edge0++) {
+            if (options.useSpatialIndex) {
+                const bboxOverlaps = tree.search(rbushTreeItem(polygon, ring0, edge0));
+                bboxOverlaps.forEach(function (bboxIsect) {
+                    const ring1 = bboxIsect.ring;
+                    const edge1 = bboxIsect.edge;
+                    ifIsectAddToOutput(ring0, edge0, ring1, edge1);
+                });
+            }
+            else {
+                for (let ring1 = 0; ring1 < polygon.length; ring1++) {
+                    for (let edge1 = 0; edge1 < polygon[ring1].length - 1; edge1++) {
+                        // TODO: speedup possible if only interested in unique: start last two loops at ring0 and edge0+1
+                        ifIsectAddToOutput(ring0, edge0, ring1, edge1);
+                    }
+                }
+            }
+        }
+    }
+    // Check if two edges intersect and add the intersection to the output
+    function ifIsectAddToOutput(ring0, edge0, ring1, edge1) {
+        const start0 = polygon[ring0][edge0];
+        const end0 = polygon[ring0][edge0 + 1];
+        const start1 = polygon[ring1][edge1];
+        const end1 = polygon[ring1][edge1 + 1];
+        const isect = intersect(start0, end0, start1, end1);
+        if (isect == undefined)
+            return; // discard parallels and coincidence
+        let frac0;
+        let frac1;
+        if (end0[0] != start0[0]) {
+            frac0 = (isect[0] - start0[0]) / (end0[0] - start0[0]);
+        }
+        else {
+            frac0 = (isect[1] - start0[1]) / (end0[1] - start0[1]);
+        }
+        if (end1[0] != start1[0]) {
+            frac1 = (isect[0] - start1[0]) / (end1[0] - start1[0]);
+        }
+        else {
+            frac1 = (isect[1] - start1[1]) / (end1[1] - start1[1]);
+        }
+        // There are roughly three cases we need to deal with.
+        // 1. If at least one of the fracs lies outside [0,1], there is no intersection.
+        if (isOutside(frac0, options.epsilon) ||
+            isOutside(frac1, options.epsilon)) {
+            return; // require segment intersection
+        }
+        // 2. If both are either exactly 0 or exactly 1, this is not an intersection but just
+        // two edge segments sharing a common vertex.
+        if (isBoundaryCase(frac0, options.epsilon) &&
+            isBoundaryCase(frac1, options.epsilon)) {
+            if (!options.reportVertexOnVertex)
+                return;
+        }
+        // 3. If only one of the fractions is exactly 0 or 1, this is
+        // a vertex-on-edge situation.
+        if (isBoundaryCase(frac0, options.epsilon) ||
+            isBoundaryCase(frac1, options.epsilon)) {
+            if (!options.reportVertexOnEdge)
+                return;
+        }
+        const key = isect;
+        const unique = !seen[String(key)];
+        if (unique) {
+            seen[String(key)] = true;
+        }
+        output.push(options.callbackFunction({
+            isect,
+            ring0,
+            edge0,
+            start0,
+            end0,
+            frac0,
+            ring1,
+            edge1,
+            start1,
+            end1,
+            frac1,
+            unique
+        }));
+    }
+    return output;
+}
+/**
+ * Compute where two lines intersect.
+ *
+ * From https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
+ *
+ * @param {Position} start0
+ * @param {Position} end0
+ * @param {Position} start1
+ * @param {Position} end1
+ * @returns {(Position | undefined)} The point of intersection, or undefined if no intersection
+ */
+export function intersect(start0, end0, start1, end1) {
+    if (equalArrays(start0, start1) ||
+        equalArrays(start0, end1) ||
+        equalArrays(end0, start1) ||
+        equalArrays(end1, start1)) {
+        return undefined;
+    }
+    const x0 = start0[0], y0 = start0[1], x1 = end0[0], y1 = end0[1], x2 = start1[0], y2 = start1[1], x3 = end1[0], y3 = end1[1];
+    const denom = (x0 - x1) * (y2 - y3) - (y0 - y1) * (x2 - x3);
+    if (denom == 0)
+        return undefined;
+    const x4 = ((x0 * y1 - y0 * x1) * (x2 - x3) - (x0 - x1) * (x2 * y3 - y2 * x3)) / denom;
+    const y4 = ((x0 * y1 - y0 * x1) * (y2 - y3) - (y0 - y1) * (x2 * y3 - y2 * x3)) / denom;
+    return [x4, y4];
+}
+// Check if arrays are equal.
+export function equalArrays(array1, array2) {
+    // If the other array is a falsy value, return
+    if (!array1 || !array2)
+        return false;
+    // Compare lengths - can save a lot of time
+    if (array1.length != array2.length)
+        return false;
+    for (let i = 0, l = array1.length; i < l; i++) {
+        // Check if we have nested arrays
+        if (array1[i] instanceof Array && array2[i] instanceof Array) {
+            // Recurse into the nested arrays
+            if (!equalArrays(array1[i], array2[i]))
+                return false;
+        }
+        else if (array1[i] != array2[i]) {
+            // Warning - two different object instances will never be equal: {x:20} != {x:20}
+            return false;
+        }
+    }
+    return true;
+}
+// Check if boundary case: true if frac is (almost) 1.0 or 0.0
+function isBoundaryCase(frac, epsilon) {
+    const e2 = epsilon * epsilon;
+    return e2 >= (frac - 1) * (frac - 1) || e2 >= frac * frac;
+}
+// Check if outside
+function isOutside(frac, epsilon) {
+    return frac < 0 - epsilon || frac > 1 + epsilon;
+}
+// Return a rbush tree item given an ring and edge number
+function rbushTreeItem(polygon, ring, edge) {
+    const start = polygon[ring][edge];
+    const end = polygon[ring][edge + 1];
+    let minX;
+    let maxX;
+    let minY;
+    let maxY;
+    if (start[0] < end[0]) {
+        minX = start[0];
+        maxX = end[0];
+    }
+    else {
+        minX = end[0];
+        maxX = start[0];
+    }
+    if (start[1] < end[1]) {
+        minY = start[1];
+        maxY = end[1];
+    }
+    else {
+        minY = end[1];
+        maxY = start[1];
+    }
+    return {
+        minX: minX,
+        minY: minY,
+        maxX: maxX,
+        maxY: maxY,
+        ring: ring,
+        edge: edge
+    };
+}
+function mergeOptions(option0, options1) {
+    return { ...option0, ...options1 };
+}

package/package.json

@@ -1,27 +1,64 @@
 {
   "name": "geojson-polygon-self-intersections",
-  "version": "1.2.1",
-  "main": "index.js",
+  "version": "2.0.0",
+  "author": {
+    "name": "Manuel Claeys Bouuaert",
+    "email": "manuel.claeys.b@gmail.com",
+    "url": "https://manuelclaeysbouuaert.be"
+  },
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mclaeysb/geojson-polygon-self-intersections.git"
   },
+  "homepage": "https://github.com/mclaeysb/geojson-polygon-self-intersections#readme",
+  "bugs": {
+    "url": "https://github.com/mclaeysb/geojson-polygon-self-intersections/issues"
+  },
+  "description": "Find self-intersections in geojson polygon (possibly with interior rings)",
   "keywords": [
     "polygon",
     "complex polygon",
     "simple polygon",
     "self-intersection"
   ],
-  "author": {
-    "name": "Manuel Claeys Bouuaert"
-  },
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/mclaeysb/geojson-polygon-self-intersections/issues"
+  "scripts": {
+    "watch": "tsc --watch",
+    "build": "tsc",
+    "test": "NODE_ENV=test vitest run",
+    "lint": "prettier --check src test && eslint src test --ext .js,.ts",
+    "format": "prettier --write src test",
+    "types": "tsc --noEmit"
   },
   "dependencies": {
-    "rbush": "^2.0.1"
+    "rbush": "4.0.1"
   },
-  "devDependencies": {},
-  "homepage": "https://github.com/mclaeysb/geojson-polygon-self-intersections#readme"
+  "devDependencies": {
+    "@eslint/eslintrc": "3.3.3",
+    "@eslint/js": "9.39.2",
+    "@types/geojson": "7946.0.16",
+    "@types/rbush": "4.0.0",
+    "eslint": "9.39.2",
+    "eslint-config-prettier": "10.1.8",
+    "globals": "16.5.0",
+    "prettier": "3.7.4",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.50.0",
+    "vitest": "4.0.16"
+  }
 }

package/index.js

@@ -1,196 +0,0 @@
-// Find self-intersections in geojson polygon (possibly with interior rings)
-var rbush = require('rbush');
-
-
-var merge = function(){
-  var output = {};
-  Array.prototype.slice.call(arguments).forEach(function(arg){
-    if(arg){
-      Object.keys(arg).forEach(function(key){
-        output[key]=arg[key];
-      });
-    }
-  });
-  return output;
-};
-var defaults = {
-  useSpatialIndex: true,
-  epsilon: 0,
-  reportVertexOnVertex: false,
-  reportVertexOnEdge: false
-};
-
-module.exports = function(feature, filterFn, options0) {
-  var options;
-  if("object" === typeof options0){
-    options = merge(defaults,options0);
-  } else {
-    options = merge(defaults,{useSpatialIndex:options0});
-  }
-
-  if (feature.geometry.type != "Polygon") throw new Error("The input feature must be a Polygon");
-
-  var coord = feature.geometry.coordinates;
-
-  var output = [];
-  var seen = {};
-
-  if (options.useSpatialIndex) {
-    var allEdgesAsRbushTreeItems = [];
-    for (var ring0 = 0; ring0 < coord.length; ring0++) {
-      for (var edge0 = 0; edge0 < coord[ring0].length-1; edge0++) {
-        allEdgesAsRbushTreeItems.push(rbushTreeItem(ring0, edge0))
-      }
-    }
-    var tree = rbush();
-    tree.load(allEdgesAsRbushTreeItems);
-  }
-
-  for (var ring0 = 0; ring0 < coord.length; ring0++) {
-    for (var edge0 = 0; edge0 < coord[ring0].length-1; edge0++) {
-      if (options.useSpatialIndex) {
-        var bboxOverlaps = tree.search(rbushTreeItem(ring0, edge0));
-        bboxOverlaps.forEach(function(bboxIsect) {
-          var ring1 = bboxIsect.ring;
-          var edge1 = bboxIsect.edge;
-          ifIsectAddToOutput(ring0, edge0, ring1, edge1);
-        });
-      }
-      else {
-        for (var ring1 = 0; ring1 < coord.length; ring1++) {
-          for (var edge1 = 0 ; edge1 < coord[ring1].length-1; edge1++) {
-            // TODO: speedup possible if only interested in unique: start last two loops at ring0 and edge0+1
-            ifIsectAddToOutput(ring0, edge0, ring1, edge1);
-          }
-        }
-      }
-    }
-  }
-
-  if (!filterFn) output = {type: "Feature", geometry: {type: "MultiPoint", coordinates: output}};
-  return output;
-
-  // true if frac is (almost) 1.0 or 0.0
-  function isBoundaryCase(frac){
-    var e2 = options.epsilon * options.epsilon;
-    return e2 >= (frac-1)*(frac-1) || e2 >= frac*frac;
-  }
-  function isOutside(frac){
-    return frac < 0 - options.epsilon || frac > 1 + options.epsilon;
-  }
-  // Function to check if two edges intersect and add the intersection to the output
-  function ifIsectAddToOutput(ring0, edge0, ring1, edge1) {
-    var start0 = coord[ring0][edge0];
-    var end0 = coord[ring0][edge0+1];
-    var start1 = coord[ring1][edge1];
-    var end1 = coord[ring1][edge1+1];
-
-    var isect = intersect(start0, end0, start1, end1);
-
-    if (isect == null) return; // discard parallels and coincidence
-    frac0, frac1;
-    if (end0[0] != start0[0]) {
-      var frac0 = (isect[0]-start0[0])/(end0[0]-start0[0]);
-    } else {
-      var frac0 = (isect[1]-start0[1])/(end0[1]-start0[1]);
-    };
-    if (end1[0] != start1[0]) {
-      var frac1 = (isect[0]-start1[0])/(end1[0]-start1[0]);
-    } else {
-      var frac1 = (isect[1]-start1[1])/(end1[1]-start1[1]);
-    };
-
-    // There are roughly three cases we need to deal with.
-    // 1. If at least one of the fracs lies outside [0,1], there is no intersection.
-    if (isOutside(frac0) || isOutside(frac1)) {
-      return; // require segment intersection
-    }
-
-    // 2. If both are either exactly 0 or exactly 1, this is not an intersection but just
-    // two edge segments sharing a common vertex.
-    if (isBoundaryCase(frac0) && isBoundaryCase(frac1)){
-      if(! options.reportVertexOnVertex) return;
-    }
-
-    // 3. If only one of the fractions is exactly 0 or 1, this is
-    // a vertex-on-edge situation.
-    if (isBoundaryCase(frac0) || isBoundaryCase(frac1)){
-      if(! options.reportVertexOnEdge) return;
-    }
-
-    var key = isect;
-    var unique = !seen[key];
-    if (unique) {
-      seen[key] = true;
-    }
-
-    if (filterFn) {
-      output.push(filterFn(isect, ring0, edge0, start0, end0, frac0, ring1, edge1, start1, end1, frac1, unique));
-    } else {
-      output.push(isect);
-    }
-  }
-
-  // Function to return a rbush tree item given an ring and edge number
-  function rbushTreeItem(ring, edge) {
-
-    var start = coord[ring][edge];
-    var end = coord[ring][edge+1];
-
-    if (start[0] < end[0]) {
-      var minX = start[0], maxX = end[0];
-    } else {
-      var minX = end[0], maxX = start[0];
-    };
-    if (start[1] < end[1]) {
-      var minY = start[1], maxY = end[1];
-    } else {
-      var minY = end[1], maxY = start[1];
-    }
-    return {minX: minX, minY: minY, maxX: maxX, maxY: maxY, ring: ring, edge: edge};
-  }
-
-}
-
-// Function to compute where two lines (not segments) intersect. From https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
-function intersect(start0, end0, start1, end1) {
-  if (equalArrays(start0,start1) || equalArrays(start0,end1) || equalArrays(end0,start1) || equalArrays(end1,start1)) return null;
-  var x0 = start0[0],
-      y0 = start0[1],
-      x1 = end0[0],
-      y1 = end0[1],
-      x2 = start1[0],
-      y2 = start1[1],
-      x3 = end1[0],
-      y3 = end1[1];
-  var denom = (x0 - x1) * (y2 - y3) - (y0 - y1) * (x2 - x3);
-  if (denom == 0) return null;
-  var x4 = ((x0 * y1 - y0 * x1) * (x2 - x3) - (x0 - x1) * (x2 * y3 - y2 * x3)) / denom;
-  var y4 = ((x0 * y1 - y0 * x1) * (y2 - y3) - (y0 - y1) * (x2 * y3 - y2 * x3)) / denom;
-  return [x4, y4];
-}
-
-// Function to compare Arrays of numbers. From http://stackoverflow.com/questions/7837456/how-to-compare-arrays-in-javascript
-function equalArrays(array1, array2) {
-  // if the other array is a falsy value, return
-  if (!array1 || !array2)
-      return false;
-
-  // compare lengths - can save a lot of time
-  if (array1.length != array2.length)
-      return false;
-
-  for (var i = 0, l=array1.length; i < l; i++) {
-      // Check if we have nested arrays
-      if (array1[i] instanceof Array && array2[i] instanceof Array) {
-          // recurse into the nested arrays
-          if (!equalArrays(array1[i],array2[i]))
-              return false;
-      }
-      else if (array1[i] != array2[i]) {
-          // Warning - two different object instances will never be equal: {x:20} != {x:20}
-          return false;
-      }
-  }
-  return true;
-}