--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/pyams_gis/resources/js/leaflet-esri-renderers-2.0.2.js	Thu May 18 17:23:48 2017 +0200
@@ -0,0 +1,1129 @@
+/* esri-leaflet-renderers - v2.0.2 - Wed Jun 15 2016 09:56:55 GMT-0700 (PDT)
+ * Copyright (c) 2016 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'leaflet'], factory) :
+	(factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}, global.L.esri.Renderers = global.L.esri.Renderers || {}),global.L));
+}(this, function (exports,L) { 'use strict';
+
+	L = 'default' in L ? L['default'] : L;
+
+	var version = "2.0.2";
+
+	var Symbol = L.Class.extend({
+	  initialize: function (symbolJson, options) {
+	    this._symbolJson = symbolJson;
+	    this.val = null;
+	    this._styles = {};
+	    this._isDefault = false;
+	    this._layerTransparency = 1;
+	    if (options && options.layerTransparency) {
+	      this._layerTransparency = 1 - (options.layerTransparency / 100.0);
+	    }
+	  },
+
+	  // the geojson values returned are in points
+	  pixelValue: function (pointValue) {
+	    return pointValue * 1.333;
+	  },
+
+	  // color is an array [r,g,b,a]
+	  colorValue: function (color) {
+	    return 'rgb(' + color[0] + ',' + color[1] + ',' + color[2] + ')';
+	  },
+
+	  alphaValue: function (color) {
+	    var alpha = color[3] / 255.0;
+	    return alpha * this._layerTransparency;
+	  },
+
+	  getSize: function (feature, sizeInfo) {
+	    var attr = feature.properties;
+	    var field = sizeInfo.field;
+	    var size = 0;
+	    var featureValue = null;
+
+	    if (field) {
+	      featureValue = attr[field];
+	      var minSize = sizeInfo.minSize;
+	      var maxSize = sizeInfo.maxSize;
+	      var minDataValue = sizeInfo.minDataValue;
+	      var maxDataValue = sizeInfo.maxDataValue;
+	      var featureRatio;
+	      var normField = sizeInfo.normalizationField;
+	      var normValue = attr ? parseFloat(attr[normField]) : undefined;
+
+	      if (featureValue === null || (normField && ((isNaN(normValue) || normValue === 0)))) {
+	        return null;
+	      }
+
+	      if (!isNaN(normValue)) {
+	        featureValue /= normValue;
+	      }
+
+	      if (minSize !== null && maxSize !== null && minDataValue !== null && maxDataValue !== null) {
+	        if (featureValue <= minDataValue) {
+	          size = minSize;
+	        } else if (featureValue >= maxDataValue) {
+	          size = maxSize;
+	        } else {
+	          featureRatio = (featureValue - minDataValue) / (maxDataValue - minDataValue);
+	          size = minSize + (featureRatio * (maxSize - minSize));
+	        }
+	      }
+	      size = isNaN(size) ? 0 : size;
+	    }
+	    return size;
+	  },
+
+	  getColor: function (feature, colorInfo) {
+	    // required information to get color
+	    if (!(feature.properties && colorInfo && colorInfo.field && colorInfo.stops)) {
+	      return null;
+	    }
+
+	    var attr = feature.properties;
+	    var featureValue = attr[colorInfo.field];
+	    var lowerBoundColor, upperBoundColor, lowerBound, upperBound;
+	    var normField = colorInfo.normalizationField;
+	    var normValue = attr ? parseFloat(attr[normField]) : undefined;
+	    if (featureValue === null || (normField && ((isNaN(normValue) || normValue === 0)))) {
+	      return null;
+	    }
+
+	    if (!isNaN(normValue)) {
+	      featureValue /= normValue;
+	    }
+
+	    if (featureValue <= colorInfo.stops[0].value) {
+	      return colorInfo.stops[0].color;
+	    }
+	    var lastStop = colorInfo.stops[colorInfo.stops.length - 1];
+	    if (featureValue >= lastStop.value) {
+	      return lastStop.color;
+	    }
+
+	    // go through the stops to find min and max
+	    for (var i = 0; i < colorInfo.stops.length; i++) {
+	      var stopInfo = colorInfo.stops[i];
+
+	      if (stopInfo.value <= featureValue) {
+	        lowerBoundColor = stopInfo.color;
+	        lowerBound = stopInfo.value;
+	      } else if (stopInfo.value > featureValue) {
+	        upperBoundColor = stopInfo.color;
+	        upperBound = stopInfo.value;
+	        break;
+	      }
+	    }
+
+	    // feature falls between two stops, interplate the colors
+	    if (!isNaN(lowerBound) && !isNaN(upperBound)) {
+	      var range = upperBound - lowerBound;
+	      if (range > 0) {
+	        // more weight the further it is from the lower bound
+	        var upperBoundColorWeight = (featureValue - lowerBound) / range;
+	        if (upperBoundColorWeight) {
+	          // more weight the further it is from the upper bound
+	          var lowerBoundColorWeight = (upperBound - featureValue) / range;
+	          if (lowerBoundColorWeight) {
+	            // interpolate the lower and upper bound color by applying the
+	            // weights to each of the rgba colors and adding them together
+	            var interpolatedColor = [];
+	            for (var j = 0; j < 4; j++) {
+	              interpolatedColor[j] = Math.round(lowerBoundColor[j] * lowerBoundColorWeight + upperBoundColor[j] * upperBoundColorWeight);
+	            }
+	            return interpolatedColor;
+	          } else {
+	            // no difference between featureValue and upperBound, 100% of upperBoundColor
+	            return upperBoundColor;
+	          }
+	        } else {
+	          // no difference between featureValue and lowerBound, 100% of lowerBoundColor
+	          return lowerBoundColor;
+	        }
+	      }
+	    }
+	    // if we get to here, none of the cases apply so return null
+	    return null;
+	  }
+	});
+
+	var ShapeMarker = L.Path.extend({
+
+	  initialize: function (latlng, size, options) {
+	    L.setOptions(this, options);
+	    this._size = size;
+	    this._latlng = L.latLng(latlng);
+	    this._svgCanvasIncludes();
+	  },
+
+	  _svgCanvasIncludes: function () {
+	    // implement in sub class
+	  },
+
+	  _project: function () {
+	    this._point = this._map.latLngToLayerPoint(this._latlng);
+	  },
+
+	  _update: function () {
+	    if (this._map) {
+	      this._updatePath();
+	    }
+	  },
+
+	  _updatePath: function () {
+	    // implement in sub class
+	  },
+
+	  setLatLng: function (latlng) {
+	    this._latlng = L.latLng(latlng);
+	    this.redraw();
+	    return this.fire('move', {latlng: this._latlng});
+	  },
+
+	  getLatLng: function () {
+	    return this._latlng;
+	  },
+
+	  setSize: function (size) {
+	    this._size = size;
+	    return this.redraw();
+	  },
+
+	  getSize: function () {
+	    return this._size;
+	  }
+	});
+
+	var CrossMarker = ShapeMarker.extend({
+
+	  initialize: function (latlng, size, options) {
+	    ShapeMarker.prototype.initialize.call(this, latlng, size, options);
+	  },
+
+	  _updatePath: function () {
+	    this._renderer._updateCrossMarker(this);
+	  },
+
+	  _svgCanvasIncludes: function () {
+	    L.Canvas.include({
+	      _updateCrossMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+	        var ctx = this._ctx;
+
+	        ctx.beginPath();
+	        ctx.moveTo(latlng.x, latlng.y + offset);
+	        ctx.lineTo(latlng.x, latlng.y - offset);
+	        this._fillStroke(ctx, layer);
+
+	        ctx.moveTo(latlng.x - offset, latlng.y);
+	        ctx.lineTo(latlng.x + offset, latlng.y);
+	        this._fillStroke(ctx, layer);
+	      }
+	    });
+
+	    L.SVG.include({
+	      _updateCrossMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+
+	        if (L.Browser.vml) {
+	          latlng._round();
+	          offset = Math.round(offset);
+	        }
+
+	        var str = 'M' + latlng.x + ',' + (latlng.y + offset) +
+	          'L' + latlng.x + ',' + (latlng.y - offset) +
+	          'M' + (latlng.x - offset) + ',' + latlng.y +
+	          'L' + (latlng.x + offset) + ',' + latlng.y;
+
+	        this._setPath(layer, str);
+	      }
+	    });
+	  }
+	});
+
+	var crossMarker = function (latlng, size, options) {
+	  return new CrossMarker(latlng, size, options);
+	};
+
+	var XMarker = ShapeMarker.extend({
+
+	  initialize: function (latlng, size, options) {
+	    ShapeMarker.prototype.initialize.call(this, latlng, size, options);
+	  },
+
+	  _updatePath: function () {
+	    this._renderer._updateXMarker(this);
+	  },
+
+	  _svgCanvasIncludes: function () {
+	    L.Canvas.include({
+	      _updateXMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+	        var ctx = this._ctx;
+
+	        ctx.beginPath();
+
+	        ctx.moveTo(latlng.x + offset, latlng.y + offset);
+	        ctx.lineTo(latlng.x - offset, latlng.y - offset);
+	        this._fillStroke(ctx, layer);
+	      }
+	    });
+
+	    L.SVG.include({
+	      _updateXMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+
+	        if (L.Browser.vml) {
+	          latlng._round();
+	          offset = Math.round(offset);
+	        }
+
+	        var str = 'M' + (latlng.x + offset) + ',' + (latlng.y + offset) +
+	          'L' + (latlng.x - offset) + ',' + (latlng.y - offset) +
+	          'M' + (latlng.x - offset) + ',' + (latlng.y + offset) +
+	          'L' + (latlng.x + offset) + ',' + (latlng.y - offset);
+
+	        this._setPath(layer, str);
+	      }
+	    });
+	  }
+	});
+
+	var xMarker = function (latlng, size, options) {
+	  return new XMarker(latlng, size, options);
+	};
+
+	var SquareMarker = ShapeMarker.extend({
+	  options: {
+	    fill: true
+	  },
+
+	  initialize: function (latlng, size, options) {
+	    ShapeMarker.prototype.initialize.call(this, latlng, size, options);
+	  },
+
+	  _updatePath: function () {
+	    this._renderer._updateSquareMarker(this);
+	  },
+
+	  _svgCanvasIncludes: function () {
+	    L.Canvas.include({
+	      _updateSquareMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+	        var ctx = this._ctx;
+
+	        ctx.beginPath();
+
+	        ctx.moveTo(latlng.x + offset, latlng.y + offset);
+	        ctx.lineTo(latlng.x - offset, latlng.y + offset);
+	        ctx.lineTo(latlng.x - offset, latlng.y - offset);
+	        ctx.lineTo(latlng.x + offset, latlng.y - offset);
+
+	        ctx.closePath();
+
+	        this._fillStroke(ctx, layer);
+	      }
+	    });
+
+	    L.SVG.include({
+	      _updateSquareMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+
+	        if (L.Browser.vml) {
+	          latlng._round();
+	          offset = Math.round(offset);
+	        }
+
+	        var str = 'M' + (latlng.x + offset) + ',' + (latlng.y + offset) +
+	          'L' + (latlng.x - offset) + ',' + (latlng.y + offset) +
+	          'L' + (latlng.x - offset) + ',' + (latlng.y - offset) +
+	          'L' + (latlng.x + offset) + ',' + (latlng.y - offset);
+
+	        str = str + (L.Browser.svg ? 'z' : 'x');
+
+	        this._setPath(layer, str);
+	      }
+	    });
+	  }
+	});
+
+	var squareMarker = function (latlng, size, options) {
+	  return new SquareMarker(latlng, size, options);
+	};
+
+	var DiamondMarker = ShapeMarker.extend({
+	  options: {
+	    fill: true
+	  },
+
+	  initialize: function (latlng, size, options) {
+	    ShapeMarker.prototype.initialize.call(this, latlng, size, options);
+	  },
+
+	  _updatePath: function () {
+	    this._renderer._updateDiamondMarker(this);
+	  },
+
+	  _svgCanvasIncludes: function () {
+	    L.Canvas.include({
+	      _updateDiamondMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+	        var ctx = this._ctx;
+
+	        ctx.beginPath();
+
+	        ctx.moveTo(latlng.x, latlng.y + offset);
+	        ctx.lineTo(latlng.x - offset, latlng.y);
+	        ctx.lineTo(latlng.x, latlng.y - offset);
+	        ctx.lineTo(latlng.x + offset, latlng.y);
+
+	        ctx.closePath();
+
+	        this._fillStroke(ctx, layer);
+	      }
+	    });
+
+	    L.SVG.include({
+	      _updateDiamondMarker: function (layer) {
+	        var latlng = layer._point;
+	        var offset = layer._size / 2.0;
+
+	        if (L.Browser.vml) {
+	          latlng._round();
+	          offset = Math.round(offset);
+	        }
+
+	        var str = 'M' + latlng.x + ',' + (latlng.y + offset) +
+	          'L' + (latlng.x - offset) + ',' + latlng.y +
+	          'L' + latlng.x + ',' + (latlng.y - offset) +
+	          'L' + (latlng.x + offset) + ',' + latlng.y;
+
+	        str = str + (L.Browser.svg ? 'z' : 'x');
+
+	        this._setPath(layer, str);
+	      }
+	    });
+	  }
+	});
+
+	var diamondMarker = function (latlng, size, options) {
+	  return new DiamondMarker(latlng, size, options);
+	};
+
+	var PointSymbol = Symbol.extend({
+
+	  statics: {
+	    MARKERTYPES: ['esriSMSCircle', 'esriSMSCross', 'esriSMSDiamond', 'esriSMSSquare', 'esriSMSX', 'esriPMS']
+	  },
+
+	  initialize: function (symbolJson, options) {
+	    Symbol.prototype.initialize.call(this, symbolJson, options);
+	    if (options) {
+	      this.serviceUrl = options.url;
+	    }
+	    if (symbolJson) {
+	      if (symbolJson.type === 'esriPMS') {
+	        var url = this.serviceUrl + 'images/' + this._symbolJson.url;
+	        this._iconUrl = options && options.token ? url + '?token=' + options.token : url;
+	        // leaflet does not allow resizing icons so keep a hash of different
+	        // icon sizes to try and keep down on the number of icons created
+	        this._icons = {};
+	        // create base icon
+	        this.icon = this._createIcon(this._symbolJson);
+	      } else {
+	        this._fillStyles();
+	      }
+	    }
+	  },
+
+	  _fillStyles: function () {
+	    if (this._symbolJson.outline && this._symbolJson.size > 0) {
+	      this._styles.stroke = true;
+	      this._styles.weight = this.pixelValue(this._symbolJson.outline.width);
+	      this._styles.color = this.colorValue(this._symbolJson.outline.color);
+	      this._styles.opacity = this.alphaValue(this._symbolJson.outline.color);
+	    } else {
+	      this._styles.stroke = false;
+	    }
+	    if (this._symbolJson.color) {
+	      this._styles.fillColor = this.colorValue(this._symbolJson.color);
+	      this._styles.fillOpacity = this.alphaValue(this._symbolJson.color);
+	    } else {
+	      this._styles.fillOpacity = 0;
+	    }
+
+	    if (this._symbolJson.style === 'esriSMSCircle') {
+	      this._styles.radius = this.pixelValue(this._symbolJson.size) / 2.0;
+	    }
+	  },
+
+	  _createIcon: function (options) {
+	    var width = this.pixelValue(options.width);
+	    var height = width;
+	    if (options.height) {
+	      height = this.pixelValue(options.height);
+	    }
+	    var xOffset = width / 2.0;
+	    var yOffset = height / 2.0;
+
+	    if (options.xoffset) {
+	      xOffset += this.pixelValue(options.xoffset);
+	    }
+	    if (options.yoffset) {
+	      yOffset += this.pixelValue(options.yoffset);
+	    }
+
+	    var icon = L.icon({
+	      iconUrl: this._iconUrl,
+	      iconSize: [width, height],
+	      iconAnchor: [xOffset, yOffset]
+	    });
+	    this._icons[options.width.toString()] = icon;
+	    return icon;
+	  },
+
+	  _getIcon: function (size) {
+	    // check to see if it is already created by size
+	    var icon = this._icons[size.toString()];
+	    if (!icon) {
+	      icon = this._createIcon({width: size});
+	    }
+	    return icon;
+	  },
+
+	  pointToLayer: function (geojson, latlng, visualVariables, options) {
+	    var size = this._symbolJson.size || this._symbolJson.width;
+	    if (!this._isDefault) {
+	      if (visualVariables.sizeInfo) {
+	        var calculatedSize = this.getSize(geojson, visualVariables.sizeInfo);
+	        if (calculatedSize) {
+	          size = calculatedSize;
+	        }
+	      }
+	      if (visualVariables.colorInfo) {
+	        var color = this.getColor(geojson, visualVariables.colorInfo);
+	        if (color) {
+	          this._styles.fillColor = this.colorValue(color);
+	          this._styles.fillOpacity = this.alphaValue(color);
+	        }
+	      }
+	    }
+
+	    if (this._symbolJson.type === 'esriPMS') {
+	      var layerOptions = L.extend({}, {icon: this._getIcon(size)}, options);
+	      return L.marker(latlng, layerOptions);
+	    }
+	    size = this.pixelValue(size);
+
+	    switch (this._symbolJson.style) {
+	      case 'esriSMSSquare':
+	        return squareMarker(latlng, size, L.extend({}, this._styles, options));
+	      case 'esriSMSDiamond':
+	        return diamondMarker(latlng, size, L.extend({}, this._styles, options));
+	      case 'esriSMSCross':
+	        return crossMarker(latlng, size, L.extend({}, this._styles, options));
+	      case 'esriSMSX':
+	        return xMarker(latlng, size, L.extend({}, this._styles, options));
+	    }
+	    this._styles.radius = size / 2.0;
+	    return L.circleMarker(latlng, L.extend({}, this._styles, options));
+	  }
+	});
+
+	function pointSymbol (symbolJson, options) {
+	  return new PointSymbol(symbolJson, options);
+	}
+
+	var LineSymbol = Symbol.extend({
+	  statics: {
+	    // Not implemented 'esriSLSNull'
+	    LINETYPES: ['esriSLSDash', 'esriSLSDot', 'esriSLSDashDotDot', 'esriSLSDashDot', 'esriSLSSolid']
+	  },
+	  initialize: function (symbolJson, options) {
+	    Symbol.prototype.initialize.call(this, symbolJson, options);
+	    this._fillStyles();
+	  },
+
+	  _fillStyles: function () {
+	    // set the defaults that show up on arcgis online
+	    this._styles.lineCap = 'butt';
+	    this._styles.lineJoin = 'miter';
+	    this._styles.fill = false;
+	    this._styles.weight = 0;
+
+	    if (!this._symbolJson) {
+	      return this._styles;
+	    }
+
+	    if (this._symbolJson.color) {
+	      this._styles.color = this.colorValue(this._symbolJson.color);
+	      this._styles.opacity = this.alphaValue(this._symbolJson.color);
+	    }
+
+	    if (!isNaN(this._symbolJson.width)) {
+	      this._styles.weight = this.pixelValue(this._symbolJson.width);
+
+	      var dashValues = [];
+
+	      switch (this._symbolJson.style) {
+	        case 'esriSLSDash':
+	          dashValues = [4, 3];
+	          break;
+	        case 'esriSLSDot':
+	          dashValues = [1, 3];
+	          break;
+	        case 'esriSLSDashDot':
+	          dashValues = [8, 3, 1, 3];
+	          break;
+	        case 'esriSLSDashDotDot':
+	          dashValues = [8, 3, 1, 3, 1, 3];
+	          break;
+	      }
+
+	      // use the dash values and the line weight to set dash array
+	      if (dashValues.length > 0) {
+	        for (var i = 0; i < dashValues.length; i++) {
+	          dashValues[i] *= this._styles.weight;
+	        }
+
+	        this._styles.dashArray = dashValues.join(',');
+	      }
+	    }
+	  },
+
+	  style: function (feature, visualVariables) {
+	    if (!this._isDefault && visualVariables) {
+	      if (visualVariables.sizeInfo) {
+	        var calculatedSize = this.pixelValue(this.getSize(feature, visualVariables.sizeInfo));
+	        if (calculatedSize) {
+	          this._styles.weight = calculatedSize;
+	        }
+	      }
+	      if (visualVariables.colorInfo) {
+	        var color = this.getColor(feature, visualVariables.colorInfo);
+	        if (color) {
+	          this._styles.color = this.colorValue(color);
+	          this._styles.opacity = this.alphaValue(color);
+	        }
+	      }
+	    }
+	    return this._styles;
+	  }
+	});
+
+	function lineSymbol (symbolJson, options) {
+	  return new LineSymbol(symbolJson, options);
+	}
+
+	var PolygonSymbol = Symbol.extend({
+	  statics: {
+	    // not implemented: 'esriSFSBackwardDiagonal','esriSFSCross','esriSFSDiagonalCross','esriSFSForwardDiagonal','esriSFSHorizontal','esriSFSNull','esriSFSVertical'
+	    POLYGONTYPES: ['esriSFSSolid']
+	  },
+	  initialize: function (symbolJson, options) {
+	    Symbol.prototype.initialize.call(this, symbolJson, options);
+	    if (symbolJson) {
+	      this._lineStyles = lineSymbol(symbolJson.outline, options).style();
+	      this._fillStyles();
+	    }
+	  },
+
+	  _fillStyles: function () {
+	    if (this._lineStyles) {
+	      if (this._lineStyles.weight === 0) {
+	        // when weight is 0, setting the stroke to false can still look bad
+	        // (gaps between the polygons)
+	        this._styles.stroke = false;
+	      } else {
+	        // copy the line symbol styles into this symbol's styles
+	        for (var styleAttr in this._lineStyles) {
+	          this._styles[styleAttr] = this._lineStyles[styleAttr];
+	        }
+	      }
+	    }
+
+	    // set the fill for the polygon
+	    if (this._symbolJson) {
+	      if (this._symbolJson.color &&
+	          // don't fill polygon if type is not supported
+	          PolygonSymbol.POLYGONTYPES.indexOf(this._symbolJson.style >= 0)) {
+	        this._styles.fill = true;
+	        this._styles.fillColor = this.colorValue(this._symbolJson.color);
+	        this._styles.fillOpacity = this.alphaValue(this._symbolJson.color);
+	      } else {
+	        this._styles.fill = false;
+	        this._styles.fillOpacity = 0;
+	      }
+	    }
+	  },
+
+	  style: function (feature, visualVariables) {
+	    if (!this._isDefault && visualVariables && visualVariables.colorInfo) {
+	      var color = this.getColor(feature, visualVariables.colorInfo);
+	      if (color) {
+	        this._styles.fillColor = this.colorValue(color);
+	        this._styles.fillOpacity = this.alphaValue(color);
+	      }
+	    }
+	    return this._styles;
+	  }
+	});
+
+	function polygonSymbol (symbolJson, options) {
+	  return new PolygonSymbol(symbolJson, options);
+	}
+
+	var Renderer = L.Class.extend({
+	  options: {
+	    proportionalPolygon: false,
+	    clickable: true
+	  },
+
+	  initialize: function (rendererJson, options) {
+	    this._rendererJson = rendererJson;
+	    this._pointSymbols = false;
+	    this._symbols = [];
+	    this._visualVariables = this._parseVisualVariables(rendererJson.visualVariables);
+	    L.Util.setOptions(this, options);
+	  },
+
+	  _parseVisualVariables: function (visualVariables) {
+	    var visVars = {};
+	    if (visualVariables) {
+	      for (var i = 0; i < visualVariables.length; i++) {
+	        visVars[visualVariables[i].type] = visualVariables[i];
+	      }
+	    }
+	    return visVars;
+	  },
+
+	  _createDefaultSymbol: function () {
+	    if (this._rendererJson.defaultSymbol) {
+	      this._defaultSymbol = this._newSymbol(this._rendererJson.defaultSymbol);
+	      this._defaultSymbol._isDefault = true;
+	    }
+	  },
+
+	  _newSymbol: function (symbolJson) {
+	    if (symbolJson.type === 'esriSMS' || symbolJson.type === 'esriPMS') {
+	      this._pointSymbols = true;
+	      return pointSymbol(symbolJson, this.options);
+	    }
+	    if (symbolJson.type === 'esriSLS') {
+	      return lineSymbol(symbolJson, this.options);
+	    }
+	    if (symbolJson.type === 'esriSFS') {
+	      return polygonSymbol(symbolJson, this.options);
+	    }
+	  },
+
+	  _getSymbol: function () {
+	    // override
+	  },
+
+	  attachStylesToLayer: function (layer) {
+	    if (this._pointSymbols) {
+	      layer.options.pointToLayer = L.Util.bind(this.pointToLayer, this);
+	    } else {
+	      layer.options.style = L.Util.bind(this.style, this);
+	      layer._originalStyle = layer.options.style;
+	    }
+	  },
+
+	  pointToLayer: function (geojson, latlng) {
+	    var sym = this._getSymbol(geojson);
+	    if (sym && sym.pointToLayer) {
+	      // right now custom panes are the only option pushed through
+	      return sym.pointToLayer(geojson, latlng, this._visualVariables, this.options);
+	    }
+	    // invisible symbology
+	    return L.circleMarker(latlng, {radius: 0, opacity: 0});
+	  },
+
+	  style: function (feature) {
+	    var userStyles;
+	    if (this.options.userDefinedStyle) {
+	      userStyles = this.options.userDefinedStyle(feature);
+	    }
+	    // find the symbol to represent this feature
+	    var sym = this._getSymbol(feature);
+	    if (sym) {
+	      return this.mergeStyles(sym.style(feature, this._visualVariables), userStyles);
+	    } else {
+	      // invisible symbology
+	      return this.mergeStyles({opacity: 0, fillOpacity: 0}, userStyles);
+	    }
+	  },
+
+	  mergeStyles: function (styles, userStyles) {
+	    var mergedStyles = {};
+	    var attr;
+	    // copy renderer style attributes
+	    for (attr in styles) {
+	      if (styles.hasOwnProperty(attr)) {
+	        mergedStyles[attr] = styles[attr];
+	      }
+	    }
+	    // override with user defined style attributes
+	    if (userStyles) {
+	      for (attr in userStyles) {
+	        if (userStyles.hasOwnProperty(attr)) {
+	          mergedStyles[attr] = userStyles[attr];
+	        }
+	      }
+	    }
+	    return mergedStyles;
+	  }
+	});
+
+	var SimpleRenderer = Renderer.extend({
+	  initialize: function (rendererJson, options) {
+	    Renderer.prototype.initialize.call(this, rendererJson, options);
+	    this._createSymbol();
+	  },
+
+	  _createSymbol: function () {
+	    if (this._rendererJson.symbol) {
+	      this._symbols.push(this._newSymbol(this._rendererJson.symbol));
+	    }
+	  },
+
+	  _getSymbol: function () {
+	    return this._symbols[0];
+	  }
+	});
+
+	function simpleRenderer (rendererJson, options) {
+	  return new SimpleRenderer(rendererJson, options);
+	}
+
+	var ClassBreaksRenderer = Renderer.extend({
+	  initialize: function (rendererJson, options) {
+	    Renderer.prototype.initialize.call(this, rendererJson, options);
+	    this._field = this._rendererJson.field;
+	    if (this._rendererJson.normalizationType && this._rendererJson.normalizationType === 'esriNormalizeByField') {
+	      this._normalizationField = this._rendererJson.normalizationField;
+	    }
+	    this._createSymbols();
+	  },
+
+	  _createSymbols: function () {
+	    var symbol;
+	    var classbreaks = this._rendererJson.classBreakInfos;
+
+	    this._symbols = [];
+
+	    // create a symbol for each class break
+	    for (var i = classbreaks.length - 1; i >= 0; i--) {
+	      if (this.options.proportionalPolygon && this._rendererJson.backgroundFillSymbol) {
+	        symbol = this._newSymbol(this._rendererJson.backgroundFillSymbol);
+	      } else {
+	        symbol = this._newSymbol(classbreaks[i].symbol);
+	      }
+	      symbol.val = classbreaks[i].classMaxValue;
+	      this._symbols.push(symbol);
+	    }
+	    // sort the symbols in ascending value
+	    this._symbols.sort(function (a, b) {
+	      return a.val > b.val ? 1 : -1;
+	    });
+	    this._createDefaultSymbol();
+	    this._maxValue = this._symbols[this._symbols.length - 1].val;
+	  },
+
+	  _getSymbol: function (feature) {
+	    var val = feature.properties[this._field];
+	    if (this._normalizationField) {
+	      var normValue = feature.properties[this._normalizationField];
+	      if (!isNaN(normValue) && normValue !== 0) {
+	        val = val / normValue;
+	      } else {
+	        return this._defaultSymbol;
+	      }
+	    }
+
+	    if (val > this._maxValue) {
+	      return this._defaultSymbol;
+	    }
+	    var symbol = this._symbols[0];
+	    for (var i = this._symbols.length - 1; i >= 0; i--) {
+	      if (val > this._symbols[i].val) {
+	        break;
+	      }
+	      symbol = this._symbols[i];
+	    }
+	    return symbol;
+	  }
+	});
+
+	function classBreaksRenderer (rendererJson, options) {
+	  return new ClassBreaksRenderer(rendererJson, options);
+	}
+
+	var UniqueValueRenderer = Renderer.extend({
+	  initialize: function (rendererJson, options) {
+	    Renderer.prototype.initialize.call(this, rendererJson, options);
+	    this._field = this._rendererJson.field1;
+	    this._createSymbols();
+	  },
+
+	  _createSymbols: function () {
+	    var symbol;
+	    var uniques = this._rendererJson.uniqueValueInfos;
+
+	    // create a symbol for each unique value
+	    for (var i = uniques.length - 1; i >= 0; i--) {
+	      symbol = this._newSymbol(uniques[i].symbol);
+	      symbol.val = uniques[i].value;
+	      this._symbols.push(symbol);
+	    }
+	    this._createDefaultSymbol();
+	  },
+
+	  _getSymbol: function (feature) {
+	    var val = feature.properties[this._field];
+	    // accumulate values if there is more than one field defined
+	    if (this._rendererJson.fieldDelimiter && this._rendererJson.field2) {
+	      var val2 = feature.properties[this._rendererJson.field2];
+	      if (val2) {
+	        val += this._rendererJson.fieldDelimiter + val2;
+	        var val3 = feature.properties[this._rendererJson.field3];
+	        if (val3) {
+	          val += this._rendererJson.fieldDelimiter + val3;
+	        }
+	      }
+	    }
+
+	    var symbol = this._defaultSymbol;
+	    for (var i = this._symbols.length - 1; i >= 0; i--) {
+	      // using the === operator does not work if the field
+	      // of the unique renderer is not a string
+	      /*eslint-disable */
+	      if (this._symbols[i].val == val) {
+	        symbol = this._symbols[i];
+	      }
+	      /*eslint-enable */
+	    }
+	    return symbol;
+	  }
+	});
+
+	function uniqueValueRenderer (rendererJson, options) {
+	  return new UniqueValueRenderer(rendererJson, options);
+	}
+
+	L.esri.FeatureLayer.addInitHook(function () {
+	  if (this.options.ignoreRenderer) {
+	    return;
+	  }
+	  var oldOnAdd = L.Util.bind(this.onAdd, this);
+	  var oldUnbindPopup = L.Util.bind(this.unbindPopup, this);
+	  var oldOnRemove = L.Util.bind(this.onRemove, this);
+	  L.Util.bind(this.createNewLayer, this);
+
+	  this.metadata(function (error, response) {
+	    if (error) {
+	      return;
+	    } if (response && response.drawingInfo) {
+	      this._setRenderers(response);
+	    } if (this._alreadyAdded) {
+	      this.setStyle(this._originalStyle);
+	    }
+	  }, this);
+
+	  this.onAdd = function (map) {
+	    oldOnAdd(map);
+	    this._addPointLayer(map);
+	    this._alreadyAdded = true;
+	  };
+
+	  this.onRemove = function (map) {
+	    oldOnRemove(map);
+	    if (this._pointLayer) {
+	      var pointLayers = this._pointLayer.getLayers();
+	      for (var i in pointLayers) {
+	        map.removeLayer(pointLayers[i]);
+	      }
+	    }
+	  };
+
+	  this.unbindPopup = function () {
+	    oldUnbindPopup();
+	    if (this._pointLayer) {
+	      var pointLayers = this._pointLayer.getLayers();
+	      for (var i in pointLayers) {
+	        pointLayers[i].unbindPopup();
+	      }
+	    }
+	  };
+
+	  this._addPointLayer = function (map) {
+	    if (this._pointLayer) {
+	      this._pointLayer.addTo(map);
+	      this._pointLayer.bringToFront();
+	    }
+	  };
+
+	  this._createPointLayer = function () {
+	    if (!this._pointLayer) {
+	      this._pointLayer = L.geoJson();
+	      // store the feature ids that have already been added to the map
+	      this._pointLayerIds = {};
+
+	      if (this._popup) {
+	        var popupFunction = function (feature, layer) {
+	          layer.bindPopup(this._popup(feature, layer), this._popupOptions);
+	        };
+	        this._pointLayer.options.onEachFeature = L.Util.bind(popupFunction, this);
+	      }
+	    }
+	  };
+
+	  this.createNewLayer = function (geojson) {
+	    var fLayer = L.GeoJSON.geometryToLayer(geojson, this.options);
+
+	    // add a point layer when the polygon is represented as proportional marker symbols
+	    if (this._hasProportionalSymbols) {
+	      var centroid = this.getPolygonCentroid(geojson.geometry.coordinates);
+	      if (!(isNaN(centroid[0]) || isNaN(centroid[0]))) {
+	        this._createPointLayer();
+
+	        var featureId = geojson.id.toString();
+	        // only add the feature if it does not already exist on the map
+	        if (!this._pointLayerIds[featureId]) {
+	          var pointjson = this.getPointJson(geojson, centroid);
+
+	          this._pointLayer.addData(pointjson);
+	          this._pointLayerIds[featureId] = true;
+	        }
+
+	        this._pointLayer.bringToFront();
+	      }
+	    }
+	    return fLayer;
+	  };
+
+	  this.getPolygonCentroid = function (coordinates) {
+	    var pts = coordinates[0][0];
+	    if (pts.length === 2) {
+	      pts = coordinates[0];
+	    }
+
+	    var twicearea = 0;
+	    var x = 0;
+	    var y = 0;
+	    var nPts = pts.length;
+	    var p1;
+	    var p2;
+	    var f;
+
+	    for (var i = 0, j = nPts - 1; i < nPts; j = i++) {
+	      p1 = pts[i]; p2 = pts[j];
+	      twicearea += p1[0] * p2[1];
+	      twicearea -= p1[1] * p2[0];
+	      f = p1[0] * p2[1] - p2[0] * p1[1];
+	      x += (p1[0] + p2[0]) * f;
+	      y += (p1[1] + p2[1]) * f;
+	    }
+	    f = twicearea * 3;
+	    return [x / f, y / f];
+	  };
+
+	  this.getPointJson = function (geojson, centroid) {
+	    return {
+	      type: 'Feature',
+	      properties: geojson.properties,
+	      id: geojson.id,
+	      geometry: {
+	        type: 'Point',
+	        coordinates: [centroid[0], centroid[1]]
+	      }
+	    };
+	  };
+
+	  this._checkForProportionalSymbols = function (geometryType, renderer) {
+	    this._hasProportionalSymbols = false;
+	    if (geometryType === 'esriGeometryPolygon') {
+	      if (renderer.backgroundFillSymbol) {
+	        this._hasProportionalSymbols = true;
+	      }
+	      // check to see if the first symbol in the classbreaks is a marker symbol
+	      if (renderer.classBreakInfos && renderer.classBreakInfos.length) {
+	        var sym = renderer.classBreakInfos[0].symbol;
+	        if (sym && (sym.type === 'esriSMS' || sym.type === 'esriPMS')) {
+	          this._hasProportionalSymbols = true;
+	        }
+	      }
+	    }
+	  };
+
+	  this._setRenderers = function (geojson) {
+	    var rend;
+	    var rendererInfo = geojson.drawingInfo.renderer;
+
+	    var options = {
+	      url: this.options.url
+	    };
+
+	    if (this.options.token) {
+	      options.token = this.options.token;
+	    }
+	    if (this.options.pane) {
+	      options.pane = this.options.pane;
+	    }
+	    if (geojson.drawingInfo.transparency) {
+	      options.layerTransparency = geojson.drawingInfo.transparency;
+	    }
+	    if (this.options.style) {
+	      options.userDefinedStyle = this.options.style;
+	    }
+
+	    switch (rendererInfo.type) {
+	      case 'classBreaks':
+	        this._checkForProportionalSymbols(geojson.geometryType, rendererInfo);
+	        if (this._hasProportionalSymbols) {
+	          this._createPointLayer();
+	          var pRend = classBreaksRenderer(rendererInfo, options);
+	          pRend.attachStylesToLayer(this._pointLayer);
+	          options.proportionalPolygon = true;
+	        }
+	        rend = classBreaksRenderer(rendererInfo, options);
+	        break;
+	      case 'uniqueValue':
+	        rend = uniqueValueRenderer(rendererInfo, options);
+	        break;
+	      default:
+	        rend = simpleRenderer(rendererInfo, options);
+	    }
+	    rend.attachStylesToLayer(this);
+	  };
+	});
+
+	exports.VERSION = version;
+	exports.Renderer = Renderer;
+	exports.SimpleRenderer = SimpleRenderer;
+	exports.simpleRenderer = simpleRenderer;
+	exports.ClassBreaksRenderer = ClassBreaksRenderer;
+	exports.classBreaksRenderer = classBreaksRenderer;
+	exports.UniqueValueRenderer = UniqueValueRenderer;
+	exports.uniqueValueRenderer = uniqueValueRenderer;
+	exports.Symbol = Symbol;
+	exports.PointSymbol = PointSymbol;
+	exports.pointSymbol = pointSymbol;
+	exports.LineSymbol = LineSymbol;
+	exports.lineSymbol = lineSymbol;
+	exports.PolygonSymbol = PolygonSymbol;
+	exports.polygonSymbol = polygonSymbol;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esri-leaflet-renderers-debug.js","sources":["../package.json","../src/Symbols/Symbol.js","../node_modules/leaflet-shape-markers/src/ShapeMarker.js","../node_modules/leaflet-shape-markers/src/CrossMarker.js","../node_modules/leaflet-shape-markers/src/XMarker.js","../node_modules/leaflet-shape-markers/src/SquareMarker.js","../node_modules/leaflet-shape-markers/src/DiamondMarker.js","../src/Symbols/PointSymbol.js","../src/Symbols/LineSymbol.js","../src/Symbols/PolygonSymbol.js","../src/Renderers/Renderer.js","../src/Renderers/SimpleRenderer.js","../src/Renderers/ClassBreaksRenderer.js","../src/Renderers/UniqueValueRenderer.js","../src/FeatureLayerHook.js"],"sourcesContent":["{\n  \"name\": \"esri-leaflet-renderers\",\n  \"description\": \"esri-leaflet plugin for rendering\",\n  \"version\": \"2.0.2\",\n  \"author\": \"Rachel Nehmer <rnehmer@esri.com>\",\n  \"bugs\": {\n    \"url\": \"https://github.com/esri/esri-leaflet-renderers/issues\"\n  },\n  \"contributors\": [\n    \"Rachel Nehmer <rnehmer@esri.com>\",\n    \"John Gravois <jgravois@esri.com>\"\n  ],\n  \"dependencies\": {\n     \"esri-leaflet\": \"^2.0.0-beta.8\",\n     \"leaflet\": \"^1.0.0-beta.2\",\n     \"leaflet-shape-markers\": \"^1.0.4\"\n  },\n  \"devDependencies\": {\n    \"babelify\": \"^6.1.3\",\n    \"chai\": \"2.3.0\",\n    \"gh-release\": \"^2.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"isparta\": \"^3.0.3\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^0.12.24\",\n    \"karma-chai-sinon\": \"^0.1.3\",\n    \"karma-coverage\": \"^0.5.3\",\n    \"karma-mocha\": \"^0.1.0\",\n    \"karma-mocha-reporter\": \"^0.2.5\",\n    \"karma-phantomjs-launcher\": \"^0.1.4\",\n    \"karma-sourcemap-loader\": \"^0.3.5\",\n    \"mkdirp\": \"^0.5.1\",\n    \"mocha\": \"^2.3.4\",\n    \"phantomjs\": \"^1.9.17\",\n    \"rollup\": \"^0.25.4\",\n    \"rollup-plugin-json\": \"^2.0.0\",\n    \"rollup-plugin-node-resolve\": \"^1.4.0\",\n    \"rollup-plugin-uglify\": \"^0.2.0\",\n    \"semistandard\": \"^7.0.5\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.7.0\",\n    \"uglify-js\": \"^2.4.23\",\n    \"watch\": \"^0.17.1\"\n  },\n  \"homepage\": \"http://esri.github.io/esri-leaflet\",\n  \"jsnext:main\": \"src/EsriLeafletRenderers.js\",\n  \"jspm\": {\n    \"registry\": \"npm\",\n    \"format\": \"es6\",\n    \"main\": \"src/EsriLeafletRenderers.js\"\n  },\n  \"keywords\": [\n    \"arcgis\",\n    \"esri\",\n    \"esri leaflet\",\n    \"gis\",\n    \"leaflet plugin\",\n    \"mapping\",\n    \"renderers\",\n    \"symbology\"\n  ],\n  \"license\": \"Apache-2.0\",\n  \"main\": \"dist/esri-leaflet-renderers-debug.js\",\n  \"browser\": \"dist/esri-leaflet-renderers-debug.js\",\n  \"readmeFilename\": \"README.md\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git@github.com:Esri/esri-leaflet-renderers.git\"\n  },\n  \"scripts\": {\n\n    \"prebuild\": \"mkdirp dist\",\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n    \"lint\": \"semistandard src/**/*.js\",\n    \"prepublish\": \"npm run build\",\n    \"pretest\": \"npm run build\",\n    \"release\": \"./scripts/release.sh\",\n    \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\",\n    \"test\": \"npm run lint && npm run build && karma start\"\n  }\n}\n","import L from 'leaflet';\n\nexport var Symbol = L.Class.extend({\n  initialize: function (symbolJson, options) {\n    this._symbolJson = symbolJson;\n    this.val = null;\n    this._styles = {};\n    this._isDefault = false;\n    this._layerTransparency = 1;\n    if (options && options.layerTransparency) {\n      this._layerTransparency = 1 - (options.layerTransparency / 100.0);\n    }\n  },\n\n  // the geojson values returned are in points\n  pixelValue: function (pointValue) {\n    return pointValue * 1.333;\n  },\n\n  // color is an array [r,g,b,a]\n  colorValue: function (color) {\n    return 'rgb(' + color[0] + ',' + color[1] + ',' + color[2] + ')';\n  },\n\n  alphaValue: function (color) {\n    var alpha = color[3] / 255.0;\n    return alpha * this._layerTransparency;\n  },\n\n  getSize: function (feature, sizeInfo) {\n    var attr = feature.properties;\n    var field = sizeInfo.field;\n    var size = 0;\n    var featureValue = null;\n\n    if (field) {\n      featureValue = attr[field];\n      var minSize = sizeInfo.minSize;\n      var maxSize = sizeInfo.maxSize;\n      var minDataValue = sizeInfo.minDataValue;\n      var maxDataValue = sizeInfo.maxDataValue;\n      var featureRatio;\n      var normField = sizeInfo.normalizationField;\n      var normValue = attr ? parseFloat(attr[normField]) : undefined;\n\n      if (featureValue === null || (normField && ((isNaN(normValue) || normValue === 0)))) {\n        return null;\n      }\n\n      if (!isNaN(normValue)) {\n        featureValue /= normValue;\n      }\n\n      if (minSize !== null && maxSize !== null && minDataValue !== null && maxDataValue !== null) {\n        if (featureValue <= minDataValue) {\n          size = minSize;\n        } else if (featureValue >= maxDataValue) {\n          size = maxSize;\n        } else {\n          featureRatio = (featureValue - minDataValue) / (maxDataValue - minDataValue);\n          size = minSize + (featureRatio * (maxSize - minSize));\n        }\n      }\n      size = isNaN(size) ? 0 : size;\n    }\n    return size;\n  },\n\n  getColor: function (feature, colorInfo) {\n    // required information to get color\n    if (!(feature.properties && colorInfo && colorInfo.field && colorInfo.stops)) {\n      return null;\n    }\n\n    var attr = feature.properties;\n    var featureValue = attr[colorInfo.field];\n    var lowerBoundColor, upperBoundColor, lowerBound, upperBound;\n    var normField = colorInfo.normalizationField;\n    var normValue = attr ? parseFloat(attr[normField]) : undefined;\n    if (featureValue === null || (normField && ((isNaN(normValue) || normValue === 0)))) {\n      return null;\n    }\n\n    if (!isNaN(normValue)) {\n      featureValue /= normValue;\n    }\n\n    if (featureValue <= colorInfo.stops[0].value) {\n      return colorInfo.stops[0].color;\n    }\n    var lastStop = colorInfo.stops[colorInfo.stops.length - 1];\n    if (featureValue >= lastStop.value) {\n      return lastStop.color;\n    }\n\n    // go through the stops to find min and max\n    for (var i = 0; i < colorInfo.stops.length; i++) {\n      var stopInfo = colorInfo.stops[i];\n\n      if (stopInfo.value <= featureValue) {\n        lowerBoundColor = stopInfo.color;\n        lowerBound = stopInfo.value;\n      } else if (stopInfo.value > featureValue) {\n        upperBoundColor = stopInfo.color;\n        upperBound = stopInfo.value;\n        break;\n      }\n    }\n\n    // feature falls between two stops, interplate the colors\n    if (!isNaN(lowerBound) && !isNaN(upperBound)) {\n      var range = upperBound - lowerBound;\n      if (range > 0) {\n        // more weight the further it is from the lower bound\n        var upperBoundColorWeight = (featureValue - lowerBound) / range;\n        if (upperBoundColorWeight) {\n          // more weight the further it is from the upper bound\n          var lowerBoundColorWeight = (upperBound - featureValue) / range;\n          if (lowerBoundColorWeight) {\n            // interpolate the lower and upper bound color by applying the\n            // weights to each of the rgba colors and adding them together\n            var interpolatedColor = [];\n            for (var j = 0; j < 4; j++) {\n              interpolatedColor[j] = Math.round(lowerBoundColor[j] * lowerBoundColorWeight + upperBoundColor[j] * upperBoundColorWeight);\n            }\n            return interpolatedColor;\n          } else {\n            // no difference between featureValue and upperBound, 100% of upperBoundColor\n            return upperBoundColor;\n          }\n        } else {\n          // no difference between featureValue and lowerBound, 100% of lowerBoundColor\n          return lowerBoundColor;\n        }\n      }\n    }\n    // if we get to here, none of the cases apply so return null\n    return null;\n  }\n});\n\n// export function symbol (symbolJson) {\n//   return new Symbol(symbolJson);\n// }\n\nexport default Symbol;\n","import L from 'leaflet';\n\nexport var ShapeMarker = L.Path.extend({\n\n  initialize: function (latlng, size, options) {\n    L.setOptions(this, options);\n    this._size = size;\n    this._latlng = L.latLng(latlng);\n    this._svgCanvasIncludes();\n  },\n\n  _svgCanvasIncludes: function () {\n    // implement in sub class\n  },\n\n  _project: function () {\n    this._point = this._map.latLngToLayerPoint(this._latlng);\n  },\n\n  _update: function () {\n    if (this._map) {\n      this._updatePath();\n    }\n  },\n\n  _updatePath: function () {\n    // implement in sub class\n  },\n\n  setLatLng: function (latlng) {\n    this._latlng = L.latLng(latlng);\n    this.redraw();\n    return this.fire('move', {latlng: this._latlng});\n  },\n\n  getLatLng: function () {\n    return this._latlng;\n  },\n\n  setSize: function (size) {\n    this._size = size;\n    return this.redraw();\n  },\n\n  getSize: function () {\n    return this._size;\n  }\n});\n","import L from 'leaflet';\nimport { ShapeMarker } from './ShapeMarker';\n\nexport var CrossMarker = ShapeMarker.extend({\n\n  initialize: function (latlng, size, options) {\n    ShapeMarker.prototype.initialize.call(this, latlng, size, options);\n  },\n\n  _updatePath: function () {\n    this._renderer._updateCrossMarker(this);\n  },\n\n  _svgCanvasIncludes: function () {\n    L.Canvas.include({\n      _updateCrossMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n        var ctx = this._ctx;\n\n        ctx.beginPath();\n        ctx.moveTo(latlng.x, latlng.y + offset);\n        ctx.lineTo(latlng.x, latlng.y - offset);\n        this._fillStroke(ctx, layer);\n\n        ctx.moveTo(latlng.x - offset, latlng.y);\n        ctx.lineTo(latlng.x + offset, latlng.y);\n        this._fillStroke(ctx, layer);\n      }\n    });\n\n    L.SVG.include({\n      _updateCrossMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n\n        if (L.Browser.vml) {\n          latlng._round();\n          offset = Math.round(offset);\n        }\n\n        var str = 'M' + latlng.x + ',' + (latlng.y + offset) +\n          'L' + latlng.x + ',' + (latlng.y - offset) +\n          'M' + (latlng.x - offset) + ',' + latlng.y +\n          'L' + (latlng.x + offset) + ',' + latlng.y;\n\n        this._setPath(layer, str);\n      }\n    });\n  }\n});\n\nexport var crossMarker = function (latlng, size, options) {\n  return new CrossMarker(latlng, size, options);\n};\n\nexport default crossMarker;\n","import L from 'leaflet';\nimport { ShapeMarker } from './ShapeMarker';\n\nexport var XMarker = ShapeMarker.extend({\n\n  initialize: function (latlng, size, options) {\n    ShapeMarker.prototype.initialize.call(this, latlng, size, options);\n  },\n\n  _updatePath: function () {\n    this._renderer._updateXMarker(this);\n  },\n\n  _svgCanvasIncludes: function () {\n    L.Canvas.include({\n      _updateXMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n        var ctx = this._ctx;\n\n        ctx.beginPath();\n\n        ctx.moveTo(latlng.x + offset, latlng.y + offset);\n        ctx.lineTo(latlng.x - offset, latlng.y - offset);\n        this._fillStroke(ctx, layer);\n      }\n    });\n\n    L.SVG.include({\n      _updateXMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n\n        if (L.Browser.vml) {\n          latlng._round();\n          offset = Math.round(offset);\n        }\n\n        var str = 'M' + (latlng.x + offset) + ',' + (latlng.y + offset) +\n          'L' + (latlng.x - offset) + ',' + (latlng.y - offset) +\n          'M' + (latlng.x - offset) + ',' + (latlng.y + offset) +\n          'L' + (latlng.x + offset) + ',' + (latlng.y - offset);\n\n        this._setPath(layer, str);\n      }\n    });\n  }\n});\n\nexport var xMarker = function (latlng, size, options) {\n  return new XMarker(latlng, size, options);\n};\n\nexport default xMarker;\n","import L from 'leaflet';\nimport { ShapeMarker } from './ShapeMarker';\n\nexport var SquareMarker = ShapeMarker.extend({\n  options: {\n    fill: true\n  },\n\n  initialize: function (latlng, size, options) {\n    ShapeMarker.prototype.initialize.call(this, latlng, size, options);\n  },\n\n  _updatePath: function () {\n    this._renderer._updateSquareMarker(this);\n  },\n\n  _svgCanvasIncludes: function () {\n    L.Canvas.include({\n      _updateSquareMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n        var ctx = this._ctx;\n\n        ctx.beginPath();\n\n        ctx.moveTo(latlng.x + offset, latlng.y + offset);\n        ctx.lineTo(latlng.x - offset, latlng.y + offset);\n        ctx.lineTo(latlng.x - offset, latlng.y - offset);\n        ctx.lineTo(latlng.x + offset, latlng.y - offset);\n\n        ctx.closePath();\n\n        this._fillStroke(ctx, layer);\n      }\n    });\n\n    L.SVG.include({\n      _updateSquareMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n\n        if (L.Browser.vml) {\n          latlng._round();\n          offset = Math.round(offset);\n        }\n\n        var str = 'M' + (latlng.x + offset) + ',' + (latlng.y + offset) +\n          'L' + (latlng.x - offset) + ',' + (latlng.y + offset) +\n          'L' + (latlng.x - offset) + ',' + (latlng.y - offset) +\n          'L' + (latlng.x + offset) + ',' + (latlng.y - offset);\n\n        str = str + (L.Browser.svg ? 'z' : 'x');\n\n        this._setPath(layer, str);\n      }\n    });\n  }\n});\n\nexport var squareMarker = function (latlng, size, options) {\n  return new SquareMarker(latlng, size, options);\n};\n\nexport default squareMarker;\n","import L from 'leaflet';\nimport { ShapeMarker } from './ShapeMarker';\n\nexport var DiamondMarker = ShapeMarker.extend({\n  options: {\n    fill: true\n  },\n\n  initialize: function (latlng, size, options) {\n    ShapeMarker.prototype.initialize.call(this, latlng, size, options);\n  },\n\n  _updatePath: function () {\n    this._renderer._updateDiamondMarker(this);\n  },\n\n  _svgCanvasIncludes: function () {\n    L.Canvas.include({\n      _updateDiamondMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n        var ctx = this._ctx;\n\n        ctx.beginPath();\n\n        ctx.moveTo(latlng.x, latlng.y + offset);\n        ctx.lineTo(latlng.x - offset, latlng.y);\n        ctx.lineTo(latlng.x, latlng.y - offset);\n        ctx.lineTo(latlng.x + offset, latlng.y);\n\n        ctx.closePath();\n\n        this._fillStroke(ctx, layer);\n      }\n    });\n\n    L.SVG.include({\n      _updateDiamondMarker: function (layer) {\n        var latlng = layer._point;\n        var offset = layer._size / 2.0;\n\n        if (L.Browser.vml) {\n          latlng._round();\n          offset = Math.round(offset);\n        }\n\n        var str = 'M' + latlng.x + ',' + (latlng.y + offset) +\n          'L' + (latlng.x - offset) + ',' + latlng.y +\n          'L' + latlng.x + ',' + (latlng.y - offset) +\n          'L' + (latlng.x + offset) + ',' + latlng.y;\n\n        str = str + (L.Browser.svg ? 'z' : 'x');\n\n        this._setPath(layer, str);\n      }\n    });\n  }\n});\n\nexport var diamondMarker = function (latlng, size, options) {\n  return new DiamondMarker(latlng, size, options);\n};\n\nexport default diamondMarker;\n","import L from 'leaflet';\nimport Symbol from './Symbol';\nimport {squareMarker, xMarker, crossMarker, diamondMarker} from 'leaflet-shape-markers';\n\nexport var PointSymbol = Symbol.extend({\n\n  statics: {\n    MARKERTYPES: ['esriSMSCircle', 'esriSMSCross', 'esriSMSDiamond', 'esriSMSSquare', 'esriSMSX', 'esriPMS']\n  },\n\n  initialize: function (symbolJson, options) {\n    Symbol.prototype.initialize.call(this, symbolJson, options);\n    if (options) {\n      this.serviceUrl = options.url;\n    }\n    if (symbolJson) {\n      if (symbolJson.type === 'esriPMS') {\n        var url = this.serviceUrl + 'images/' + this._symbolJson.url;\n        this._iconUrl = options && options.token ? url + '?token=' + options.token : url;\n        // leaflet does not allow resizing icons so keep a hash of different\n        // icon sizes to try and keep down on the number of icons created\n        this._icons = {};\n        // create base icon\n        this.icon = this._createIcon(this._symbolJson);\n      } else {\n        this._fillStyles();\n      }\n    }\n  },\n\n  _fillStyles: function () {\n    if (this._symbolJson.outline && this._symbolJson.size > 0) {\n      this._styles.stroke = true;\n      this._styles.weight = this.pixelValue(this._symbolJson.outline.width);\n      this._styles.color = this.colorValue(this._symbolJson.outline.color);\n      this._styles.opacity = this.alphaValue(this._symbolJson.outline.color);\n    } else {\n      this._styles.stroke = false;\n    }\n    if (this._symbolJson.color) {\n      this._styles.fillColor = this.colorValue(this._symbolJson.color);\n      this._styles.fillOpacity = this.alphaValue(this._symbolJson.color);\n    } else {\n      this._styles.fillOpacity = 0;\n    }\n\n    if (this._symbolJson.style === 'esriSMSCircle') {\n      this._styles.radius = this.pixelValue(this._symbolJson.size) / 2.0;\n    }\n  },\n\n  _createIcon: function (options) {\n    var width = this.pixelValue(options.width);\n    var height = width;\n    if (options.height) {\n      height = this.pixelValue(options.height);\n    }\n    var xOffset = width / 2.0;\n    var yOffset = height / 2.0;\n\n    if (options.xoffset) {\n      xOffset += this.pixelValue(options.xoffset);\n    }\n    if (options.yoffset) {\n      yOffset += this.pixelValue(options.yoffset);\n    }\n\n    var icon = L.icon({\n      iconUrl: this._iconUrl,\n      iconSize: [width, height],\n      iconAnchor: [xOffset, yOffset]\n    });\n    this._icons[options.width.toString()] = icon;\n    return icon;\n  },\n\n  _getIcon: function (size) {\n    // check to see if it is already created by size\n    var icon = this._icons[size.toString()];\n    if (!icon) {\n      icon = this._createIcon({width: size});\n    }\n    return icon;\n  },\n\n  pointToLayer: function (geojson, latlng, visualVariables, options) {\n    var size = this._symbolJson.size || this._symbolJson.width;\n    if (!this._isDefault) {\n      if (visualVariables.sizeInfo) {\n        var calculatedSize = this.getSize(geojson, visualVariables.sizeInfo);\n        if (calculatedSize) {\n          size = calculatedSize;\n        }\n      }\n      if (visualVariables.colorInfo) {\n        var color = this.getColor(geojson, visualVariables.colorInfo);\n        if (color) {\n          this._styles.fillColor = this.colorValue(color);\n          this._styles.fillOpacity = this.alphaValue(color);\n        }\n      }\n    }\n\n    if (this._symbolJson.type === 'esriPMS') {\n      var layerOptions = L.extend({}, {icon: this._getIcon(size)}, options);\n      return L.marker(latlng, layerOptions);\n    }\n    size = this.pixelValue(size);\n\n    switch (this._symbolJson.style) {\n      case 'esriSMSSquare':\n        return squareMarker(latlng, size, L.extend({}, this._styles, options));\n      case 'esriSMSDiamond':\n        return diamondMarker(latlng, size, L.extend({}, this._styles, options));\n      case 'esriSMSCross':\n        return crossMarker(latlng, size, L.extend({}, this._styles, options));\n      case 'esriSMSX':\n        return xMarker(latlng, size, L.extend({}, this._styles, options));\n    }\n    this._styles.radius = size / 2.0;\n    return L.circleMarker(latlng, L.extend({}, this._styles, options));\n  }\n});\n\nexport function pointSymbol (symbolJson, options) {\n  return new PointSymbol(symbolJson, options);\n}\n\nexport default pointSymbol;\n","import Symbol from './Symbol';\n\nexport var LineSymbol = Symbol.extend({\n  statics: {\n    // Not implemented 'esriSLSNull'\n    LINETYPES: ['esriSLSDash', 'esriSLSDot', 'esriSLSDashDotDot', 'esriSLSDashDot', 'esriSLSSolid']\n  },\n  initialize: function (symbolJson, options) {\n    Symbol.prototype.initialize.call(this, symbolJson, options);\n    this._fillStyles();\n  },\n\n  _fillStyles: function () {\n    // set the defaults that show up on arcgis online\n    this._styles.lineCap = 'butt';\n    this._styles.lineJoin = 'miter';\n    this._styles.fill = false;\n    this._styles.weight = 0;\n\n    if (!this._symbolJson) {\n      return this._styles;\n    }\n\n    if (this._symbolJson.color) {\n      this._styles.color = this.colorValue(this._symbolJson.color);\n      this._styles.opacity = this.alphaValue(this._symbolJson.color);\n    }\n\n    if (!isNaN(this._symbolJson.width)) {\n      this._styles.weight = this.pixelValue(this._symbolJson.width);\n\n      var dashValues = [];\n\n      switch (this._symbolJson.style) {\n        case 'esriSLSDash':\n          dashValues = [4, 3];\n          break;\n        case 'esriSLSDot':\n          dashValues = [1, 3];\n          break;\n        case 'esriSLSDashDot':\n          dashValues = [8, 3, 1, 3];\n          break;\n        case 'esriSLSDashDotDot':\n          dashValues = [8, 3, 1, 3, 1, 3];\n          break;\n      }\n\n      // use the dash values and the line weight to set dash array\n      if (dashValues.length > 0) {\n        for (var i = 0; i < dashValues.length; i++) {\n          dashValues[i] *= this._styles.weight;\n        }\n\n        this._styles.dashArray = dashValues.join(',');\n      }\n    }\n  },\n\n  style: function (feature, visualVariables) {\n    if (!this._isDefault && visualVariables) {\n      if (visualVariables.sizeInfo) {\n        var calculatedSize = this.pixelValue(this.getSize(feature, visualVariables.sizeInfo));\n        if (calculatedSize) {\n          this._styles.weight = calculatedSize;\n        }\n      }\n      if (visualVariables.colorInfo) {\n        var color = this.getColor(feature, visualVariables.colorInfo);\n        if (color) {\n          this._styles.color = this.colorValue(color);\n          this._styles.opacity = this.alphaValue(color);\n        }\n      }\n    }\n    return this._styles;\n  }\n});\n\nexport function lineSymbol (symbolJson, options) {\n  return new LineSymbol(symbolJson, options);\n}\n\nexport default lineSymbol;\n","import Symbol from './Symbol';\nimport lineSymbol from './LineSymbol';\n\nexport var PolygonSymbol = Symbol.extend({\n  statics: {\n    // not implemented: 'esriSFSBackwardDiagonal','esriSFSCross','esriSFSDiagonalCross','esriSFSForwardDiagonal','esriSFSHorizontal','esriSFSNull','esriSFSVertical'\n    POLYGONTYPES: ['esriSFSSolid']\n  },\n  initialize: function (symbolJson, options) {\n    Symbol.prototype.initialize.call(this, symbolJson, options);\n    if (symbolJson) {\n      this._lineStyles = lineSymbol(symbolJson.outline, options).style();\n      this._fillStyles();\n    }\n  },\n\n  _fillStyles: function () {\n    if (this._lineStyles) {\n      if (this._lineStyles.weight === 0) {\n        // when weight is 0, setting the stroke to false can still look bad\n        // (gaps between the polygons)\n        this._styles.stroke = false;\n      } else {\n        // copy the line symbol styles into this symbol's styles\n        for (var styleAttr in this._lineStyles) {\n          this._styles[styleAttr] = this._lineStyles[styleAttr];\n        }\n      }\n    }\n\n    // set the fill for the polygon\n    if (this._symbolJson) {\n      if (this._symbolJson.color &&\n          // don't fill polygon if type is not supported\n          PolygonSymbol.POLYGONTYPES.indexOf(this._symbolJson.style >= 0)) {\n        this._styles.fill = true;\n        this._styles.fillColor = this.colorValue(this._symbolJson.color);\n        this._styles.fillOpacity = this.alphaValue(this._symbolJson.color);\n      } else {\n        this._styles.fill = false;\n        this._styles.fillOpacity = 0;\n      }\n    }\n  },\n\n  style: function (feature, visualVariables) {\n    if (!this._isDefault && visualVariables && visualVariables.colorInfo) {\n      var color = this.getColor(feature, visualVariables.colorInfo);\n      if (color) {\n        this._styles.fillColor = this.colorValue(color);\n        this._styles.fillOpacity = this.alphaValue(color);\n      }\n    }\n    return this._styles;\n  }\n});\n\nexport function polygonSymbol (symbolJson, options) {\n  return new PolygonSymbol(symbolJson, options);\n}\n\nexport default polygonSymbol;\n","import L from 'leaflet';\n\nimport pointSymbol from '../Symbols/PointSymbol';\nimport lineSymbol from '../Symbols/LineSymbol';\nimport polygonSymbol from '../Symbols/PolygonSymbol';\n\nexport var Renderer = L.Class.extend({\n  options: {\n    proportionalPolygon: false,\n    clickable: true\n  },\n\n  initialize: function (rendererJson, options) {\n    this._rendererJson = rendererJson;\n    this._pointSymbols = false;\n    this._symbols = [];\n    this._visualVariables = this._parseVisualVariables(rendererJson.visualVariables);\n    L.Util.setOptions(this, options);\n  },\n\n  _parseVisualVariables: function (visualVariables) {\n    var visVars = {};\n    if (visualVariables) {\n      for (var i = 0; i < visualVariables.length; i++) {\n        visVars[visualVariables[i].type] = visualVariables[i];\n      }\n    }\n    return visVars;\n  },\n\n  _createDefaultSymbol: function () {\n    if (this._rendererJson.defaultSymbol) {\n      this._defaultSymbol = this._newSymbol(this._rendererJson.defaultSymbol);\n      this._defaultSymbol._isDefault = true;\n    }\n  },\n\n  _newSymbol: function (symbolJson) {\n    if (symbolJson.type === 'esriSMS' || symbolJson.type === 'esriPMS') {\n      this._pointSymbols = true;\n      return pointSymbol(symbolJson, this.options);\n    }\n    if (symbolJson.type === 'esriSLS') {\n      return lineSymbol(symbolJson, this.options);\n    }\n    if (symbolJson.type === 'esriSFS') {\n      return polygonSymbol(symbolJson, this.options);\n    }\n  },\n\n  _getSymbol: function () {\n    // override\n  },\n\n  attachStylesToLayer: function (layer) {\n    if (this._pointSymbols) {\n      layer.options.pointToLayer = L.Util.bind(this.pointToLayer, this);\n    } else {\n      layer.options.style = L.Util.bind(this.style, this);\n      layer._originalStyle = layer.options.style;\n    }\n  },\n\n  pointToLayer: function (geojson, latlng) {\n    var sym = this._getSymbol(geojson);\n    if (sym && sym.pointToLayer) {\n      // right now custom panes are the only option pushed through\n      return sym.pointToLayer(geojson, latlng, this._visualVariables, this.options);\n    }\n    // invisible symbology\n    return L.circleMarker(latlng, {radius: 0, opacity: 0});\n  },\n\n  style: function (feature) {\n    var userStyles;\n    if (this.options.userDefinedStyle) {\n      userStyles = this.options.userDefinedStyle(feature);\n    }\n    // find the symbol to represent this feature\n    var sym = this._getSymbol(feature);\n    if (sym) {\n      return this.mergeStyles(sym.style(feature, this._visualVariables), userStyles);\n    } else {\n      // invisible symbology\n      return this.mergeStyles({opacity: 0, fillOpacity: 0}, userStyles);\n    }\n  },\n\n  mergeStyles: function (styles, userStyles) {\n    var mergedStyles = {};\n    var attr;\n    // copy renderer style attributes\n    for (attr in styles) {\n      if (styles.hasOwnProperty(attr)) {\n        mergedStyles[attr] = styles[attr];\n      }\n    }\n    // override with user defined style attributes\n    if (userStyles) {\n      for (attr in userStyles) {\n        if (userStyles.hasOwnProperty(attr)) {\n          mergedStyles[attr] = userStyles[attr];\n        }\n      }\n    }\n    return mergedStyles;\n  }\n});\n\nexport default Renderer;\n","import Renderer from './Renderer';\n\nexport var SimpleRenderer = Renderer.extend({\n  initialize: function (rendererJson, options) {\n    Renderer.prototype.initialize.call(this, rendererJson, options);\n    this._createSymbol();\n  },\n\n  _createSymbol: function () {\n    if (this._rendererJson.symbol) {\n      this._symbols.push(this._newSymbol(this._rendererJson.symbol));\n    }\n  },\n\n  _getSymbol: function () {\n    return this._symbols[0];\n  }\n});\n\nexport function simpleRenderer (rendererJson, options) {\n  return new SimpleRenderer(rendererJson, options);\n}\n\nexport default simpleRenderer;\n","import Renderer from './Renderer';\n\nexport var ClassBreaksRenderer = Renderer.extend({\n  initialize: function (rendererJson, options) {\n    Renderer.prototype.initialize.call(this, rendererJson, options);\n    this._field = this._rendererJson.field;\n    if (this._rendererJson.normalizationType && this._rendererJson.normalizationType === 'esriNormalizeByField') {\n      this._normalizationField = this._rendererJson.normalizationField;\n    }\n    this._createSymbols();\n  },\n\n  _createSymbols: function () {\n    var symbol;\n    var classbreaks = this._rendererJson.classBreakInfos;\n\n    this._symbols = [];\n\n    // create a symbol for each class break\n    for (var i = classbreaks.length - 1; i >= 0; i--) {\n      if (this.options.proportionalPolygon && this._rendererJson.backgroundFillSymbol) {\n        symbol = this._newSymbol(this._rendererJson.backgroundFillSymbol);\n      } else {\n        symbol = this._newSymbol(classbreaks[i].symbol);\n      }\n      symbol.val = classbreaks[i].classMaxValue;\n      this._symbols.push(symbol);\n    }\n    // sort the symbols in ascending value\n    this._symbols.sort(function (a, b) {\n      return a.val > b.val ? 1 : -1;\n    });\n    this._createDefaultSymbol();\n    this._maxValue = this._symbols[this._symbols.length - 1].val;\n  },\n\n  _getSymbol: function (feature) {\n    var val = feature.properties[this._field];\n    if (this._normalizationField) {\n      var normValue = feature.properties[this._normalizationField];\n      if (!isNaN(normValue) && normValue !== 0) {\n        val = val / normValue;\n      } else {\n        return this._defaultSymbol;\n      }\n    }\n\n    if (val > this._maxValue) {\n      return this._defaultSymbol;\n    }\n    var symbol = this._symbols[0];\n    for (var i = this._symbols.length - 1; i >= 0; i--) {\n      if (val > this._symbols[i].val) {\n        break;\n      }\n      symbol = this._symbols[i];\n    }\n    return symbol;\n  }\n});\n\nexport function classBreaksRenderer (rendererJson, options) {\n  return new ClassBreaksRenderer(rendererJson, options);\n}\n\nexport default classBreaksRenderer;\n","import Renderer from './Renderer';\n\nexport var UniqueValueRenderer = Renderer.extend({\n  initialize: function (rendererJson, options) {\n    Renderer.prototype.initialize.call(this, rendererJson, options);\n    this._field = this._rendererJson.field1;\n    this._createSymbols();\n  },\n\n  _createSymbols: function () {\n    var symbol;\n    var uniques = this._rendererJson.uniqueValueInfos;\n\n    // create a symbol for each unique value\n    for (var i = uniques.length - 1; i >= 0; i--) {\n      symbol = this._newSymbol(uniques[i].symbol);\n      symbol.val = uniques[i].value;\n      this._symbols.push(symbol);\n    }\n    this._createDefaultSymbol();\n  },\n\n  _getSymbol: function (feature) {\n    var val = feature.properties[this._field];\n    // accumulate values if there is more than one field defined\n    if (this._rendererJson.fieldDelimiter && this._rendererJson.field2) {\n      var val2 = feature.properties[this._rendererJson.field2];\n      if (val2) {\n        val += this._rendererJson.fieldDelimiter + val2;\n        var val3 = feature.properties[this._rendererJson.field3];\n        if (val3) {\n          val += this._rendererJson.fieldDelimiter + val3;\n        }\n      }\n    }\n\n    var symbol = this._defaultSymbol;\n    for (var i = this._symbols.length - 1; i >= 0; i--) {\n      // using the === operator does not work if the field\n      // of the unique renderer is not a string\n      /*eslint-disable */\n      if (this._symbols[i].val == val) {\n        symbol = this._symbols[i];\n      }\n      /*eslint-enable */\n    }\n    return symbol;\n  }\n});\n\nexport function uniqueValueRenderer (rendererJson, options) {\n  return new UniqueValueRenderer(rendererJson, options);\n}\n\nexport default uniqueValueRenderer;\n"," import L from 'leaflet';\n\nimport classBreaksRenderer from './Renderers/ClassBreaksRenderer';\nimport uniqueValueRenderer from './Renderers/UniqueValueRenderer';\nimport simpleRenderer from './Renderers/SimpleRenderer';\n\nL.esri.FeatureLayer.addInitHook(function () {\n  if (this.options.ignoreRenderer) {\n    return;\n  }\n  var oldOnAdd = L.Util.bind(this.onAdd, this);\n  var oldUnbindPopup = L.Util.bind(this.unbindPopup, this);\n  var oldOnRemove = L.Util.bind(this.onRemove, this);\n  L.Util.bind(this.createNewLayer, this);\n\n  this.metadata(function (error, response) {\n    if (error) {\n      return;\n    } if (response && response.drawingInfo) {\n      this._setRenderers(response);\n    } if (this._alreadyAdded) {\n      this.setStyle(this._originalStyle);\n    }\n  }, this);\n\n  this.onAdd = function (map) {\n    oldOnAdd(map);\n    this._addPointLayer(map);\n    this._alreadyAdded = true;\n  };\n\n  this.onRemove = function (map) {\n    oldOnRemove(map);\n    if (this._pointLayer) {\n      var pointLayers = this._pointLayer.getLayers();\n      for (var i in pointLayers) {\n        map.removeLayer(pointLayers[i]);\n      }\n    }\n  };\n\n  this.unbindPopup = function () {\n    oldUnbindPopup();\n    if (this._pointLayer) {\n      var pointLayers = this._pointLayer.getLayers();\n      for (var i in pointLayers) {\n        pointLayers[i].unbindPopup();\n      }\n    }\n  };\n\n  this._addPointLayer = function (map) {\n    if (this._pointLayer) {\n      this._pointLayer.addTo(map);\n      this._pointLayer.bringToFront();\n    }\n  };\n\n  this._createPointLayer = function () {\n    if (!this._pointLayer) {\n      this._pointLayer = L.geoJson();\n      // store the feature ids that have already been added to the map\n      this._pointLayerIds = {};\n\n      if (this._popup) {\n        var popupFunction = function (feature, layer) {\n          layer.bindPopup(this._popup(feature, layer), this._popupOptions);\n        };\n        this._pointLayer.options.onEachFeature = L.Util.bind(popupFunction, this);\n      }\n    }\n  };\n\n  this.createNewLayer = function (geojson) {\n    var fLayer = L.GeoJSON.geometryToLayer(geojson, this.options);\n\n    // add a point layer when the polygon is represented as proportional marker symbols\n    if (this._hasProportionalSymbols) {\n      var centroid = this.getPolygonCentroid(geojson.geometry.coordinates);\n      if (!(isNaN(centroid[0]) || isNaN(centroid[0]))) {\n        this._createPointLayer();\n\n        var featureId = geojson.id.toString();\n        // only add the feature if it does not already exist on the map\n        if (!this._pointLayerIds[featureId]) {\n          var pointjson = this.getPointJson(geojson, centroid);\n\n          this._pointLayer.addData(pointjson);\n          this._pointLayerIds[featureId] = true;\n        }\n\n        this._pointLayer.bringToFront();\n      }\n    }\n    return fLayer;\n  };\n\n  this.getPolygonCentroid = function (coordinates) {\n    var pts = coordinates[0][0];\n    if (pts.length === 2) {\n      pts = coordinates[0];\n    }\n\n    var twicearea = 0;\n    var x = 0;\n    var y = 0;\n    var nPts = pts.length;\n    var p1;\n    var p2;\n    var f;\n\n    for (var i = 0, j = nPts - 1; i < nPts; j = i++) {\n      p1 = pts[i]; p2 = pts[j];\n      twicearea += p1[0] * p2[1];\n      twicearea -= p1[1] * p2[0];\n      f = p1[0] * p2[1] - p2[0] * p1[1];\n      x += (p1[0] + p2[0]) * f;\n      y += (p1[1] + p2[1]) * f;\n    }\n    f = twicearea * 3;\n    return [x / f, y / f];\n  };\n\n  this.getPointJson = function (geojson, centroid) {\n    return {\n      type: 'Feature',\n      properties: geojson.properties,\n      id: geojson.id,\n      geometry: {\n        type: 'Point',\n        coordinates: [centroid[0], centroid[1]]\n      }\n    };\n  };\n\n  this._checkForProportionalSymbols = function (geometryType, renderer) {\n    this._hasProportionalSymbols = false;\n    if (geometryType === 'esriGeometryPolygon') {\n      if (renderer.backgroundFillSymbol) {\n        this._hasProportionalSymbols = true;\n      }\n      // check to see if the first symbol in the classbreaks is a marker symbol\n      if (renderer.classBreakInfos && renderer.classBreakInfos.length) {\n        var sym = renderer.classBreakInfos[0].symbol;\n        if (sym && (sym.type === 'esriSMS' || sym.type === 'esriPMS')) {\n          this._hasProportionalSymbols = true;\n        }\n      }\n    }\n  };\n\n  this._setRenderers = function (geojson) {\n    var rend;\n    var rendererInfo = geojson.drawingInfo.renderer;\n\n    var options = {\n      url: this.options.url\n    };\n\n    if (this.options.token) {\n      options.token = this.options.token;\n    }\n    if (this.options.pane) {\n      options.pane = this.options.pane;\n    }\n    if (geojson.drawingInfo.transparency) {\n      options.layerTransparency = geojson.drawingInfo.transparency;\n    }\n    if (this.options.style) {\n      options.userDefinedStyle = this.options.style;\n    }\n\n    switch (rendererInfo.type) {\n      case 'classBreaks':\n        this._checkForProportionalSymbols(geojson.geometryType, rendererInfo);\n        if (this._hasProportionalSymbols) {\n          this._createPointLayer();\n          var pRend = classBreaksRenderer(rendererInfo, options);\n          pRend.attachStylesToLayer(this._pointLayer);\n          options.proportionalPolygon = true;\n        }\n        rend = classBreaksRenderer(rendererInfo, options);\n        break;\n      case 'uniqueValue':\n        rend = uniqueValueRenderer(rendererInfo, options);\n        break;\n      default:\n        rend = simpleRenderer(rendererInfo, options);\n    }\n    rend.attachStylesToLayer(this);\n  };\n});\n"],"names":[],"mappings":"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"}
\ No newline at end of file