blacklight_heatmaps 1.3.1 → 1.4.0

data/app/assets/javascripts/blacklight_heatmaps/default.js

@@ -1,8 +1,2006 @@
-//= require geostats
-//= require leaflet
-//= require L.Control.Sidebar
-//= require leaflet_solr_heatmap
-//= require blacklight_heatmaps/blacklight_heatmaps
-//= require blacklight_heatmaps/basemaps
-//= require blacklight_heatmaps/icons
-//= require_tree ./viewers
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('leaflet')) :
+	typeof define === 'function' && define.amd ? define(['leaflet'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.BlacklightHeatmaps = factory(global.L));
+})(this, (function (L$1) { 'use strict';
+
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
+	var geostats$1 = {exports: {}};
+
+	/**
+	* geostats() is a tiny and standalone javascript library for classification
+	* Project page - https://github.com/simogeo/geostats
+	* Copyright (c) 2011 Simon Georget, http://www.intermezzo-coop.eu
+	* Licensed under the MIT license
+	*/
+
+	var hasRequiredGeostats;
+
+	function requireGeostats () {
+		if (hasRequiredGeostats) return geostats$1.exports;
+		hasRequiredGeostats = 1;
+		(function (module, exports) {
+			(function (definition) {
+			    // This file will function properly as a <script> tag, or a module
+			    // using CommonJS and NodeJS or RequireJS module formats.
+
+			    // CommonJS
+			    {
+			        module.exports = definition();
+
+			    // RequireJS
+			    }
+
+			})(function () {
+
+			var isInt = function(n) {
+			   return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
+			}; // 6 characters
+
+			var _t = function(str) {
+				return str;
+			};
+
+			//taking from http://stackoverflow.com/questions/18082/validate-decimal-numbers-in-javascript-isnumeric
+			var isNumber = function(n) {
+				  return !isNaN(parseFloat(n)) && isFinite(n);
+			};
+
+
+
+			//indexOf polyfill
+			// from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf
+			if (!Array.prototype.indexOf) {
+			    Array.prototype.indexOf = function (searchElement, fromIndex) {
+			      if ( this === undefined || this === null ) {
+			        throw new TypeError( '"this" is null or not defined' );
+			      }
+
+			      var length = this.length >>> 0; // Hack to convert object.length to a UInt32
+
+			      fromIndex = +fromIndex || 0;
+
+			      if (Math.abs(fromIndex) === Infinity) {
+			        fromIndex = 0;
+			      }
+
+			      if (fromIndex < 0) {
+			        fromIndex += length;
+			        if (fromIndex < 0) {
+			          fromIndex = 0;
+			        }
+			      }
+
+			      for (;fromIndex < length; fromIndex++) {
+			        if (this[fromIndex] === searchElement) {
+			          return fromIndex;
+			        }
+			      }
+
+			      return -1;
+			    };
+			  }
+
+			var geostats = function(a) {
+
+				this.objectID = '';
+				this.separator = ' - ';
+				this.legendSeparator = this.separator;
+				this.method  = '';
+				this.precision = 0;
+				this.precisionflag = 'auto';
+				this.roundlength 	= 2; // Number of decimals, round values
+				this.is_uniqueValues = false;
+				this.debug =  false;
+				this.silent = false;
+
+				this.bounds  = Array();
+				this.ranges  = Array();
+				this.inner_ranges  = null;
+				this.colors  = Array();
+				this.counter = Array();
+
+				// statistics information
+				this.stat_sorted	= null;
+				this.stat_mean 		= null;
+				this.stat_median 	= null;
+				this.stat_sum 		= null;
+				this.stat_max 		= null;
+				this.stat_min 		= null;
+				this.stat_pop 		= null;
+				this.stat_variance	= null;
+				this.stat_stddev	= null;
+				this.stat_cov		= null;
+
+
+				/**
+				 * logging method
+				 */
+				this.log = function(msg, force) {
+
+					if(this.debug == true || force != null)
+						console.log(this.objectID + "(object id) :: " + msg);
+
+				};
+
+				/**
+				 * Set bounds
+				 */
+				this.setBounds = function(a) {
+
+					this.log('Setting bounds (' + a.length + ') : ' + a.join());
+
+					this.bounds = Array(); // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
+
+					this.bounds = a;
+					//this.bounds = this.decimalFormat(a);
+
+				};
+
+				/**
+				 * Set a new serie
+				 */
+				this.setSerie = function(a) {
+
+					this.log('Setting serie (' + a.length + ') : ' + a.join());
+
+					this.serie = Array(); // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
+					this.serie = a;
+
+					//reset statistics after changing serie
+				    this.resetStatistics();
+
+					this.setPrecision();
+
+				};
+
+				/**
+				 * Set colors
+				 */
+				this.setColors = function(colors) {
+
+					this.log('Setting color ramp (' + colors.length + ') : '  + colors.join());
+
+					this.colors = colors;
+
+				};
+
+				/**
+				 * Get feature count
+				 * With bounds array(0, 0.75, 1.5, 2.25, 3);
+				 * should populate this.counter with 5 keys
+				 * and increment counters for each key
+				 */
+				this.doCount = function() {
+
+					if (this._nodata())
+						return;
+
+
+					var tmp = this.sorted();
+
+					this.counter = new Array();
+
+					// we init counter with 0 value
+					if(this.is_uniqueValues == true) {
+						for (var i = 0; i < this.bounds.length; i++) {
+							this.counter[i]= 0;
+						}
+					} else {
+						for (var i = 0; i < this.bounds.length -1; i++) {
+							this.counter[i]= 0;
+						}
+					}
+
+					for (var j=0; j < tmp.length; j++) {
+
+						// get current class for value to increment the counter
+						var cclass = this.getClass(tmp[j]);
+						this.counter[cclass]++;
+
+					}
+
+				};
+
+				/**
+				 * Set decimal precision according to user input
+				 * or automatcally determined according
+				 * to the given serie.
+				 */
+				this.setPrecision = function(decimals) {
+
+					// only when called from user
+					if(typeof decimals !== "undefined") {
+						this.precisionflag = 'manual';
+						this.precision = decimals;
+					}
+
+					// we calculate the maximal decimal length on given serie
+					if(this.precisionflag == 'auto') {
+
+						for (var i = 0; i < this.serie.length; i++) {
+
+							// check if the given value is a number and a float
+							if (!isNaN((this.serie[i]+"")) && (this.serie[i]+"").toString().indexOf('.') != -1) {
+								var precision = (this.serie[i] + "").split(".")[1].length;
+							} else {
+								var precision = 0;
+							}
+
+							if(precision > this.precision) {
+								this.precision = precision;
+							}
+
+						}
+
+					}
+					if(this.precision > 20) {
+						// prevent "Uncaught RangeError: toFixed() digits argument must be between 0 and 20" bug. See https://github.com/simogeo/geostats/issues/34
+						this.log('this.precision value (' + this.precision + ') is greater than max value. Automatic set-up to 20 to prevent "Uncaught RangeError: toFixed()" when calling decimalFormat() method.');
+						this.precision = 20;
+					}
+
+					this.log('Calling setPrecision(). Mode : ' + this.precisionflag + ' - Decimals : '+ this.precision);
+
+					this.serie = this.decimalFormat(this.serie);
+
+				};
+
+				/**
+				 * Format array numbers regarding to precision
+				 */
+				this.decimalFormat = function(a) {
+
+					var b = new Array();
+
+					for (var i = 0; i < a.length; i++) {
+						// check if the given value is a number
+						if (isNumber(a[i])) {
+							b[i] = parseFloat(parseFloat(a[i]).toFixed(this.precision));
+						} else {
+							b[i] = a[i];
+						}
+					}
+
+					return b;
+				};
+
+				/**
+				 * Transform a bounds array to a range array the following array : array(0,
+				 * 0.75, 1.5, 2.25, 3); becomes : array('0-0.75', '0.75-1.5', '1.5-2.25',
+				 * '2.25-3');
+				 */
+				this.setRanges = function() {
+
+					this.ranges = Array(); // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
+
+					for (var i = 0; i < (this.bounds.length - 1); i++) {
+						this.ranges[i] = this.bounds[i] + this.separator + this.bounds[i + 1];
+					}
+				};
+
+				/** return min value */
+				this.min = function(exclude = []) {
+
+					if (this._nodata())
+						return;
+
+					if(!exclude.includes(this.serie[0])) this.stat_min = this.serie[0];
+					else this.stat_min = 999999999999;
+
+
+					for (var i = 0; i < this.pop(); i++) {
+						if (this.serie[i] < this.stat_min && !exclude.includes(this.serie[i])) {
+							this.stat_min = this.serie[i];
+						}
+					}
+
+					return this.stat_min;
+				};
+
+				/** return max value */
+				this.max = function(exclude = []) {
+
+					if (this._nodata())
+						return;
+
+					if(!exclude.includes(this.serie[0])) this.stat_max = this.serie[0];
+					else this.stat_max = -999999999999;
+
+					for (var i = 0; i < this.pop(); i++) {
+						if (this.serie[i] > this.stat_max && !exclude.includes(this.serie[i])) {
+							this.stat_max = this.serie[i];
+						}
+					}
+
+					return this.stat_max;
+				};
+
+				/** return sum value */
+				this.sum = function() {
+
+					if (this._nodata())
+						return;
+
+					if (this.stat_sum  == null) {
+
+						this.stat_sum = 0;
+						for (var i = 0; i < this.pop(); i++) {
+							this.stat_sum += parseFloat(this.serie[i]);
+						}
+
+					}
+
+					return this.stat_sum;
+				};
+
+				/** return population number */
+				this.pop = function() {
+
+					if (this._nodata())
+						return;
+
+					if (this.stat_pop  == null) {
+
+						this.stat_pop = this.serie.length;
+
+					}
+
+					return this.stat_pop;
+				};
+
+				/** return mean value */
+				this.mean = function() {
+
+					if (this._nodata())
+						return;
+
+					if (this.stat_mean  == null) {
+
+						this.stat_mean = parseFloat(this.sum() / this.pop());
+
+					}
+
+					return this.stat_mean;
+				};
+
+				/** return median value */
+				this.median = function() {
+
+					if (this._nodata())
+						return;
+
+					if (this.stat_median  == null) {
+
+						this.stat_median = 0;
+						var tmp = this.sorted();
+
+						// serie pop is odd
+						if (tmp.length % 2) {
+							this.stat_median = parseFloat(tmp[(Math.ceil(tmp.length / 2) - 1)]);
+
+						// serie pop is even
+						} else {
+							this.stat_median = ( parseFloat(tmp[((tmp.length / 2) - 1)]) + parseFloat(tmp[(tmp.length / 2)]) ) / 2;
+						}
+
+					}
+
+					return this.stat_median;
+				};
+
+				/** return variance value */
+				this.variance = function() {
+
+					var round = (typeof round === "undefined") ? true : false;
+
+					if (this._nodata())
+						return;
+
+					if (this.stat_variance  == null) {
+
+						var tmp = 0, serie_mean = this.mean();
+						for (var i = 0; i < this.pop(); i++) {
+							tmp += Math.pow( (this.serie[i] - serie_mean), 2 );
+						}
+
+						this.stat_variance =  tmp / this.pop();
+
+						if(round == true) {
+							this.stat_variance = Math.round(this.stat_variance * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
+						}
+
+					}
+
+					return this.stat_variance;
+				};
+
+				/** return standard deviation value */
+				this.stddev = function(round) {
+
+					var round = (typeof round === "undefined") ? true : false;
+
+					if (this._nodata())
+						return;
+
+					if (this.stat_stddev  == null) {
+
+						this.stat_stddev = Math.sqrt(this.variance());
+
+						if(round == true) {
+							this.stat_stddev = Math.round(this.stat_stddev * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
+						}
+
+					}
+
+					return this.stat_stddev;
+				};
+
+				/** coefficient of variation - measure of dispersion */
+				this.cov = function(round) {
+
+					var round = (typeof round === "undefined") ? true : false;
+
+					if (this._nodata())
+						return;
+
+					if (this.stat_cov  == null) {
+
+						this.stat_cov = this.stddev() / this.mean();
+
+						if(round == true) {
+							this.stat_cov = Math.round(this.stat_cov * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
+						}
+
+					}
+
+					return this.stat_cov;
+				};
+
+				/** reset all attributes after setting a new serie */
+				this.resetStatistics = function() {
+				    this.stat_sorted    = null;
+				    this.stat_mean  = null;
+				    this.stat_median    = null;
+				    this.stat_sum       = null;
+				    this.stat_max       = null;
+				    this.stat_min       = null;
+				    this.stat_pop       = null;
+				    this.stat_variance  = null;
+				    this.stat_stddev    = null;
+				    this.stat_cov       = null;
+				};
+
+				/** data test */
+				this._nodata = function() {
+					if (this.serie.length == 0) {
+
+						if(this.silent) this.log("[silent mode] Error. You should first enter a serie!", true);
+						else throw new TypeError("Error. You should first enter a serie!");
+						return 1;
+					} else
+						return 0;
+
+				};
+
+				/** data test */
+				this._classificationCheck = function(nbClass) {
+
+					if(nbClass >= this.pop()) {
+						var errnum ='Error. ' + nbClass + ' classes are defined for only ' + this.pop() + ' values in serie ! For the current serie, no more than ' + (this.pop() - 1 ) + ' classes can be defined.';
+
+						if(this.silent) this.log(errnum, true);
+						else {
+							alert(errnum);
+							throw new TypeError(errnum);
+						}
+
+					}
+
+				};
+
+				/** ensure nbClass is an integer */
+				this._nbClassInt = function(nbClass) {
+
+					var nbclassTmp = parseInt(nbClass, 10);
+					if (isNaN(nbclassTmp)) {
+						if(this.silent) this.log("[silent mode] '" + nbclassTmp + "' is not a valid integer. Enable to set class number.", true);
+						else throw new TypeError("'" + nbclassTmp + "' is not a valid integer. Enable to set class number.");
+					} else {
+						return nbclassTmp;
+					}
+
+				};
+
+				/** check if the serie contains negative value */
+				this._hasNegativeValue = function() {
+
+					for (var i = 0; i < this.serie.length; i++) {
+				    	if(this.serie[i] < 0)
+				    		return true;
+				    }
+
+					return false;
+				};
+
+				/** check if the serie contains zero value */
+				this._hasZeroValue = function() {
+
+					for (var i = 0; i < this.serie.length; i++) {
+				    	if(parseFloat(this.serie[i]) === 0)
+				    		return true;
+				    }
+
+					return false;
+				};
+
+				/** return sorted values (as array) */
+				this.sorted = function() {
+
+					if (this.stat_sorted  == null) {
+
+						if(this.is_uniqueValues == false) {
+							this.stat_sorted = this.serie.sort(function(a, b) {
+								return a - b;
+							});
+						} else {
+							this.stat_sorted = this.serie.sort(function(a,b){
+								var nameA=a.toString().toLowerCase(), nameB=b.toString().toLowerCase();
+							    if(nameA < nameB) return -1;
+							    if(nameA > nameB) return 1;
+							    return 0;
+							});
+						}
+					}
+
+					return this.stat_sorted;
+
+				};
+
+				/** return all info */
+				this.info = function() {
+
+					if (this._nodata())
+						return;
+
+					var content = '';
+					content += _t('Population') + ' : ' + this.pop() + ' - [' + _t('Min')
+							+ ' : ' + this.min() + ' | ' + _t('Max') + ' : ' + this.max()
+							+ ']' + "\n";
+					content += _t('Mean') + ' : ' + this.mean() + ' - ' + _t('Median')	+ ' : ' + this.median() + "\n";
+					content += _t('Variance') + ' : ' + this.variance() + ' - ' + _t('Standard deviation')	+ ' : ' + this.stddev()
+							+ ' - ' + _t('Coefficient of variation')	+ ' : ' + this.cov() + "\n";
+
+					return content;
+				};
+
+				/**
+				 * Set Manual classification Return an array with bounds : ie array(0,
+				 * 0.75, 1.5, 2.25, 3);
+				 * Set ranges and prepare data for displaying legend
+				 *
+				 */
+				this.setClassManually = function(array) {
+
+					if (this._nodata())
+				        return;
+
+				    if(array[0] !== this.min() || array[array.length-1] !== this.max()) {
+				    	if(this.silent) this.log("[silent mode] " + t('Given bounds may not be correct! please check your input.\nMin value : ' + this.min() + ' / Max value : ' + this.max()), true);
+						else throw new TypeError(_t('Given bounds may not be correct! please check your input.\nMin value : ' + this.min() + ' / Max value : ' + this.max()));
+				    	return;
+				    }
+
+				    this.setBounds(array);
+				    this.setRanges();
+
+				    // we specify the classification method
+				    this.method = _t('manual classification') + ' (' + (array.length -1) + ' ' + _t('classes') + ')';
+
+				    return this.bounds;
+				};
+
+				/**
+				 * Equal intervals classification Return an array with bounds : ie array(0,
+				 * 0.75, 1.5, 2.25, 3);
+				 */
+				this.getClassEqInterval = function(nbClass, forceMin, forceMax) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					if (this._nodata())
+				        return;
+
+					var tmpMin = (typeof forceMin === "undefined") ? this.min() : forceMin;
+					var tmpMax = (typeof forceMax === "undefined") ? this.max() : forceMax;
+
+				    var a = Array();
+				    var val = tmpMin;
+				    var interval = (tmpMax - tmpMin) / nbClass;
+
+				    for (var i = 0; i <= nbClass; i++) {
+				        a[i] = val;
+				        val += interval;
+				    }
+
+				    //-> Fix last bound to Max of values
+				    a[nbClass] = tmpMax;
+
+				    this.setBounds(a);
+				    this.setRanges();
+
+				    // we specify the classification method
+				    this.method = _t('eq. intervals') + ' (' + nbClass + ' ' + _t('classes') + ')';
+
+				    return this.bounds;
+				};
+
+
+				this.getQuantiles = function(nbClass) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					var tmp = this.sorted();
+					var quantiles = [];
+
+					var step = this.pop() / nbClass;
+					for (var i = 1; i < nbClass; i++) {
+						var qidx = Math.round(i*step+0.49);
+						quantiles.push(tmp[qidx-1]); // zero-based
+					}
+
+					return quantiles;
+				};
+
+				/**
+				 * Quantile classification Return an array with bounds : ie array(0, 0.75,
+				 * 1.5, 2.25, 3);
+				 */
+				this.getClassQuantile = function(nbClass) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					if (this._nodata())
+						return;
+
+					this._classificationCheck(nbClass); // be sure number of classes is valid
+
+					var tmp = this.sorted();
+					var bounds = this.getQuantiles(nbClass);
+					bounds.unshift(tmp[0]);
+
+					if (bounds[tmp.length - 1] !== tmp[tmp.length - 1])
+						bounds.push(tmp[tmp.length - 1]);
+
+					this.setBounds(bounds);
+					this.setRanges();
+
+					// we specify the classification method
+					this.method = _t('quantile') + ' (' + nbClass + ' ' + _t('classes') + ')';
+
+					return this.bounds;
+
+				};
+
+				/**
+				 * Standard Deviation classification
+				 * Return an array with bounds : ie array(0,
+				 * 0.75, 1.5, 2.25, 3);
+				 */
+				this.getClassStdDeviation = function(nbClass, matchBounds) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					if (this._nodata())
+				        return;
+
+				    var tmpMax = this.max();
+					var tmpMin = this.min();
+					var tmpStdDev = this.stddev();
+					var tmpMean = this.mean();
+
+				    var a = Array();
+
+				    // number of classes is odd
+				    if(nbClass % 2 == 1) {
+
+				    	// Euclidean division to get the inferior bound
+				    	var infBound = Math.floor(nbClass / 2);
+
+				    	var supBound = infBound + 1;
+
+				    	// we set the central bounds
+				    	a[infBound] = tmpMean - (tmpStdDev / 2);
+				    	a[supBound] = tmpMean + (tmpStdDev / 2);
+
+				    	// Values < to infBound, except first one
+				    	for (var i = infBound - 1; i > 0; i--) {
+				    		var val = a[i+1] - tmpStdDev;
+					        a[i] = val;
+					    }
+
+				    	// Values > to supBound, except last one
+				    	for (var i = supBound + 1; i < nbClass; i++) {
+				    		var val = a[i-1] + tmpStdDev;
+					        a[i] = val;
+					    }
+
+				    	// number of classes is even
+				    } else {
+
+				    	var meanBound = nbClass / 2;
+
+				    	// we get the mean value
+				    	a[meanBound] = tmpMean;
+
+				    	// Values < to the mean, except first one
+				    	for (var i = meanBound - 1; i > 0; i--) {
+				    		var val = a[i+1] - tmpStdDev;
+					        a[i] = val;
+					    }
+
+				    	// Values > to the mean, except last one
+				    	for (var i = meanBound + 1; i < nbClass; i++) {
+				    		var val = a[i-1] + tmpStdDev;
+					        a[i] = val;
+					    }
+				    }
+
+
+				    // we finally set the first value
+				    // do we excatly match min value or not ?
+				    a[0] = (typeof matchBounds === "undefined") ? a[1]- tmpStdDev : tmpMin;
+
+			    	// we finally set the last value
+				    // do we excatly match max value or not ?
+			    	a[nbClass] = (typeof matchBounds === "undefined") ? a[nbClass-1] + tmpStdDev : tmpMax;
+
+				    this.setBounds(a);
+				    this.setRanges();
+
+				    // we specify the classification method
+				    this.method = _t('std deviation') + ' (' + nbClass + ' ' + _t('classes')+ ')';
+
+				    return this.bounds;
+				};
+
+
+				/**
+				 * Geometric Progression classification
+				 * http://en.wikipedia.org/wiki/Geometric_progression
+				 * Return an array with bounds : ie array(0,
+				 * 0.75, 1.5, 2.25, 3);
+				 */
+				this.getClassGeometricProgression = function(nbClass) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					if (this._nodata())
+				        return;
+
+				    if(this._hasNegativeValue() || this._hasZeroValue()) {
+				    	if(this.silent) this.log("[silent mode] " + _t('geometric progression can\'t be applied with a serie containing negative or zero values.'), true);
+						else throw new TypeError(_t('geometric progression can\'t be applied with a serie containing negative or zero values.'));
+				    	return;
+				    }
+
+				    var a = Array();
+				    var tmpMin = this.min();
+				    var tmpMax = this.max();
+
+				    var logMax = Math.log(tmpMax) / Math.LN10; // max decimal logarithm (or base 10)
+				    var logMin = Math.log(tmpMin) / Math.LN10;
+				    var interval = (logMax - logMin) / nbClass;
+
+				    // we compute log bounds
+				    for (var i = 0; i < nbClass; i++) {
+				    	if(i == 0) {
+				    		a[i] = logMin;
+				    	} else {
+				    		a[i] = a[i-1] + interval;
+				    	}
+				    }
+
+				    // we compute antilog
+				    a = a.map(function(x) { return Math.pow(10, x); });
+
+				    // and we finally add max value
+				    a.push(this.max());
+
+				    this.setBounds(a);
+				    this.setRanges();
+
+				    // we specify the classification method
+				    this.method = _t('geometric progression') + ' (' + nbClass + ' ' + _t('classes') + ')';
+
+				    return this.bounds;
+				};
+
+				/**
+				 * Arithmetic Progression classification
+				 * http://en.wikipedia.org/wiki/Arithmetic_progression
+				 * Return an array with bounds : ie array(0,
+				 * 0.75, 1.5, 2.25, 3);
+				 */
+				this.getClassArithmeticProgression = function(nbClass) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					if (this._nodata())
+				        return;
+
+				    var denominator = 0;
+
+				    // we compute the (french) "Raison"
+				    for (var i = 1; i <= nbClass; i++) {
+				        denominator += i;
+				    }
+
+				    var a = Array();
+				    var tmpMin = this.min();
+				    var tmpMax = this.max();
+
+				    var interval = (tmpMax - tmpMin) / denominator;
+
+				    for (var i = 0; i <= nbClass; i++) {
+				    	if(i == 0) {
+				    		a[i] = tmpMin;
+						} else if(i == nbClass) {
+							a[i] = tmpMax;
+						} else {
+				    		a[i] = a[i-1] + (i * interval);
+				    	}
+				    }
+
+				    this.setBounds(a);
+				    this.setRanges();
+
+				    // we specify the classification method
+				    this.method = _t('arithmetic progression') + ' (' + nbClass + ' ' + _t('classes') + ')';
+
+				    return this.bounds;
+				};
+
+				/**
+				 * Credits : Doug Curl (javascript) and Daniel J Lewis (python implementation)
+				 * http://www.arcgis.com/home/item.html?id=0b633ff2f40d412995b8be377211c47b
+				 * http://danieljlewis.org/2010/06/07/jenks-natural-breaks-algorithm-in-python/
+				 */
+				this.getClassJenks2 = function(nbClass) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					if (this._nodata())
+						return;
+
+					this._classificationCheck(nbClass); // be sure number of classes is valid
+
+					var dataList = this.sorted();
+
+					// now iterate through the datalist:
+					// determine mat1 and mat2
+					// really not sure how these 2 different arrays are set - the code for
+					// each seems the same!
+					// but the effect are 2 different arrays: mat1 and mat2
+					var mat1 = [];
+					for ( var x = 0, xl = dataList.length + 1; x < xl; x++) {
+						var temp = [];
+						for ( var j = 0, jl = nbClass + 1; j < jl; j++) {
+							temp.push(0);
+						}
+						mat1.push(temp);
+					}
+
+					var mat2 = [];
+					for ( var i = 0, il = dataList.length + 1; i < il; i++) {
+						var temp2 = [];
+						for ( var c = 0, cl = nbClass + 1; c < cl; c++) {
+							temp2.push(0);
+						}
+						mat2.push(temp2);
+					}
+
+					// absolutely no idea what this does - best I can tell, it sets the 1st
+					// group in the
+					// mat1 and mat2 arrays to 1 and 0 respectively
+					for ( var y = 1, yl = nbClass + 1; y < yl; y++) {
+						mat1[0][y] = 1;
+						mat2[0][y] = 0;
+						for ( var t = 1, tl = dataList.length + 1; t < tl; t++) {
+							mat2[t][y] = Infinity;
+						}
+						var v = 0.0;
+					}
+
+					// and this part - I'm a little clueless on - but it works
+					// pretty sure it iterates across the entire dataset and compares each
+					// value to
+					// one another to and adjust the indices until you meet the rules:
+					// minimum deviation
+					// within a class and maximum separation between classes
+					for ( var l = 2, ll = dataList.length + 1; l < ll; l++) {
+						var s1 = 0.0;
+						var s2 = 0.0;
+						var w = 0.0;
+						for ( var m = 1, ml = l + 1; m < ml; m++) {
+							var i3 = l - m + 1;
+							var val = parseFloat(dataList[i3 - 1]);
+							s2 += val * val;
+							s1 += val;
+							w += 1;
+							v = s2 - (s1 * s1) / w;
+							var i4 = i3 - 1;
+							if (i4 != 0) {
+								for ( var p = 2, pl = nbClass + 1; p < pl; p++) {
+									if (mat2[l][p] >= (v + mat2[i4][p - 1])) {
+										mat1[l][p] = i3;
+										mat2[l][p] = v + mat2[i4][p - 1];
+									}
+								}
+							}
+						}
+						mat1[l][1] = 1;
+						mat2[l][1] = v;
+					}
+
+					var k = dataList.length;
+					var kclass = [];
+
+					// fill the kclass (classification) array with zeros:
+					for (var i = 0; i <= nbClass; i++) {
+						kclass.push(0);
+					}
+
+					// this is the last number in the array:
+					kclass[nbClass] = parseFloat(dataList[dataList.length - 1]);
+					// this is the first number - can set to zero, but want to set to lowest
+					// to use for legend:
+					kclass[0] = parseFloat(dataList[0]);
+					var countNum = nbClass;
+					while (countNum >= 2) {
+						var id = parseInt((mat1[k][countNum]) - 2);
+						kclass[countNum - 1] = dataList[id];
+						k = parseInt((mat1[k][countNum] - 1));
+						// spits out the rank and value of the break values:
+						// console.log("id="+id,"rank = " + String(mat1[k][countNum]),"val =
+						// " + String(dataList[id]))
+						// count down:
+						countNum -= 1;
+					}
+					// check to see if the 0 and 1 in the array are the same - if so, set 0
+					// to 0:
+					if (kclass[0] == kclass[1]) {
+						kclass[0] = 0;
+					}
+
+					this.setBounds(kclass);
+					this.setRanges();
+
+
+					this.method = _t('Jenks2') + ' (' + nbClass + ' ' + _t('classes') + ')';
+
+					return this.bounds; //array of breaks
+				};
+
+				/**
+				 * Credits from simple-statistics library
+				 * https://github.com/simple-statistics/simple-statistics
+				 * https://gist.githubusercontent.com/tmcw/4969184/raw/cfd9572d00db6bcdc34f07b088738fc3a47846b4/simple_statistics.js
+				 */
+				this.getClassJenks = function(nbClass) {
+
+					var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+					if (this._nodata())
+						return;
+
+					this._classificationCheck(nbClass); // be sure number of classes is valid
+
+					var dataList = this.sorted();
+
+					// Compute the matrices required for Jenks breaks. These matrices
+					// can be used for any classing of data with `classes <= n_classes`
+					var jenksMatrices = function(data, n_classes) {
+
+						// in the original implementation, these matrices are referred to
+						// as `LC` and `OP`
+						//
+						// * lower_class_limits (LC): optimal lower class limits
+						// * variance_combinations (OP): optimal variance combinations for all classes
+						var lower_class_limits = [],
+							variance_combinations = [],
+							// loop counters
+							i, j,
+							// the variance, as computed at each step in the calculation
+							variance = 0;
+
+						// Initialize and fill each matrix with zeroes
+						for (var i = 0; i < data.length + 1; i++) {
+							var tmp1 = [], tmp2 = [];
+							for (var j = 0; j < n_classes + 1; j++) {
+								tmp1.push(0);
+								tmp2.push(0);
+							}
+							lower_class_limits.push(tmp1);
+							variance_combinations.push(tmp2);
+						}
+
+						for (var i = 1; i < n_classes + 1; i++) {
+							lower_class_limits[1][i] = 1;
+							variance_combinations[1][i] = 0;
+							// in the original implementation, 9999999 is used but
+							// since Javascript has `Infinity`, we use that.
+							for (var j = 2; j < data.length + 1; j++) {
+								variance_combinations[j][i] = Infinity;
+							}
+						}
+
+						for (var l = 2; l < data.length + 1; l++) {
+
+							// `SZ` originally. this is the sum of the values seen thus
+							// far when calculating variance.
+							var sum = 0,
+								// `ZSQ` originally. the sum of squares of values seen
+								// thus far
+								sum_squares = 0,
+								// `WT` originally. This is the number of
+								w = 0,
+								// `IV` originally
+								i4 = 0;
+
+							// in several instances, you could say `Math.pow(x, 2)`
+							// instead of `x * x`, but this is slower in some browsers
+							// introduces an unnecessary concept.
+							for (var m = 1; m < l + 1; m++) {
+
+								// `III` originally
+								var lower_class_limit = l - m + 1,
+									val = data[lower_class_limit - 1];
+
+								// here we're estimating variance for each potential classing
+								// of the data, for each potential number of classes. `w`
+								// is the number of data points considered so far.
+								w++;
+
+								// increase the current sum and sum-of-squares
+								sum += val;
+								sum_squares += val * val;
+
+								// the variance at this point in the sequence is the difference
+								// between the sum of squares and the total x 2, over the number
+								// of samples.
+								variance = sum_squares - (sum * sum) / w;
+
+								i4 = lower_class_limit - 1;
+
+								if (i4 !== 0) {
+									for (var j = 2; j < n_classes + 1; j++) {
+										if (variance_combinations[l][j] >=
+											(variance + variance_combinations[i4][j - 1])) {
+											lower_class_limits[l][j] = lower_class_limit;
+											variance_combinations[l][j] = variance +
+												variance_combinations[i4][j - 1];
+										}
+									}
+								}
+							}
+
+							lower_class_limits[l][1] = 1;
+							variance_combinations[l][1] = variance;
+						}
+
+						return {
+							lower_class_limits: lower_class_limits,
+							variance_combinations: variance_combinations
+						};
+					};
+
+			        // get our basic matrices
+			        var matrices = jenksMatrices(dataList, nbClass),
+			            // we only need lower class limits here
+			            lower_class_limits = matrices.lower_class_limits,
+			            k = dataList.length - 1,
+			            kclass = [],
+			            countNum = nbClass;
+
+			        // the calculation of classes will never include the upper and
+			        // lower bounds, so we need to explicitly set them
+			        kclass[nbClass] = dataList[dataList.length - 1];
+			        kclass[0] = dataList[0];
+
+			        // the lower_class_limits matrix is used as indexes into itself
+			        // here: the `k` variable is reused in each iteration.
+			        while (countNum > 1) {
+			            kclass[countNum - 1] = dataList[lower_class_limits[k][countNum] - 2];
+			            k = lower_class_limits[k][countNum] - 1;
+			            countNum--;
+			        }
+
+					this.setBounds(kclass);
+					this.setRanges();
+
+
+					this.method = _t('Jenks') + ' (' + nbClass + ' ' + _t('classes') + ')';
+
+					return this.bounds; //array of breaks
+				};
+
+
+				/**
+				 * Unique classification Return as many entries as unique values : ie array('blue', 'red', yellow')
+				 * 1.5, 2.25, 3);
+				 */
+				this.getClassUniqueValues = function() {
+
+					if (this._nodata())
+						return;
+
+					this.is_uniqueValues = true;
+
+					var tmp = this.sorted(); // display in alphabetical order
+
+					var a = Array();
+
+					for (var i = 0; i < this.pop(); i++) {
+						if(a.indexOf(tmp[i]) === -1)
+							a.push(tmp[i]);
+					}
+
+					this.bounds = a;
+
+					// we specify the classification method
+					this.method = _t('unique values');
+
+					return a;
+
+				};
+
+
+				/**
+				 * Return the class of a given value.
+				 * For example value : 6
+				 * and bounds array = (0, 4, 8, 12);
+				 * Return 2
+				 */
+				this.getClass = function(value) {
+
+					for (var i = 0; i < this.bounds.length; i++) {
+
+						if(this.is_uniqueValues == true) {
+
+							if(value == this.bounds[i]) {
+								// console.log(value + ' - ' + this.bounds[i] + ' returned value : ' + i);
+								return i;
+							}
+						} else {
+							// parseFloat() is necessary
+							if(parseFloat(value) <= this.bounds[i + 1]) {
+								return i;
+							}
+						}
+					}
+
+					return _t("Unable to get value's class.");
+
+				};
+
+				/**
+				 * Return the ranges array : array('0-0.75', '0.75-1.5', '1.5-2.25',
+				 * '2.25-3');
+				 */
+				this.getRanges = function() {
+
+					return this.ranges;
+
+				};
+
+				/**
+				 * Returns the number/index of this.ranges that value falls into
+				 */
+				this.getRangeNum = function(value) {
+
+					var bounds, i;
+
+					for (var i = 0; i < this.ranges.length; i++) {
+						bounds = this.ranges[i].split(/ - /);
+						if (value <= parseFloat(bounds[1])) {
+							return i;
+						}
+					}
+				};
+
+				/*
+				 * Compute inner ranges based on serie.
+				 * Produce discontinous ranges used for legend - return an array similar to :
+				 * array('0.00-0.74', '0.98-1.52', '1.78-2.25', '2.99-3.14');
+				 * If inner ranges already computed, return array values.
+				 */
+				this.getInnerRanges = function() {
+
+					// if already computed, we return the result
+					if(this.inner_ranges != null)
+						return this.inner_ranges;
+
+
+					var a = new Array();
+					var tmp = this.sorted();
+
+					var cnt = 1; // bounds array counter
+
+					for (var i = 0; i < tmp.length; i++) {
+
+						if(i == 0) var range_firstvalue = tmp[i]; // we init first range value
+
+						if(parseFloat(tmp[i]) > parseFloat(this.bounds[cnt])) {
+
+							a[cnt - 1] = '' + range_firstvalue + this.separator + tmp[i-1];
+
+							var range_firstvalue =  tmp[i];
+
+							cnt++;
+
+						}
+
+						// we reach the last range, we finally complete manually
+						// and return the array
+						if(cnt == (this.bounds.length - 1)) {
+							// we set the last value
+							a[cnt - 1] = '' + range_firstvalue + this.separator + tmp[tmp.length-1];
+
+							this.inner_ranges = a;
+							return this.inner_ranges;
+						}
+
+
+					}
+
+				};
+
+				this.getSortedlist = function() {
+
+					return this.sorted().join(', ');
+
+				};
+
+				/**
+				 * Return an html legend
+				 * colors : specify an array of color (hexadecimal values)
+				 * legend :  specify a text input for the legend. By default, just displays 'legend'
+				 * counter : if not null, display counter value
+				 * callback : if not null, callback function applied on legend boundaries
+				 * mode : 	null, 'default', 'distinct', 'discontinuous' :
+				 * 			- if mode is null, will display legend as 'default mode'
+				 * 			- 'default' : displays ranges like in ranges array (continuous values), sample :  29.26 - 378.80 / 378.80 - 2762.25 /  2762.25 - 6884.84
+				 * 			- 'distinct' : Add + 1 according to decimal precision to distinguish classes (discrete values), sample :  29.26 - 378.80 / 378.81 - 2762.25 /  2762.26 - 6884.84
+				 * 			- 'discontinuous' : indicates the range of data actually falling in each class , sample :  29.26 - 225.43 / 852.12 - 2762.20 /  3001.25 - 6884.84 / not implemented yet
+				 * order : 	null, 'ASC', 'DESC'
+				 */
+				this.getHtmlLegend = function(colors, legend, counter, callback, mode, order) {
+
+					var cnt= '';
+					var elements = new Array();
+
+					this.doCount(); // we do count, even if not displayed
+
+					if(colors != null) {
+						ccolors = colors;
+					}
+					else {
+						ccolors = this.colors;
+					}
+
+					if(legend != null) {
+						lg = legend;
+					}
+					else {
+						lg =  'Legend';
+					}
+
+					if(counter != null) {
+						getcounter = true;
+					}
+					else {
+						getcounter = false;
+					}
+
+					if(callback != null) {
+						fn = callback;
+					}
+					else {
+						fn = function(o) {return o;};
+					}
+					if(mode == null) {
+						mode = 'default';
+					}
+					if(mode == 'discontinuous') {
+						this.getInnerRanges();
+						// check if some classes are not populated / equivalent of in_array function
+						if(this.counter.indexOf(0) !== -1) {
+					    	if(this.silent) this.log("[silent mode] " + _t("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!"), true);
+							else throw new TypeError(_t("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!"));
+							return;
+						}
+
+					}
+					if(order !== 'DESC') order = 'ASC';
+
+					if(ccolors.length < this.ranges.length) {
+						if(this.silent) this.log("[silent mode] " + _t('The number of colors should fit the number of ranges. Exit!'), true);
+						else throw new TypeError(_t('The number of colors should fit the number of ranges. Exit!'));
+						return;
+					}
+
+					if(this.is_uniqueValues == false) {
+
+						for (var i = 0; i < (this.ranges.length); i++) {
+							if(getcounter===true) {
+								cnt = ' <span class="geostats-legend-counter">(' + this.counter[i] + ')</span>';
+							}
+							//console.log("Ranges : " + this.ranges[i]);
+
+							// default mode
+							var tmp = this.ranges[i].split(this.separator);
+
+							var start_value = parseFloat(tmp[0]).toFixed(this.precision);
+							var end_value = parseFloat(tmp[1]).toFixed(this.precision);
+
+
+							// if mode == 'distinct' and we are not working on the first value
+							if(mode == 'distinct' && i != 0) {
+
+								if(isInt(start_value)) {
+									start_value = parseInt(start_value) + 1;
+									// format to float if necessary
+									if(this.precisionflag == 'manual' && this.precision != 0) start_value = parseFloat(start_value).toFixed(this.precision);
+								} else {
+
+									start_value = parseFloat(start_value) + (1 / Math.pow(10,this.precision));
+									// strangely the formula above return sometimes long decimal values,
+									// the following instruction fix it
+									start_value = parseFloat(start_value).toFixed(this.precision);
+								}
+							}
+
+							// if mode == 'discontinuous'
+							if(mode == 'discontinuous') {
+
+								var tmp = this.inner_ranges[i].split(this.separator);
+								// console.log("Ranges : " + this.inner_ranges[i]);
+
+								var start_value = parseFloat(tmp[0]).toFixed(this.precision);
+								var end_value = parseFloat(tmp[1]).toFixed(this.precision);
+
+							}
+
+							// we apply callback function
+							var el = fn(start_value) + this.legendSeparator + fn(end_value);
+
+							var block = '<div><div class="geostats-legend-block" style="background-color:' + ccolors[i] + '"></div> ' + el + cnt + '</div>';
+							elements.push(block);
+						}
+
+					} else {
+
+						// only if classification is done on unique values
+						for (var i = 0; i < (this.bounds.length); i++) {
+							if(getcounter===true) {
+								cnt = ' <span class="geostats-legend-counter">(' + this.counter[i] + ')</span>';
+							}
+							var el = fn(this.bounds[i]);
+							var block = '<div><div class="geostats-legend-block" style="background-color:' + ccolors[i] + '"></div> ' + el + cnt + '</div>';
+
+							elements.push(block);
+						}
+
+					}
+
+					// do we reverse the return legend ?
+					if(order === 'DESC') elements.reverse();
+
+					// finally we create HTML and return it
+					var content  = '<div class="geostats-legend"><div class="geostats-legend-title">' + _t(lg) + '</div>';
+					for (var i = 0; i < (elements.length); i++) {
+						content += elements[i];
+					}
+					content += '</div>';
+
+					return content;
+				};
+
+
+
+				// object constructor
+				// At the end of script. If not setPrecision() method is not known
+
+				// we create an object identifier for debugging
+				this.objectID = new Date().getUTCMilliseconds();
+				this.log('Creating new geostats object');
+
+				if(typeof a !== 'undefined' && a.length > 0) {
+					this.serie = a;
+					this.setPrecision();
+					this.log('Setting serie (' + a.length + ') : ' + a.join());
+				} else {
+					this.serie = Array();
+
+				}
+				// creating aliases on classification function for backward compatibility
+				this.getJenks = this.getClassJenks;
+				this.getJenks2 = this.getClassJenks2;
+				this.getGeometricProgression = this.getClassGeometricProgression;
+				this.getEqInterval = this.getClassEqInterval;
+				this.getQuantile = this.getClassQuantile;
+				this.getStdDeviation = this.getClassStdDeviation;
+				this.getUniqueValues = this.getClassUniqueValues;
+				this.getArithmeticProgression = this.getClassArithmeticProgression;
+
+			};
+
+
+			return geostats;
+			}); 
+		} (geostats$1));
+		return geostats$1.exports;
+	}
+
+	var geostatsExports = requireGeostats();
+	const geostats = /*@__PURE__*/getDefaultExportFromCjs(geostatsExports);
+
+	L.SolrHeatmap = L.GeoJSON.extend({
+	  options: {
+	    solrRequestHandler: 'select',
+	    type: 'geojsonGrid',
+	    colors: ['#f1eef6', '#d7b5d8', '#df65b0', '#dd1c77', '#980043'],
+	    maxSampleSize: Number.MAX_SAFE_INTEGER,  // for Jenks classification
+	    logging: false,
+	  },
+
+	  initialize: function (url, options) {
+	    var _this = this;
+	    options = L.setOptions(_this, options);
+	    _this._solrUrl = url;
+	    _this._layers = {};
+	    _this._getData();
+	  },
+
+	  onAdd: function (map) {
+	    var _this = this;
+
+	    // Call the parent function
+	    L.GeoJSON.prototype.onAdd.call(_this, map);
+
+	    map.on('moveend', function () {
+	      _this._getData();
+	    });
+	  },
+
+	  _computeHeatmapObject: function (data) {
+	    var _this = this;
+	    _this.facetHeatmap = data.response.facet_heatmaps[this.options.field];
+	    this._computeIntArrays();
+	  },
+
+	  _clearLayers: function () {
+	    var _this = this;
+
+	    switch (_this.options.type) {
+	      case 'geojsonGrid':
+	        _this.clearLayers();
+	        break;
+	      case 'clusters':
+	        _this.clusterMarkers.clearLayers();
+	        break;
+	      case 'heatmap':
+	        _this._map.removeLayer(_this.heatmapLayer);
+	        break;
+	    }
+	  },
+
+	  _createGeojson: function () {
+	    var _this = this;
+	    var geojson = {};
+
+	    geojson.type = 'FeatureCollection';
+	    geojson.features = [];
+
+	    _this.facetHeatmap.counts_ints2D.forEach(function(value, row) {
+	      if (value === null) {
+	        return;
+	      }
+
+	      value.forEach(function (val, column) {
+	        if (val === 0) {
+	          return;
+	        }
+
+	        var newFeature = {
+	          type: 'Feature',
+	          geometry: {
+	            type: 'Polygon',
+	            coordinates: [
+	              [
+	                [_this._minLng(column), _this._minLat(row)],
+	                [_this._minLng(column), _this._maxLat(row)],
+	                [_this._maxLng(column), _this._maxLat(row)],
+	                [_this._maxLng(column), _this._minLat(row)],
+	                [_this._minLng(column), _this._minLat(row)]
+	              ]
+	            ]
+	          },
+	          properties: {
+	            count: val
+	          }
+	        };
+	        geojson.features.push(newFeature);
+	      });
+	    });
+
+	    _this.addData(geojson);
+	    var colors = _this.options.colors;
+	    if (_this.facetHeatmap.counts_ints2D && _this.facetHeatmap.counts_ints2D.length > 0) {
+	      var classifications = _this._getClassifications(colors.length);
+	      _this._styleByCount(classifications);
+	      _this._showRenderTime();
+	    }
+	  },
+
+	  _createHeatmap: function () {
+	    var _this = this;
+	    var heatmapCells = [];
+	    var cellSize = _this._getCellSize() * .75;
+	    var colors = _this.options.colors;
+	    var classifications = _this._getClassifications(colors.length - 1);
+	    var maxValue = classifications[classifications.length - 1];
+	    var gradient = _this._getGradient(classifications);
+
+	    _this.facetHeatmap.counts_ints2D.forEach(function(value, row) {
+	      if (value === null) {
+	        return;
+	      }
+
+	      value.forEach(function (val, column) {
+	        if (val === 0) {
+	          return;
+	        }
+
+	        var scaledValue = Math.min((val / maxValue), 1);
+	        var current = [_this._minLat(row), _this._minLng(column), scaledValue];
+	        heatmapCells.push(current);
+
+	        // need to create options object to set gradient, blu, radius, max
+	      });
+	    });
+
+	    // settting max due to bug
+	    // http://stackoverflow.com/questions/26767722/leaflet-heat-issue-with-adding-points-with-intensity
+	    var options = { max: .0001, radius: cellSize, gradient: gradient };
+	    var heatmapLayer = L.heatLayer(heatmapCells, options);
+	    heatmapLayer.addTo(_this._map);
+	    _this.heatmapLayer = heatmapLayer;
+	    _this._showRenderTime();
+	  },
+
+	  // heatmap display need hash of scaled counts value, color pairs
+	  _getGradient: function (classifications) {
+	    var gradient = {};
+	    var maxValue = classifications[classifications.length - 1];
+	    var colors = _this.options.colors;
+	    // skip first lower bound, assumed to be 0 from Jenks
+	    for (var i = 1; i < classifications.length; i++)
+	  gradient[classifications[i] / maxValue] = colors[i];
+	    return gradient;
+	  },
+
+	  // compute size of heatmap cells in pixels
+	  _getCellSize: function () {
+	    _this = this;
+	    var mapSize = _this._map.getSize();  // should't we use solr returned map extent?
+	    var widthInPixels = mapSize.x;
+	    var heightInPixels = mapSize.y;
+	    var heatmapRows = _this.facetHeatmap.rows;
+	    var heatmapColumns = _this.facetHeatmap.columns;
+	    var sizeX = widthInPixels / heatmapColumns;
+	    var sizeY = heightInPixels / heatmapRows;
+	    var size = Math.ceil(Math.max(sizeX, sizeY));
+	    return size;
+	  },
+
+	  _showRenderTime: function () {
+	    if (this.options.logging) {
+	      var _this = this;
+	      var renderTime = 'Render time: ' + (Date.now() - _this.renderStart) + ' ms';
+	      console.log(renderTime);
+	    }
+	  },
+
+	  _createClusters: function() {
+	    var _this = this;
+
+	    _this.clusterMarkers = new L.MarkerClusterGroup({
+	      maxClusterRadius: 140,
+	    });
+
+	    _this.facetHeatmap.counts_ints2D.forEach(function(value, row) {
+	      if (value === null) {
+	        return;
+	      }
+
+	      value.forEach(function (val, column) {
+	        if (val === 0) {
+	          return;
+	        }
+
+	        var bounds = new L.latLngBounds([
+	          [_this._minLat(row), _this._minLng(column)],
+	          [_this._maxLat(row), _this._maxLng(column)],
+	        ]);
+	        _this.clusterMarkers.addLayer(new L.Marker(bounds.getCenter(), {
+	          count: val,
+	        }).bindPopup(val.toString()));
+	      });
+	    });
+
+	    _this._map.addLayer(_this.clusterMarkers);
+	    _this._showRenderTime();
+	  },
+
+	  _computeIntArrays: function () {
+	    var _this = this;
+
+	    _this.lengthX = (_this.facetHeatmap.maxX - _this.facetHeatmap.minX) / _this.facetHeatmap.columns;
+	    _this.lengthY = (_this.facetHeatmap.maxY - _this.facetHeatmap.minY) / _this.facetHeatmap.rows;
+	    _this._clearLayers();
+	    switch (_this.options.type) {
+	      case 'geojsonGrid':
+	        _this._createGeojson();
+	        break;
+	      case 'clusters':
+	        _this._createClusters();
+	        break;
+	      case 'heatmap':
+	        _this._createHeatmap();
+	        break;
+	    }
+	  },
+
+	  _getClassifications: function (howMany) {
+	    var _this = this;
+	    var oneDArray = [];
+	    _this.facetHeatmap.counts_ints2D.forEach(function(value, row) {
+	      if (value != null) {
+	        oneDArray = oneDArray.concat(value);
+	      }
+	    });
+
+	    var sampledArray = _this._sampleCounts(oneDArray);
+
+	    var series = new geostats(sampledArray);
+	    _this.options.colors;
+	    var classifications = series.getClassJenks(howMany - 1);
+	    return classifications.reduce(function (previous, current) {
+	      if (previous.indexOf(current) == -1) {
+	        previous.push(current);
+	      }
+
+	      return previous;
+	    }, []);
+	  },
+
+	  _styleByCount: function (classifications) {
+	    var _this = this;
+	    var scale = _this.options.colors.slice(this.options.colors.length - classifications.length, this.options.colors.length);
+
+	    _this.eachLayer(function (layer) {
+	      var color;
+	      classifications.forEach(function (val, i) {
+	        if (layer.feature.properties.count >= val) {
+	          color = scale[i];
+	        }
+	      });
+
+	      layer.setStyle({
+	        fillColor: color,
+	        fillOpacity: 0.5,
+	        weight: 0,
+	      });
+	    });
+	  },
+
+	  // Jenks classification can be slow so we optionally sample the data
+	  // typically any big sample of counts are much the same, don't need to classify on all of them
+	  _sampleCounts: function (passedArray) {
+	    const _this = this;
+	    if (passedArray.length <= _this.options.maxSampleSize) {
+	      return passedArray;   // array too small to sample
+	    }
+
+	    var maxValue = Math.max.apply(Math, passedArray);
+	    var sampledArray = [];
+	    var period = Math.ceil(passedArray.length / _this.options.maxSampleSize);
+	    for (let i = 0; i < passedArray.length; i = i + period) {
+	      sampledArray.push(passedArray[i]);
+	    }
+
+	    sampledArray.push(maxValue);  // make sure largest value gets in, doesn't matter much if duplicated
+	    return sampledArray;
+	  },
+
+	  _minLng: function (column) {
+	    return this.facetHeatmap.minX + (this.lengthX * column);
+	  },
+
+	  _minLat: function (row) {
+	    return this.facetHeatmap.maxY - (this.lengthY * row) - this.lengthY;
+	  },
+
+	  _maxLng: function (column) {
+	    return this.facetHeatmap.minX + (this.lengthX * column) + this.lengthX;
+	  },
+
+	  _maxLat: function (row) {
+	    return this.facetHeatmap.maxY - (this.lengthY * row);
+	  },
+
+	  _getData: function () {
+	    var _this = this;
+	    var startTime = Date.now();
+
+	    var url = new URL(_this._solrUrl);
+	    url.searchParams.append('bbox', _this._mapViewToBbox());
+
+	    fetch(url, {
+	      headers: {
+	        'Accept': 'application/json',
+	      }
+	    }).then(function (response) {
+	      return response.json();
+	    }).then(function (data) {
+	      var totalTime = 'Solr response time: ' + (Date.now() - startTime) + ' ms';
+	      if (_this.options.logging) {
+	        console.log(totalTime);
+	      }
+
+	      _this.docsCount = data.response.numFound;
+	      _this.renderStart = Date.now();
+	      _this._computeHeatmapObject(data);
+	      _this.fireEvent('dataAdded', data);
+	    });
+	  },
+
+	  _mapViewToBbox: function () {
+	    if (this._map === undefined) {
+	      return '-180,-90,180,90';
+	    }
+
+	    var bounds = this._map.getBounds();
+	    var wrappedSw = bounds.getSouthWest().wrap();
+	    var wrappedNe = bounds.getNorthEast().wrap();
+	    return [wrappedSw.lng, bounds.getSouth(), wrappedNe.lng, bounds.getNorth()].join(',');
+	  },
+
+	  _mapViewToEnvelope: function () {
+	    if (this._map === undefined) {
+	      return ':"Intersects(ENVELOPE(-180, 180, 90, -90))"';
+	    }
+
+	    var bounds = this._map.getBounds();
+	    var wrappedSw = bounds.getSouthWest().wrap();
+	    var wrappedNe = bounds.getNorthEast().wrap();
+	    return ':"Intersects(ENVELOPE(' + wrappedSw.lng + ', ' + wrappedNe.lng + ', ' + bounds.getNorth() + ', ' + bounds.getSouth() + '))"';
+	  },
+
+	  _mapViewToWkt: function () {
+	    if (this._map === undefined) {
+	      return '["-180 -90" TO "180 90"]';
+	    }
+
+	    var bounds = this._map.getBounds();
+	    var wrappedSw = bounds.getSouthWest().wrap();
+	    var wrappedNe = bounds.getNorthEast().wrap();
+	    return '["' + wrappedSw.lng + ' ' + bounds.getSouth() + '" TO "' + wrappedNe.lng + ' ' + bounds.getNorth() + '"]';
+	  },
+
+	  _solrQuery: function () {
+	    return '/' + this.options.solrRequestHandler + '?' + this.options.field;
+	  },
+	});
+
+	L.solrHeatmap = function (url, options) {
+	  return new L.SolrHeatmap(url, options);
+	};
+
+	// Check if L.MarkerCluster is included
+	if (typeof L.MarkerCluster !== 'undefined') {
+	  L.MarkerCluster.prototype.initialize = function (group, zoom, a, b) {
+
+	    L.Marker.prototype.initialize.call(this, a ? (a._cLatLng || a.getLatLng()) : new L.LatLng(0, 0), { icon: this });
+
+	    this._group = group;
+	    this._zoom = zoom;
+
+	    this._markers = [];
+	    this._childClusters = [];
+	    this._childCount = 0;
+	    this._iconNeedsUpdate = true;
+
+	    this._bounds = new L.LatLngBounds();
+
+	    if (a) {
+	      this._addChild(a);
+	    }
+
+	    if (b) {
+	      this._addChild(b);
+	      this._childCount = b.options.count;
+	    }
+	  };
+	}
+
+	const Basemaps = {
+	  darkMatter: L.tileLayer(
+	    'https://cartodb-basemaps-{s}.global.ssl.fastly.net/dark_all/{z}/{x}/{y}.png', {
+	      attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://cartodb.com/attributions">CartoDB</a>',
+	      maxZoom: 18,
+	      worldCopyJump: true,
+	      detectRetina: true,
+	    }
+	  ),
+	  positron: L.tileLayer(
+	    'https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png', {
+	      attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://cartodb.com/attributions">CartoDB</a>',
+	      maxZoom: 18,
+	      worldCopyJump: true,
+	      detectRetina: true,
+	    }
+	  ),
+	  'OpenStreetMap.HOT': L.tileLayer(
+	    'https://{s}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png', {
+	      attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>, Tiles courtesy of <a href="http://hot.openstreetmap.org/" target="_blank">Humanitarian OpenStreetMap Team</a>',
+	      maxZoom: 19,
+	    }
+	  ),
+	};
+
+	const Icons = {
+	  default: new L.Icon.Default()
+	};
+
+	const IndexView = L.Class.extend({
+	  options: {},
+
+	  initialize: function (el, options) {
+	    var requestUrl = el.dataset.searchUrl + '&format=heatmaps';
+	    var geometryField = el.dataset.geometryField;
+	    var template = el.dataset.sidebarTemplate;
+	    var colorRamp = JSON.parse(el.dataset.colorRamp);
+
+	    // Blank out page link content first and disable pagination
+	    document.querySelectorAll('#sortAndPerPage .page-links').forEach(function (links) {
+	      links.innerHTML = '';
+	    });
+	    document.querySelectorAll('ul.pagination').forEach(function (links) {
+	      links.classList.add('d-none');
+	    });
+
+	    var map = L.map(el.id).setView([0, 0], 1);
+	    BlacklightHeatmaps.selectBasemap(
+	      el.dataset.basemapProvider
+	    ).addTo(map);
+
+	    var solrLayer = L.solrHeatmap(requestUrl, {
+	      field: geometryField,
+	      maxSampleSize: 50,
+	      colors: colorRamp,
+	    }).addTo(map);
+
+	    var sidebar = L.control.sidebar('index-map-sidebar', {
+	      position: 'right',
+	    });
+
+	    map.addControl(sidebar);
+
+	    solrLayer.on('click', function (e) {
+	      if (!sidebar.isVisible()) {
+	        map.setView(e.latlng);
+	      } else {
+	        var point = map.project(e.latlng);
+	        var offset = sidebar.getOffset();
+	        var newPoint = L.point(point.x - (offset / 2), point.y);
+	        map.setView(map.unproject(newPoint));
+	      }
+
+	      sidebar.show();
+	    });
+
+	    solrLayer.on('dataAdded', function (e) {
+	      if (e.response && e.response.docs) {
+	        var html = '';
+	        e.response.docs.forEach(function (value) {
+	          html += L.Util.template(template, value);
+	        });
+
+	        sidebar.setContent(html);
+
+	        var docCount = e.response.pages.total_count;
+
+	        document.querySelectorAll('#sortAndPerPage .page-links').forEach(function (links) {
+	          links.innerHTML = parseInt(docCount).toLocaleString() + ' ' + (docCount == 1 ? 'item' : 'items') + ' found';
+	        });
+	      }
+	    });
+	  },
+
+	  pluralize: function (count, word) {
+	    switch (count) {
+	      case 1:
+	        return word;
+	      default:
+	        return word + 's';
+	    }
+	  },
+	});
+
+	const ShowView = L.Class.extend({
+	  options: {},
+
+	  initialize: function (el, options) {
+	    var json = JSON.parse(el.dataset.features);
+
+	    var map = L.map(el.id).setView([0, 0], 1);
+	    BlacklightHeatmaps.selectBasemap(
+	      el.dataset.basemapProvider
+	    ).addTo(map);
+
+	    var features = L.geoJson(json, {
+	      pointToLayer: function(feature, latlng) {
+	        return L.marker(latlng, {
+	          icon: BlacklightHeatmaps.Icons.default
+	        })
+	      }
+	    }).addTo(map);
+
+	    map.fitBounds(features.getBounds());
+	  },
+	});
+
+	const BlacklightHeatmaps$1 = L$1.Class.extend({
+	  statics: {
+	    __version__: '0.0.3',
+
+	    selectBasemap: function (basemap) {
+	      if (basemap && basemap !== undefined) {
+	        return BlacklightHeatmaps$1.Basemaps[basemap];
+	      } else {
+	        return BlacklightHeatmaps$1.Basemaps.positron;
+	      }
+	    },
+	  },
+	});
+
+	BlacklightHeatmaps$1.Basemaps = Basemaps;
+	BlacklightHeatmaps$1.Icons = Icons;
+	BlacklightHeatmaps$1.IndexView = IndexView;
+	BlacklightHeatmaps$1.indexView = function (el, options) {
+	    return new IndexView(el, options)
+	};
+	BlacklightHeatmaps$1.ShowView = ShowView;
+	BlacklightHeatmaps$1.showView = function (el, options) {
+	  return new ShowView(el, options);
+	};
+
+	Blacklight.onLoad(function () {
+	  document.querySelectorAll('[data-index-map]').forEach(function (el) {
+	    BlacklightHeatmaps$1.indexView(el, {});
+	  });
+	  document.querySelectorAll('[data-show-map]').forEach(function (el) {
+	    BlacklightHeatmaps$1.showView(el);
+	  });
+	});
+
+	return BlacklightHeatmaps$1;
+
+}));
+//# sourceMappingURL=default.js.map