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){
  'use strict';
  var immediate = require('immediate');
  
  /* istanbul ignore next */
  function INTERNAL() {}
  
  var handlers = {};
  
  var REJECTED = ['REJECTED'];
  var FULFILLED = ['FULFILLED'];
  var PENDING = ['PENDING'];
  
  module.exports = exports = Promise;
  
  function Promise(resolver) {
    if (typeof resolver !== 'function') {
      throw new TypeError('resolver must be a function');
    }
    this.state = PENDING;
    this.queue = [];
    this.outcome = void 0;
    if (resolver !== INTERNAL) {
      safelyResolveThenable(this, resolver);
    }
  }
  
  Promise.prototype["catch"] = function (onRejected) {
    return this.then(null, onRejected);
  };
  Promise.prototype.then = function (onFulfilled, onRejected) {
    if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
      typeof onRejected !== 'function' && this.state === REJECTED) {
      return this;
    }
    var promise = new this.constructor(INTERNAL);
    if (this.state !== PENDING) {
      var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
      unwrap(promise, resolver, this.outcome);
    } else {
      this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
    }
  
    return promise;
  };
  function QueueItem(promise, onFulfilled, onRejected) {
    this.promise = promise;
    if (typeof onFulfilled === 'function') {
      this.onFulfilled = onFulfilled;
      this.callFulfilled = this.otherCallFulfilled;
    }
    if (typeof onRejected === 'function') {
      this.onRejected = onRejected;
      this.callRejected = this.otherCallRejected;
    }
  }
  QueueItem.prototype.callFulfilled = function (value) {
    handlers.resolve(this.promise, value);
  };
  QueueItem.prototype.otherCallFulfilled = function (value) {
    unwrap(this.promise, this.onFulfilled, value);
  };
  QueueItem.prototype.callRejected = function (value) {
    handlers.reject(this.promise, value);
  };
  QueueItem.prototype.otherCallRejected = function (value) {
    unwrap(this.promise, this.onRejected, value);
  };
  
  function unwrap(promise, func, value) {
    immediate(function () {
      var returnValue;
      try {
        returnValue = func(value);
      } catch (e) {
        return handlers.reject(promise, e);
      }
      if (returnValue === promise) {
        handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
      } else {
        handlers.resolve(promise, returnValue);
      }
    });
  }
  
  handlers.resolve = function (self, value) {
    var result = tryCatch(getThen, value);
    if (result.status === 'error') {
      return handlers.reject(self, result.value);
    }
    var thenable = result.value;
  
    if (thenable) {
      safelyResolveThenable(self, thenable);
    } else {
      self.state = FULFILLED;
      self.outcome = value;
      var i = -1;
      var len = self.queue.length;
      while (++i < len) {
        self.queue[i].callFulfilled(value);
      }
    }
    return self;
  };
  handlers.reject = function (self, error) {
    self.state = REJECTED;
    self.outcome = error;
    var i = -1;
    var len = self.queue.length;
    while (++i < len) {
      self.queue[i].callRejected(error);
    }
    return self;
  };
  
  function getThen(obj) {
    // Make sure we only access the accessor once as required by the spec
    var then = obj && obj.then;
    if (obj && typeof obj === 'object' && typeof then === 'function') {
      return function appyThen() {
        then.apply(obj, arguments);
      };
    }
  }
  
  function safelyResolveThenable(self, thenable) {
    // Either fulfill, reject or reject with error
    var called = false;
    function onError(value) {
      if (called) {
        return;
      }
      called = true;
      handlers.reject(self, value);
    }
  
    function onSuccess(value) {
      if (called) {
        return;
      }
      called = true;
      handlers.resolve(self, value);
    }
  
    function tryToUnwrap() {
      thenable(onSuccess, onError);
    }
  
    var result = tryCatch(tryToUnwrap);
    if (result.status === 'error') {
      onError(result.value);
    }
  }
  
  function tryCatch(func, value) {
    var out = {};
    try {
      out.value = func(value);
      out.status = 'success';
    } catch (e) {
      out.status = 'error';
      out.value = e;
    }
    return out;
  }
  
  exports.resolve = resolve;
  function resolve(value) {
    if (value instanceof this) {
      return value;
    }
    return handlers.resolve(new this(INTERNAL), value);
  }
  
  exports.reject = reject;
  function reject(reason) {
    var promise = new this(INTERNAL);
    return handlers.reject(promise, reason);
  }
  
  exports.all = all;
  function all(iterable) {
    var self = this;
    if (Object.prototype.toString.call(iterable) !== '[object Array]') {
      return this.reject(new TypeError('must be an array'));
    }
  
    var len = iterable.length;
    var called = false;
    if (!len) {
      return this.resolve([]);
    }
  
    var values = new Array(len);
    var resolved = 0;
    var i = -1;
    var promise = new this(INTERNAL);
  
    while (++i < len) {
      allResolver(iterable[i], i);
    }
    return promise;
    function allResolver(value, i) {
      self.resolve(value).then(resolveFromAll, function (error) {
        if (!called) {
          called = true;
          handlers.reject(promise, error);
        }
      });
      function resolveFromAll(outValue) {
        values[i] = outValue;
        if (++resolved === len && !called) {
          called = true;
          handlers.resolve(promise, values);
        }
      }
    }
  }
  
  exports.race = race;
  function race(iterable) {
    var self = this;
    if (Object.prototype.toString.call(iterable) !== '[object Array]') {
      return this.reject(new TypeError('must be an array'));
    }
  
    var len = iterable.length;
    var called = false;
    if (!len) {
      return this.resolve([]);
    }
  
    var i = -1;
    var promise = new this(INTERNAL);
  
    while (++i < len) {
      resolver(iterable[i]);
    }
    return promise;
    function resolver(value) {
      self.resolve(value).then(function (response) {
        if (!called) {
          called = true;
          handlers.resolve(promise, response);
        }
      }, function (error) {
        if (!called) {
          called = true;
          handlers.reject(promise, error);
        }
      });
    }
  }
  
  },{"immediate":2}],2:[function(require,module,exports){
  (function (global){
  'use strict';
  var Mutation = global.MutationObserver || global.WebKitMutationObserver;
  
  var scheduleDrain;
  
  {
    if (Mutation) {
      var called = 0;
      var observer = new Mutation(nextTick);
      var element = global.document.createTextNode('');
      observer.observe(element, {
        characterData: true
      });
      scheduleDrain = function () {
        element.data = (called = ++called % 2);
      };
    } else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {
      var channel = new global.MessageChannel();
      channel.port1.onmessage = nextTick;
      scheduleDrain = function () {
        channel.port2.postMessage(0);
      };
    } else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {
      scheduleDrain = function () {
  
        // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
        // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
        var scriptEl = global.document.createElement('script');
        scriptEl.onreadystatechange = function () {
          nextTick();
  
          scriptEl.onreadystatechange = null;
          scriptEl.parentNode.removeChild(scriptEl);
          scriptEl = null;
        };
        global.document.documentElement.appendChild(scriptEl);
      };
    } else {
      scheduleDrain = function () {
        setTimeout(nextTick, 0);
      };
    }
  }
  
  var draining;
  var queue = [];
  //named nextTick for less confusing stack traces
  function nextTick() {
    draining = true;
    var i, oldQueue;
    var len = queue.length;
    while (len) {
      oldQueue = queue;
      queue = [];
      i = -1;
      while (++i < len) {
        oldQueue[i]();
      }
      len = queue.length;
    }
    draining = false;
  }
  
  module.exports = immediate;
  function immediate(task) {
    if (queue.push(task) === 1 && !draining) {
      scheduleDrain();
    }
  }
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{}],3:[function(require,module,exports){
  (function (global){
  'use strict';
  var jsonp = require('./jsonp');
  var Promise = require('lie');
  
  module.exports = function (url, options) {
    options = options || {};
    if (options.jsonp) {
      return jsonp(url, options);
    }
    var request;
    var cancel;
    var out = new Promise(function (resolve, reject) {
      cancel = reject;
      if (global.XMLHttpRequest === undefined) {
        reject('XMLHttpRequest is not supported');
      }
      var response;
      request = new global.XMLHttpRequest();
      request.open('GET', url);
      if (options.headers) {
        Object.keys(options.headers).forEach(function (key) {
          request.setRequestHeader(key, options.headers[key]);
        });
      }
      request.onreadystatechange = function () {
        if (request.readyState === 4) {
          if ((request.status < 400 && options.local) || request.status === 200) {
            if (global.JSON) {
              response = JSON.parse(request.responseText);
            } else {
              reject(new Error('JSON is not supported'));
            }
            resolve(response);
          } else {
            if (!request.status) {
              reject('Attempted cross origin request without CORS enabled');
            } else {
              reject(request.statusText);
            }
          }
        }
      };
      request.send();
    });
    out.catch(function (reason) {
      request.abort();
      return reason;
    });
    out.abort = cancel;
    return out;
  };
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./jsonp":5,"lie":1}],4:[function(require,module,exports){
  (function (global){
  'use strict';
  var L = global.L || require('leaflet');
  var Promise = require('lie');
  var ajax = require('./ajax');
  L.GeoJSON.AJAX = L.GeoJSON.extend({
    defaultAJAXparams: {
      dataType: 'json',
      callbackParam: 'callback',
      local: false,
      middleware: function (f) {
        return f;
      }
    },
    initialize: function (url, options) {
      this.urls = [];
      if (url) {
        if (typeof url === 'string') {
          this.urls.push(url);
        } else if (typeof url.pop === 'function') {
          this.urls = this.urls.concat(url);
        } else {
          options = url;
          url = undefined;
        }
      }
      var ajaxParams = L.Util.extend({}, this.defaultAJAXparams);
  
      for (var i in options) {
        if (this.defaultAJAXparams.hasOwnProperty(i)) {
          ajaxParams[i] = options[i];
        }
      }
      this.ajaxParams = ajaxParams;
      this._layers = {};
      L.Util.setOptions(this, options);
      this.on('data:loaded', function () {
        if (this.filter) {
          this.refilter(this.filter);
        }
      }, this);
      var self = this;
      if (this.urls.length > 0) {
        new Promise(function (resolve) {
          resolve();
        }).then(function () {
          self.addUrl();
        });
      }
    },
    clearLayers: function () {
      this.urls = [];
      L.GeoJSON.prototype.clearLayers.call(this);
      return this;
    },
    addUrl: function (url) {
      var self = this;
      if (url) {
        if (typeof url === 'string') {
          self.urls.push(url);
        } else if (typeof url.pop === 'function') {
          self.urls = self.urls.concat(url);
        }
      }
      var loading = self.urls.length;
      var done = 0;
      self.fire('data:loading');
      self.urls.forEach(function (url) {
        if (self.ajaxParams.dataType.toLowerCase() === 'json') {
          ajax(url, self.ajaxParams).then(function (d) {
            var data = self.ajaxParams.middleware(d);
            self.addData(data);
            self.fire('data:progress', data);
          }, function (err) {
            self.fire('data:progress', {
              error: err
            });
          });
        } else if (self.ajaxParams.dataType.toLowerCase() === 'jsonp') {
          L.Util.jsonp(url, self.ajaxParams).then(function (d) {
            var data = self.ajaxParams.middleware(d);
            self.addData(data);
            self.fire('data:progress', data);
          }, function (err) {
            self.fire('data:progress', {
              error: err
            });
          });
        }
      });
      self.on('data:progress', function () {
        if (++done === loading) {
          self.fire('data:loaded');
        }
      });
    },
    refresh: function (url) {
      url = url || this.urls;
      this.clearLayers();
      this.addUrl(url);
    },
    refilter: function (func) {
      if (typeof func !== 'function') {
        this.filter = false;
        this.eachLayer(function (a) {
          a.setStyle({
            stroke: true,
            clickable: true
          });
        });
      } else {
        this.filter = func;
        this.eachLayer(function (a) {
          if (func(a.feature)) {
            a.setStyle({
              stroke: true,
              clickable: true
            });
          } else {
            a.setStyle({
              stroke: false,
              clickable: false
            });
          }
        });
      }
    }
  });
  L.Util.Promise = Promise;
  L.Util.ajax = ajax;
  L.Util.jsonp = require('./jsonp');
  L.geoJson.ajax = function (geojson, options) {
    return new L.GeoJSON.AJAX(geojson, options);
  };
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"./ajax":3,"./jsonp":5,"leaflet":undefined,"lie":1}],5:[function(require,module,exports){
  (function (global){
  'use strict';
  var L = global.L || require('leaflet');
  var Promise = require('lie');
  
  module.exports = function (url, options) {
    options = options || {};
    var head = document.getElementsByTagName('head')[0];
    var scriptNode = L.DomUtil.create('script', '', head);
    var cbName, ourl, cbSuffix, cancel;
    var out = new Promise(function (resolve, reject) {
      cancel = reject;
      var cbParam = options.cbParam || 'callback';
      if (options.callbackName) {
        cbName = options.callbackName;
      } else {
        cbSuffix = '_' + ('' + Math.random()).slice(2);
        cbName = '_leafletJSONPcallbacks.' + cbSuffix;
      }
      scriptNode.type = 'text/javascript';
      if (cbSuffix) {
        if (!global._leafletJSONPcallbacks) {
          global._leafletJSONPcallbacks = {
            length: 0
          };
        }
        global._leafletJSONPcallbacks.length++;
        global._leafletJSONPcallbacks[cbSuffix] = function (data) {
          head.removeChild(scriptNode);
          delete global._leafletJSONPcallbacks[cbSuffix];
          global._leafletJSONPcallbacks.length--;
          if (!global._leafletJSONPcallbacks.length) {
            delete global._leafletJSONPcallbacks;
          }
          resolve(data);
        };
      }
      if (url.indexOf('?') === -1) {
        ourl = url + '?' + cbParam + '=' + cbName;
      } else {
        ourl = url + '&' + cbParam + '=' + cbName;
      }
      scriptNode.src = ourl;
    }).then(null, function (reason) {
      head.removeChild(scriptNode);
      delete L.Util.ajax.cb[cbSuffix];
      return reason;
    });
    out.abort = cancel;
    return out;
  };
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{"leaflet":undefined,"lie":1}]},{},[4]);