@turf/polygonize 6.5.0 → 7.0.0-alpha.1

package/dist/es/lib/Graph.js

@@ -17,7 +17,7 @@ function validateGeoJson(geoJson) {
         geoJson.type !== "MultiLineString" &&
         geoJson.type !== "LineString" &&
         geoJson.type !== "Feature")
-        throw new Error("Invalid input type '" + geoJson.type + "'. Geojson must be FeatureCollection, GeometryCollection, LineString, MultiLineString or Feature");
+        throw new Error(`Invalid input type '${geoJson.type}'. Geojson must be FeatureCollection, GeometryCollection, LineString, MultiLineString or Feature`);
 }
 /**
  * Represents a planar graph of edges and nodes that can be used to compute a polygonization.
@@ -28,8 +28,8 @@ function validateGeoJson(geoJson) {
  *
  * This graph is directed (both directions are created)
  */
-var Graph = /** @class */ (function () {
-    function Graph() {
+export default class Graph {
+    constructor() {
         this.edges = []; //< {Edge[]} dirEdges
         // The key is the `id` of the Node (ie: coordinates.join(','))
         this.nodes = {};
@@ -41,35 +41,35 @@ var Graph = /** @class */ (function () {
      * @returns {Graph} - The newly created graph
      * @throws {Error} if geoJson is invalid.
      */
-    Graph.fromGeoJson = function (geoJson) {
+    static fromGeoJson(geoJson) {
         validateGeoJson(geoJson);
-        var graph = new Graph();
-        flattenEach(geoJson, function (feature) {
+        const graph = new Graph();
+        flattenEach(geoJson, (feature) => {
             featureOf(feature, "LineString", "Graph::fromGeoJson");
             // When a LineString if formed by many segments, split them
-            coordReduce(feature, function (prev, cur) {
+            coordReduce(feature, (prev, cur) => {
                 if (prev) {
-                    var start = graph.getNode(prev), end = graph.getNode(cur);
+                    const start = graph.getNode(prev), end = graph.getNode(cur);
                     graph.addEdge(start, end);
                 }
                 return cur;
             });
         });
         return graph;
-    };
+    }
     /**
      * Creates or get a Node.
      *
      * @param {number[]} coordinates - Coordinates of the node
      * @returns {Node} - The created or stored node
      */
-    Graph.prototype.getNode = function (coordinates) {
-        var id = Node.buildId(coordinates);
-        var node = this.nodes[id];
+    getNode(coordinates) {
+        const id = Node.buildId(coordinates);
+        let node = this.nodes[id];
         if (!node)
             node = this.nodes[id] = new Node(coordinates);
         return node;
-    };
+    }
     /**
      * Adds an Edge and its symetricall.
      *
@@ -78,20 +78,19 @@ var Graph = /** @class */ (function () {
      * @param {Node} from - Node which starts the Edge
      * @param {Node} to - Node which ends the Edge
      */
-    Graph.prototype.addEdge = function (from, to) {
-        var edge = new Edge(from, to), symetricEdge = edge.getSymetric();
+    addEdge(from, to) {
+        const edge = new Edge(from, to), symetricEdge = edge.getSymetric();
         this.edges.push(edge);
         this.edges.push(symetricEdge);
-    };
+    }
     /**
      * Removes Dangle Nodes (nodes with grade 1).
      */
-    Graph.prototype.deleteDangles = function () {
-        var _this = this;
+    deleteDangles() {
         Object.keys(this.nodes)
-            .map(function (id) { return _this.nodes[id]; })
-            .forEach(function (node) { return _this._removeIfDangle(node); });
-    };
+            .map((id) => this.nodes[id])
+            .forEach((node) => this._removeIfDangle(node));
+    }
     /**
      * Check if node is dangle, if so, remove it.
      *
@@ -99,15 +98,14 @@ var Graph = /** @class */ (function () {
      *
      * @param {Node} node - Node to check if it's a dangle
      */
-    Graph.prototype._removeIfDangle = function (node) {
-        var _this = this;
+    _removeIfDangle(node) {
         // As edges are directed and symetrical, we count only innerEdges
         if (node.innerEdges.length <= 1) {
-            var outerNodes = node.getOuterEdges().map(function (e) { return e.to; });
+            const outerNodes = node.getOuterEdges().map((e) => e.to);
             this.removeNode(node);
-            outerNodes.forEach(function (n) { return _this._removeIfDangle(n); });
+            outerNodes.forEach((n) => this._removeIfDangle(n));
         }
-    };
+    }
     /**
      * Delete cut-edges (bridge edges).
      *
@@ -115,18 +113,17 @@ var Graph = /** @class */ (function () {
      * in which they are. (The label is a number incremented by 1). Edges with the same
      * label are cut-edges.
      */
-    Graph.prototype.deleteCutEdges = function () {
-        var _this = this;
+    deleteCutEdges() {
         this._computeNextCWEdges();
         this._findLabeledEdgeRings();
         // Cut-edges (bridges) are edges where both edges have the same label
-        this.edges.forEach(function (edge) {
+        this.edges.forEach((edge) => {
             if (edge.label === edge.symetric.label) {
-                _this.removeEdge(edge.symetric);
-                _this.removeEdge(edge);
+                this.removeEdge(edge.symetric);
+                this.removeEdge(edge);
             }
         });
-    };
+    }
     /**
      * Set the `next` property of each Edge.
      *
@@ -135,19 +132,16 @@ var Graph = /** @class */ (function () {
      *
      * @param {Node} [node] - If no node is passed, the function calls itself for every node in the Graph
      */
-    Graph.prototype._computeNextCWEdges = function (node) {
-        var _this = this;
+    _computeNextCWEdges(node) {
         if (typeof node === "undefined") {
-            Object.keys(this.nodes).forEach(function (id) {
-                return _this._computeNextCWEdges(_this.nodes[id]);
-            });
+            Object.keys(this.nodes).forEach((id) => this._computeNextCWEdges(this.nodes[id]));
         }
         else {
-            node.getOuterEdges().forEach(function (edge, i) {
+            node.getOuterEdges().forEach((edge, i) => {
                 node.getOuterEdge((i === 0 ? node.getOuterEdges().length : i) - 1).symetric.next = edge;
             });
         }
-    };
+    }
     /**
      * Computes the next edge pointers going CCW around the given node, for the given edgering label.
      *
@@ -159,11 +153,11 @@ var Graph = /** @class */ (function () {
      * @param {Node} node - Node
      * @param {number} label - Ring's label
      */
-    Graph.prototype._computeNextCCWEdges = function (node, label) {
-        var edges = node.getOuterEdges();
-        var firstOutDE, prevInDE;
-        for (var i = edges.length - 1; i >= 0; --i) {
-            var de = edges[i], sym = de.symetric, outDE = void 0, inDE = void 0;
+    _computeNextCCWEdges(node, label) {
+        const edges = node.getOuterEdges();
+        let firstOutDE, prevInDE;
+        for (let i = edges.length - 1; i >= 0; --i) {
+            let de = edges[i], sym = de.symetric, outDE, inDE;
             if (de.label === label)
                 outDE = de;
             if (sym.label === label)
@@ -184,7 +178,7 @@ var Graph = /** @class */ (function () {
         }
         if (prevInDE)
             prevInDE.next = firstOutDE;
-    };
+    }
     /**
      * Finds rings and labels edges according to which rings are.
      *
@@ -192,14 +186,14 @@ var Graph = /** @class */ (function () {
      *
      * @returns {Edge[]} edges that start rings
      */
-    Graph.prototype._findLabeledEdgeRings = function () {
-        var edgeRingStarts = [];
-        var label = 0;
-        this.edges.forEach(function (edge) {
+    _findLabeledEdgeRings() {
+        const edgeRingStarts = [];
+        let label = 0;
+        this.edges.forEach((edge) => {
             if (edge.label >= 0)
                 return;
             edgeRingStarts.push(edge);
-            var e = edge;
+            let e = edge;
             do {
                 e.label = label;
                 e = e.next;
@@ -207,96 +201,89 @@ var Graph = /** @class */ (function () {
             label++;
         });
         return edgeRingStarts;
-    };
+    }
     /**
      * Computes the EdgeRings formed by the edges in this graph.
      *
      * @returns {EdgeRing[]} - A list of all the EdgeRings in the graph.
      */
-    Graph.prototype.getEdgeRings = function () {
-        var _this = this;
+    getEdgeRings() {
         this._computeNextCWEdges();
         // Clear labels
-        this.edges.forEach(function (edge) {
+        this.edges.forEach((edge) => {
             edge.label = undefined;
         });
-        this._findLabeledEdgeRings().forEach(function (edge) {
+        this._findLabeledEdgeRings().forEach((edge) => {
             // convertMaximalToMinimalEdgeRings
-            _this._findIntersectionNodes(edge).forEach(function (node) {
-                _this._computeNextCCWEdges(node, edge.label);
+            this._findIntersectionNodes(edge).forEach((node) => {
+                this._computeNextCCWEdges(node, edge.label);
             });
         });
-        var edgeRingList = [];
+        const edgeRingList = [];
         // find all edgerings
-        this.edges.forEach(function (edge) {
+        this.edges.forEach((edge) => {
             if (edge.ring)
                 return;
-            edgeRingList.push(_this._findEdgeRing(edge));
+            edgeRingList.push(this._findEdgeRing(edge));
         });
         return edgeRingList;
-    };
+    }
     /**
      * Find all nodes in a Maxima EdgeRing which are self-intersection nodes.
      *
      * @param {Node} startEdge - Start Edge of the Ring
      * @returns {Node[]} - intersection nodes
      */
-    Graph.prototype._findIntersectionNodes = function (startEdge) {
-        var intersectionNodes = [];
-        var edge = startEdge;
-        var _loop_1 = function () {
+    _findIntersectionNodes(startEdge) {
+        const intersectionNodes = [];
+        let edge = startEdge;
+        do {
             // getDegree
-            var degree = 0;
-            edge.from.getOuterEdges().forEach(function (e) {
+            let degree = 0;
+            edge.from.getOuterEdges().forEach((e) => {
                 if (e.label === startEdge.label)
                     ++degree;
             });
             if (degree > 1)
                 intersectionNodes.push(edge.from);
             edge = edge.next;
-        };
-        do {
-            _loop_1();
         } while (!startEdge.isEqual(edge));
         return intersectionNodes;
-    };
+    }
     /**
      * Get the edge-ring which starts from the provided Edge.
      *
      * @param {Edge} startEdge - starting edge of the edge ring
      * @returns {EdgeRing} - EdgeRing which start Edge is the provided one.
      */
-    Graph.prototype._findEdgeRing = function (startEdge) {
-        var edge = startEdge;
-        var edgeRing = new EdgeRing();
+    _findEdgeRing(startEdge) {
+        let edge = startEdge;
+        const edgeRing = new EdgeRing();
         do {
             edgeRing.push(edge);
             edge.ring = edgeRing;
             edge = edge.next;
         } while (!startEdge.isEqual(edge));
         return edgeRing;
-    };
+    }
     /**
      * Removes a node from the Graph.
      *
      * It also removes edges asociated to that node
      * @param {Node} node - Node to be removed
      */
-    Graph.prototype.removeNode = function (node) {
-        var _this = this;
-        node.getOuterEdges().forEach(function (edge) { return _this.removeEdge(edge); });
-        node.innerEdges.forEach(function (edge) { return _this.removeEdge(edge); });
+    removeNode(node) {
+        node.getOuterEdges().forEach((edge) => this.removeEdge(edge));
+        node.innerEdges.forEach((edge) => this.removeEdge(edge));
         delete this.nodes[node.id];
-    };
+    }
     /**
      * Remove edge from the graph and deletes the edge.
      *
      * @param {Edge} edge - Edge to be removed
      */
-    Graph.prototype.removeEdge = function (edge) {
-        this.edges = this.edges.filter(function (e) { return !e.isEqual(edge); });
+    removeEdge(edge) {
+        this.edges = this.edges.filter((e) => !e.isEqual(edge));
         edge.deleteEdge();
-    };
-    return Graph;
-}());
-export default Graph;
+    }
+}

package/dist/es/lib/Node.js

@@ -2,8 +2,8 @@ import { orientationIndex } from "./util.js";
 /**
  * Node
  */
-var Node = /** @class */ (function () {
-    function Node(coordinates) {
+export default class Node {
+    constructor(coordinates) {
         this.id = Node.buildId(coordinates);
         this.coordinates = coordinates; //< {Number[]}
         this.innerEdges = []; //< {Edge[]}
@@ -11,64 +11,63 @@ var Node = /** @class */ (function () {
         this.outerEdges = []; //< {Edge[]}
         this.outerEdgesSorted = false; //< {Boolean} flag that stores if the outer Edges had been sorted
     }
-    Node.buildId = function (coordinates) {
+    static buildId(coordinates) {
         return coordinates.join(",");
-    };
-    Node.prototype.removeInnerEdge = function (edge) {
-        this.innerEdges = this.innerEdges.filter(function (e) { return e.from.id !== edge.from.id; });
-    };
-    Node.prototype.removeOuterEdge = function (edge) {
-        this.outerEdges = this.outerEdges.filter(function (e) { return e.to.id !== edge.to.id; });
-    };
+    }
+    removeInnerEdge(edge) {
+        this.innerEdges = this.innerEdges.filter((e) => e.from.id !== edge.from.id);
+    }
+    removeOuterEdge(edge) {
+        this.outerEdges = this.outerEdges.filter((e) => e.to.id !== edge.to.id);
+    }
     /**
      * Outer edges are stored CCW order.
      *
      * @memberof Node
      * @param {Edge} edge - Edge to add as an outerEdge.
      */
-    Node.prototype.addOuterEdge = function (edge) {
+    addOuterEdge(edge) {
         this.outerEdges.push(edge);
         this.outerEdgesSorted = false;
-    };
+    }
     /**
      * Sorts outer edges in CCW way.
      *
      * @memberof Node
      * @private
      */
-    Node.prototype.sortOuterEdges = function () {
-        var _this = this;
+    sortOuterEdges() {
         if (!this.outerEdgesSorted) {
             //this.outerEdges.sort((a, b) => a.compareTo(b));
             // Using this comparator in order to be deterministic
-            this.outerEdges.sort(function (a, b) {
-                var aNode = a.to, bNode = b.to;
-                if (aNode.coordinates[0] - _this.coordinates[0] >= 0 &&
-                    bNode.coordinates[0] - _this.coordinates[0] < 0)
+            this.outerEdges.sort((a, b) => {
+                const aNode = a.to, bNode = b.to;
+                if (aNode.coordinates[0] - this.coordinates[0] >= 0 &&
+                    bNode.coordinates[0] - this.coordinates[0] < 0)
                     return 1;
-                if (aNode.coordinates[0] - _this.coordinates[0] < 0 &&
-                    bNode.coordinates[0] - _this.coordinates[0] >= 0)
+                if (aNode.coordinates[0] - this.coordinates[0] < 0 &&
+                    bNode.coordinates[0] - this.coordinates[0] >= 0)
                     return -1;
-                if (aNode.coordinates[0] - _this.coordinates[0] === 0 &&
-                    bNode.coordinates[0] - _this.coordinates[0] === 0) {
-                    if (aNode.coordinates[1] - _this.coordinates[1] >= 0 ||
-                        bNode.coordinates[1] - _this.coordinates[1] >= 0)
+                if (aNode.coordinates[0] - this.coordinates[0] === 0 &&
+                    bNode.coordinates[0] - this.coordinates[0] === 0) {
+                    if (aNode.coordinates[1] - this.coordinates[1] >= 0 ||
+                        bNode.coordinates[1] - this.coordinates[1] >= 0)
                         return aNode.coordinates[1] - bNode.coordinates[1];
                     return bNode.coordinates[1] - aNode.coordinates[1];
                 }
-                var det = orientationIndex(_this.coordinates, aNode.coordinates, bNode.coordinates);
+                const det = orientationIndex(this.coordinates, aNode.coordinates, bNode.coordinates);
                 if (det < 0)
                     return 1;
                 if (det > 0)
                     return -1;
-                var d1 = Math.pow(aNode.coordinates[0] - _this.coordinates[0], 2) +
-                    Math.pow(aNode.coordinates[1] - _this.coordinates[1], 2), d2 = Math.pow(bNode.coordinates[0] - _this.coordinates[0], 2) +
-                    Math.pow(bNode.coordinates[1] - _this.coordinates[1], 2);
+                const d1 = Math.pow(aNode.coordinates[0] - this.coordinates[0], 2) +
+                    Math.pow(aNode.coordinates[1] - this.coordinates[1], 2), d2 = Math.pow(bNode.coordinates[0] - this.coordinates[0], 2) +
+                    Math.pow(bNode.coordinates[1] - this.coordinates[1], 2);
                 return d1 - d2;
             });
             this.outerEdgesSorted = true;
         }
-    };
+    }
     /**
      * Retrieves outer edges.
      *
@@ -77,17 +76,15 @@ var Node = /** @class */ (function () {
      * @memberof Node
      * @returns {Edge[]} - List of outer edges sorted in a CCW order.
      */
-    Node.prototype.getOuterEdges = function () {
+    getOuterEdges() {
         this.sortOuterEdges();
         return this.outerEdges;
-    };
-    Node.prototype.getOuterEdge = function (i) {
+    }
+    getOuterEdge(i) {
         this.sortOuterEdges();
         return this.outerEdges[i];
-    };
-    Node.prototype.addInnerEdge = function (edge) {
+    }
+    addInnerEdge(edge) {
         this.innerEdges.push(edge);
-    };
-    return Node;
-}());
-export default Node;
+    }
+}

package/dist/es/lib/util.js

@@ -19,7 +19,7 @@ function mathSign(x) {
  *     0 if q is colinear with p1->p2
  */
 export function orientationIndex(p1, p2, q) {
-    var dx1 = p2[0] - p1[0], dy1 = p2[1] - p1[1], dx2 = q[0] - p2[0], dy2 = q[1] - p2[1];
+    const dx1 = p2[0] - p1[0], dy1 = p2[1] - p1[1], dx2 = q[0] - p2[0], dy2 = q[1] - p2[1];
     return mathSign(dx1 * dy2 - dx2 * dy1);
 }
 /**
@@ -32,7 +32,7 @@ export function orientationIndex(p1, p2, q) {
  * @returns {boolean} - True if the envelopes are equal
  */
 export function envelopeIsEqual(env1, env2) {
-    var envX1 = env1.geometry.coordinates[0].map(function (c) { return c[0]; }), envY1 = env1.geometry.coordinates[0].map(function (c) { return c[1]; }), envX2 = env2.geometry.coordinates[0].map(function (c) { return c[0]; }), envY2 = env2.geometry.coordinates[0].map(function (c) { return c[1]; });
+    const envX1 = env1.geometry.coordinates[0].map((c) => c[0]), envY1 = env1.geometry.coordinates[0].map((c) => c[1]), envX2 = env2.geometry.coordinates[0].map((c) => c[0]), envY2 = env2.geometry.coordinates[0].map((c) => c[1]);
     return (Math.max.apply(null, envX1) === Math.max.apply(null, envX2) &&
         Math.max.apply(null, envY1) === Math.max.apply(null, envY2) &&
         Math.min.apply(null, envX1) === Math.min.apply(null, envX2) &&
@@ -50,9 +50,7 @@ export function envelopeIsEqual(env1, env2) {
  * @returns {boolean} - True if env is contained in self
  */
 export function envelopeContains(self, env) {
-    return env.geometry.coordinates[0].every(function (c) {
-        return booleanPointInPolygon(point(c), self);
-    });
+    return env.geometry.coordinates[0].every((c) => booleanPointInPolygon(point(c), self));
 }
 /**
  * Checks if two coordinates are equal.

package/dist/js/index.d.ts

@@ -1,4 +1,4 @@
-import { Feature, FeatureCollection, LineString, MultiLineString, Polygon } from "@turf/helpers";
+import { Feature, FeatureCollection, LineString, MultiLineString, Polygon } from "geojson";
 /**
  * Polygonizes {@link LineString|(Multi)LineString(s)} into {@link Polygons}.
  *

package/dist/js/index.js

@@ -1,11 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var helpers_1 = require("@turf/helpers");
-var Graph_1 = __importDefault(require("./lib/Graph"));
-var EdgeRing_1 = __importDefault(require("./lib/EdgeRing"));
+const tslib_1 = require("tslib");
+const helpers_1 = require("@turf/helpers");
+const Graph_1 = tslib_1.__importDefault(require("./lib/Graph"));
+const EdgeRing_1 = tslib_1.__importDefault(require("./lib/EdgeRing"));
 /**
  * Polygonizes {@link LineString|(Multi)LineString(s)} into {@link Polygons}.
  *
@@ -25,28 +23,28 @@ var EdgeRing_1 = __importDefault(require("./lib/EdgeRing"));
  * @throws {Error} if geoJson is invalid.
  */
 function polygonize(geoJson) {
-    var graph = Graph_1.default.fromGeoJson(geoJson);
+    const graph = Graph_1.default.fromGeoJson(geoJson);
     // 1. Remove dangle node
     graph.deleteDangles();
     // 2. Remove cut-edges (bridge edges)
     graph.deleteCutEdges();
     // 3. Get all holes and shells
-    var holes = [], shells = [];
+    const holes = [], shells = [];
     graph
         .getEdgeRings()
-        .filter(function (edgeRing) { return edgeRing.isValid(); })
-        .forEach(function (edgeRing) {
+        .filter((edgeRing) => edgeRing.isValid())
+        .forEach((edgeRing) => {
         if (edgeRing.isHole())
             holes.push(edgeRing);
         else
             shells.push(edgeRing);
     });
     // 4. Assign Holes to Shells
-    holes.forEach(function (hole) {
+    holes.forEach((hole) => {
         if (EdgeRing_1.default.findEdgeRingContaining(hole, shells))
             shells.push(hole);
     });
     // 5. EdgeRings to Polygons
-    return helpers_1.featureCollection(shells.map(function (shell) { return shell.toPolygon(); }));
+    return helpers_1.featureCollection(shells.map((shell) => shell.toPolygon()));
 }
 exports.default = polygonize;

package/dist/js/lib/Edge.d.ts

@@ -40,7 +40,7 @@ export default class Edge {
      *
      * @returns {Feature<LineString>} - LineString representation of the Edge
      */
-    toLineString(): import("@turf/helpers").Feature<import("@turf/helpers").LineString, import("@turf/helpers").Properties>;
+    toLineString(): import("geojson").Feature<import("geojson").LineString, import("geojson").GeoJsonProperties>;
     /**
      * Comparator of two edges.
      *

package/dist/js/lib/Edge.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var helpers_1 = require("@turf/helpers");
-var util_1 = require("./util");
+const helpers_1 = require("@turf/helpers");
+const util_1 = require("./util");
 /**
  * This class is inspired by GEOS's geos::operation::polygonize::PolygonizeDirectedEdge
  */
-var Edge = /** @class */ (function () {
+class Edge {
     /**
      * @param {Node} from - start node of the Edge
      * @param {Node} to - end node of the edge
      */
-    function Edge(from, to) {
+    constructor(from, to) {
         this.from = from; //< start
         this.to = to; //< End
         this.next = undefined; //< The edge to be computed after
@@ -25,20 +25,20 @@ var Edge = /** @class */ (function () {
      *
      * @returns {Edge} - Symetric Edge.
      */
-    Edge.prototype.getSymetric = function () {
+    getSymetric() {
         if (!this.symetric) {
             this.symetric = new Edge(this.to, this.from);
             this.symetric.symetric = this;
         }
         return this.symetric;
-    };
+    }
     /**
      * Removes edge from from and to nodes.
      */
-    Edge.prototype.deleteEdge = function () {
+    deleteEdge() {
         this.from.removeOuterEdge(this);
         this.to.removeInnerEdge(this);
-    };
+    }
     /**
      * Compares Edge equallity.
      *
@@ -47,20 +47,20 @@ var Edge = /** @class */ (function () {
      * @param {Edge} edge - Another Edge
      * @returns {boolean} - True if Edges are equal, False otherwise
      */
-    Edge.prototype.isEqual = function (edge) {
+    isEqual(edge) {
         return this.from.id === edge.from.id && this.to.id === edge.to.id;
-    };
-    Edge.prototype.toString = function () {
-        return "Edge { " + this.from.id + " -> " + this.to.id + " }";
-    };
+    }
+    toString() {
+        return `Edge { ${this.from.id} -> ${this.to.id} }`;
+    }
     /**
      * Returns a LineString representation of the Edge
      *
      * @returns {Feature<LineString>} - LineString representation of the Edge
      */
-    Edge.prototype.toLineString = function () {
+    toLineString() {
         return helpers_1.lineString([this.from.coordinates, this.to.coordinates]);
-    };
+    }
     /**
      * Comparator of two edges.
      *
@@ -71,9 +71,8 @@ var Edge = /** @class */ (function () {
      *          0 if the Edges are colinear,
      *          1 otherwise
      */
-    Edge.prototype.compareTo = function (edge) {
+    compareTo(edge) {
         return util_1.orientationIndex(edge.from.coordinates, edge.to.coordinates, this.to.coordinates);
-    };
-    return Edge;
-}());
+    }
+}
 exports.default = Edge;

package/dist/js/lib/EdgeRing.d.ts

@@ -1,4 +1,4 @@
-import { Polygon, Feature, Point } from "@turf/helpers";
+import { Polygon, Feature, Point } from "geojson";
 import Edge from "./Edge";
 /**
  * Ring of edges which form a polygon.
@@ -84,7 +84,7 @@ export default class EdgeRing {
      * @memberof EdgeRing
      * @returns {Feature<MultiPoint>} - Multipoint representation of the EdgeRing
      */
-    toMultiPoint(): Feature<import("@turf/helpers").MultiPoint, import("@turf/helpers").Properties>;
+    toMultiPoint(): Feature<import("geojson").MultiPoint, import("geojson").GeoJsonProperties>;
     /**
      * Creates a Polygon representing the EdgeRing.
      *