text: (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){
  (function (global){
  global.extent = require('turf-extent');
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"turf-extent":2}],2:[function(require,module,exports){
  var each = require('turf-meta').coordEach;
  
  /**
   * Takes any {@link GeoJSON} object, calculates the extent of all input features, and returns a bounding box.
   *
   * @module turf/extent
   * @category measurement
   * @param {GeoJSON} input any valid GeoJSON Object
   * @return {Array<number>} the bounding box of `input` given
   * as an array in WSEN order (west, south, east, north)
   * @example
   * var input = {
   *   "type": "FeatureCollection",
   *   "features": [
   *     {
   *       "type": "Feature",
   *       "properties": {},
   *       "geometry": {
   *         "type": "Point",
   *         "coordinates": [114.175329, 22.2524]
   *       }
   *     }, {
   *       "type": "Feature",
   *       "properties": {},
   *       "geometry": {
   *         "type": "Point",
   *         "coordinates": [114.170007, 22.267969]
   *       }
   *     }, {
   *       "type": "Feature",
   *       "properties": {},
   *       "geometry": {
   *         "type": "Point",
   *         "coordinates": [114.200649, 22.274641]
   *       }
   *     }, {
   *       "type": "Feature",
   *       "properties": {},
   *       "geometry": {
   *         "type": "Point",
   *         "coordinates": [114.186744, 22.265745]
   *       }
   *     }
   *   ]
   * };
   *
   * var bbox = turf.extent(input);
   *
   * var bboxPolygon = turf.bboxPolygon(bbox);
   *
   * var resultFeatures = input.features.concat(bboxPolygon);
   * var result = {
   *   "type": "FeatureCollection",
   *   "features": resultFeatures
   * };
   *
   * //=result
   */
  module.exports = function(layer) {
      var extent = [Infinity, Infinity, -Infinity, -Infinity];
      each(layer, function(coord) {
        if (extent[0] > coord[0]) extent[0] = coord[0];
        if (extent[1] > coord[1]) extent[1] = coord[1];
        if (extent[2] < coord[0]) extent[2] = coord[0];
        if (extent[3] < coord[1]) extent[3] = coord[1];
      });
      return extent;
  };
  
  },{"turf-meta":3}],3:[function(require,module,exports){
  /**
   * Lazily iterate over coordinates in any GeoJSON object, similar to
   * Array.forEach.
   *
   * @param {Object} layer any GeoJSON object
   * @param {Function} callback a method that takes (value)
   * @param {boolean=} excludeWrapCoord whether or not to include
   * the final coordinate of LinearRings that wraps the ring in its iteration.
   * @example
   * var point = { type: 'Point', coordinates: [0, 0] };
   * coordEach(point, function(coords) {
   *   // coords is equal to [0, 0]
   * });
   */
  function coordEach(layer, callback, excludeWrapCoord) {
    var i, j, k, g, geometry, stopG, coords,
      geometryMaybeCollection,
      wrapShrink = 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);
        } else if (geometry.type === 'LineString' || geometry.type === 'MultiPoint') {
          for (j = 0; j < coords.length; j++) callback(coords[j]);
        } 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]);
        } 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]);
        } else {
          throw new Error('Unknown Geometry Type');
        }
      }
    }
  }
  module.exports.coordEach = coordEach;
  
  /**
   * Lazily reduce coordinates 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 coordinates is unnecessary.
   *
   * @param {Object} layer any GeoJSON object
   * @param {Function} callback a method that takes (memo, value) and returns
   * a new memo
   * @param {boolean=} excludeWrapCoord whether or not to include
   * the final coordinate of LinearRings that wraps the ring in its iteration.
   * @param {*} memo the starting value of memo: can be any type.
   */
  function coordReduce(layer, callback, memo, excludeWrapCoord) {
    coordEach(layer, function(coord) {
      memo = callback(memo, coord);
    }, excludeWrapCoord);
    return memo;
  }
  module.exports.coordReduce = coordReduce;
  
  /**
   * Lazily iterate over property objects in any GeoJSON object, similar to
   * Array.forEach.
   *
   * @param {Object} layer any GeoJSON object
   * @param {Function} callback a method that takes (value)
   * @example
   * var point = { type: 'Feature', geometry: null, properties: { foo: 1 } };
   * propEach(point, function(props) {
   *   // props is equal to { foo: 1}
   * });
   */
  function propEach(layer, callback) {
    var i;
    switch (layer.type) {
        case 'FeatureCollection':
          features = layer.features;
          for (i = 0; i < layer.features.length; i++) {
              callback(layer.features[i].properties);
          }
          break;
        case 'Feature':
          callback(layer.properties);
          break;
    }
  }
  module.exports.propEach = propEach;
  
  /**
   * Lazily 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.
   *
   * @param {Object} layer any GeoJSON object
   * @param {Function} callback a method that takes (memo, coord) and returns
   * a new memo
   * @param {*} memo the starting value of memo: can be any type.
   */
  function propReduce(layer, callback, memo) {
    propEach(layer, function(prop) {
      memo = callback(memo, prop);
    });
    return memo;
  }
  module.exports.propReduce = propReduce;
  
  },{}]},{},[1]);
  