diff --git a/dist/esri-leaflet-renderers-debug.js b/dist/esri-leaflet-renderers-debug.js
new file mode 100644
index 0000000..c4e2a2f
--- /dev/null
+++ b/dist/esri-leaflet-renderers-debug.js
@@ -0,0 +1,1180 @@
+/* esri-leaflet-renderers - v2.0.5 - Fri Jun 02 2017 09:54:10 GMT-0700 (PDT)
+ * Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet'), require('esri-leaflet')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'leaflet', 'esri-leaflet'], factory) :
+	(factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}, global.L.esri.Renderers = global.L.esri.Renderers || {}),global.L,global.L.esri));
+}(this, function (exports,L,Esri) { 'use strict';
+
+	L = 'default' in L ? L['default'] : L;
+	Esri = 'default' in Esri ? Esri['default'] : Esri;
+
+	var version = "2.0.5";
+
+	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();
+	  },
+
+	  toGeoJSON: function () {
+	    return L.GeoJSON.getFeature(this, {
+	      type: 'Point',
+	      coordinates: L.GeoJSON.latLngToCoords(this.getLatLng())
+	    });
+	  },
+
+	  _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) {
+	    var url;
+	    Symbol.prototype.initialize.call(this, symbolJson, options);
+	    if (options) {
+	      this.serviceUrl = options.url;
+	    }
+	    if (symbolJson) {
+	      if (symbolJson.type === 'esriPMS') {
+	        var imageUrl = this._symbolJson.url;
+	        if ((imageUrl && imageUrl.substr(0, 7) === 'http://') || (imageUrl.substr(0, 8) === 'https://')) {
+	          // web image
+	          url = this.sanitize(imageUrl);
+	          this._iconUrl = url;
+	        } else {
+	          url = this.serviceUrl + 'images/' + imageUrl;
+	          this._iconUrl = options && options.token ? url + '?token=' + options.token : url;
+	        }
+	        if (symbolJson.imageData) {
+	          this._iconUrl = 'data:' + symbolJson.contentType + ';base64,' + symbolJson.imageData;
+	        }
+	        // 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();
+	      }
+	    }
+	  },
+
+	  // prevent html injection in strings
+	  sanitize: function (str) {
+	    if (!str) {
+	      return '';
+	    }
+	    var text;
+	    try {
+	      // removes html but leaves url link text
+	      text = str.replace(/<br>/gi, '\n');
+	      text = text.replace(/<p.*>/gi, '\n');
+	      text = text.replace(/<a.*href='(.*?)'.*>(.*?)<\/a>/gi, ' $2 ($1) ');
+	      text = text.replace(/<(?:.|\s)*?>/g, '');
+	    } catch (ex) {
+	      text = null;
+	    }
+	    return text;
+	  },
+
+	  _fillStyles: function () {
+	    if (this._symbolJson.outline && this._symbolJson.size > 0 && this._symbolJson.outline.style !== 'esriSLSNull') {
+	      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) {
+	      if (symbolJson.outline && symbolJson.outline.style === 'esriSLSNull') {
+	        this._lineStyles = { weight: 0 };
+	      } else {
+	        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);
+	}
+
+	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.onAdd = function (map) {
+	    this.metadata(function (error, response) {
+	      if (error) {
+	        console.warn('failed to load metadata from the service.');
+	        return;
+	      } if (response && response.drawingInfo) {
+	        if (this.options.drawingInfo) {
+	          // allow L.esri.webmap (and others) to override service symbology with info provided in layer constructor
+	          response.drawingInfo = this.options.drawingInfo;
+	        }
+
+	        // the default pane for lines and polygons is 'overlayPane', for points it is 'markerPane'
+	        if (this.options.pane === 'overlayPane' && response.geometryType === 'esriGeometryPoint') {
+	          this.options.pane = 'markerPane';
+	        }
+
+	        this._setRenderers(response);
+	        oldOnAdd(map);
+	        this._addPointLayer(map);
+	      }
+	    }, this);
+	  };
+
+	  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 (serviceInfo) {
+	    var rend;
+	    var rendererInfo = serviceInfo.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 (serviceInfo.drawingInfo.transparency) {
+	      options.layerTransparency = serviceInfo.drawingInfo.transparency;
+	    }
+
+	    if (this.options.style) {
+	      options.userDefinedStyle = this.options.style;
+	    }
+
+	    switch (rendererInfo.type) {
+	      case 'classBreaks':
+	        this._checkForProportionalSymbols(serviceInfo.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.5\",\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\",\n    \"leaflet\": \"^1.0.0-rc.3\",\n    \"leaflet-shape-markers\": \"^1.0.4\"\n  },\n  \"devDependencies\": {\n    \"babelify\": \"^6.1.3\",\n    \"chai\": \"3.5.0\",\n    \"gh-release\": \"^2.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"isparta\": \"^4.0.0\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^1.3.0\",\n    \"karma-chai-sinon\": \"^0.1.3\",\n    \"karma-coverage\": \"^1.1.1\",\n    \"karma-mocha\": \"^1.3.0\",\n    \"karma-mocha-reporter\": \"^2.2.1\",\n    \"karma-phantomjs-launcher\": \"^1.0.2\",\n    \"karma-sourcemap-loader\": \"^0.3.5\",\n    \"mkdirp\": \"^0.5.1\",\n    \"mocha\": \"^3.1.0\",\n    \"phantomjs-prebuilt\": \"^2.0.0\",\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.3.1\",\n    \"semistandard\": \"^10.0.0\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.8.0\",\n    \"snazzy\": \"^5.0.0\",\n    \"uglify-js\": \"^2.6.1\",\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  \"module\": \"src/EsriLeafletRenderers.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    \"prebuild\": \"mkdirp dist\",\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n    \"lint\": \"semistandard src/**/*.js | snazzy\",\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 && 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  toGeoJSON: function () {\n    return L.GeoJSON.getFeature(this, {\n      type: 'Point',\n      coordinates: L.GeoJSON.latLngToCoords(this.getLatLng())\n    });\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    var url;\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 imageUrl = this._symbolJson.url;\n        if ((imageUrl && imageUrl.substr(0, 7) === 'http://') || (imageUrl.substr(0, 8) === 'https://')) {\n          // web image\n          url = this.sanitize(imageUrl);\n          this._iconUrl = url;\n        } else {\n          url = this.serviceUrl + 'images/' + imageUrl;\n          this._iconUrl = options && options.token ? url + '?token=' + options.token : url;\n        }\n        if (symbolJson.imageData) {\n          this._iconUrl = 'data:' + symbolJson.contentType + ';base64,' + symbolJson.imageData;\n        }\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  // prevent html injection in strings\n  sanitize: function (str) {\n    if (!str) {\n      return '';\n    }\n    var text;\n    try {\n      // removes html but leaves url link text\n      text = str.replace(/<br>/gi, '\\n');\n      text = text.replace(/<p.*>/gi, '\\n');\n      text = text.replace(/<a.*href='(.*?)'.*>(.*?)<\\/a>/gi, ' $2 ($1) ');\n      text = text.replace(/<(?:.|\\s)*?>/g, '');\n    } catch (ex) {\n      text = null;\n    }\n    return text;\n  },\n\n  _fillStyles: function () {\n    if (this._symbolJson.outline && this._symbolJson.size > 0 && this._symbolJson.outline.style !== 'esriSLSNull') {\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      if (symbolJson.outline && symbolJson.outline.style === 'esriSLSNull') {\n        this._lineStyles = { weight: 0 };\n      } else {\n        this._lineStyles = lineSymbol(symbolJson.outline, options).style();\n      }\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';\nimport Esri from 'esri-leaflet';\nimport classBreaksRenderer from './Renderers/ClassBreaksRenderer';\nimport uniqueValueRenderer from './Renderers/UniqueValueRenderer';\nimport simpleRenderer from './Renderers/SimpleRenderer';\n\nEsri.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.onAdd = function (map) {\n    this.metadata(function (error, response) {\n      if (error) {\n        console.warn('failed to load metadata from the service.');\n        return;\n      } if (response && response.drawingInfo) {\n        if (this.options.drawingInfo) {\n          // allow L.esri.webmap (and others) to override service symbology with info provided in layer constructor\n          response.drawingInfo = this.options.drawingInfo;\n        }\n\n        // the default pane for lines and polygons is 'overlayPane', for points it is 'markerPane'\n        if (this.options.pane === 'overlayPane' && response.geometryType === 'esriGeometryPoint') {\n          this.options.pane = 'markerPane';\n        }\n\n        this._setRenderers(response);\n        oldOnAdd(map);\n        this._addPointLayer(map);\n      }\n    }, this);\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 (serviceInfo) {\n    var rend;\n    var rendererInfo = serviceInfo.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\n    if (this.options.pane) {\n      options.pane = this.options.pane;\n    }\n\n    if (serviceInfo.drawingInfo.transparency) {\n      options.layerTransparency = serviceInfo.drawingInfo.transparency;\n    }\n\n    if (this.options.style) {\n      options.userDefinedStyle = this.options.style;\n    }\n\n    switch (rendererInfo.type) {\n      case 'classBreaks':\n        this._checkForProportionalSymbols(serviceInfo.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
diff --git a/dist/esri-leaflet-renderers.js b/dist/esri-leaflet-renderers.js
new file mode 100644
index 0000000..2b83f23
--- /dev/null
+++ b/dist/esri-leaflet-renderers.js
@@ -0,0 +1,5 @@
+/* esri-leaflet-renderers - v2.0.5 - Fri Jun 02 2017 09:54:10 GMT-0700 (PDT)
+ * Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+!function(t,i){"object"==typeof exports&&"undefined"!=typeof module?i(exports,require("leaflet"),require("esri-leaflet")):"function"==typeof define&&define.amd?define(["exports","leaflet","esri-leaflet"],i):i((t.L=t.L||{},t.L.esri=t.L.esri||{},t.L.esri.Renderers=t.L.esri.Renderers||{}),t.L,t.L.esri)}(this,function(t,i,e){"use strict";function s(t,i){return new b(t,i)}function o(t,i){return new v(t,i)}function n(t,i){return new g(t,i)}function r(t,i){return new x(t,i)}function l(t,i){return new z(t,i)}function a(t,i){return new P(t,i)}i="default"in i?i.default:i,e="default"in e?e.default:e;var h=i.Class.extend({initialize:function(t,i){this._symbolJson=t,this.val=null,this._styles={},this._isDefault=!1,this._layerTransparency=1,i&&i.layerTransparency&&(this._layerTransparency=1-i.layerTransparency/100)},pixelValue:function(t){return 1.333*t},colorValue:function(t){return"rgb("+t[0]+","+t[1]+","+t[2]+")"},alphaValue:function(t){return t[3]/255*this._layerTransparency},getSize:function(t,i){var e=t.properties,s=i.field,o=0,n=null;if(s){n=e[s];var r,l=i.minSize,a=i.maxSize,h=i.minDataValue,u=i.maxDataValue,y=i.normalizationField,_=e?parseFloat(e[y]):void 0;if(null===n||y&&(isNaN(_)||0===_))return null;isNaN(_)||(n/=_),null!==l&&null!==a&&null!==h&&null!==u&&(n<=h?o=l:n>=u?o=a:(r=(n-h)/(u-h),o=l+r*(a-l))),o=isNaN(o)?0:o}return o},getColor:function(t,i){if(!(t.properties&&i&&i.field&&i.stops))return null;var e,s,o,n,r=t.properties,l=r[i.field],a=i.normalizationField,h=r?parseFloat(r[a]):void 0;if(null===l||a&&(isNaN(h)||0===h))return null;if(isNaN(h)||(l/=h),l<=i.stops[0].value)return i.stops[0].color;var u=i.stops[i.stops.length-1];if(l>=u.value)return u.color;for(var y=0;y<i.stops.length;y++){var _=i.stops[y];if(_.value<=l)e=_.color,o=_.value;else if(_.value>l){s=_.color,n=_.value;break}}if(!isNaN(o)&&!isNaN(n)){var c=n-o;if(c>0){var f=(l-o)/c;if(f){var p=(n-l)/c;if(p){for(var d=[],S=0;S<4;S++)d[S]=Math.round(e[S]*p)+s[S]*f;return d}return s}return e}}return null}}),u=i.Path.extend({initialize:function(t,e,s){i.setOptions(this,s),this._size=e,this._latlng=i.latLng(t),this._svgCanvasIncludes()},toGeoJSON:function(){return i.GeoJSON.getFeature(this,{type:"Point",coordinates:i.GeoJSON.latLngToCoords(this.getLatLng())})},_svgCanvasIncludes:function(){},_project:function(){this._point=this._map.latLngToLayerPoint(this._latlng)},_update:function(){this._map&&this._updatePath()},_updatePath:function(){},setLatLng:function(t){return this._latlng=i.latLng(t),this.redraw(),this.fire("move",{latlng:this._latlng})},getLatLng:function(){return this._latlng},setSize:function(t){return this._size=t,this.redraw()},getSize:function(){return this._size}}),y=u.extend({initialize:function(t,i,e){u.prototype.initialize.call(this,t,i,e)},_updatePath:function(){this._renderer._updateCrossMarker(this)},_svgCanvasIncludes:function(){i.Canvas.include({_updateCrossMarker:function(t){var i=t._point,e=t._size/2,s=this._ctx;s.beginPath(),s.moveTo(i.x,i.y+e),s.lineTo(i.x,i.y-e),this._fillStroke(s,t),s.moveTo(i.x-e,i.y),s.lineTo(i.x+e,i.y),this._fillStroke(s,t)}}),i.SVG.include({_updateCrossMarker:function(t){var e=t._point,s=t._size/2;i.Browser.vml&&(e._round(),s=Math.round(s));var o="M"+e.x+","+(e.y+s)+"L"+e.x+","+(e.y-s)+"M"+(e.x-s)+","+e.y+"L"+(e.x+s)+","+e.y;this._setPath(t,o)}})}}),_=function(t,i,e){return new y(t,i,e)},c=u.extend({initialize:function(t,i,e){u.prototype.initialize.call(this,t,i,e)},_updatePath:function(){this._renderer._updateXMarker(this)},_svgCanvasIncludes:function(){i.Canvas.include({_updateXMarker:function(t){var i=t._point,e=t._size/2,s=this._ctx;s.beginPath(),s.moveTo(i.x+e,i.y+e),s.lineTo(i.x-e,i.y-e),this._fillStroke(s,t)}}),i.SVG.include({_updateXMarker:function(t){var e=t._point,s=t._size/2;i.Browser.vml&&(e._round(),s=Math.round(s));var o="M"+(e.x+s)+","+(e.y+s)+"L"+(e.x-s)+","+(e.y-s)+"M"+(e.x-s)+","+(e.y+s)+"L"+(e.x+s)+","+(e.y-s);this._setPath(t,o)}})}}),f=function(t,i,e){return new c(t,i,e)},p=u.extend({options:{fill:!0},initialize:function(t,i,e){u.prototype.initialize.call(this,t,i,e)},_updatePath:function(){this._renderer._updateSquareMarker(this)},_svgCanvasIncludes:function(){i.Canvas.include({_updateSquareMarker:function(t){var i=t._point,e=t._size/2,s=this._ctx;s.beginPath(),s.moveTo(i.x+e,i.y+e),s.lineTo(i.x-e,i.y+e),s.lineTo(i.x-e,i.y-e),s.lineTo(i.x+e,i.y-e),s.closePath(),this._fillStroke(s,t)}}),i.SVG.include({_updateSquareMarker:function(t){var e=t._point,s=t._size/2;i.Browser.vml&&(e._round(),s=Math.round(s));var o="M"+(e.x+s)+","+(e.y+s)+"L"+(e.x-s)+","+(e.y+s)+"L"+(e.x-s)+","+(e.y-s)+"L"+(e.x+s)+","+(e.y-s);o+=i.Browser.svg?"z":"x",this._setPath(t,o)}})}}),d=function(t,i,e){return new p(t,i,e)},S=u.extend({options:{fill:!0},initialize:function(t,i,e){u.prototype.initialize.call(this,t,i,e)},_updatePath:function(){this._renderer._updateDiamondMarker(this)},_svgCanvasIncludes:function(){i.Canvas.include({_updateDiamondMarker:function(t){var i=t._point,e=t._size/2,s=this._ctx;s.beginPath(),s.moveTo(i.x,i.y+e),s.lineTo(i.x-e,i.y),s.lineTo(i.x,i.y-e),s.lineTo(i.x+e,i.y),s.closePath(),this._fillStroke(s,t)}}),i.SVG.include({_updateDiamondMarker:function(t){var e=t._point,s=t._size/2;i.Browser.vml&&(e._round(),s=Math.round(s));var o="M"+e.x+","+(e.y+s)+"L"+(e.x-s)+","+e.y+"L"+e.x+","+(e.y-s)+"L"+(e.x+s)+","+e.y;o+=i.Browser.svg?"z":"x",this._setPath(t,o)}})}}),m=function(t,i,e){return new S(t,i,e)},b=h.extend({statics:{MARKERTYPES:["esriSMSCircle","esriSMSCross","esriSMSDiamond","esriSMSSquare","esriSMSX","esriPMS"]},initialize:function(t,i){var e;if(h.prototype.initialize.call(this,t,i),i&&(this.serviceUrl=i.url),t)if("esriPMS"===t.type){var s=this._symbolJson.url;s&&"http://"===s.substr(0,7)||"https://"===s.substr(0,8)?(e=this.sanitize(s),this._iconUrl=e):(e=this.serviceUrl+"images/"+s,this._iconUrl=i&&i.token?e+"?token="+i.token:e),t.imageData&&(this._iconUrl="data:"+t.contentType+";base64,"+t.imageData),this._icons={},this.icon=this._createIcon(this._symbolJson)}else this._fillStyles()},sanitize:function(t){if(!t)return"";var i;try{i=t.replace(/<br>/gi,"\n"),i=i.replace(/<p.*>/gi,"\n"),i=i.replace(/<a.*href='(.*?)'.*>(.*?)<\/a>/gi," $2 ($1) "),i=i.replace(/<(?:.|\s)*?>/g,"")}catch(t){i=null}return i},_fillStyles:function(){this._symbolJson.outline&&this._symbolJson.size>0&&"esriSLSNull"!==this._symbolJson.outline.style?(this._styles.stroke=!0,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)):this._styles.stroke=!1,this._symbolJson.color?(this._styles.fillColor=this.colorValue(this._symbolJson.color),this._styles.fillOpacity=this.alphaValue(this._symbolJson.color)):this._styles.fillOpacity=0,"esriSMSCircle"===this._symbolJson.style&&(this._styles.radius=this.pixelValue(this._symbolJson.size)/2)},_createIcon:function(t){var e=this.pixelValue(t.width),s=e;t.height&&(s=this.pixelValue(t.height));var o=e/2,n=s/2;t.xoffset&&(o+=this.pixelValue(t.xoffset)),t.yoffset&&(n+=this.pixelValue(t.yoffset));var r=i.icon({iconUrl:this._iconUrl,iconSize:[e,s],iconAnchor:[o,n]});return this._icons[t.width.toString()]=r,r},_getIcon:function(t){var i=this._icons[t.toString()];return i||(i=this._createIcon({width:t})),i},pointToLayer:function(t,e,s,o){var n=this._symbolJson.size||this._symbolJson.width;if(!this._isDefault){if(s.sizeInfo){var r=this.getSize(t,s.sizeInfo);r&&(n=r)}if(s.colorInfo){var l=this.getColor(t,s.colorInfo);l&&(this._styles.fillColor=this.colorValue(l),this._styles.fillOpacity=this.alphaValue(l))}}if("esriPMS"===this._symbolJson.type){var a=i.extend({},{icon:this._getIcon(n)},o);return i.marker(e,a)}switch(n=this.pixelValue(n),this._symbolJson.style){case"esriSMSSquare":return d(e,n,i.extend({},this._styles,o));case"esriSMSDiamond":return m(e,n,i.extend({},this._styles,o));case"esriSMSCross":return _(e,n,i.extend({},this._styles,o));case"esriSMSX":return f(e,n,i.extend({},this._styles,o))}return this._styles.radius=n/2,i.circleMarker(e,i.extend({},this._styles,o))}}),v=h.extend({statics:{LINETYPES:["esriSLSDash","esriSLSDot","esriSLSDashDotDot","esriSLSDashDot","esriSLSSolid"]},initialize:function(t,i){h.prototype.initialize.call(this,t,i),this._fillStyles()},_fillStyles:function(){if(this._styles.lineCap="butt",this._styles.lineJoin="miter",this._styles.fill=!1,this._styles.weight=0,!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)),!isNaN(this._symbolJson.width)){this._styles.weight=this.pixelValue(this._symbolJson.width);var t=[];switch(this._symbolJson.style){case"esriSLSDash":t=[4,3];break;case"esriSLSDot":t=[1,3];break;case"esriSLSDashDot":t=[8,3,1,3];break;case"esriSLSDashDotDot":t=[8,3,1,3,1,3]}if(t.length>0){for(var i=0;i<t.length;i++)t[i]*=this._styles.weight;this._styles.dashArray=t.join(",")}}},style:function(t,i){if(!this._isDefault&&i){if(i.sizeInfo){var e=this.pixelValue(this.getSize(t,i.sizeInfo));e&&(this._styles.weight=e)}if(i.colorInfo){var s=this.getColor(t,i.colorInfo);s&&(this._styles.color=this.colorValue(s),this._styles.opacity=this.alphaValue(s))}}return this._styles}}),g=h.extend({statics:{POLYGONTYPES:["esriSFSSolid"]},initialize:function(t,i){h.prototype.initialize.call(this,t,i),t&&(t.outline&&"esriSLSNull"===t.outline.style?this._lineStyles={weight:0}:this._lineStyles=o(t.outline,i).style(),this._fillStyles())},_fillStyles:function(){if(this._lineStyles)if(0===this._lineStyles.weight)this._styles.stroke=!1;else for(var t in this._lineStyles)this._styles[t]=this._lineStyles[t];this._symbolJson&&(this._symbolJson.color&&g.POLYGONTYPES.indexOf(this._symbolJson.style>=0)?(this._styles.fill=!0,this._styles.fillColor=this.colorValue(this._symbolJson.color),this._styles.fillOpacity=this.alphaValue(this._symbolJson.color)):(this._styles.fill=!1,this._styles.fillOpacity=0))},style:function(t,i){if(!this._isDefault&&i&&i.colorInfo){var e=this.getColor(t,i.colorInfo);e&&(this._styles.fillColor=this.colorValue(e),this._styles.fillOpacity=this.alphaValue(e))}return this._styles}}),L=i.Class.extend({options:{proportionalPolygon:!1,clickable:!0},initialize:function(t,e){this._rendererJson=t,this._pointSymbols=!1,this._symbols=[],this._visualVariables=this._parseVisualVariables(t.visualVariables),i.Util.setOptions(this,e)},_parseVisualVariables:function(t){var i={};if(t)for(var e=0;e<t.length;e++)i[t[e].type]=t[e];return i},_createDefaultSymbol:function(){this._rendererJson.defaultSymbol&&(this._defaultSymbol=this._newSymbol(this._rendererJson.defaultSymbol),this._defaultSymbol._isDefault=!0)},_newSymbol:function(t){return"esriSMS"===t.type||"esriPMS"===t.type?(this._pointSymbols=!0,s(t,this.options)):"esriSLS"===t.type?o(t,this.options):"esriSFS"===t.type?n(t,this.options):void 0},_getSymbol:function(){},attachStylesToLayer:function(t){this._pointSymbols?t.options.pointToLayer=i.Util.bind(this.pointToLayer,this):(t.options.style=i.Util.bind(this.style,this),t._originalStyle=t.options.style)},pointToLayer:function(t,e){var s=this._getSymbol(t);return s&&s.pointToLayer?s.pointToLayer(t,e,this._visualVariables,this.options):i.circleMarker(e,{radius:0,opacity:0})},style:function(t){var i;this.options.userDefinedStyle&&(i=this.options.userDefinedStyle(t));var e=this._getSymbol(t);return e?this.mergeStyles(e.style(t,this._visualVariables),i):this.mergeStyles({opacity:0,fillOpacity:0},i)},mergeStyles:function(t,i){var e,s={};for(e in t)t.hasOwnProperty(e)&&(s[e]=t[e]);if(i)for(e in i)i.hasOwnProperty(e)&&(s[e]=i[e]);return s}}),x=L.extend({initialize:function(t,i){L.prototype.initialize.call(this,t,i),this._createSymbol()},_createSymbol:function(){this._rendererJson.symbol&&this._symbols.push(this._newSymbol(this._rendererJson.symbol))},_getSymbol:function(){return this._symbols[0]}}),z=L.extend({initialize:function(t,i){L.prototype.initialize.call(this,t,i),this._field=this._rendererJson.field,this._rendererJson.normalizationType&&"esriNormalizeByField"===this._rendererJson.normalizationType&&(this._normalizationField=this._rendererJson.normalizationField),this._createSymbols()},_createSymbols:function(){var t,i=this._rendererJson.classBreakInfos;this._symbols=[];for(var e=i.length-1;e>=0;e--)t=this.options.proportionalPolygon&&this._rendererJson.backgroundFillSymbol?this._newSymbol(this._rendererJson.backgroundFillSymbol):this._newSymbol(i[e].symbol),t.val=i[e].classMaxValue,this._symbols.push(t);this._symbols.sort(function(t,i){return t.val>i.val?1:-1}),this._createDefaultSymbol(),this._maxValue=this._symbols[this._symbols.length-1].val},_getSymbol:function(t){var i=t.properties[this._field];if(this._normalizationField){var e=t.properties[this._normalizationField];if(isNaN(e)||0===e)return this._defaultSymbol;i/=e}if(i>this._maxValue)return this._defaultSymbol;for(var s=this._symbols[0],o=this._symbols.length-1;o>=0&&!(i>this._symbols[o].val);o--)s=this._symbols[o];return s}}),P=L.extend({initialize:function(t,i){L.prototype.initialize.call(this,t,i),this._field=this._rendererJson.field1,this._createSymbols()},_createSymbols:function(){for(var t,i=this._rendererJson.uniqueValueInfos,e=i.length-1;e>=0;e--)t=this._newSymbol(i[e].symbol),t.val=i[e].value,this._symbols.push(t);this._createDefaultSymbol()},_getSymbol:function(t){var i=t.properties[this._field];if(this._rendererJson.fieldDelimiter&&this._rendererJson.field2){var e=t.properties[this._rendererJson.field2];if(e){i+=this._rendererJson.fieldDelimiter+e;var s=t.properties[this._rendererJson.field3];s&&(i+=this._rendererJson.fieldDelimiter+s)}}for(var o=this._defaultSymbol,n=this._symbols.length-1;n>=0;n--)this._symbols[n].val==i&&(o=this._symbols[n]);return o}});e.FeatureLayer.addInitHook(function(){if(!this.options.ignoreRenderer){var t=i.Util.bind(this.onAdd,this),e=i.Util.bind(this.unbindPopup,this),s=i.Util.bind(this.onRemove,this);i.Util.bind(this.createNewLayer,this),this.onAdd=function(i){this.metadata(function(e,s){if(e)return void console.warn("failed to load metadata from the service.");s&&s.drawingInfo&&(this.options.drawingInfo&&(s.drawingInfo=this.options.drawingInfo),"overlayPane"===this.options.pane&&"esriGeometryPoint"===s.geometryType&&(this.options.pane="markerPane"),this._setRenderers(s),t(i),this._addPointLayer(i))},this)},this.onRemove=function(t){if(s(t),this._pointLayer){var i=this._pointLayer.getLayers();for(var e in i)t.removeLayer(i[e])}},this.unbindPopup=function(){if(e(),this._pointLayer){var t=this._pointLayer.getLayers();for(var i in t)t[i].unbindPopup()}},this._addPointLayer=function(t){this._pointLayer&&(this._pointLayer.addTo(t),this._pointLayer.bringToFront())},this._createPointLayer=function(){if(!this._pointLayer&&(this._pointLayer=i.geoJson(),this._pointLayerIds={},this._popup)){var t=function(t,i){i.bindPopup(this._popup(t,i),this._popupOptions)};this._pointLayer.options.onEachFeature=i.Util.bind(t,this)}},this.createNewLayer=function(t){var e=i.GeoJSON.geometryToLayer(t,this.options);if(this._hasProportionalSymbols){var s=this.getPolygonCentroid(t.geometry.coordinates);if(!isNaN(s[0])&&!isNaN(s[0])){this._createPointLayer();var o=t.id.toString();if(!this._pointLayerIds[o]){var n=this.getPointJson(t,s);this._pointLayer.addData(n),this._pointLayerIds[o]=!0}this._pointLayer.bringToFront()}}return e},this.getPolygonCentroid=function(t){var i=t[0][0];2===i.length&&(i=t[0]);for(var e,s,o,n=0,r=0,l=0,a=i.length,h=0,u=a-1;h<a;u=h++)e=i[h],s=i[u],n+=e[0]*s[1],n-=e[1]*s[0],o=e[0]*s[1]-s[0]*e[1],r+=(e[0]+s[0])*o,l+=(e[1]+s[1])*o;return o=3*n,[r/o,l/o]},this.getPointJson=function(t,i){return{type:"Feature",properties:t.properties,id:t.id,geometry:{type:"Point",coordinates:[i[0],i[1]]}}},this._checkForProportionalSymbols=function(t,i){if(this._hasProportionalSymbols=!1,"esriGeometryPolygon"===t&&(i.backgroundFillSymbol&&(this._hasProportionalSymbols=!0),i.classBreakInfos&&i.classBreakInfos.length)){var e=i.classBreakInfos[0].symbol;!e||"esriSMS"!==e.type&&"esriPMS"!==e.type||(this._hasProportionalSymbols=!0)}},this._setRenderers=function(t){var i,e=t.drawingInfo.renderer,s={url:this.options.url};switch(this.options.token&&(s.token=this.options.token),this.options.pane&&(s.pane=this.options.pane),t.drawingInfo.transparency&&(s.layerTransparency=t.drawingInfo.transparency),this.options.style&&(s.userDefinedStyle=this.options.style),e.type){case"classBreaks":if(this._checkForProportionalSymbols(t.geometryType,e),this._hasProportionalSymbols){this._createPointLayer();l(e,s).attachStylesToLayer(this._pointLayer),s.proportionalPolygon=!0}i=l(e,s);break;case"uniqueValue":i=a(e,s);break;default:i=r(e,s)}i.attachStylesToLayer(this)}}}),t.VERSION="2.0.5",t.Renderer=L,t.SimpleRenderer=x,t.simpleRenderer=r,t.ClassBreaksRenderer=z,t.classBreaksRenderer=l,t.UniqueValueRenderer=P,t.uniqueValueRenderer=a,t.Symbol=h,t.PointSymbol=b,t.pointSymbol=s,t.LineSymbol=v,t.lineSymbol=o,t.PolygonSymbol=g,t.polygonSymbol=n});
+//# sourceMappingURL=esri-leaflet-renderers.js.map
\ No newline at end of file
diff --git a/dist/esri-leaflet-renderers.js.map b/dist/esri-leaflet-renderers.js.map
new file mode 100644
index 0000000..bbee424
--- /dev/null
+++ b/dist/esri-leaflet-renderers.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"esri-leaflet-renderers.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.5\",\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\",\n    \"leaflet\": \"^1.0.0-rc.3\",\n    \"leaflet-shape-markers\": \"^1.0.4\"\n  },\n  \"devDependencies\": {\n    \"babelify\": \"^6.1.3\",\n    \"chai\": \"3.5.0\",\n    \"gh-release\": \"^2.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"isparta\": \"^4.0.0\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^1.3.0\",\n    \"karma-chai-sinon\": \"^0.1.3\",\n    \"karma-coverage\": \"^1.1.1\",\n    \"karma-mocha\": \"^1.3.0\",\n    \"karma-mocha-reporter\": \"^2.2.1\",\n    \"karma-phantomjs-launcher\": \"^1.0.2\",\n    \"karma-sourcemap-loader\": \"^0.3.5\",\n    \"mkdirp\": \"^0.5.1\",\n    \"mocha\": \"^3.1.0\",\n    \"phantomjs-prebuilt\": \"^2.0.0\",\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.3.1\",\n    \"semistandard\": \"^10.0.0\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.8.0\",\n    \"snazzy\": \"^5.0.0\",\n    \"uglify-js\": \"^2.6.1\",\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  \"module\": \"src/EsriLeafletRenderers.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    \"prebuild\": \"mkdirp dist\",\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n    \"lint\": \"semistandard src/**/*.js | snazzy\",\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 && 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  toGeoJSON: function () {\n    return L.GeoJSON.getFeature(this, {\n      type: 'Point',\n      coordinates: L.GeoJSON.latLngToCoords(this.getLatLng())\n    });\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    var url;\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 imageUrl = this._symbolJson.url;\n        if ((imageUrl && imageUrl.substr(0, 7) === 'http://') || (imageUrl.substr(0, 8) === 'https://')) {\n          // web image\n          url = this.sanitize(imageUrl);\n          this._iconUrl = url;\n        } else {\n          url = this.serviceUrl + 'images/' + imageUrl;\n          this._iconUrl = options && options.token ? url + '?token=' + options.token : url;\n        }\n        if (symbolJson.imageData) {\n          this._iconUrl = 'data:' + symbolJson.contentType + ';base64,' + symbolJson.imageData;\n        }\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  // prevent html injection in strings\n  sanitize: function (str) {\n    if (!str) {\n      return '';\n    }\n    var text;\n    try {\n      // removes html but leaves url link text\n      text = str.replace(/<br>/gi, '\\n');\n      text = text.replace(/<p.*>/gi, '\\n');\n      text = text.replace(/<a.*href='(.*?)'.*>(.*?)<\\/a>/gi, ' $2 ($1) ');\n      text = text.replace(/<(?:.|\\s)*?>/g, '');\n    } catch (ex) {\n      text = null;\n    }\n    return text;\n  },\n\n  _fillStyles: function () {\n    if (this._symbolJson.outline && this._symbolJson.size > 0 && this._symbolJson.outline.style !== 'esriSLSNull') {\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      if (symbolJson.outline && symbolJson.outline.style === 'esriSLSNull') {\n        this._lineStyles = { weight: 0 };\n      } else {\n        this._lineStyles = lineSymbol(symbolJson.outline, options).style();\n      }\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';\nimport Esri from 'esri-leaflet';\nimport classBreaksRenderer from './Renderers/ClassBreaksRenderer';\nimport uniqueValueRenderer from './Renderers/UniqueValueRenderer';\nimport simpleRenderer from './Renderers/SimpleRenderer';\n\nEsri.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.onAdd = function (map) {\n    this.metadata(function (error, response) {\n      if (error) {\n        console.warn('failed to load metadata from the service.');\n        return;\n      } if (response && response.drawingInfo) {\n        if (this.options.drawingInfo) {\n          // allow L.esri.webmap (and others) to override service symbology with info provided in layer constructor\n          response.drawingInfo = this.options.drawingInfo;\n        }\n\n        // the default pane for lines and polygons is 'overlayPane', for points it is 'markerPane'\n        if (this.options.pane === 'overlayPane' && response.geometryType === 'esriGeometryPoint') {\n          this.options.pane = 'markerPane';\n        }\n\n        this._setRenderers(response);\n        oldOnAdd(map);\n        this._addPointLayer(map);\n      }\n    }, this);\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 (serviceInfo) {\n    var rend;\n    var rendererInfo = serviceInfo.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\n    if (this.options.pane) {\n      options.pane = this.options.pane;\n    }\n\n    if (serviceInfo.drawingInfo.transparency) {\n      options.layerTransparency = serviceInfo.drawingInfo.transparency;\n    }\n\n    if (this.options.style) {\n      options.userDefinedStyle = this.options.style;\n    }\n\n    switch (rendererInfo.type) {\n      case 'classBreaks':\n        this._checkForProportionalSymbols(serviceInfo.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":["pointSymbol","symbolJson","options","PointSymbol","lineSymbol","LineSymbol","polygonSymbol","PolygonSymbol","simpleRenderer","rendererJson","SimpleRenderer","classBreaksRenderer","ClassBreaksRenderer","uniqueValueRenderer","UniqueValueRenderer","Symbol","L","Class","extend","initialize","this","_symbolJson","val","_styles","_isDefault","_layerTransparency","layerTransparency","pixelValue","pointValue","colorValue","color","alphaValue","getSize","feature","sizeInfo","attr","properties","field","size","featureValue","featureRatio","minSize","maxSize","minDataValue","maxDataValue","normField","normalizationField","normValue","parseFloat","undefined","isNaN","getColor","colorInfo","stops","lowerBoundColor","upperBoundColor","lowerBound","upperBound","value","lastStop","length","i","stopInfo","range","upperBoundColorWeight","lowerBoundColorWeight","interpolatedColor","j","Math","round","ShapeMarker","Path","latlng","setOptions","_size","_latlng","latLng","_svgCanvasIncludes","toGeoJSON","GeoJSON","getFeature","type","coordinates","latLngToCoords","getLatLng","_project","_point","_map","latLngToLayerPoint","_update","_updatePath","setLatLng","redraw","fire","setSize","CrossMarker","prototype","call","_renderer","_updateCrossMarker","Canvas","include","layer","offset","ctx","_ctx","beginPath","moveTo","x","y","lineTo","_fillStroke","SVG","Browser","vml","_round","str","_setPath","crossMarker","XMarker","_updateXMarker","xMarker","SquareMarker","fill","_updateSquareMarker","closePath","svg","squareMarker","DiamondMarker","_updateDiamondMarker","diamondMarker","statics","MARKERTYPES","url","serviceUrl","imageUrl","substr","sanitize","_iconUrl","token","imageData","contentType","_icons","icon","_createIcon","_fillStyles","text","replace","ex","outline","style","stroke","weight","width","opacity","fillColor","fillOpacity","radius","height","xOffset","yOffset","xoffset","yoffset","iconUrl","iconSize","iconAnchor","toString","_getIcon","pointToLayer","geojson","visualVariables","calculatedSize","layerOptions","marker","circleMarker","LINETYPES","lineCap","lineJoin","dashValues","dashArray","join","POLYGONTYPES","_lineStyles","styleAttr","indexOf","Renderer","proportionalPolygon","clickable","_rendererJson","_pointSymbols","_symbols","_visualVariables","_parseVisualVariables","Util","visVars","_createDefaultSymbol","defaultSymbol","_defaultSymbol","_newSymbol","_getSymbol","attachStylesToLayer","bind","_originalStyle","sym","userStyles","userDefinedStyle","mergeStyles","styles","mergedStyles","hasOwnProperty","_createSymbol","symbol","push","_field","normalizationType","_normalizationField","_createSymbols","classbreaks","classBreakInfos","backgroundFillSymbol","classMaxValue","sort","a","b","_maxValue","field1","uniques","uniqueValueInfos","fieldDelimiter","field2","val2","val3","field3","Esri","FeatureLayer","addInitHook","ignoreRenderer","oldOnAdd","onAdd","oldUnbindPopup","unbindPopup","oldOnRemove","onRemove","createNewLayer","map","metadata","error","response","console","warn","drawingInfo","pane","geometryType","_setRenderers","_addPointLayer","_pointLayer","pointLayers","getLayers","removeLayer","addTo","bringToFront","_createPointLayer","geoJson","_pointLayerIds","_popup","popupFunction","bindPopup","_popupOptions","onEachFeature","fLayer","geometryToLayer","_hasProportionalSymbols","centroid","getPolygonCentroid","geometry","featureId","id","pointjson","getPointJson","addData","pts","p1","p2","f","twicearea","nPts","_checkForProportionalSymbols","renderer","serviceInfo","rend","rendererInfo","transparency"],"mappings":"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"}
\ No newline at end of file