(function (f) {
    if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() }
    else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this } g.turf = f() }
})(function () {
    var meta_1,invariant_1;
    var define, module, exports; return (function e(t, n, r) { function s(o, u) { if (!n[o]) { if (!t[o]) { var a = typeof require == "function" && require; if (!u && a) return a(o, !0); if (i) return i(o, !0); var f = new Error("Cannot find module '" + o + "'"); throw f.code = "MODULE_NOT_FOUND", f } var l = n[o] = { exports: {} }; t[o][0].call(l.exports, function (e) { var n = t[o][1][e]; return s(n ? n : e) }, l, l.exports, e, t, n, r) } return n[o].exports } var i = typeof require == "function" && require; for (var o = 0; o < r.length; o++) s(r[o]); return s })({
        1: [function (require, module, exports) {
            module.exports = {
                lineIntersect: require('@turf/line-intersect'),
                bboxClip: require('@turf/bbox-clip'),
                polygonToLineString: require('@turf/polygon-to-linestring'),
                meta:meta_1,
                invariant:invariant_1
            };
        }, { "@turf/bbox-clip": 2, "@turf/line-intersect": 7, "@turf/polygon-to-linestring": 17 }], 2: [function (require, module, exports) {
            var helpers = require('@turf/helpers');
            var lineclip = require('lineclip');
            invariant_1=require('@turf/invariant');
            var getCoords = require('@turf/invariant').getCoords;
            var lineString = helpers.lineString;
            var multiLineString = helpers.multiLineString;
            var polygon = helpers.polygon;
            var multiPolygon = helpers.multiPolygon;

            /**
             * Takes a {@link Feature} and a bbox and clips the feature to the bbox using [lineclip](https://github.com/mapbox/lineclip).
             * May result in degenerate edges when clipping Polygons.
             *
             * @name bbox-clip
             * @param {Feature<LineString|MultiLineString|Polygon|MultiPolygon>} feature feature to clip to the bbox
             * @param {Array<number>} bbox extent in [minX, minY, maxX, maxY] order
             * @returns {Feature<LineString|MultiLineString|Polygon|MultiPolygon>} clipped Feature
             * @example
             * var bbox = [0, 0, 10, 10];
             * var poly = {
             *   "type": "Feature",
             *   "properties": {},
             *   "geometry": {
             *     "type": "Polygon",
             *     "coordinates": [[[2, 2], [8, 4], [12, 8], [3, 7], [2, 2]]]
             *   }
             * }
             *
             * var clipped = turf.bboxClip(poly, bbox);
             *
             * //=clipped
             */
            module.exports = function (feature, bbox) {
                var geom = getGeom(feature);
                var coords = getCoords(feature);
                var properties = feature.properties;

                switch (geom) {
                    case 'LineString':
                    case 'MultiLineString':
                        var lines = [];
                        if (geom === 'LineString') coords = [coords];
                        coords.forEach(function (line) {
                            lineclip(line, bbox, lines);
                        });
                        if (lines.length === 1) return lineString(lines[0], properties);
                        return multiLineString(lines, properties);
                    case 'Polygon':
                        return polygon(clipPolygon(coords, bbox), properties);
                    case 'MultiPolygon':
                        return multiPolygon(coords.map(function (polygon) {
                            return clipPolygon(polygon, bbox);
                        }), properties);
                    default:
                        throw new Error('geometry ' + geom + ' not supported');
                }
            };

            function clipPolygon(rings, bbox) {
                var outRings = [];
                for (var i = 0; i < rings.length; i++) {
                    var clipped = lineclip.polygon(rings[i], bbox);
                    if (clipped.length > 0) {
                        if (clipped[0][0] !== clipped[clipped.length - 1][0] || clipped[0][1] !== clipped[clipped.length - 1][1]) {
                            clipped.push(clipped[0]);
                        }
                        outRings.push(clipped);
                    }
                }
                return outRings;
            }

            function getGeom(feature) {
                return (feature.geometry) ? feature.geometry.type : feature.type;
            }

        }, { "@turf/helpers": 3, "@turf/invariant": 4, "lineclip": 21 }], 3: [function (require, module, exports) {
            /**
             * Wraps a GeoJSON {@link Geometry} in a GeoJSON {@link Feature}.
             *
             * @name feature
             * @param {Geometry} geometry input geometry
             * @param {Object} properties properties
             * @returns {FeatureCollection} a FeatureCollection of input features
             * @example
             * var geometry = {
             *      "type": "Point",
             *      "coordinates": [
             *        67.5,
             *        32.84267363195431
             *      ]
             *    }
             *
             * var feature = turf.feature(geometry);
             *
             * //=feature
             */
            function feature(geometry, properties) {
                if (!geometry) throw new Error('No geometry passed');

                return {
                    type: 'Feature',
                    properties: properties || {},
                    geometry: geometry
                };
            }

            /**
             * Takes coordinates and properties (optional) and returns a new {@link Point} feature.
             *
             * @name point
             * @param {Array<number>} coordinates longitude, latitude position (each in decimal degrees)
             * @param {Object=} properties an Object that is used as the {@link Feature}'s
             * properties
             * @returns {Feature<Point>} a Point feature
             * @example
             * var pt1 = turf.point([-75.343, 39.984]);
             *
             * //=pt1
             */
            function point(coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');
                if (coordinates.length === undefined) throw new Error('Coordinates must be an array');
                if (coordinates.length < 2) throw new Error('Coordinates must be at least 2 numbers long');
                if (typeof coordinates[0] !== 'number' || typeof coordinates[1] !== 'number') throw new Error('Coordinates must numbers');

                return feature({
                    type: 'Point',
                    coordinates: coordinates
                }, properties);
            }

            /**
             * Takes an array of LinearRings and optionally an {@link Object} with properties and returns a {@link Polygon} feature.
             *
             * @name polygon
             * @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
             * @param {Object=} properties a properties object
             * @returns {Feature<Polygon>} a Polygon feature
             * @throws {Error} throw an error if a LinearRing of the polygon has too few positions
             * or if a LinearRing of the Polygon does not have matching Positions at the
             * beginning & end.
             * @example
             * var polygon = turf.polygon([[
             *  [-2.275543, 53.464547],
             *  [-2.275543, 53.489271],
             *  [-2.215118, 53.489271],
             *  [-2.215118, 53.464547],
             *  [-2.275543, 53.464547]
             * ]], { name: 'poly1', population: 400});
             *
             * //=polygon
             */
            function polygon(coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                for (var i = 0; i < coordinates.length; i++) {
                    var ring = coordinates[i];
                    if (ring.length < 4) {
                        throw new Error('Each LinearRing of a Polygon must have 4 or more Positions.');
                    }
                    for (var j = 0; j < ring[ring.length - 1].length; j++) {
                        if (ring[ring.length - 1][j] !== ring[0][j]) {
                            throw new Error('First and last Position are not equivalent.');
                        }
                    }
                }

                return feature({
                    type: 'Polygon',
                    coordinates: coordinates
                }, properties);
            }

            /**
             * Creates a {@link LineString} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name lineString
             * @param {Array<Array<number>>} coordinates an array of Positions
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<LineString>} a LineString feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var linestring1 = turf.lineString([
             *   [-21.964416, 64.148203],
             *   [-21.956176, 64.141316],
             *   [-21.93901, 64.135924],
             *   [-21.927337, 64.136673]
             * ]);
             * var linestring2 = turf.lineString([
             *   [-21.929054, 64.127985],
             *   [-21.912918, 64.134726],
             *   [-21.916007, 64.141016],
             *   [-21.930084, 64.14446]
             * ], {name: 'line 1', distance: 145});
             *
             * //=linestring1
             *
             * //=linestring2
             */
            function lineString(coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'LineString',
                    coordinates: coordinates
                }, properties);
            }

            /**
             * Takes one or more {@link Feature|Features} and creates a {@link FeatureCollection}.
             *
             * @name featureCollection
             * @param {Feature[]} features input features
             * @returns {FeatureCollection} a FeatureCollection of input features
             * @example
             * var features = [
             *  turf.point([-75.343, 39.984], {name: 'Location A'}),
             *  turf.point([-75.833, 39.284], {name: 'Location B'}),
             *  turf.point([-75.534, 39.123], {name: 'Location C'})
             * ];
             *
             * var fc = turf.featureCollection(features);
             *
             * //=fc
             */
            function featureCollection(features) {
                if (!features) throw new Error('No features passed');

                return {
                    type: 'FeatureCollection',
                    features: features
                };
            }

            /**
             * Creates a {@link Feature<MultiLineString>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name multiLineString
             * @param {Array<Array<Array<number>>>} coordinates an array of LineStrings
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<MultiLineString>} a MultiLineString feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var multiLine = turf.multiLineString([[[0,0],[10,10]]]);
             *
             * //=multiLine
             *
             */
            function multiLineString(coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'MultiLineString',
                    coordinates: coordinates
                }, properties);
            }

            /**
             * Creates a {@link Feature<MultiPoint>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name multiPoint
             * @param {Array<Array<number>>} coordinates an array of Positions
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<MultiPoint>} a MultiPoint feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var multiPt = turf.multiPoint([[0,0],[10,10]]);
             *
             * //=multiPt
             *
             */
            function multiPoint(coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'MultiPoint',
                    coordinates: coordinates
                }, properties);
            }


            /**
             * Creates a {@link Feature<MultiPolygon>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name multiPolygon
             * @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygons
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<MultiPolygon>} a multipolygon feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var multiPoly = turf.multiPolygon([[[[0,0],[0,10],[10,10],[10,0],[0,0]]]]);
             *
             * //=multiPoly
             *
             */
            function multiPolygon(coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'MultiPolygon',
                    coordinates: coordinates
                }, properties);
            }

            /**
             * Creates a {@link Feature<GeometryCollection>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name geometryCollection
             * @param {Array<{Geometry}>} geometries an array of GeoJSON Geometries
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<GeometryCollection>} a GeoJSON GeometryCollection Feature
             * @example
             * var pt = {
             *     "type": "Point",
             *       "coordinates": [100, 0]
             *     };
             * var line = {
             *     "type": "LineString",
             *     "coordinates": [ [101, 0], [102, 1] ]
             *   };
             * var collection = turf.geometryCollection([pt, line]);
             *
             * //=collection
             */
            function geometryCollection(geometries, properties) {
                if (!geometries) throw new Error('No geometries passed');

                return feature({
                    type: 'GeometryCollection',
                    geometries: geometries
                }, properties);
            }

            var factors = {
                miles: 3960,
                nauticalmiles: 3441.145,
                degrees: 57.2957795,
                radians: 1,
                inches: 250905600,
                yards: 6969600,
                meters: 6373000,
                metres: 6373000,
                kilometers: 6373,
                kilometres: 6373,
                feet: 20908792.65
            };

            /**
             * Convert a distance measurement from radians to a more friendly unit.
             *
             * @name radiansToDistance
             * @param {number} radians in radians across the sphere
             * @param {string} [units=kilometers] can be degrees, radians, miles, or kilometers inches, yards, metres, meters, kilometres, kilometers.
             * @returns {number} distance
             */
            function radiansToDistance(radians, units) {
                var factor = factors[units || 'kilometers'];
                if (factor === undefined) throw new Error('Invalid unit');

                return radians * factor;
            }

            /**
             * Convert a distance measurement from a real-world unit into radians
             *
             * @name distanceToRadians
             * @param {number} distance in real units
             * @param {string} [units=kilometers] can be degrees, radians, miles, or kilometers inches, yards, metres, meters, kilometres, kilometers.
             * @returns {number} radians
             */
            function distanceToRadians(distance, units) {
                var factor = factors[units || 'kilometers'];
                if (factor === undefined) throw new Error('Invalid unit');

                return distance / factor;
            }

            /**
             * Convert a distance measurement from a real-world unit into degrees
             *
             * @name distanceToDegrees
             * @param {number} distance in real units
             * @param {string} [units=kilometers] can be degrees, radians, miles, or kilometers inches, yards, metres, meters, kilometres, kilometers.
             * @returns {number} degrees
             */
            function distanceToDegrees(distance, units) {
                var factor = factors[units || 'kilometers'];
                if (factor === undefined) throw new Error('Invalid unit');

                return (distance / factor) * 57.2958;
            }

            module.exports = {
                feature: feature,
                featureCollection: featureCollection,
                geometryCollection: geometryCollection,
                point: point,
                multiPoint: multiPoint,
                lineString: lineString,
                multiLineString: multiLineString,
                polygon: polygon,
                multiPolygon: multiPolygon,
                radiansToDistance: radiansToDistance,
                distanceToRadians: distanceToRadians,
                distanceToDegrees: distanceToDegrees
            };

        }, {}], 4: [function (require, module, exports) {
            /**
             * Unwrap a coordinate from a Point Feature, Geometry or a single coordinate.
             *
             * @name getCoord
             * @param {Array<any>|Geometry|Feature<Point>} obj any value
             * @returns {Array<number>} coordinates
             */
            function getCoord(obj) {
                if (!obj) throw new Error('No obj passed');

                var coordinates = getCoords(obj);

                // getCoord() must contain at least two numbers (Point)
                if (coordinates.length > 1 &&
                    typeof coordinates[0] === 'number' &&
                    typeof coordinates[1] === 'number') {
                    return coordinates;
                } else {
                    throw new Error('Coordinate is not a valid Point');
                }
            }

            /**
             * Unwrap coordinates from a Feature, Geometry Object or an Array of numbers
             *
             * @name getCoords
             * @param {Array<any>|Geometry|Feature<any>} obj any value
             * @returns {Array<any>} coordinates
             */
            function getCoords(obj) {
                if (!obj) throw new Error('No obj passed');
                var coordinates;

                // Array of numbers
                if (obj.length) {
                    coordinates = obj;

                    // Geometry Object
                } else if (obj.coordinates) {
                    coordinates = obj.coordinates;

                    // Feature
                } else if (obj.geometry && obj.geometry.coordinates) {
                    coordinates = obj.geometry.coordinates;
                }
                // Checks if coordinates contains a number
                if (coordinates) {
                    containsNumber(coordinates);
                    return coordinates;
                }
                throw new Error('No valid coordinates');
            }

            /**
             * Checks if coordinates contains a number
             *
             * @name containsNumber
             * @param {Array<any>} coordinates GeoJSON Coordinates
             * @returns {boolean} true if Array contains a number
             */
            function containsNumber(coordinates) {
                if (coordinates.length > 1 &&
                    typeof coordinates[0] === 'number' &&
                    typeof coordinates[1] === 'number') {
                    return true;
                }

                if (Array.isArray(coordinates[0]) && coordinates[0].length) {
                    return containsNumber(coordinates[0]);
                }
                throw new Error('coordinates must only contain numbers');
            }

            /**
             * Enforce expectations about types of GeoJSON objects for Turf.
             *
             * @name geojsonType
             * @param {GeoJSON} value any GeoJSON object
             * @param {string} type expected GeoJSON type
             * @param {string} name name of calling function
             * @throws {Error} if value is not the expected type.
             */
            function geojsonType(value, type, name) {
                if (!type || !name) throw new Error('type and name required');

                if (!value || value.type !== type) {
                    throw new Error('Invalid input to ' + name + ': must be a ' + type + ', given ' + value.type);
                }
            }

            /**
             * Enforce expectations about types of {@link Feature} inputs for Turf.
             * Internally this uses {@link geojsonType} to judge geometry types.
             *
             * @name featureOf
             * @param {Feature} feature a feature with an expected geometry type
             * @param {string} type expected GeoJSON type
             * @param {string} name name of calling function
             * @throws {Error} error if value is not the expected type.
             */
            function featureOf(feature, type, name) {
                if (!feature) throw new Error('No feature passed');
                if (!name) throw new Error('.featureOf() requires a name');
                if (!feature || feature.type !== 'Feature' || !feature.geometry) {
                    throw new Error('Invalid input to ' + name + ', Feature with geometry required');
                }
                if (!feature.geometry || feature.geometry.type !== type) {
                    throw new Error('Invalid input to ' + name + ': must be a ' + type + ', given ' + feature.geometry.type);
                }
            }

            /**
             * Enforce expectations about types of {@link FeatureCollection} inputs for Turf.
             * Internally this uses {@link geojsonType} to judge geometry types.
             *
             * @name collectionOf
             * @param {FeatureCollection} featureCollection a FeatureCollection for which features will be judged
             * @param {string} type expected GeoJSON type
             * @param {string} name name of calling function
             * @throws {Error} if value is not the expected type.
             */
            function collectionOf(featureCollection, type, name) {
                if (!featureCollection) throw new Error('No featureCollection passed');
                if (!name) throw new Error('.collectionOf() requires a name');
                if (!featureCollection || featureCollection.type !== 'FeatureCollection') {
                    throw new Error('Invalid input to ' + name + ', FeatureCollection required');
                }
                for (var i = 0; i < featureCollection.features.length; i++) {
                    var feature = featureCollection.features[i];
                    if (!feature || feature.type !== 'Feature' || !feature.geometry) {
                        throw new Error('Invalid input to ' + name + ', Feature with geometry required');
                    }
                    if (!feature.geometry || feature.geometry.type !== type) {
                        throw new Error('Invalid input to ' + name + ': must be a ' + type + ', given ' + feature.geometry.type);
                    }
                }
            }

            module.exports = {
                geojsonType: geojsonType,
                collectionOf: collectionOf,
                featureOf: featureOf,
                getCoord: getCoord,
                getCoords: getCoords,
                containsNumber: containsNumber
            };

        }, {}], 5: [function (require, module, exports) {
            meta_1=require('@turf/meta');
            var each = require('@turf/meta').coordEach;
 
            /**
             * Takes a set of features, calculates the bbox of all input features, and returns a bounding box.
             *
             * @name bbox
             * @param {(Feature|FeatureCollection)} geojson input features
             * @return {Array<number>} bbox extent in [minX, minY, maxX, maxY] order
             * @example
             * var pt1 = turf.point([114.175329, 22.2524])
             * var pt2 = turf.point([114.170007, 22.267969])
             * var pt3 = turf.point([114.200649, 22.274641])
             * var pt4 = turf.point([114.200649, 22.274641])
             * var pt5 = turf.point([114.186744, 22.265745])
             * var features = turf.featureCollection([pt1, pt2, pt3, pt4, pt5])
             *
             * var bbox = turf.bbox(features);
             *
             * var bboxPolygon = turf.bboxPolygon(bbox);
             *
             * //=bbox
             *
             * //=bboxPolygon
             */
            module.exports = function (geojson) {
                var bbox = [Infinity, Infinity, -Infinity, -Infinity];
                each(geojson, function (coord) {
                    if (bbox[0] > coord[0]) bbox[0] = coord[0];
                    if (bbox[1] > coord[1]) bbox[1] = coord[1];
                    if (bbox[2] < coord[0]) bbox[2] = coord[0];
                    if (bbox[3] < coord[1]) bbox[3] = coord[1];
                });
                return bbox;
            };

        }, { "@turf/meta": 16 }], 6: [function (require, module, exports) {
            /**
             * Wraps a GeoJSON {@link Geometry} in a GeoJSON {@link Feature}.
             *
             * @name feature
             * @param {Geometry} geometry input geometry
             * @param {Object} properties properties
             * @returns {FeatureCollection} a FeatureCollection of input features
             * @example
             * var geometry = {
             *      "type": "Point",
             *      "coordinates": [
             *        67.5,
             *        32.84267363195431
             *      ]
             *    }
             *
             * var feature = turf.feature(geometry);
             *
             * //=feature
             */
            function feature(geometry, properties) {
                if (!geometry) throw new Error('No geometry passed');

                return {
                    type: 'Feature',
                    properties: properties || {},
                    geometry: geometry
                };
            }
            module.exports.feature = feature;

            /**
             * Takes coordinates and properties (optional) and returns a new {@link Point} feature.
             *
             * @name point
             * @param {Array<number>} coordinates longitude, latitude position (each in decimal degrees)
             * @param {Object=} properties an Object that is used as the {@link Feature}'s
             * properties
             * @returns {Feature<Point>} a Point feature
             * @example
             * var pt1 = turf.point([-75.343, 39.984]);
             *
             * //=pt1
             */
            module.exports.point = function (coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');
                if (coordinates.length === undefined) throw new Error('Coordinates must be an array');
                if (coordinates.length < 2) throw new Error('Coordinates must be at least 2 numbers long');
                if (typeof coordinates[0] !== 'number' || typeof coordinates[1] !== 'number') throw new Error('Coordinates must numbers');

                return feature({
                    type: 'Point',
                    coordinates: coordinates
                }, properties);
            };

            /**
             * Takes an array of LinearRings and optionally an {@link Object} with properties and returns a {@link Polygon} feature.
             *
             * @name polygon
             * @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
             * @param {Object=} properties a properties object
             * @returns {Feature<Polygon>} a Polygon feature
             * @throws {Error} throw an error if a LinearRing of the polygon has too few positions
             * or if a LinearRing of the Polygon does not have matching Positions at the
             * beginning & end.
             * @example
             * var polygon = turf.polygon([[
             *  [-2.275543, 53.464547],
             *  [-2.275543, 53.489271],
             *  [-2.215118, 53.489271],
             *  [-2.215118, 53.464547],
             *  [-2.275543, 53.464547]
             * ]], { name: 'poly1', population: 400});
             *
             * //=polygon
             */
            module.exports.polygon = function (coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                for (var i = 0; i < coordinates.length; i++) {
                    var ring = coordinates[i];
                    if (ring.length < 4) {
                        throw new Error('Each LinearRing of a Polygon must have 4 or more Positions.');
                    }
                    for (var j = 0; j < ring[ring.length - 1].length; j++) {
                        if (ring[ring.length - 1][j] !== ring[0][j]) {
                            throw new Error('First and last Position are not equivalent.');
                        }
                    }
                }

                return feature({
                    type: 'Polygon',
                    coordinates: coordinates
                }, properties);
            };

            /**
             * Creates a {@link LineString} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name lineString
             * @param {Array<Array<number>>} coordinates an array of Positions
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<LineString>} a LineString feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var linestring1 = turf.lineString([
             *   [-21.964416, 64.148203],
             *   [-21.956176, 64.141316],
             *   [-21.93901, 64.135924],
             *   [-21.927337, 64.136673]
             * ]);
             * var linestring2 = turf.lineString([
             *   [-21.929054, 64.127985],
             *   [-21.912918, 64.134726],
             *   [-21.916007, 64.141016],
             *   [-21.930084, 64.14446]
             * ], {name: 'line 1', distance: 145});
             *
             * //=linestring1
             *
             * //=linestring2
             */
            module.exports.lineString = function (coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'LineString',
                    coordinates: coordinates
                }, properties);
            };

            /**
             * Takes one or more {@link Feature|Features} and creates a {@link FeatureCollection}.
             *
             * @name featureCollection
             * @param {Feature[]} features input features
             * @returns {FeatureCollection} a FeatureCollection of input features
             * @example
             * var features = [
             *  turf.point([-75.343, 39.984], {name: 'Location A'}),
             *  turf.point([-75.833, 39.284], {name: 'Location B'}),
             *  turf.point([-75.534, 39.123], {name: 'Location C'})
             * ];
             *
             * var fc = turf.featureCollection(features);
             *
             * //=fc
             */
            module.exports.featureCollection = function (features) {
                if (!features) throw new Error('No features passed');

                return {
                    type: 'FeatureCollection',
                    features: features
                };
            };

            /**
             * Creates a {@link Feature<MultiLineString>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name multiLineString
             * @param {Array<Array<Array<number>>>} coordinates an array of LineStrings
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<MultiLineString>} a MultiLineString feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var multiLine = turf.multiLineString([[[0,0],[10,10]]]);
             *
             * //=multiLine
             *
             */
            module.exports.multiLineString = function (coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'MultiLineString',
                    coordinates: coordinates
                }, properties);
            };

            /**
             * Creates a {@link Feature<MultiPoint>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name multiPoint
             * @param {Array<Array<number>>} coordinates an array of Positions
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<MultiPoint>} a MultiPoint feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var multiPt = turf.multiPoint([[0,0],[10,10]]);
             *
             * //=multiPt
             *
             */
            module.exports.multiPoint = function (coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'MultiPoint',
                    coordinates: coordinates
                }, properties);
            };


            /**
             * Creates a {@link Feature<MultiPolygon>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name multiPolygon
             * @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygons
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<MultiPolygon>} a multipolygon feature
             * @throws {Error} if no coordinates are passed
             * @example
             * var multiPoly = turf.multiPolygon([[[[0,0],[0,10],[10,10],[10,0],[0,0]]]]);
             *
             * //=multiPoly
             *
             */
            module.exports.multiPolygon = function (coordinates, properties) {
                if (!coordinates) throw new Error('No coordinates passed');

                return feature({
                    type: 'MultiPolygon',
                    coordinates: coordinates
                }, properties);
            };

            /**
             * Creates a {@link Feature<GeometryCollection>} based on a
             * coordinate array. Properties can be added optionally.
             *
             * @name geometryCollection
             * @param {Array<{Geometry}>} geometries an array of GeoJSON Geometries
             * @param {Object=} properties an Object of key-value pairs to add as properties
             * @returns {Feature<GeometryCollection>} a GeoJSON GeometryCollection Feature
             * @example
             * var pt = {
             *     "type": "Point",
             *       "coordinates": [100, 0]
             *     };
             * var line = {
             *     "type": "LineString",
             *     "coordinates": [ [101, 0], [102, 1] ]
             *   };
             * var collection = turf.geometryCollection([pt, line]);
             *
             * //=collection
             */
            module.exports.geometryCollection = function (geometries, properties) {
                if (!geometries) throw new Error('No geometries passed');

                return feature({
                    type: 'GeometryCollection',
                    geometries: geometries
                }, properties);
            };

            var factors = {
                miles: 3960,
                nauticalmiles: 3441.145,
                degrees: 57.2957795,
                radians: 1,
                inches: 250905600,
                yards: 6969600,
                meters: 6373000,
                metres: 6373000,
                kilometers: 6373,
                kilometres: 6373,
                feet: 20908792.65
            };

            /*
             * Convert a distance measurement from radians to a more friendly unit.
             *
             * @name radiansToDistance
             * @param {number} distance in radians across the sphere
             * @param {string} [units=kilometers] can be degrees, radians, miles, or kilometers
             * inches, yards, metres, meters, kilometres, kilometers.
             * @returns {number} distance
             */
            module.exports.radiansToDistance = function (radians, units) {
                var factor = factors[units || 'kilometers'];
                if (factor === undefined) throw new Error('Invalid unit');

                return radians * factor;
            };

            /*
             * Convert a distance measurement from a real-world unit into radians
             *
             * @name distanceToRadians
             * @param {number} distance in real units
             * @param {string} [units=kilometers] can be degrees, radians, miles, or kilometers
             * inches, yards, metres, meters, kilometres, kilometers.
             * @returns {number} radians
             */
            module.exports.distanceToRadians = function (distance, units) {
                var factor = factors[units || 'kilometers'];
                if (factor === undefined) throw new Error('Invalid unit');

                return distance / factor;
            };

            /*
             * Convert a distance measurement from a real-world unit into degrees
             *
             * @name distanceToRadians
             * @param {number} distance in real units
             * @param {string} [units=kilometers] can be degrees, radians, miles, or kilometers
             * inches, yards, metres, meters, kilometres, kilometers.
             * @returns {number} degrees
             */
            module.exports.distanceToDegrees = function (distance, units) {
                var factor = factors[units || 'kilometers'];
                if (factor === undefined) throw new Error('Invalid unit');

                return (distance / factor) * 57.2958;
            };

        }, {}], 7: [function (require, module, exports) {
            var helpers = require('@turf/helpers');
            var meta = require('@turf/meta');
            var lineSegment = require('@turf/line-segment');
            var getCoords = require('@turf/invariant').getCoords;
            var rbush = require('geojson-rbush');
            var point = helpers.point;
            var featureCollection = helpers.featureCollection;
            var featureEach = meta.featureEach;

            /**
             * Takes any LineString or Polygon GeoJSON and returns the intersecting point(s).
             *
             * @name lineIntersect
             * @param {FeatureCollection|Feature<LineString|MultiLineString|Polygon|MultiPolygon>} line1 any LineString or Polygon
             * @param {FeatureCollection|Feature<LineString|MultiLineString|Polygon|MultiPolygon>} line2 any LineString or Polygon
             * @returns {FeatureCollection<Point>} point(s) that intersect both
             * @example
             * var line1 = {
             *   "type": "Feature",
             *   "properties": {},
             *   "geometry": {
             *     "type": "LineString",
             *     "coordinates": [[126, -11], [129, -21]]
             *   }
             * };
             * var line2 = {
             *   "type": "Feature",
             *   "properties": {},
             *   "geometry": {
             *     "type": "LineString",
             *     "coordinates": [[123, -18], [131, -14]]
             *   }
             * };
             * var points = turf.lineIntersect(line1, line2);
             * //= points
             */
            module.exports = function (line1, line2) {
                var results = [];
                // Handles simple 2-vertex segments
                if (line1.geometry.type === 'LineString' &&
                    line2.geometry.type === 'LineString' &&
                    line1.geometry.coordinates.length === 2 &&
                    line2.geometry.coordinates.length === 2) {
                    var intersect = intersects(line1, line2);
                    if (intersect) results.push(intersect);
                    return featureCollection(results);
                }
                // Handles complex GeoJSON Geometries
                var tree = rbush();
                tree.load(lineSegment(line2));
                featureEach(lineSegment(line1), function (segment) {
                    featureEach(tree.search(segment), function (match) {
                        var intersect = intersects(segment, match);
                        if (intersect) results.push(intersect);
                    });
                });
                return featureCollection(results);
            };

            /**
             * Find a point that intersects LineStrings with two coordinates each
             *
             * @private
             * @param {Feature<LineString>} line1 GeoJSON LineString (Must only contain 2 coordinates)
             * @param {Feature<LineString>} line2 GeoJSON LineString (Must only contain 2 coordinates)
             * @returns {Feature<Point>} intersecting GeoJSON Point
             */
            function intersects(line1, line2) {
                var coords1 = getCoords(line1);
                var coords2 = getCoords(line2);
                if (coords1.length !== 2) {
                    throw new Error('<intersects> line1 must only contain 2 coordinates');
                }
                if (coords2.length !== 2) {
                    throw new Error('<intersects> line2 must only contain 2 coordinates');
                }
                var x1 = coords1[0][0];
                var y1 = coords1[0][1];
                var x2 = coords1[1][0];
                var y2 = coords1[1][1];
                var x3 = coords2[0][0];
                var y3 = coords2[0][1];
                var x4 = coords2[1][0];
                var y4 = coords2[1][1];
                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 null;
                    }
                    return null;
                }

                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 point([x, y]);
                }
                return null;
            }

        }, { "@turf/helpers": 8, "@turf/invariant": 9, "@turf/line-segment": 11, "@turf/meta": 10, "geojson-rbush": 20 }], 8: [function (require, module, exports) {
            arguments[4][3][0].apply(exports, arguments)
        }, { "dup": 3 }], 9: [function (require, module, exports) {
            arguments[4][4][0].apply(exports, arguments)
        }, { "dup": 4 }], 10: [function (require, module, exports) {
            /**
             * Callback for coordEach
             *
             * @private
             * @callback coordEachCallback
             * @param {Array<number>} currentCoords The current coordinates being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Iterate over coordinates in any GeoJSON object, similar to Array.forEach()
             *
             * @name coordEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentCoords, currentIndex)
             * @param {boolean} [excludeWrapCoord=false] whether or not to include
             * the final coordinate of LinearRings that wraps the ring in its iteration.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.coordEach(features, function (currentCoords, currentIndex) {
             *   //=currentCoords
             *   //=currentIndex
             * });
             */
            function coordEach(layer, callback, excludeWrapCoord) {
                var i, j, k, g, l, geometry, stopG, coords,
                    geometryMaybeCollection,
                    wrapShrink = 0,
                    currentIndex = 0,
                    isGeometryCollection,
                    isFeatureCollection = layer.type === 'FeatureCollection',
                    isFeature = layer.type === 'Feature',
                    stop = isFeatureCollection ? layer.features.length : 1;

                // This logic may look a little weird. The reason why it is that way
                // is because it's trying to be fast. GeoJSON supports multiple kinds
                // of objects at its root: FeatureCollection, Features, Geometries.
                // This function has the responsibility of handling all of them, and that
                // means that some of the `for` loops you see below actually just don't apply
                // to certain inputs. For instance, if you give this just a
                // Point geometry, then both loops are short-circuited and all we do
                // is gradually rename the input until it's called 'geometry'.
                //
                // This also aims to allocate as few resources as possible: just a
                // few numbers and booleans, rather than any temporary arrays as would
                // be required with the normalization approach.
                for (i = 0; i < stop; i++) {

                    geometryMaybeCollection = (isFeatureCollection ? layer.features[i].geometry :
                    (isFeature ? layer.geometry : layer));
                    isGeometryCollection = geometryMaybeCollection.type === 'GeometryCollection';
                    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;

                    for (g = 0; g < stopG; g++) {
                        geometry = isGeometryCollection ?
                        geometryMaybeCollection.geometries[g] : geometryMaybeCollection;
                        coords = geometry.coordinates;

                        wrapShrink = (excludeWrapCoord &&
                            (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon')) ?
                            1 : 0;

                        if (geometry.type === 'Point') {
                            callback(coords, currentIndex);
                            currentIndex++;
                        } else if (geometry.type === 'LineString' || geometry.type === 'MultiPoint') {
                            for (j = 0; j < coords.length; j++) {
                                callback(coords[j], currentIndex);
                                currentIndex++;
                            }
                        } else if (geometry.type === 'Polygon' || geometry.type === 'MultiLineString') {
                            for (j = 0; j < coords.length; j++)
                                for (k = 0; k < coords[j].length - wrapShrink; k++) {
                                    callback(coords[j][k], currentIndex);
                                    currentIndex++;
                                }
                        } else if (geometry.type === 'MultiPolygon') {
                            for (j = 0; j < coords.length; j++)
                                for (k = 0; k < coords[j].length; k++)
                                    for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
                                        callback(coords[j][k][l], currentIndex);
                                        currentIndex++;
                                    }
                        } else if (geometry.type === 'GeometryCollection') {
                            for (j = 0; j < geometry.geometries.length; j++)
                                coordEach(geometry.geometries[j], callback, excludeWrapCoord);
                        } else {
                            throw new Error('Unknown Geometry Type');
                        }
                    }
                }
            }

            /**
             * Callback for coordReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback coordReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {Array<Number>} currentCoords The current coordinate being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce coordinates in any GeoJSON object, similar to Array.reduce()
             *
             * @name coordReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentCoords, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @param {boolean} [excludeWrapCoord=false] whether or not to include
             * the final coordinate of LinearRings that wraps the ring in its iteration.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.coordReduce(features, function (previousValue, currentCoords, currentIndex) {
             *   //=previousValue
             *   //=currentCoords
             *   //=currentIndex
             *   return currentCoords;
             * });
             */
            function coordReduce(layer, callback, initialValue, excludeWrapCoord) {
                var previousValue = initialValue;
                coordEach(layer, function (currentCoords, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentCoords;
                    } else {
                        previousValue = callback(previousValue, currentCoords, currentIndex);
                    }
                }, excludeWrapCoord);
                return previousValue;
            }

            /**
             * Callback for propEach
             *
             * @private
             * @callback propEachCallback
             * @param {*} currentProperties The current properties being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Iterate over properties in any GeoJSON object, similar to Array.forEach()
             *
             * @name propEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentProperties, currentIndex)
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.propEach(features, function (currentProperties, currentIndex) {
             *   //=currentProperties
             *   //=currentIndex
             * });
             */
            function propEach(layer, callback) {
                var i;
                switch (layer.type) {
                    case 'FeatureCollection':
                        for (i = 0; i < layer.features.length; i++) {
                            callback(layer.features[i].properties, i);
                        }
                        break;
                    case 'Feature':
                        callback(layer.properties, 0);
                        break;
                }
            }


            /**
             * Callback for propReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback propReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {*} currentProperties The current properties being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce properties in any GeoJSON object into a single value,
             * similar to how Array.reduce works. However, in this case we lazily run
             * the reduction, so an array of all properties is unnecessary.
             *
             * @name propReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentProperties, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.propReduce(features, function (previousValue, currentProperties, currentIndex) {
             *   //=previousValue
             *   //=currentProperties
             *   //=currentIndex
             *   return currentProperties
             * });
             */
            function propReduce(layer, callback, initialValue) {
                var previousValue = initialValue;
                propEach(layer, function (currentProperties, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentProperties;
                    } else {
                        previousValue = callback(previousValue, currentProperties, currentIndex);
                    }
                });
                return previousValue;
            }

            /**
             * Callback for featureEach
             *
             * @private
             * @callback featureEachCallback
             * @param {Feature<any>} currentFeature The current feature being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Iterate over features in any GeoJSON object, similar to
             * Array.forEach.
             *
             * @name featureEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentFeature, currentIndex)
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.featureEach(features, function (currentFeature, currentIndex) {
             *   //=currentFeature
             *   //=currentIndex
             * });
             */
            function featureEach(layer, callback) {
                if (layer.type === 'Feature') {
                    callback(layer, 0);
                } else if (layer.type === 'FeatureCollection') {
                    for (var i = 0; i < layer.features.length; i++) {
                        callback(layer.features[i], i);
                    }
                }
            }

            /**
             * Callback for featureReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback featureReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {Feature<any>} currentFeature The current Feature being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce features in any GeoJSON object, similar to Array.reduce().
             *
             * @name featureReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentFeature, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.featureReduce(features, function (previousValue, currentFeature, currentIndex) {
             *   //=previousValue
             *   //=currentFeature
             *   //=currentIndex
             *   return currentFeature
             * });
             */
            function featureReduce(layer, callback, initialValue) {
                var previousValue = initialValue;
                featureEach(layer, function (currentFeature, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentFeature;
                    } else {
                        previousValue = callback(previousValue, currentFeature, currentIndex);
                    }
                });
                return previousValue;
            }

            /**
             * Get all coordinates from any GeoJSON object.
             *
             * @name coordAll
             * @param {Object} layer any GeoJSON object
             * @returns {Array<Array<number>>} coordinate position array
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * var coords = turf.coordAll(features);
             * //=coords
             */
            function coordAll(layer) {
                var coords = [];
                coordEach(layer, function (coord) {
                    coords.push(coord);
                });
                return coords;
            }

            /**
             * Iterate over each geometry in any GeoJSON object, similar to Array.forEach()
             *
             * @name geomEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentGeometry, currentIndex)
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.geomEach(features, function (currentGeometry, currentIndex) {
             *   //=currentGeometry
             *   //=currentIndex
             * });
             */
            function geomEach(layer, callback) {
                var i, j, g, geometry, stopG,
                    geometryMaybeCollection,
                    isGeometryCollection,
                    currentIndex = 0,
                    isFeatureCollection = layer.type === 'FeatureCollection',
                    isFeature = layer.type === 'Feature',
                    stop = isFeatureCollection ? layer.features.length : 1;

                // This logic may look a little weird. The reason why it is that way
                // is because it's trying to be fast. GeoJSON supports multiple kinds
                // of objects at its root: FeatureCollection, Features, Geometries.
                // This function has the responsibility of handling all of them, and that
                // means that some of the `for` loops you see below actually just don't apply
                // to certain inputs. For instance, if you give this just a
                // Point geometry, then both loops are short-circuited and all we do
                // is gradually rename the input until it's called 'geometry'.
                //
                // This also aims to allocate as few resources as possible: just a
                // few numbers and booleans, rather than any temporary arrays as would
                // be required with the normalization approach.
                for (i = 0; i < stop; i++) {

                    geometryMaybeCollection = (isFeatureCollection ? layer.features[i].geometry :
                    (isFeature ? layer.geometry : layer));
                    isGeometryCollection = geometryMaybeCollection.type === 'GeometryCollection';
                    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;

                    for (g = 0; g < stopG; g++) {
                        geometry = isGeometryCollection ?
                        geometryMaybeCollection.geometries[g] : geometryMaybeCollection;

                        if (geometry.type === 'Point' ||
                            geometry.type === 'LineString' ||
                            geometry.type === 'MultiPoint' ||
                            geometry.type === 'Polygon' ||
                            geometry.type === 'MultiLineString' ||
                            geometry.type === 'MultiPolygon') {
                            callback(geometry, currentIndex);
                            currentIndex++;
                        } else if (geometry.type === 'GeometryCollection') {
                            for (j = 0; j < geometry.geometries.length; j++) {
                                callback(geometry.geometries[j], currentIndex);
                                currentIndex++;
                            }
                        } else {
                            throw new Error('Unknown Geometry Type');
                        }
                    }
                }
            }

            /**
             * Callback for geomReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback geomReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {*} currentGeometry The current Feature being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce geometry in any GeoJSON object, similar to Array.reduce().
             *
             * @name geomReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentGeometry, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.geomReduce(features, function (previousValue, currentGeometry, currentIndex) {
             *   //=previousValue
             *   //=currentGeometry
             *   //=currentIndex
             *   return currentGeometry
             * });
             */
            function geomReduce(layer, callback, initialValue) {
                var previousValue = initialValue;
                geomEach(layer, function (currentGeometry, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentGeometry;
                    } else {
                        previousValue = callback(previousValue, currentGeometry, currentIndex);
                    }
                });
                return previousValue;
            }

            module.exports = {
                coordEach: coordEach,
                coordReduce: coordReduce,
                propEach: propEach,
                propReduce: propReduce,
                featureEach: featureEach,
                featureReduce: featureReduce,
                coordAll: coordAll,
                geomEach: geomEach,
                geomReduce: geomReduce
            };

        }, {}], 11: [function (require, module, exports) {
            var flatten = require('@turf/flatten');
            var featureEach = require('@turf/meta').featureEach;
            var lineString = require('@turf/helpers').lineString;
            var featureCollection = require('@turf/helpers').featureCollection;
            var getCoords = require('@turf/invariant').getCoords;

            /**
             * Creates a {@link FeatureCollection} of 2-vertex {@link LineString} segments from a {@link LineString}, {@link MultiLineString}, {@link MultiPolygon} or {@link Polygon}.
             *
             * @name lineSegment
             * @param {FeatureCollection|Feature<LineString|MultiLineString|MultiPolygon|Polygon>} geojson GeoJSON Polygon or LineString
             * @returns {FeatureCollection<LineString>} 2-vertex line segments
             * @example
             * var polygon = {
             *   "type": "Feature",
             *   "properties": {},
             *   "geometry": {
             *     "type": "Polygon",
             *     "coordinates": [[[-50, 5], [-40, -10], [-50, -10], [-40, 5], [-50, 5]]]
             *   }
             * }
             * var segments = turf.lineSegment(polygon);
             * //=segments
             */
            module.exports = function (geojson) {
                var results = [];
                var index = 0;
                featureEach(geojson, function (multiFeature) {
                    featureEach(flatten(multiFeature), function (feature) {
                        var coords = [];
                        var type = (feature.geometry) ? feature.geometry.type : feature.type;
                        switch (type) {
                            case 'Polygon':
                                coords = getCoords(feature);
                                break;
                            case 'LineString':
                                coords = [getCoords(feature)];
                        }
                        coords.forEach(function (coord) {
                            var segments = createSegments(coord, feature.properties);
                            segments.forEach(function (segment) {
                                segment.id = index;
                                results.push(segment);
                                index++;
                            });
                        });
                    });
                });
                return featureCollection(results);
            };

            /**
             * Create Segments from LineString coordinates
             *
             * @private
             * @param {LineString} coords LineString coordinates
             * @param {*} properties GeoJSON properties
             * @returns {Array<Feature<LineString>>} line segments
             */
            function createSegments(coords, properties) {
                var segments = [];
                coords.reduce(function (previousCoords, currentCoords) {
                    var segment = lineString([previousCoords, currentCoords], properties);
                    segment.bbox = bbox(previousCoords, currentCoords);
                    segments.push(segment);
                    return currentCoords;
                });
                return segments;
            }

            /**
             * Create BBox between two coordinates (faster than @turf/bbox)
             *
             * @private
             * @param {Array<Number>} coords1 Point coordinate
             * @param {Array<Number>} coords2 Point coordinate
             * @returns {BBox} [west, south, east, north]
             */
            function bbox(coords1, coords2) {
                var x1 = coords1[0];
                var y1 = coords1[1];
                var x2 = coords2[0];
                var y2 = coords2[1];
                var west = (x1 < x2) ? x1 : x2;
                var south = (y1 < y2) ? y1 : y2;
                var east = (x1 > x2) ? x1 : x2;
                var north = (y1 > y2) ? y1 : y2;
                return [west, south, east, north];
            }

        }, { "@turf/flatten": 12, "@turf/helpers": 13, "@turf/invariant": 14, "@turf/meta": 15 }], 12: [function (require, module, exports) {
            var featureEach = require('@turf/meta').featureEach;
            var geomEach = require('@turf/meta').geomEach;
            var getCoords = require('@turf/invariant').getCoords;
            var helpers = require('@turf/helpers');
            var point = helpers.point;
            var lineString = helpers.lineString;
            var polygon = helpers.polygon;
            var featureCollection = helpers.featureCollection;

            /**
             * Flattens any {@link GeoJSON} to a {@link FeatureCollection} inspired by [geojson-flatten](https://github.com/tmcw/geojson-flatten).
             *
             * @name flatten
             * @param {Feature} geojson any valid {@link GeoJSON} with multi-geometry {@link Feature}s
             * @returns {FeatureCollection} a flattened {@link FeatureCollection}
             * @example
             * var geometry = {
             *   "type": "MultiPolygon",
             *   "coordinates": [
             *     [[[102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]]],
             *      [[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]],
             *      [[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]]
             *    ]
             *  };
             *
             * var flattened = turf.flatten(geometry);
             *
             * //=flattened
             */
            function flatten(geojson) {
                var type = (geojson.geometry) ? geojson.geometry.type : geojson.type;
                switch (type) {
                    case 'MultiPoint':
                        return flattenMultiPoint(geojson);
                    case 'MultiPolygon':
                        return flattenMultiPolygon(geojson);
                    case 'MultiLineString':
                        return flattenMultiLineString(geojson);
                    case 'FeatureCollection':
                        return flattenFeatureCollection(geojson);
                    case 'GeometryCollection':
                        return flattenGeometryCollection(geojson);
                    case 'Point':
                    case 'LineString':
                    case 'Polygon':
                        return featureCollection([geojson]);
                }
            }
            module.exports = flatten;

            /**
             * Flatten MultiPoint
             *
             * @private
             * @param {Feature<MultiPoint>} geojson GeoJSON Feature
             * @returns {FeatureCollection<Point>} Feature Collection
             */
            function flattenMultiPoint(geojson) {
                var points = [];
                getCoords(geojson).forEach(function (coords) {
                    points.push(point(coords, geojson.properties));
                });
                return featureCollection(points);
            }

            /**
             * Flatten MultiLineString
             *
             * @private
             * @param {Feature<MultiLineString>} geojson GeoJSON Feature
             * @returns {FeatureCollection<LineString>} Feature Collection
             */
            function flattenMultiLineString(geojson) {
                var lines = [];
                getCoords(geojson).forEach(function (coords) {
                    lines.push(lineString(coords, geojson.properties));
                });
                return featureCollection(lines);
            }

            /**
             * Flatten MultiPolygon
             *
             * @private
             * @param {Feature<MultiPolygon>} geojson GeoJSON Feature
             * @returns {FeatureCollection<Polygon>} Feature Collection
             */
            function flattenMultiPolygon(geojson) {
                var polygons = [];
                getCoords(geojson).forEach(function (coords) {
                    polygons.push(polygon(coords, geojson.properties));
                });
                return featureCollection(polygons);
            }

            /**
             * Flatten FeatureCollection
             *
             * @private
             * @param {FeatureCollection<any>} geojson GeoJSON Feature
             * @returns {FeatureCollection<any>} Feature Collection
             */
            function flattenFeatureCollection(geojson) {
                var features = [];
                featureEach(geojson, function (multiFeature) {
                    switch (multiFeature.geometry.type) {
                        case 'MultiPoint':
                        case 'MultiLineString':
                        case 'MultiPolygon':
                            featureEach(flatten(multiFeature), function (feature) {
                                features.push(feature);
                            });
                            break;
                        default:
                            features.push(multiFeature);
                    }
                });
                return featureCollection(features);
            }

            /**
             * Flatten GeometryCollection
             *
             * @private
             * @param {GeometryCollection<any>} geojson GeoJSON Geometry Collection
             * @param {*} [properties] translate properties to Feature
             * @returns {FeatureCollection<any>} Feature Collection
             */
            function flattenGeometryCollection(geojson) {
                var features = [];
                geomEach(geojson, function (geometry) {
                    switch (geometry.type) {
                        case 'MultiPoint':
                        case 'MultiLineString':
                        case 'MultiPolygon':
                            featureEach(flatten(geometry), function (feature) {
                                features.push(feature);
                            });
                            break;
                        default:
                            var feature = {
                                type: 'Feature',
                                properties: {},
                                geometry: geometry
                            };
                            features.push(feature);
                    }
                });
                return featureCollection(features);
            }

        }, { "@turf/helpers": 13, "@turf/invariant": 14, "@turf/meta": 15 }], 13: [function (require, module, exports) {
            arguments[4][3][0].apply(exports, arguments)
        }, { "dup": 3 }], 14: [function (require, module, exports) {
            arguments[4][4][0].apply(exports, arguments)
        }, { "dup": 4 }], 15: [function (require, module, exports) {
            arguments[4][10][0].apply(exports, arguments)
        }, { "dup": 10 }], 16: [function (require, module, exports) {
            /**
             * Callback for coordEach
             *
             * @private
             * @callback coordEachCallback
             * @param {Array<Number>} currentCoords The current coordinates being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Iterate over coordinates in any GeoJSON object, similar to Array.forEach()
             *
             * @name coordEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentCoords, currentIndex)
             * @param {boolean} [excludeWrapCoord=false] whether or not to include
             * the final coordinate of LinearRings that wraps the ring in its iteration.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.coordEach(features, function (currentCoords, currentIndex) {
             *   //=currentCoords
             *   //=currentIndex
             * });
             */
            function coordEach(layer, callback, excludeWrapCoord) {
                var i, j, k, g, l, geometry, stopG, coords,
                    geometryMaybeCollection,
                    wrapShrink = 0,
                    currentIndex = 0,
                    isGeometryCollection,
                    isFeatureCollection = layer.type === 'FeatureCollection',
                    isFeature = layer.type === 'Feature',
                    stop = isFeatureCollection ? layer.features.length : 1;

                // This logic may look a little weird. The reason why it is that way
                // is because it's trying to be fast. GeoJSON supports multiple kinds
                // of objects at its root: FeatureCollection, Features, Geometries.
                // This function has the responsibility of handling all of them, and that
                // means that some of the `for` loops you see below actually just don't apply
                // to certain inputs. For instance, if you give this just a
                // Point geometry, then both loops are short-circuited and all we do
                // is gradually rename the input until it's called 'geometry'.
                //
                // This also aims to allocate as few resources as possible: just a
                // few numbers and booleans, rather than any temporary arrays as would
                // be required with the normalization approach.
                for (i = 0; i < stop; i++) {

                    geometryMaybeCollection = (isFeatureCollection ? layer.features[i].geometry :
                    (isFeature ? layer.geometry : layer));
                    isGeometryCollection = geometryMaybeCollection.type === 'GeometryCollection';
                    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;

                    for (g = 0; g < stopG; g++) {
                        geometry = isGeometryCollection ?
                        geometryMaybeCollection.geometries[g] : geometryMaybeCollection;
                        coords = geometry.coordinates;

                        wrapShrink = (excludeWrapCoord &&
                            (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon')) ?
                            1 : 0;

                        if (geometry.type === 'Point') {
                            callback(coords, currentIndex);
                            currentIndex++;
                        } else if (geometry.type === 'LineString' || geometry.type === 'MultiPoint') {
                            for (j = 0; j < coords.length; j++) {
                                callback(coords[j], currentIndex);
                                currentIndex++;
                            }
                        } else if (geometry.type === 'Polygon' || geometry.type === 'MultiLineString') {
                            for (j = 0; j < coords.length; j++)
                                for (k = 0; k < coords[j].length - wrapShrink; k++) {
                                    callback(coords[j][k], currentIndex);
                                    currentIndex++;
                                }
                        } else if (geometry.type === 'MultiPolygon') {
                            for (j = 0; j < coords.length; j++)
                                for (k = 0; k < coords[j].length; k++)
                                    for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
                                        callback(coords[j][k][l], currentIndex);
                                        currentIndex++;
                                    }
                        } else if (geometry.type === 'GeometryCollection') {
                            for (j = 0; j < geometry.geometries.length; j++)
                                coordEach(geometry.geometries[j], callback, excludeWrapCoord);
                        } else {
                            throw new Error('Unknown Geometry Type');
                        }
                    }
                }
            }
            module.exports.coordEach = coordEach;

            /**
             * Callback for coordReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback coordReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {Array<Number>} currentCoords The current coordinate being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce coordinates in any GeoJSON object, similar to Array.reduce()
             *
             * @name coordReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentCoords, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @param {boolean} [excludeWrapCoord=false] whether or not to include
             * the final coordinate of LinearRings that wraps the ring in its iteration.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.coordReduce(features, function (previousValue, currentCoords, currentIndex) {
             *   //=previousValue
             *   //=currentCoords
             *   //=currentIndex
             *   return currentCoords;
             * });
             */
            function coordReduce(layer, callback, initialValue, excludeWrapCoord) {
                var previousValue = initialValue;
                coordEach(layer, function (currentCoords, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentCoords;
                    } else {
                        previousValue = callback(previousValue, currentCoords, currentIndex);
                    }
                }, excludeWrapCoord);
                return previousValue;
            }
            module.exports.coordReduce = coordReduce;

            /**
             * Callback for propEach
             *
             * @private
             * @callback propEachCallback
             * @param {*} currentProperties The current properties being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Iterate over properties in any GeoJSON object, similar to Array.forEach()
             *
             * @name propEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentProperties, currentIndex)
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.propEach(features, function (currentProperties, currentIndex) {
             *   //=currentProperties
             *   //=currentIndex
             * });
             */
            function propEach(layer, callback) {
                var i;
                switch (layer.type) {
                    case 'FeatureCollection':
                        for (i = 0; i < layer.features.length; i++) {
                            callback(layer.features[i].properties, i);
                        }
                        break;
                    case 'Feature':
                        callback(layer.properties, 0);
                        break;
                }
            }
            module.exports.propEach = propEach;


            /**
             * Callback for propReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback propReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {*} currentProperties The current properties being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce properties in any GeoJSON object into a single value,
             * similar to how Array.reduce works. However, in this case we lazily run
             * the reduction, so an array of all properties is unnecessary.
             *
             * @name propReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentProperties, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.propReduce(features, function (previousValue, currentProperties, currentIndex) {
             *   //=previousValue
             *   //=currentProperties
             *   //=currentIndex
             *   return currentProperties
             * });
             */
            function propReduce(layer, callback, initialValue) {
                var previousValue = initialValue;
                propEach(layer, function (currentProperties, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentProperties;
                    } else {
                        previousValue = callback(previousValue, currentProperties, currentIndex);
                    }
                });
                return previousValue;
            }
            module.exports.propReduce = propReduce;

            /**
             * Callback for featureEach
             *
             * @private
             * @callback featureEachCallback
             * @param {Feature<any>} currentFeature The current feature being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Iterate over features in any GeoJSON object, similar to
             * Array.forEach.
             *
             * @name featureEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentFeature, currentIndex)
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.featureEach(features, function (currentFeature, currentIndex) {
             *   //=currentFeature
             *   //=currentIndex
             * });
             */
            function featureEach(layer, callback) {
                if (layer.type === 'Feature') {
                    callback(layer, 0);
                } else if (layer.type === 'FeatureCollection') {
                    for (var i = 0; i < layer.features.length; i++) {
                        callback(layer.features[i], i);
                    }
                }
            }
            module.exports.featureEach = featureEach;

            /**
             * Callback for featureReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback featureReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {Feature<any>} currentFeature The current Feature being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce features in any GeoJSON object, similar to Array.reduce().
             *
             * @name featureReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentFeature, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.featureReduce(features, function (previousValue, currentFeature, currentIndex) {
             *   //=previousValue
             *   //=currentFeature
             *   //=currentIndex
             *   return currentFeature
             * });
             */
            function featureReduce(layer, callback, initialValue) {
                var previousValue = initialValue;
                featureEach(layer, function (currentFeature, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentFeature;
                    } else {
                        previousValue = callback(previousValue, currentFeature, currentIndex);
                    }
                });
                return previousValue;
            }
            module.exports.featureReduce = featureReduce;

            /**
             * Get all coordinates from any GeoJSON object.
             *
             * @name coordAll
             * @param {Object} layer any GeoJSON object
             * @returns {Array<Array<number>>} coordinate position array
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * var coords = turf.coordAll(features);
             * //=coords
             */
            function coordAll(layer) {
                var coords = [];
                coordEach(layer, function (coord) {
                    coords.push(coord);
                });
                return coords;
            }
            module.exports.coordAll = coordAll;

            /**
             * Iterate over each geometry in any GeoJSON object, similar to Array.forEach()
             *
             * @name geomEach
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (currentGeometry, currentIndex)
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.geomEach(features, function (currentGeometry, currentIndex) {
             *   //=currentGeometry
             *   //=currentIndex
             * });
             */
            function geomEach(layer, callback) {
                var i, j, g, geometry, stopG,
                    geometryMaybeCollection,
                    isGeometryCollection,
                    currentIndex = 0,
                    isFeatureCollection = layer.type === 'FeatureCollection',
                    isFeature = layer.type === 'Feature',
                    stop = isFeatureCollection ? layer.features.length : 1;

                // This logic may look a little weird. The reason why it is that way
                // is because it's trying to be fast. GeoJSON supports multiple kinds
                // of objects at its root: FeatureCollection, Features, Geometries.
                // This function has the responsibility of handling all of them, and that
                // means that some of the `for` loops you see below actually just don't apply
                // to certain inputs. For instance, if you give this just a
                // Point geometry, then both loops are short-circuited and all we do
                // is gradually rename the input until it's called 'geometry'.
                //
                // This also aims to allocate as few resources as possible: just a
                // few numbers and booleans, rather than any temporary arrays as would
                // be required with the normalization approach.
                for (i = 0; i < stop; i++) {

                    geometryMaybeCollection = (isFeatureCollection ? layer.features[i].geometry :
                    (isFeature ? layer.geometry : layer));
                    isGeometryCollection = geometryMaybeCollection.type === 'GeometryCollection';
                    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;

                    for (g = 0; g < stopG; g++) {
                        geometry = isGeometryCollection ?
                        geometryMaybeCollection.geometries[g] : geometryMaybeCollection;

                        if (geometry.type === 'Point' ||
                            geometry.type === 'LineString' ||
                            geometry.type === 'MultiPoint' ||
                            geometry.type === 'Polygon' ||
                            geometry.type === 'MultiLineString' ||
                            geometry.type === 'MultiPolygon') {
                            callback(geometry, currentIndex);
                            currentIndex++;
                        } else if (geometry.type === 'GeometryCollection') {
                            for (j = 0; j < geometry.geometries.length; j++) {
                                callback(geometry.geometries[j], currentIndex);
                                currentIndex++;
                            }
                        } else {
                            throw new Error('Unknown Geometry Type');
                        }
                    }
                }
            }
            module.exports.geomEach = geomEach;

            /**
             * Callback for geomReduce
             *
             * The first time the callback function is called, the values provided as arguments depend
             * on whether the reduce method has an initialValue argument.
             *
             * If an initialValue is provided to the reduce method:
             *  - The previousValue argument is initialValue.
             *  - The currentValue argument is the value of the first element present in the array.
             *
             * If an initialValue is not provided:
             *  - The previousValue argument is the value of the first element present in the array.
             *  - The currentValue argument is the value of the second element present in the array.
             *
             * @private
             * @callback geomReduceCallback
             * @param {*} previousValue The accumulated value previously returned in the last invocation
             * of the callback, or initialValue, if supplied.
             * @param {*} currentGeometry The current Feature being processed.
             * @param {number} currentIndex The index of the current element being processed in the
             * array.Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
             */

            /**
             * Reduce geometry in any GeoJSON object, similar to Array.reduce().
             *
             * @name geomReduce
             * @param {Object} layer any GeoJSON object
             * @param {Function} callback a method that takes (previousValue, currentGeometry, currentIndex)
             * @param {*} [initialValue] Value to use as the first argument to the first call of the callback.
             * @returns {*} The value that results from the reduction.
             * @example
             * var features = {
             *   "type": "FeatureCollection",
             *   "features": [
             *     {
             *       "type": "Feature",
             *       "properties": {"foo": "bar"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [26, 37]
             *       }
             *     },
             *     {
             *       "type": "Feature",
             *       "properties": {"hello": "world"},
             *       "geometry": {
             *         "type": "Point",
             *         "coordinates": [36, 53]
             *       }
             *     }
             *   ]
             * };
             * turf.geomReduce(features, function (previousValue, currentGeometry, currentIndex) {
             *   //=previousValue
             *   //=currentGeometry
             *   //=currentIndex
             *   return currentGeometry
             * });
             */
            function geomReduce(layer, callback, initialValue) {
                var previousValue = initialValue;
                geomEach(layer, function (currentGeometry, currentIndex) {
                    if (currentIndex === 0 && initialValue === undefined) {
                        previousValue = currentGeometry;
                    } else {
                        previousValue = callback(previousValue, currentGeometry, currentIndex);
                    }
                });
                return previousValue;
            }
            module.exports.geomReduce = geomReduce;

        }, {}], 17: [function (require, module, exports) {
            var getCoords = require('@turf/invariant').getCoords;
            var helpers = require('@turf/helpers');
            var lineString = helpers.lineString;
            var multiLineString = helpers.multiLineString;
            var featureCollection = helpers.featureCollection;

            /**
             * Converts a {@link Polygon} or {@link MultiPolygon} to a {@link FeatureCollection} of {@link LineString} or {@link MultiLineString}.
             *
             * @name polygonToLineString
             * @param {Feature<Polygon|MultiPolygon>} polygon Feature to convert
             * @returns {FeatureCollection<LineString|MultiLinestring>} converted Feature to Lines
             * @example
             * var poly = {
             *   'type': 'Feature',
             *   'properties': {},
             *   'geometry': {
             *     'type': 'Polygon',
             *     'coordinates': [[[125, -30], [145, -30], [145, -20], [125, -20], [125, -30]]]
             *   }
             * }
             * var lines = turf.polygonToLineString(poly);
             * //addToMap
             * var addToMap = [lines]
             */
            module.exports = function (polygon) {
                var geom = getGeomType(polygon);
                var coords = getCoords(polygon);
                var properties = polygon.properties;
                if (!coords.length) throw new Error('polygon must contain coordinates');

                switch (geom) {
                    case 'Polygon':
                        return featureCollection([coordsToLine(coords, properties)]);
                    case 'MultiPolygon':
                        var lines = [];
                        coords.forEach(function (coord) {
                            lines.push(coordsToLine(coord, properties));
                        });
                        return featureCollection(lines);
                    default:
                        throw new Error('geom ' + geom + ' not supported');
                }
            };

            function coordsToLine(coords, properties) {
                if (coords.length > 1) return multiLineString(coords, properties);
                return lineString(coords[0], properties);
            }

            function getGeomType(feature) {
                return (feature.geometry) ? feature.geometry.type : feature.type;
            }

        }, { "@turf/helpers": 18, "@turf/invariant": 19 }], 18: [function (require, module, exports) {
            arguments[4][3][0].apply(exports, arguments)
        }, { "dup": 3 }], 19: [function (require, module, exports) {
            arguments[4][4][0].apply(exports, arguments)
        }, { "dup": 4 }], 20: [function (require, module, exports) {
            var turfBBox = require('@turf/bbox');
            var featureCollection = require('@turf/helpers').featureCollection;
            var featureEach = require('@turf/meta').featureEach;
            var rbush = require('rbush');

            /**
             * GeoJSON implementation of [RBush](https://github.com/mourner/rbush#rbush) spatial index.
             *
             * @name rbush
             * @param {number} [maxEntries=9] defines the maximum number of entries in a tree node. 9 (used by default) is a
             * reasonable choice for most applications. Higher value means faster insertion and slower search, and vice versa.
             * @returns {RBush} GeoJSON RBush
             * @example
             * var rbush = require('geojson-rbush')
             * var tree = rbush()
             */
            module.exports = function (maxEntries) {
                var tree = rbush(maxEntries);
                /**
                 * [insert](https://github.com/mourner/rbush#data-format)
                 *
                 * @param {Feature<any>} feature insert single GeoJSON Feature
                 * @returns {RBush} GeoJSON RBush
                 * @example
                 * var polygon = {
                 *   "type": "Feature",
                 *   "properties": {},
                 *   "geometry": {
                 *     "type": "Polygon",
                 *     "coordinates": [[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]
                 *   }
                 * }
                 * tree.insert(polygon)
                 */
                tree.insert = function (feature) {
                    feature.bbox = feature.bbox ? feature.bbox : turfBBox(feature);
                    return rbush.prototype.insert.call(this, feature);
                };

                /**
                 * [load](https://github.com/mourner/rbush#bulk-inserting-data)
                 *
                 * @param {FeatureCollection<any>} features load entire GeoJSON FeatureCollection
                 * @returns {RBush} GeoJSON RBush
                 * @example
                 * var polygons = {
                 *   "type": "FeatureCollection",
                 *   "features": [
                 *     {
                 *       "type": "Feature",
                 *       "properties": {},
                 *       "geometry": {
                 *         "type": "Polygon",
                 *         "coordinates": [[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]
                 *       }
                 *     },
                 *     {
                 *       "type": "Feature",
                 *       "properties": {},
                 *       "geometry": {
                 *         "type": "Polygon",
                 *         "coordinates": [[[-93, 32], [-83, 32], [-83, 39], [-93, 39], [-93, 32]]]
                 *       }
                 *     }
                 *   ]
                 * }
                 * tree.load(polygons)
                 */
                tree.load = function (features) {
                    var load = [];
                    featureEach(features, function (feature) {
                        feature.bbox = feature.bbox ? feature.bbox : turfBBox(feature);
                        load.push(feature);
                    });
                    return rbush.prototype.load.call(this, load);
                };

                /**
                 * [remove](https://github.com/mourner/rbush#removing-data)
                 *
                 * @param {Feature<any>} feature remove single GeoJSON Feature
                 * @returns {RBush} GeoJSON RBush
                 * @example
                 * var polygon = {
                 *   "type": "Feature",
                 *   "properties": {},
                 *   "geometry": {
                 *     "type": "Polygon",
                 *     "coordinates": [[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]
                 *   }
                 * }
                 * tree.remove(polygon)
                 */
                tree.remove = function (feature) {
                    return rbush.prototype.remove.call(this, feature);
                };

                /**
                 * [clear](https://github.com/mourner/rbush#removing-data)
                 *
                 * @returns {RBush} GeoJSON Rbush
                 * @example
                 * tree.clear()
                 */
                tree.clear = function () {
                    return rbush.prototype.clear.call(this);
                };

                /**
                 * [search](https://github.com/mourner/rbush#search)
                 *
                 * @param {FeatureCollection|Feature<any>} geojson search with GeoJSON
                 * @returns {FeatureCollection<any>} all features that intersects with the given GeoJSON.
                 * @example
                 * var polygon = {
                 *   "type": "Feature",
                 *   "properties": {},
                 *   "geometry": {
                 *     "type": "Polygon",
                 *     "coordinates": [[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]
                 *   }
                 * }
                 * tree.search(polygon)
                 */
                tree.search = function (geojson) {
                    var search = rbush.prototype.search.call(this, this.toBBox(geojson));
                    return featureCollection(search);
                };

                /**
                 * [collides](https://github.com/mourner/rbush#collisions)
                 *
                 * @param {FeatureCollection|Feature<any>} geojson collides with GeoJSON
                 * @returns {boolean} true if there are any items intersecting the given GeoJSON, otherwise false.
                 * @example
                 * var polygon = {
                 *   "type": "Feature",
                 *   "properties": {},
                 *   "geometry": {
                 *     "type": "Polygon",
                 *     "coordinates": [[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]
                 *   }
                 * }
                 * tree.collides(polygon)
                 */
                tree.collides = function (geojson) {
                    return rbush.prototype.collides.call(this, this.toBBox(geojson));
                };

                /**
                 * [all](https://github.com/mourner/rbush#search)
                 *
                 * @returns {FeatureCollection<any>} all the features in RBush
                 * @example
                 * tree.all()
                 * //=FeatureCollection
                 */
                tree.all = function () {
                    var all = rbush.prototype.all.call(this);
                    return featureCollection(all);
                };

                /**
                 * [toJSON](https://github.com/mourner/rbush#export-and-import)
                 *
                 * @returns {any} export data as JSON object
                 * @example
                 * var exported = tree.toJSON()
                 * //=JSON object
                 */
                tree.toJSON = function () {
                    return rbush.prototype.toJSON.call(this);
                };

                /**
                 * [fromJSON](https://github.com/mourner/rbush#export-and-import)
                 *
                 * @param {any} json import previously exported data
                 * @returns {RBush} GeoJSON RBush
                 * @example
                 * var exported = {
                 *   "children": [
                 *     {
                 *       "type": "Feature",
                 *       "geometry": {
                 *         "type": "Point",
                 *         "coordinates": [110, 50]
                 *       },
                 *       "properties": {},
                 *       "bbox": [110, 50, 110, 50]
                 *     }
                 *   ],
                 *   "height": 1,
                 *   "leaf": true,
                 *   "minX": 110,
                 *   "minY": 50,
                 *   "maxX": 110,
                 *   "maxY": 50
                 * }
                 * tree.fromJSON(exported)
                 */
                tree.fromJSON = function (json) {
                    return rbush.prototype.fromJSON.call(this, json);
                };

                /**
                 * Converts GeoJSON to {minX, minY, maxX, maxY} schema
                 *
                 * @private
                 * @param {FeatureCollectio|Feature<any>} geojson feature(s) to retrieve BBox from
                 * @returns {Object} converted to {minX, minY, maxX, maxY}
                 */
                tree.toBBox = function (geojson) {
                    var bbox = geojson.bbox ? geojson.bbox : turfBBox(geojson);
                    return {
                        minX: bbox[0],
                        minY: bbox[1],
                        maxX: bbox[2],
                        maxY: bbox[3]
                    };
                };
                return tree;
            };

        }, { "@turf/bbox": 5, "@turf/helpers": 6, "@turf/meta": 16, "rbush": 23 }], 21: [function (require, module, exports) {
            'use strict';

            module.exports = lineclip;

            lineclip.polyline = lineclip;
            lineclip.polygon = polygonclip;


            // Cohen-Sutherland line clippign algorithm, adapted to efficiently
            // handle polylines rather than just segments

            function lineclip(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)) { // accept
                            part.push(a);

                            if (codeB !== lastCode) { // segment went outside
                                part.push(b);

                                if (i < len - 1) { // start a new line
                                    result.push(part);
                                    part = [];
                                }
                            } else if (i === len - 1) {
                                part.push(b);
                            }
                            break;

                        } else if (codeA & codeB) { // trivial reject
                            break;

                        } else if (codeA) { // a outside, intersect with clip edge
                            a = intersect(a, b, codeA, bbox);
                            codeA = bitCode(a, bbox);

                        } else { // b outside
                            b = intersect(a, b, codeB, bbox);
                            codeB = bitCode(b, bbox);
                        }
                    }

                    codeA = lastCode;
                }

                if (part.length) result.push(part);

                return result;
            }

            // Sutherland-Hodgeman polygon clipping algorithm

            function polygonclip(points, bbox) {

                var result, edge, prev, prevInside, i, p, inside;

                // clip against each side of the clip rectangle
                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 segment goes through the clip window, add an intersection
                        if (inside !== prevInside) result.push(intersect(prev, p, edge, bbox));

                        if (inside) result.push(p); // add a point if it's inside

                        prev = p;
                        prevInside = inside;
                    }

                    points = result;

                    if (!points.length) break;
                }

                return result;
            }

            // intersect a segment against one of the 4 lines that make up the bbox

            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]] : // top
                       edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox[1] - a[1]) / (b[1] - a[1]), bbox[1]] : // bottom
                       edge & 2 ? [bbox[2], a[1] + (b[1] - a[1]) * (bbox[2] - a[0]) / (b[0] - a[0])] : // right
                       edge & 1 ? [bbox[0], a[1] + (b[1] - a[1]) * (bbox[0] - a[0]) / (b[0] - a[0])] : // left
                       null;
            }

            // bit code reflects the point position relative to the bbox:

            //         left  mid  right
            //    top  1001  1000  1010
            //    mid  0001  0000  0010
            // bottom  0101  0100  0110

            function bitCode(p, bbox) {
                var code = 0;

                if (p[0] < bbox[0]) code |= 1; // left
                else if (p[0] > bbox[2]) code |= 2; // right

                if (p[1] < bbox[1]) code |= 4; // bottom
                else if (p[1] > bbox[3]) code |= 8; // top

                return code;
            }

        }, {}], 22: [function (require, module, exports) {
            'use strict';

            module.exports = partialSort;

            // Floyd-Rivest selection algorithm:
            // Rearrange items so that all items in the [left, k] range are smaller than all items in (k, right];
            // The k-th element will have the (k - left + 1)th smallest value in [left, right]

            function partialSort(arr, k, left, right, compare) {
                left = left || 0;
                right = right || (arr.length - 1);
                compare = compare || defaultCompare;

                while (right > left) {
                    if (right - left > 600) {
                        var n = right - left + 1;
                        var m = k - left + 1;
                        var z = Math.log(n);
                        var s = 0.5 * Math.exp(2 * z / 3);
                        var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
                        var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
                        var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
                        partialSort(arr, k, newLeft, newRight, compare);
                    }

                    var t = arr[k];
                    var i = left;
                    var j = right;

                    swap(arr, left, k);
                    if (compare(arr[right], t) > 0) swap(arr, left, right);

                    while (i < j) {
                        swap(arr, i, j);
                        i++;
                        j--;
                        while (compare(arr[i], t) < 0) i++;
                        while (compare(arr[j], t) > 0) j--;
                    }

                    if (compare(arr[left], t) === 0) swap(arr, left, j);
                    else {
                        j++;
                        swap(arr, j, right);
                    }

                    if (j <= k) left = j + 1;
                    if (k <= j) right = j - 1;
                }
            }

            function swap(arr, i, j) {
                var tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }

            function defaultCompare(a, b) {
                return a < b ? -1 : a > b ? 1 : 0;
            }

        }, {}], 23: [function (require, module, exports) {
            'use strict';

            module.exports = rbush;

            var quickselect = require('quickselect');

            function rbush(maxEntries, format) {
                if (!(this instanceof rbush)) return new rbush(maxEntries, format);

                // max entries in a node is 9 by default; min node fill is 40% for best performance
                this._maxEntries = Math.max(4, maxEntries || 9);
                this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));

                if (format) {
                    this._initFormat(format);
                }

                this.clear();
            }

            rbush.prototype = {

                all: function () {
                    return this._all(this.data, []);
                },

                search: function (bbox) {

                    var node = this.data,
                        result = [],
                        toBBox = this.toBBox;

                    if (!intersects(bbox, node)) return result;

                    var nodesToSearch = [],
                        i, len, child, childBBox;

                    while (node) {
                        for (i = 0, len = node.children.length; i < len; i++) {

                            child = node.children[i];
                            childBBox = node.leaf ? toBBox(child) : child;

                            if (intersects(bbox, childBBox)) {
                                if (node.leaf) result.push(child);
                                else if (contains(bbox, childBBox)) this._all(child, result);
                                else nodesToSearch.push(child);
                            }
                        }
                        node = nodesToSearch.pop();
                    }

                    return result;
                },

                collides: function (bbox) {

                    var node = this.data,
                        toBBox = this.toBBox;

                    if (!intersects(bbox, node)) return false;

                    var nodesToSearch = [],
                        i, len, child, childBBox;

                    while (node) {
                        for (i = 0, len = node.children.length; i < len; i++) {

                            child = node.children[i];
                            childBBox = node.leaf ? toBBox(child) : child;

                            if (intersects(bbox, childBBox)) {
                                if (node.leaf || contains(bbox, childBBox)) return true;
                                nodesToSearch.push(child);
                            }
                        }
                        node = nodesToSearch.pop();
                    }

                    return false;
                },

                load: function (data) {
                    if (!(data && data.length)) return this;

                    if (data.length < this._minEntries) {
                        for (var i = 0, len = data.length; i < len; i++) {
                            this.insert(data[i]);
                        }
                        return this;
                    }

                    // recursively build the tree with the given data from stratch using OMT algorithm
                    var node = this._build(data.slice(), 0, data.length - 1, 0);

                    if (!this.data.children.length) {
                        // save as is if tree is empty
                        this.data = node;

                    } else if (this.data.height === node.height) {
                        // split root if trees have the same height
                        this._splitRoot(this.data, node);

                    } else {
                        if (this.data.height < node.height) {
                            // swap trees if inserted one is bigger
                            var tmpNode = this.data;
                            this.data = node;
                            node = tmpNode;
                        }

                        // insert the small tree into the large tree at appropriate level
                        this._insert(node, this.data.height - node.height - 1, true);
                    }

                    return this;
                },

                insert: function (item) {
                    if (item) this._insert(item, this.data.height - 1);
                    return this;
                },

                clear: function () {
                    this.data = createNode([]);
                    return this;
                },

                remove: function (item, equalsFn) {
                    if (!item) return this;

                    var node = this.data,
                        bbox = this.toBBox(item),
                        path = [],
                        indexes = [],
                        i, parent, index, goingUp;

                    // depth-first iterative tree traversal
                    while (node || path.length) {

                        if (!node) { // go up
                            node = path.pop();
                            parent = path[path.length - 1];
                            i = indexes.pop();
                            goingUp = true;
                        }

                        if (node.leaf) { // check current node
                            index = findItem(item, node.children, equalsFn);

                            if (index !== -1) {
                                // item found, remove the item and condense tree upwards
                                node.children.splice(index, 1);
                                path.push(node);
                                this._condense(path);
                                return this;
                            }
                        }

                        if (!goingUp && !node.leaf && contains(node, bbox)) { // go down
                            path.push(node);
                            indexes.push(i);
                            i = 0;
                            parent = node;
                            node = node.children[0];

                        } else if (parent) { // go right
                            i++;
                            node = parent.children[i];
                            goingUp = false;

                        } else node = null; // nothing found
                    }

                    return this;
                },

                toBBox: function (item) { return item; },

                compareMinX: compareNodeMinX,
                compareMinY: compareNodeMinY,

                toJSON: function () { return this.data; },

                fromJSON: function (data) {
                    this.data = data;
                    return this;
                },

                _all: function (node, result) {
                    var nodesToSearch = [];
                    while (node) {
                        if (node.leaf) result.push.apply(result, node.children);
                        else nodesToSearch.push.apply(nodesToSearch, node.children);

                        node = nodesToSearch.pop();
                    }
                    return result;
                },

                _build: function (items, left, right, height) {

                    var N = right - left + 1,
                        M = this._maxEntries,
                        node;

                    if (N <= M) {
                        // reached leaf level; return leaf
                        node = createNode(items.slice(left, right + 1));
                        calcBBox(node, this.toBBox);
                        return node;
                    }

                    if (!height) {
                        // target height of the bulk-loaded tree
                        height = Math.ceil(Math.log(N) / Math.log(M));

                        // target number of root entries to maximize storage utilization
                        M = Math.ceil(N / Math.pow(M, height - 1));
                    }

                    node = createNode([]);
                    node.leaf = false;
                    node.height = height;

                    // split the items into M mostly square tiles

                    var N2 = Math.ceil(N / M),
                        N1 = N2 * Math.ceil(Math.sqrt(M)),
                        i, j, right2, right3;

                    multiSelect(items, left, right, N1, this.compareMinX);

                    for (i = left; i <= right; i += N1) {

                        right2 = Math.min(i + N1 - 1, right);

                        multiSelect(items, i, right2, N2, this.compareMinY);

                        for (j = i; j <= right2; j += N2) {

                            right3 = Math.min(j + N2 - 1, right2);

                            // pack each entry recursively
                            node.children.push(this._build(items, j, right3, height - 1));
                        }
                    }

                    calcBBox(node, this.toBBox);

                    return node;
                },

                _chooseSubtree: function (bbox, node, level, path) {

                    var i, len, child, targetNode, area, enlargement, minArea, minEnlargement;

                    while (true) {
                        path.push(node);

                        if (node.leaf || path.length - 1 === level) break;

                        minArea = minEnlargement = Infinity;

                        for (i = 0, len = node.children.length; i < len; i++) {
                            child = node.children[i];
                            area = bboxArea(child);
                            enlargement = enlargedArea(bbox, child) - area;

                            // choose entry with the least area enlargement
                            if (enlargement < minEnlargement) {
                                minEnlargement = enlargement;
                                minArea = area < minArea ? area : minArea;
                                targetNode = child;

                            } else if (enlargement === minEnlargement) {
                                // otherwise choose one with the smallest area
                                if (area < minArea) {
                                    minArea = area;
                                    targetNode = child;
                                }
                            }
                        }

                        node = targetNode || node.children[0];
                    }

                    return node;
                },

                _insert: function (item, level, isNode) {

                    var toBBox = this.toBBox,
                        bbox = isNode ? item : toBBox(item),
                        insertPath = [];

                    // find the best node for accommodating the item, saving all nodes along the path too
                    var node = this._chooseSubtree(bbox, this.data, level, insertPath);

                    // put the item into the node
                    node.children.push(item);
                    extend(node, bbox);

                    // split on node overflow; propagate upwards if necessary
                    while (level >= 0) {
                        if (insertPath[level].children.length > this._maxEntries) {
                            this._split(insertPath, level);
                            level--;
                        } else break;
                    }

                    // adjust bboxes along the insertion path
                    this._adjustParentBBoxes(bbox, insertPath, level);
                },

                // split overflowed node into two
                _split: function (insertPath, level) {

                    var node = insertPath[level],
                        M = node.children.length,
                        m = this._minEntries;

                    this._chooseSplitAxis(node, m, M);

                    var splitIndex = this._chooseSplitIndex(node, m, M);

                    var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
                    newNode.height = node.height;
                    newNode.leaf = node.leaf;

                    calcBBox(node, this.toBBox);
                    calcBBox(newNode, this.toBBox);

                    if (level) insertPath[level - 1].children.push(newNode);
                    else this._splitRoot(node, newNode);
                },

                _splitRoot: function (node, newNode) {
                    // split root node
                    this.data = createNode([node, newNode]);
                    this.data.height = node.height + 1;
                    this.data.leaf = false;
                    calcBBox(this.data, this.toBBox);
                },

                _chooseSplitIndex: function (node, m, M) {

                    var i, bbox1, bbox2, overlap, area, minOverlap, minArea, index;

                    minOverlap = minArea = Infinity;

                    for (i = m; i <= M - m; i++) {
                        bbox1 = distBBox(node, 0, i, this.toBBox);
                        bbox2 = distBBox(node, i, M, this.toBBox);

                        overlap = intersectionArea(bbox1, bbox2);
                        area = bboxArea(bbox1) + bboxArea(bbox2);

                        // choose distribution with minimum overlap
                        if (overlap < minOverlap) {
                            minOverlap = overlap;
                            index = i;

                            minArea = area < minArea ? area : minArea;

                        } else if (overlap === minOverlap) {
                            // otherwise choose distribution with minimum area
                            if (area < minArea) {
                                minArea = area;
                                index = i;
                            }
                        }
                    }

                    return index;
                },

                // sorts node children by the best axis for split
                _chooseSplitAxis: function (node, m, M) {

                    var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX,
                        compareMinY = node.leaf ? this.compareMinY : compareNodeMinY,
                        xMargin = this._allDistMargin(node, m, M, compareMinX),
                        yMargin = this._allDistMargin(node, m, M, compareMinY);

                    // if total distributions margin value is minimal for x, sort by minX,
                    // otherwise it's already sorted by minY
                    if (xMargin < yMargin) node.children.sort(compareMinX);
                },

                // total margin of all possible split distributions where each node is at least m full
                _allDistMargin: function (node, m, M, compare) {

                    node.children.sort(compare);

                    var toBBox = this.toBBox,
                        leftBBox = distBBox(node, 0, m, toBBox),
                        rightBBox = distBBox(node, M - m, M, toBBox),
                        margin = bboxMargin(leftBBox) + bboxMargin(rightBBox),
                        i, child;

                    for (i = m; i < M - m; i++) {
                        child = node.children[i];
                        extend(leftBBox, node.leaf ? toBBox(child) : child);
                        margin += bboxMargin(leftBBox);
                    }

                    for (i = M - m - 1; i >= m; i--) {
                        child = node.children[i];
                        extend(rightBBox, node.leaf ? toBBox(child) : child);
                        margin += bboxMargin(rightBBox);
                    }

                    return margin;
                },

                _adjustParentBBoxes: function (bbox, path, level) {
                    // adjust bboxes along the given tree path
                    for (var i = level; i >= 0; i--) {
                        extend(path[i], bbox);
                    }
                },

                _condense: function (path) {
                    // go through the path, removing empty nodes and updating bboxes
                    for (var i = path.length - 1, siblings; i >= 0; i--) {
                        if (path[i].children.length === 0) {
                            if (i > 0) {
                                siblings = path[i - 1].children;
                                siblings.splice(siblings.indexOf(path[i]), 1);

                            } else this.clear();

                        } else calcBBox(path[i], this.toBBox);
                    }
                },

                _initFormat: function (format) {
                    // data format (minX, minY, maxX, maxY accessors)

                    // uses eval-type function compilation instead of just accepting a toBBox function
                    // because the algorithms are very sensitive to sorting functions performance,
                    // so they should be dead simple and without inner calls

                    var compareArr = ['return a', ' - b', ';'];

                    this.compareMinX = new Function('a', 'b', compareArr.join(format[0]));
                    this.compareMinY = new Function('a', 'b', compareArr.join(format[1]));

                    this.toBBox = new Function('a',
                        'return {minX: a' + format[0] +
                        ', minY: a' + format[1] +
                        ', maxX: a' + format[2] +
                        ', maxY: a' + format[3] + '};');
                }
            };

            function findItem(item, items, equalsFn) {
                if (!equalsFn) return items.indexOf(item);

                for (var i = 0; i < items.length; i++) {
                    if (equalsFn(item, items[i])) return i;
                }
                return -1;
            }

            // calculate node's bbox from bboxes of its children
            function calcBBox(node, toBBox) {
                distBBox(node, 0, node.children.length, toBBox, node);
            }

            // min bounding rectangle of node children from k to p-1
            function distBBox(node, k, p, toBBox, destNode) {
                if (!destNode) destNode = createNode(null);
                destNode.minX = Infinity;
                destNode.minY = Infinity;
                destNode.maxX = -Infinity;
                destNode.maxY = -Infinity;

                for (var i = k, child; i < p; i++) {
                    child = node.children[i];
                    extend(destNode, node.leaf ? toBBox(child) : child);
                }

                return destNode;
            }

            function extend(a, b) {
                a.minX = Math.min(a.minX, b.minX);
                a.minY = Math.min(a.minY, b.minY);
                a.maxX = Math.max(a.maxX, b.maxX);
                a.maxY = Math.max(a.maxY, b.maxY);
                return a;
            }

            function compareNodeMinX(a, b) { return a.minX - b.minX; }
            function compareNodeMinY(a, b) { return a.minY - b.minY; }

            function bboxArea(a) { return (a.maxX - a.minX) * (a.maxY - a.minY); }
            function bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }

            function enlargedArea(a, b) {
                return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *
                       (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
            }

            function intersectionArea(a, b) {
                var minX = Math.max(a.minX, b.minX),
                    minY = Math.max(a.minY, b.minY),
                    maxX = Math.min(a.maxX, b.maxX),
                    maxY = Math.min(a.maxY, b.maxY);

                return Math.max(0, maxX - minX) *
                       Math.max(0, maxY - minY);
            }

            function contains(a, b) {
                return a.minX <= b.minX &&
                       a.minY <= b.minY &&
                       b.maxX <= a.maxX &&
                       b.maxY <= a.maxY;
            }

            function intersects(a, b) {
                return b.minX <= a.maxX &&
                       b.minY <= a.maxY &&
                       b.maxX >= a.minX &&
                       b.maxY >= a.minY;
            }

            function createNode(children) {
                return {
                    children: children,
                    height: 1,
                    leaf: true,
                    minX: Infinity,
                    minY: Infinity,
                    maxX: -Infinity,
                    maxY: -Infinity
                };
            }

            // sort an array so that items come in groups of n unsorted items, with groups sorted between each other;
            // combines selection algorithm with binary divide & conquer approach

            function multiSelect(arr, left, right, n, compare) {
                var stack = [left, right],
                    mid;

                while (stack.length) {
                    right = stack.pop();
                    left = stack.pop();

                    if (right - left <= n) continue;

                    mid = left + Math.ceil((right - left) / n / 2) * n;
                    quickselect(arr, mid, left, right, compare);

                    stack.push(left, mid, mid, right);
                }
            }

        }, { "quickselect": 22 }]
    }, {}, [1])(1)
});