(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.turf2 = f()
    }
})(function () {
    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 = {
                bboxClip: require('@turf/bbox-clip'),
                invariant:require('@turf/invariant') 
            };
        }, { "@turf/bbox-clip": 2 }], 2: [function (require, module, exports) {
            var helpers = require('@turf/helpers');
            var lineclip = require('lineclip');
            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": 5 }], 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) {
            '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;
            }

        }, {}]
    }, {}, [1])(1)
});