text: /*
  * Leaflet Heatmap Overlay
  *
  * Copyright (c) 2008-2016, Patrick Wied (https://www.patrick-wied.at)
  * Dual-licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
  * and the Beerware (http://en.wikipedia.org/wiki/Beerware) license.
  */
  ; (function (name, context, factory) {
      // Supports UMD. AMD, CommonJS/Node.js and browser context
      if (typeof module !== "undefined" && module.exports) {
          module.exports = factory(
              require('heatmap.js'),
              require('leaflet')
          );
      } else if (typeof define === "function" && define.amd) {
          define(['heatmap.js', 'leaflet'], factory);
      } else {
          // browser globals
          if (typeof window.h337 === 'undefined') {
              throw new Error('heatmap.js must be loaded before the leaflet heatmap plugin');
          }
          if (typeof window.L === 'undefined') {
              throw new Error('Leaflet must be loaded before the leaflet heatmap plugin');
          }
          context[name] = factory(window.h337, window.L);
      }
  
  })("HeatmapOverlay", this, function (h337, L) {
      'use strict';
  
      // Leaflet < 0.8 compatibility
      if (typeof L.Layer === 'undefined') {
          L.Layer = L.Class;
      }
  
      var HeatmapOverlay = L.Layer.extend({
  
          initialize: function (config) {
              this.cfg = config;
              this._el = L.DomUtil.create('div', 'leaflet-zoom-hide');
              this._data = [];
              this._max = 1;
              this._min = 0;
              this.cfg.container = this._el;
          },
  
          onAdd: function (map) {
              var size = map.getSize();
  
              this._map = map;
  
              this._width = size.x;
              this._height = size.y;
  
              this._el.style.width = size.x + 'px';
              this._el.style.height = size.y + 'px';
              this._el.style.position = 'absolute';
  
              this._origin = this._map.layerPointToLatLng(new L.Point(0, 0));
  
              map.getPanes().overlayPane.appendChild(this._el);
  
              if (!this._heatmap) {
                  this._heatmap = h337.create(this.cfg);
              }
  
              // this resets the origin and redraws whenever
              // the zoom changed or the map has been moved
              map.on('moveend', this._reset, this);
              this._draw();
          },
  
          addTo: function (map) {
              map.addLayer(this);
              return this;
          },
  
          onRemove: function (map) {
              // remove layer's DOM elements and listeners
              map.getPanes().overlayPane.removeChild(this._el);
  
              map.off('moveend', this._reset, this);
          },
          _draw: function () {
              if (!this._map) { return; }
  
              var mapPane = this._map.getPanes().mapPane;
              var point = mapPane._leaflet_pos;
  
              // reposition the layer
              this._el.style[HeatmapOverlay.CSS_TRANSFORM] = 'translate(' +
                  -Math.round(point.x) + 'px,' +
                  -Math.round(point.y) + 'px)';
  
              this._update();
          },
          _update: function () {
              var bounds, zoom, scale;
              var generatedData = { max: this._max, min: this._min, data: [] };
  
              bounds = this._map.getBounds();
              zoom = this._map.getZoom();
              scale = Math.pow(2, zoom);
  
              if (this._data.length == 0) {
                  if (this._heatmap) {
                      this._heatmap.setData(generatedData);
                  }
                  return;
              }
  
  
              var latLngPoints = [];
              var radiusMultiplier = this.cfg.scaleRadius ? scale : 1;
              var localMax = 0;
              var localMin = 0;
              var valueField = this.cfg.valueField;
              var len = this._data.length;
  
              while (len--) {
                  var entry = this._data[len];
                  var value = entry[valueField];
                  var latlng = entry.latlng;
  
  
                  // we don't wanna render points that are not even on the map ;-)
                  if (!bounds.contains(latlng)) {
                      continue;
                  }
                  // local max is the maximum within current bounds
                  localMax = Math.max(value, localMax);
                  localMin = Math.min(value, localMin);
  
                  var point = this._map.latLngToContainerPoint(latlng);
                  var latlngPoint = { x: Math.round(point.x), y: Math.round(point.y) };
                  latlngPoint[valueField] = value;
  
                  var radius;
  
                  if (entry.radius) {
                      radius = entry.radius * radiusMultiplier;
                  } else {
                      radius = (this.cfg.radius || 2) * radiusMultiplier;
                  }
                  latlngPoint.radius = radius;
                  latLngPoints.push(latlngPoint);
              }
              if (this.cfg.useLocalExtrema) {
                  generatedData.max = localMax;
                  generatedData.min = localMin;
              }
  
              generatedData.data = latLngPoints;
  
              this._heatmap.setData(generatedData);
          },
          setData: function (data) {
              this._max = data.max || this._max;
              this._min = data.min || this._min;
              var latField = this.cfg.latField || 'lat';
              var lngField = this.cfg.lngField || 'lng';
              var valueField = this.cfg.valueField || 'value';
  
              // transform data to latlngs
              var data = data.data;
              var len = data.length;
              var d = [];
  
              while (len--) {
                  var entry = data[len];
                  var latlng = new L.LatLng(entry[latField], entry[lngField]);
                  var dataObj = { latlng: latlng };
                  dataObj[valueField] = entry[valueField];
                  if (entry.radius) {
                      dataObj.radius = entry.radius;
                  }
                  d.push(dataObj);
              }
              this._data = d;
  
              this._draw();
          },
          // experimential... not ready.
          addData: function (pointOrArray) {
              if (pointOrArray.length > 0) {
                  var len = pointOrArray.length;
                  while (len--) {
                      this.addData(pointOrArray[len]);
                  }
              } else {
                  var latField = this.cfg.latField || 'lat';
                  var lngField = this.cfg.lngField || 'lng';
                  var valueField = this.cfg.valueField || 'value';
                  var entry = pointOrArray;
                  var latlng = new L.LatLng(entry[latField], entry[lngField]);
                  var dataObj = { latlng: latlng };
  
                  dataObj[valueField] = entry[valueField];
                  this._max = Math.max(this._max, dataObj[valueField]);
                  this._min = Math.min(this._min, dataObj[valueField]);
  
                  if (entry.radius) {
                      dataObj.radius = entry.radius;
                  }
                  this._data.push(dataObj);
                  this._draw();
              }
          },
          _reset: function () {
              this._origin = this._map.layerPointToLatLng(new L.Point(0, 0));
  
              var size = this._map.getSize();
              if (this._width !== size.x || this._height !== size.y) {
                  this._width = size.x;
                  this._height = size.y;
  
                  this._el.style.width = this._width + 'px';
                  this._el.style.height = this._height + 'px';
  
                  this._heatmap._renderer.setDimensions(this._width, this._height);
              }
              this._draw();
          }
      });
  
      HeatmapOverlay.CSS_TRANSFORM = (function () {
          var div = document.createElement('div');
          var props = [
              'transform',
              'WebkitTransform',
              'MozTransform',
              'OTransform',
              'msTransform'
          ];
  
          for (var i = 0; i < props.length; i++) {
              var prop = props[i];
              if (div.style[prop] !== undefined) {
                  return prop;
              }
          }
          return props[0];
      })();
  
      return HeatmapOverlay;
  });