gMarkers.buildMarker = ({ position, mapIconItem }) => {
    //create and add associate with map
    let marker = new google.maps.Marker({
        clickable: mapIconItem.icon.isClickable,
        position: position,
        title: mapIconItem.title,
        zIndex: mapIconItem.zindex,
        preventClustering: mapIconItem.icon.preventClustering
    });

    return marker;
}

gMarkers.setIcon = (marker, icon) => {
    marker.setIcon(icon);
}

gMarkers.getMapId = () => {
    //a placeholder function.  It is needed for new_gMarkers.js
    return  undefined;
}

gMarkers.getPosition = (marker) => {
    return marker.getPosition();
}

gMarkers.setMarker = (options) => {
    let marker = new google.maps.Marker(options);
    return marker;
}

gMarkers.getHeight = (marker) => {
    return marker.get('anchorSize').height;
}
/**
 * @name MarkerClusterer for Google Maps v3
 * @version version 1.0
 * @author Luke Mahe
 * @fileoverview
 * The library creates and manages per-zoom-level clusters for large amounts of
 * markers.
 * <br/>
 * This is a v3 implementation of the
 * <a href="http://gmaps-utility-library-dev.googlecode.com/svn/tags/markerclusterer/"
 * >v2 MarkerClusterer</a>.
 */

/**
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


/******* See line 171 and 990 for our code modification, plus line 1105 to stop click propagation *******/


/**
 * A Marker Clusterer that clusters markers.
 *
 * @param {google.maps.Map} map The Google map to attach to.
 * @param {Array.<google.maps.Marker>=} opt_markers Optional markers to add to
 *   the cluster.
 * @param {Object=} opt_options support the following options:
 *     'gridSize': (number) The grid size of a cluster in pixels.
 *     'maxZoom': (number) The maximum zoom level that a marker can be part of a
 *                cluster.
 *     'zoomOnClick': (boolean) Whether the default behaviour of clicking on a
 *                    cluster is to zoom into it.
 *     'averageCenter': (boolean) Wether the center of each cluster should be
 *                      the average of all markers in the cluster.
 *     'minimumClusterSize': (number) The minimum number of markers to be in a
 *                           cluster before the markers are hidden and a count
 *                           is shown.
 *     'styles': (object) An object that has style properties:
 *       'url': (string) The image url.
 *       'height': (number) The image height.
 *       'width': (number) The image width.
 *       'anchor': (Array) The anchor position of the label text.
 *       'textColor': (string) The text color.
 *       'textSize': (number) The text size.
 *       'backgroundPosition': (string) The position of the backgound x, y.
 *       'iconAnchor': (Array) The anchor position of the icon x, y.
 * @constructor
 * @extends google.maps.OverlayView
 */
function MarkerClusterer(map, opt_markers, opt_options, oms) {
    // MarkerClusterer implements google.maps.OverlayView interface. We use the
    // extend function to extend MarkerClusterer with google.maps.OverlayView
    // because it might not always be available when the code is defined so we
    // look for it at the last possible moment. If it doesn't exist now then
    // there is no point going ahead :)
    this.extend(MarkerClusterer, google.maps.OverlayView);
    this.map_ = map;
    this.oms_ = oms;

    /**
     * @type {Array.<google.maps.Marker>}
     * @private
     */
    this.markers_ = [];

    /**
     *  @type {Array.<Cluster>}
     */
    this.clusters_ = [];

    this.sizes = [53, 56, 66, 78, 90];

    /**
     * @private
     */
    this.styles_ = [];

    /**
     * @type {boolean}
     * @private
     */
    this.ready_ = false;

    var options = opt_options || {};

    /**
     * @type {number}
     * @private
     */
    this.gridSize_ = options['gridSize'] || 60;

    /**
     * @private
     */
    this.minClusterSize_ = options['minimumClusterSize'] || 2;


    /**
     * @type {?number}
     * @private
     */
    this.maxZoom_ = options['maxZoom'] || null;

    this.styles_ = options['styles'] || [];

    /**
     * @type {string}
     * @private
     */
    this.imagePath_ = options['imagePath'] ||
        this.MARKER_CLUSTER_IMAGE_PATH_;

    /**
     * @type {string}
     * @private
     */
    this.imageExtension_ = options['imageExtension'] ||
        this.MARKER_CLUSTER_IMAGE_EXTENSION_;

    /**
     * @type {boolean}
     * @private
     */
    this.zoomOnClick_ = true;

    if (options['zoomOnClick'] != undefined) {
        this.zoomOnClick_ = options['zoomOnClick'];
    }

    /**
     * @type {boolean}
     * @private
     */
    this.averageCenter_ = false;

    if (options['averageCenter'] != undefined) {
        this.averageCenter_ = options['averageCenter'];
    }

    this.setupStyles_();

    this.setMap(map);

    /**
     * @type {number}
     * @private
     */
    this.prevZoom_ = this.map_.getZoom();

    // Add the map event listeners
    var that = this;
    google.maps.event.addListener(this.map_, 'zoom_changed', function () {
        var zoom = that.map_.getZoom();

        if (that.prevZoom_ != zoom) {
            that.prevZoom_ = zoom;
            that.resetViewport();
        }
    });

    //Remove idle listener since we call redraw ourselves
    //google.maps.event.addListener(this.map_, 'idle', function () {
    //    that.redraw();
    //});

    // Finally, add the markers
    if (opt_markers && opt_markers.length) {
        this.addMarkers(opt_markers, false);
    }
}


/**
 * The marker cluster image path.
 *
 * @type {string}
 * @private
 */
MarkerClusterer.prototype.MARKER_CLUSTER_IMAGE_PATH_ =
    'https://google-maps-utility-library-v3.googlecode.com/svn/trunk/markerclusterer/' +
    'images/m';


/**
 * The marker cluster image path.
 *
 * @type {string}
 * @private
 */
MarkerClusterer.prototype.MARKER_CLUSTER_IMAGE_EXTENSION_ = 'png';


/**
 * Extends a objects prototype by anothers.
 *
 * @param {Object} obj1 The object to be extended.
 * @param {Object} obj2 The object to extend with.
 * @return {Object} The new extended object.
 * @ignore
 */
MarkerClusterer.prototype.extend = function (obj1, obj2) {
    return (function (object) {
        for (var property in object.prototype) {
            this.prototype[property] = object.prototype[property];
        }
        return this;
    }).apply(obj1, [obj2]);
};


/**
 * Implementaion of the interface method.
 * @ignore
 */
MarkerClusterer.prototype.onAdd = function () {
    this.setReady_(true);
};

/**
 * Implementaion of the interface method.
 * @ignore
 */
MarkerClusterer.prototype.draw = function () { };

/**
 * Sets up the styles object.
 *
 * @private
 */
MarkerClusterer.prototype.setupStyles_ = function () {
    if (this.styles_.length) {
        return;
    }

    for (var i = 0, size; size = this.sizes[i]; i++) {
        this.styles_.push({
            url: this.imagePath_ + (i + 1) + '.' + this.imageExtension_,
            height: size,
            width: size
        });
    }
};

/**
 *  Fit the map to the bounds of the markers in the clusterer.
 */
MarkerClusterer.prototype.fitMapToMarkers = function () {
    var markers = this.getMarkers();
    var bounds = new google.maps.LatLngBounds();
    for (var i = 0, marker; marker = markers[i]; i++) {
        bounds.extend(marker.getPosition());
    }

    this.map_.fitBounds(bounds);
    this.map_.panBy(0, 0);
};


/**
 *  Sets the styles.
 *
 *  @param {Object} styles The style to set.
 */
MarkerClusterer.prototype.setStyles = function (styles) {
    this.styles_ = styles;
};


/**
 *  Gets the styles.
 *
 *  @return {Object} The styles object.
 */
MarkerClusterer.prototype.getStyles = function () {
    return this.styles_;
};


/**
 * Whether zoom on click is set.
 *
 * @return {boolean} True if zoomOnClick_ is set.
 */
MarkerClusterer.prototype.isZoomOnClick = function () {
    return this.zoomOnClick_;
};

/**
 * Whether average center is set.
 *
 * @return {boolean} True if averageCenter_ is set.
 */
MarkerClusterer.prototype.isAverageCenter = function () {
    return this.averageCenter_;
};


/**
 *  Returns the array of markers in the clusterer.
 *
 *  @return {Array.<google.maps.Marker>} The markers.
 */
MarkerClusterer.prototype.getMarkers = function () {
    return this.markers_;
};


/**
 *  Returns the number of markers in the clusterer
 *
 *  @return {Number} The number of markers.
 */
MarkerClusterer.prototype.getTotalMarkers = function () {
    return this.markers_.length;
};


/**
 *  Sets the max zoom for the clusterer.
 *
 *  @param {number} maxZoom The max zoom level.
 */
MarkerClusterer.prototype.setMaxZoom = function (maxZoom) {
    this.maxZoom_ = maxZoom;
};


/**
 *  Gets the max zoom for the clusterer.
 *
 *  @return {number} The max zoom level.
 */
MarkerClusterer.prototype.getMaxZoom = function () {
    return this.maxZoom_;
};


/**
 *  The function for calculating the cluster icon image.
 *
 *  @param {Array.<google.maps.Marker>} markers The markers in the clusterer.
 *  @param {number} numStyles The number of styles available.
 *  @return {Object} A object properties: 'text' (string) and 'index' (number).
 *  @private
 */
MarkerClusterer.prototype.calculator_ = function (markers, numStyles) {
    var index = 0;
    var count = markers.length;
    var dv = count;
    while (dv !== 0) {
        dv = parseInt(dv / 10, 10);
        index++;
    }

    index = Math.min(index, numStyles);
    return {
        text: count,
        index: index
    };
};


/**
 * Set the calculator function.
 *
 * @param {function(Array, number)} calculator The function to set as the
 *     calculator. The function should return a object properties:
 *     'text' (string) and 'index' (number).
 *
 */
MarkerClusterer.prototype.setCalculator = function (calculator) {
    this.calculator_ = calculator;
};


/**
 * Get the calculator function.
 *
 * @return {function(Array, number)} the calculator function.
 */
MarkerClusterer.prototype.getCalculator = function () {
    return this.calculator_;
};


/**
 * Add an array of markers to the clusterer.
 *
 * @param {Array.<google.maps.Marker>} markers The markers to add.
 * @param {boolean=} opt_nodraw Whether to redraw the clusters.
 */
MarkerClusterer.prototype.addMarkers = function (markers, opt_nodraw) {
    for (var i = 0, marker; marker = markers[i]; i++) {
        if (!marker.preventClustering) {
          //ToDo: get oms to work with new Google markers
            this.oms_.addMarker(marker);
        }
        this.pushMarkerTo_(marker);
    }
    if (!opt_nodraw) {
        this.redraw();
    }
};


/**
 * Pushes a marker to the clusterer.
 *
 * @param {google.maps.Marker} marker The marker to add.
 * @private
 */
MarkerClusterer.prototype.pushMarkerTo_ = function (marker) {
    marker.isAdded = false;
    if (marker['draggable']) {
        // If the marker is draggable add a listener so we update the clusters on
        // the drag end.
        var that = this;
        google.maps.event.addListener(marker, 'dragend', function () {
            marker.isAdded = false;
            that.repaint();
        });
    }
    this.markers_.push(marker);
};


/**
 * Adds a marker to the clusterer and redraws if needed.
 *
 * @param {google.maps.Marker} marker The marker to add.
 * @param {boolean=} opt_nodraw Whether to redraw the clusters.
 */
MarkerClusterer.prototype.addMarker = function (marker, opt_nodraw) {
    if (!marker.preventClustering) {
        this.oms_.addMarker(marker);
    }
    this.pushMarkerTo_(marker);
    if (!opt_nodraw) {
        this.redraw();
    }
};


/**
 * Removes a marker and returns true if removed, false if not
 *
 * @param {google.maps.Marker} marker The marker to remove
 * @return {boolean} Whether the marker was removed or not
 * @private
 */
MarkerClusterer.prototype.removeMarker_ = function (marker) {
    var index = -1;
    if (this.markers_.indexOf) {
        index = this.markers_.indexOf(marker);
    } else {
        for (var i = 0, m; m = this.markers_[i]; i++) {
            if (m == marker) {
                index = i;
                break;
            }
        }
    }

    if (index == -1) {
        // Marker is not in our list of markers.
        return false;
    }

    marker.setMap(null);
    marker.clustered = true;
    google.maps.event.trigger(marker, 'marker-clustered', true);
    this.markers_.splice(index, 1);

    return true;
};


/**
 * Remove a marker from the cluster.
 *
 * @param {google.maps.Marker} marker The marker to remove.
 * @param {boolean=} opt_nodraw Optional boolean to force no redraw.
 * @return {boolean} True if the marker was removed.
 */
MarkerClusterer.prototype.removeMarker = function (marker, opt_nodraw) {
    this.oms_.removeMarker(marker);
    var removed = this.removeMarker_(marker);

    if (!opt_nodraw && removed) {
        this.resetViewport();
        this.redraw();
        return true;
    } else {
        return false;
    }
};


/**
 * Removes an array of markers from the cluster.
 *
 * @param {Array.<google.maps.Marker>} markers The markers to remove.
 * @param {boolean=} opt_nodraw Optional boolean to force no redraw.
 */
MarkerClusterer.prototype.removeMarkers = function (markers, opt_nodraw) {
    var removed = false;

    for (var i = 0, marker; marker = markers[i]; i++) {
        this.oms_.removeMarker(marker);
        var r = this.removeMarker_(marker);
        removed = removed || r;
    }

    if (!opt_nodraw && removed) {
        this.resetViewport();
        this.redraw();
        return true;
    }
};


/**
 * Sets the clusterer's ready state.
 *
 * @param {boolean} ready The state.
 * @private
 */
MarkerClusterer.prototype.setReady_ = function (ready) {
    if (!this.ready_) {
        this.ready_ = ready;
        this.createClusters_();
    }
};


/**
 * Returns the number of clusters in the clusterer.
 *
 * @return {number} The number of clusters.
 */
MarkerClusterer.prototype.getTotalClusters = function () {
    return this.clusters_.length;
};


/**
 * Returns the google map that the clusterer is associated with.
 *
 * @return {google.maps.Map} The map.
 */
MarkerClusterer.prototype.getMap = function () {
    return this.map_;
};


/**
 * Sets the google map that the clusterer is associated with.
 *
 * @param {google.maps.Map} map The map.
 */
MarkerClusterer.prototype.setMap = function (map) {
    this.map_ = map;
};


/**
 * Returns the size of the grid.
 *
 * @return {number} The grid size.
 */
MarkerClusterer.prototype.getGridSize = function () {
    return this.gridSize_;
};


/**
 * Sets the size of the grid.
 *
 * @param {number} size The grid size.
 */
MarkerClusterer.prototype.setGridSize = function (size) {
    this.gridSize_ = size;
};


/**
 * Returns the min cluster size.
 *
 * @return {number} The grid size.
 */
MarkerClusterer.prototype.getMinClusterSize = function () {
    return this.minClusterSize_;
};

/**
 * Sets the min cluster size.
 *
 * @param {number} size The grid size.
 */
MarkerClusterer.prototype.setMinClusterSize = function (size) {
    this.minClusterSize_ = size;
};


/**
 * Extends a bounds object by the grid size.
 *
 * @param {google.maps.LatLngBounds} bounds The bounds to extend.
 * @return {google.maps.LatLngBounds} The extended bounds.
 */
MarkerClusterer.prototype.getExtendedBounds = function (bounds) {
    var projection = this.getProjection();

    // Turn the bounds into latlng.
    var tr = new google.maps.LatLng(bounds.getNorthEast().lat(),
        bounds.getNorthEast().lng());
    var bl = new google.maps.LatLng(bounds.getSouthWest().lat(),
        bounds.getSouthWest().lng());

    // Convert the points to pixels and the extend out by the grid size.
    var trPix = projection.fromLatLngToDivPixel(tr);
    trPix.x += this.gridSize_;
    trPix.y -= this.gridSize_;

    var blPix = projection.fromLatLngToDivPixel(bl);
    blPix.x -= this.gridSize_;
    blPix.y += this.gridSize_;

    // Convert the pixel points back to LatLng
    var ne = projection.fromDivPixelToLatLng(trPix);
    var sw = projection.fromDivPixelToLatLng(blPix);

    // Extend the bounds to contain the new bounds.
    bounds.extend(ne);
    bounds.extend(sw);

    return bounds;
};


/**
 * Determins if a marker is contained in a bounds.
 *
 * @param {google.maps.Marker} marker The marker to check.
 * @param {google.maps.LatLngBounds} bounds The bounds to check against.
 * @return {boolean} True if the marker is in the bounds.
 * @private
 */
MarkerClusterer.prototype.isMarkerInBounds_ = function (marker, bounds) {
    if (marker.getPosition) return bounds.contains(marker.getPosition());
    else return false;
};


/**
 * Clears all clusters and markers from the clusterer.
 */
MarkerClusterer.prototype.clearMarkers = function () {
    this.resetViewport(true);

    // Set the markers a empty array.
    this.markers_ = [];
};


/**
 * Clears all existing clusters and recreates them.
 * @param {boolean} opt_hide To also hide the marker.
 */
MarkerClusterer.prototype.resetViewport = function (opt_hide) {
    // Remove all the clusters
    for (var i = 0, cluster; cluster = this.clusters_[i]; i++) {
        cluster.remove();
    }

    // Reset the markers to not be added and to be invisible.
    for (var i = 0, marker; marker = this.markers_[i]; i++) {
        marker.isAdded = false;
        if (opt_hide) {
            marker.setMap(null);
        }
    }

    this.clusters_ = [];
};

/**
 *
 */
MarkerClusterer.prototype.repaint = function () {
    var oldClusters = this.clusters_.slice();
    this.clusters_.length = 0;
    this.resetViewport();
    this.redraw();

    // Remove the old clusters.
    // Do it in a timeout so the other clusters have been drawn first.
    window.setTimeout(function () {
        for (var i = 0, cluster; cluster = oldClusters[i]; i++) {
            cluster.remove();
        }
    }, 0);
};


/**
 * Redraws the clusters.
 */
MarkerClusterer.prototype.redraw = function () {
    this.createClusters_();
};


/**
 * Calculates the distance between two latlng locations in km.
 * @see http://www.movable-type.co.uk/scripts/latlong.html
 *
 * @param {google.maps.LatLng} p1 The first lat lng point.
 * @param {google.maps.LatLng} p2 The second lat lng point.
 * @return {number} The distance between the two points in km.
 * @private
*/
MarkerClusterer.prototype.distanceBetweenPoints_ = function (p1, p2) {
    if (!p1 || !p2) {
        return 0;
    }

    var R = 6371; // Radius of the Earth in km
    var dLat = (p2.lat() - p1.lat()) * Math.PI / 180;
    var dLon = (p2.lng() - p1.lng()) * Math.PI / 180;
    var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
        Math.cos(p1.lat() * Math.PI / 180) * Math.cos(p2.lat() * Math.PI / 180) *
        Math.sin(dLon / 2) * Math.sin(dLon / 2);
    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    var d = R * c;
    return d;
};


/**
 * Add a marker to a cluster, or creates a new cluster.
 *
 * @param {google.maps.Marker} marker The marker to add.
 * @private
 */
MarkerClusterer.prototype.addToClosestCluster_ = function (marker) {
    var distance = 40000; // Some large number
    var clusterToAddTo = null;
    var pos = marker.getPosition();
    for (var i = 0, cluster; cluster = this.clusters_[i]; i++) {
        var center = cluster.getCenter();
        if (center) {
            var d = this.distanceBetweenPoints_(center, marker.getPosition());
            if (d < distance) {
                distance = d;
                clusterToAddTo = cluster;
            }
        }
    }

    if (clusterToAddTo && clusterToAddTo.isMarkerInClusterBounds(marker)) {
        clusterToAddTo.addMarker(marker);
    } else {
        var cluster = new Cluster(this);
        cluster.addMarker(marker);
        this.clusters_.push(cluster);
    }
};


/**
 * Creates the clusters.
 *
 * @private
 */
MarkerClusterer.prototype.createClusters_ = function () {
    if (!this.ready_) {
        return;
    }

    // Get our current map view bounds.
    // Create a new bounds object so we don't affect the map.
    var mapBounds = new google.maps.LatLngBounds(this.map_.getBounds().getSouthWest(),
        this.map_.getBounds().getNorthEast());
    var bounds = this.getExtendedBounds(mapBounds);

    for (var i = 0, marker; marker = this.markers_[i]; i++) {
        if (!marker.isAdded && this.isMarkerInBounds_(marker, bounds)) {
            this.addToClosestCluster_(marker);
        }
    }
};


/**
 * A cluster that contains markers.
 *
 * @param {MarkerClusterer} markerClusterer The markerclusterer that this
 *     cluster is associated with.
 * @constructor
 * @ignore
 */
function Cluster(markerClusterer) {
    this.markerClusterer_ = markerClusterer;
    this.map_ = markerClusterer.getMap();
    this.gridSize_ = markerClusterer.getGridSize();
    this.minClusterSize_ = markerClusterer.getMinClusterSize();
    this.averageCenter_ = markerClusterer.isAverageCenter();
    this.center_ = null;
    this.markers_ = [];
    this.bounds_ = null;
    this.clusterIcon_ = new ClusterIcon(this, markerClusterer.getStyles(),
        markerClusterer.getGridSize());
}

/**
 * Determins if a marker is already added to the cluster.
 *
 * @param {google.maps.Marker} marker The marker to check.
 * @return {boolean} True if the marker is already added.
 */
Cluster.prototype.isMarkerAlreadyAdded = function (marker) {
    if (this.markers_.indexOf) {
        return this.markers_.indexOf(marker) != -1;
    } else {
        for (var i = 0, m; m = this.markers_[i]; i++) {
            if (m == marker) {
                return true;
            }
        }
    }
    return false;
};


/**
 * Add a marker the cluster.
 *
 * @param {google.maps.Marker} marker The marker to add.
 * @return {boolean} True if the marker was added.
 */
Cluster.prototype.addMarker = function (marker) {
    if (this.isMarkerAlreadyAdded(marker)) {
        return false;
    }

    if (!this.center_) {
        this.center_ = marker.getPosition();
        this.calculateBounds_();
    } else {
        if (this.averageCenter_) {
            var l = this.markers_.length + 1;
            var lat = (this.center_.lat() * (l - 1) + marker.getPosition().lat()) / l;
            var lng = (this.center_.lng() * (l - 1) + marker.getPosition().lng()) / l;
            this.center_ = new google.maps.LatLng(lat, lng);
            this.calculateBounds_();
        }
    }

    marker.isAdded = true;
    if (!marker.preventClustering) {
        this.markers_.push(marker);
    }
    
    var len = this.markers_.length;
    if (len < this.minClusterSize_ || marker.preventClustering) {
        // Min cluster size not reached so show the marker.
        if (marker.getMap() != this.map_) {
            marker.setMap(this.map_);
        }
        marker.clustered = false;
        google.maps.event.trigger(marker, 'marker-clustered', false);
    }

    if (len == this.minClusterSize_) {
        // Hide the markers that were showing.
        for (var i = 0; i < len; i++) {
            this.markers_[i].setMap(null);
            this.markers_[i].clustered = true;
            google.maps.event.trigger(this.markers_[i], 'marker-clustered', true);
        }
    }

    if (len >= this.minClusterSize_ && !marker.preventClustering) {
        marker.setMap(null);
        marker.clustered = true;
        google.maps.event.trigger(marker, 'marker-clustered', true);
    }

    this.updateIcon();
    return true;
};


/**
 * Returns the marker clusterer that the cluster is associated with.
 *
 * @return {MarkerClusterer} The associated marker clusterer.
 */
Cluster.prototype.getMarkerClusterer = function () {
    return this.markerClusterer_;
};


/**
 * Returns the bounds of the cluster.
 *
 * @return {google.maps.LatLngBounds} the cluster bounds.
 */
Cluster.prototype.getBounds = function () {
    var bounds = new google.maps.LatLngBounds(this.center_, this.center_);
    var markers = this.getMarkers();
    for (var i = 0, marker; marker = markers[i]; i++) {
        bounds.extend(marker.getPosition());
    }
    return bounds;
};


/**
 * Removes the cluster
 */
Cluster.prototype.remove = function () {
    this.clusterIcon_.remove();
    this.markers_.length = 0;
    delete this.markers_;
};


/**
 * Returns the center of the cluster.
 *
 * @return {number} The cluster center.
 */
Cluster.prototype.getSize = function () {
    return this.markers_.length;
};


/**
 * Returns the center of the cluster.
 *
 * @return {Array.<google.maps.Marker>} The cluster center.
 */
Cluster.prototype.getMarkers = function () {
    return this.markers_;
};


/**
 * Returns the center of the cluster.
 *
 * @return {google.maps.LatLng} The cluster center.
 */
Cluster.prototype.getCenter = function () {
    return this.center_;
};


/**
 * Calculated the extended bounds of the cluster with the grid.
 *
 * @private
 */
Cluster.prototype.calculateBounds_ = function () {
    var bounds = new google.maps.LatLngBounds(this.center_, this.center_);
    this.bounds_ = this.markerClusterer_.getExtendedBounds(bounds);
};


/**
 * Determines if a marker lies in the clusters bounds.
 *
 * @param {google.maps.Marker} marker The marker to check.
 * @return {boolean} True if the marker lies in the bounds.
 */
Cluster.prototype.isMarkerInClusterBounds = function (marker) {
    return this.bounds_.contains(marker.getPosition());
};


/**
 * Returns the map that the cluster is associated with.
 *
 * @return {google.maps.Map} The map.
 */
Cluster.prototype.getMap = function () {
    return this.map_;
};


/**
 * Updates the cluster icon
 */
Cluster.prototype.updateIcon = function () {
    var zoom = this.map_.getZoom();
    var mz = this.markerClusterer_.getMaxZoom();

    if (mz && zoom > mz) {
        // The zoom is greater than our max zoom so show all the markers in cluster.
        for (var i = 0, marker; marker = this.markers_[i]; i++) {
            //check to see if the map is already set so we don't flicker the icon
            if (marker.map !== this.map_) {
                marker.setMap(this.map_);
                marker.clustered = false;
                google.maps.event.trigger(marker, 'marker-clustered', false);
            }
        }
        return;
    }

    if (this.markers_.length < this.minClusterSize_) {
        // Min cluster size not yet reached.
        this.clusterIcon_.hide();
        return;
    }

    var numStyles = this.markerClusterer_.getStyles().length;
    var sums = this.markerClusterer_.getCalculator()(this.markers_, numStyles);
    this.clusterIcon_.setCenter(this.center_);
    this.clusterIcon_.setSums(sums);
    this.clusterIcon_.show();
};


/**
 * A cluster icon
 *
 * @param {Cluster} cluster The cluster to be associated with.
 * @param {Object} styles An object that has style properties:
 *     'url': (string) The image url.
 *     'height': (number) The image height.
 *     'width': (number) The image width.
 *     'anchor': (Array) The anchor position of the label text.
 *     'textColor': (string) The text color.
 *     'textSize': (number) The text size.
 *     'backgroundPosition: (string) The background postition x, y.
 * @param {number=} opt_padding Optional padding to apply to the cluster icon.
 * @constructor
 * @extends google.maps.OverlayView
 * @ignore
 */
function ClusterIcon(cluster, styles, opt_padding) {
    cluster.getMarkerClusterer().extend(ClusterIcon, google.maps.OverlayView);

    this.styles_ = styles;
    this.padding_ = opt_padding || 0;
    this.cluster_ = cluster;
    this.center_ = null;
    this.map_ = cluster.getMap();
    this.div_ = null;
    this.sums_ = null;
    this.visible_ = false;

    this.setMap(this.map_);
}


/**
 * Triggers the clusterclick event and zoom's if the option is set.
 *
 * @param {google.maps.MouseEvent} event The event to propagate
 */
ClusterIcon.prototype.triggerClusterClick = function (event) {
    var markerClusterer = this.cluster_.getMarkerClusterer();

    // Trigger the clusterclick event.
    google.maps.event.trigger(markerClusterer, 'clusterclick', this.cluster_, event);

    if (markerClusterer.isZoomOnClick()) {
        // Zoom into the cluster.
        this.map_.fitBounds(this.cluster_.getBounds());
        this.map_.panBy(0, 0);
    }
};


/**
 * Adding the cluster icon to the dom.
 * @ignore
 */
ClusterIcon.prototype.onAdd = function () {
    this.div_ = document.createElement('DIV');
    if (this.visible_) {
        var pos = this.getPosFromLatLng_(this.center_);
        this.div_.style.cssText = this.createCss(pos);
        this.div_.innerHTML = this.sums_.text;
    }

    var panes = this.getPanes();
    panes.overlayMouseTarget.appendChild(this.div_);

    var that = this;
    this.div_.addEventListener('click', function (event) {
        event.stopPropagation();  //to avoid click conflict with KML layer (County Boundary)
        that.triggerClusterClick(event);
    });
};


/**
 * Returns the position to place the div dending on the latlng.
 *
 * @param {google.maps.LatLng} latlng The position in latlng.
 * @return {google.maps.Point} The position in pixels.
 * @private
 */
ClusterIcon.prototype.getPosFromLatLng_ = function (latlng) {
    var pos = this.getProjection().fromLatLngToDivPixel(latlng);

    if (typeof this.iconAnchor_ === 'object' && this.iconAnchor_.length === 2) {
        pos.x -= this.iconAnchor_[0];
        pos.y -= this.iconAnchor_[1];
    } else {
        pos.x -= parseInt(this.width_ / 2, 10);
        pos.y -= parseInt(this.height_ / 2, 10);
    }
    return pos;
};


/**
 * Draw the icon.
 * @ignore
 */
ClusterIcon.prototype.draw = function () {
    if (this.visible_) {
        var pos = this.getPosFromLatLng_(this.center_);
        this.div_.style.top = pos.y + 'px';
        this.div_.style.left = pos.x + 'px';
    }
};


/**
 * Hide the icon.
 */
ClusterIcon.prototype.hide = function () {
    if (this.div_) {
        this.div_.style.display = 'none';
    }
    this.visible_ = false;
};


/**
 * Position and show the icon.
 */
ClusterIcon.prototype.show = function () {
    if (this.div_) {
        var pos = this.getPosFromLatLng_(this.center_);
        this.div_.style.cssText = this.createCss(pos);
        this.div_.style.display = '';
    }
    this.visible_ = true;
};


/**
 * Remove the icon from the map
 */
ClusterIcon.prototype.remove = function () {
    this.setMap(null);
};


/**
 * Implementation of the onRemove interface.
 * @ignore
 */
ClusterIcon.prototype.onRemove = function () {
    if (this.div_ && this.div_.parentNode) {
        this.hide();
        this.div_.parentNode.removeChild(this.div_);
        this.div_ = null;
    }
};


/**
 * Set the sums of the icon.
 *
 * @param {Object} sums The sums containing:
 *   'text': (string) The text to display in the icon.
 *   'index': (number) The style index of the icon.
 */
ClusterIcon.prototype.setSums = function (sums) {
    this.sums_ = sums;
    this.text_ = sums.text;
    this.index_ = sums.index;
    if (this.div_) {
        this.div_.innerHTML = sums.text;
    }

    this.useStyle();
};


/**
 * Sets the icon to the the styles.
 */
ClusterIcon.prototype.useStyle = function () {
    var index = Math.max(0, this.sums_.index - 1);
    index = Math.min(this.styles_.length - 1, index);
    var style = this.styles_[index];
    this.url_ = style['url'];
    this.height_ = style['height'];
    this.width_ = style['width'];
    this.textColor_ = style['textColor'];
    this.anchor_ = style['anchor'];
    this.textSize_ = style['textSize'];
    this.backgroundPosition_ = style['backgroundPosition'];
    this.iconAnchor_ = style['iconAnchor'];
};


/**
 * Sets the center of the icon.
 *
 * @param {google.maps.LatLng} center The latlng to set as the center.
 */
ClusterIcon.prototype.setCenter = function (center) {
    this.center_ = center;
};


/**
 * Create the css text based on the position of the icon.
 *
 * @param {google.maps.Point} pos The position.
 * @return {string} The css style text.
 */
ClusterIcon.prototype.createCss = function (pos) {
    var style = [];
    style.push('background-image:url(' + this.url_ + ');');
    var backgroundPosition = this.backgroundPosition_ ? this.backgroundPosition_ : '0 0';
    style.push('background-position:' + backgroundPosition + ';');

    if (typeof this.anchor_ === 'object') {
        if (typeof this.anchor_[0] === 'number' && this.anchor_[0] > 0 &&
            this.anchor_[0] < this.height_) {
            style.push('height:' + (this.height_ - this.anchor_[0]) +
                'px; padding-top:' + this.anchor_[0] + 'px;');
        } else if (typeof this.anchor_[0] === 'number' && this.anchor_[0] < 0 &&
            -this.anchor_[0] < this.height_) {
            style.push('height:' + this.height_ + 'px; line-height:' + (this.height_ + this.anchor_[0]) +
                'px;');
        } else {
            style.push('height:' + this.height_ + 'px; line-height:' + this.height_ +
                'px;');
        }
        if (typeof this.anchor_[1] === 'number' && this.anchor_[1] > 0 &&
            this.anchor_[1] < this.width_) {
            style.push('width:' + (this.width_ - this.anchor_[1]) +
                'px; padding-left:' + this.anchor_[1] + 'px;');
        } else {
            style.push('width:' + this.width_ + 'px; text-align:center;');
        }
    } else {
        style.push('height:' + this.height_ + 'px; line-height:' +
            this.height_ + 'px; width:' + this.width_ + 'px; text-align:center;');
    }

    var txtColor = this.textColor_ ? this.textColor_ : 'black';
    var txtSize = this.textSize_ ? this.textSize_ : 11;

    style.push('cursor:pointer; top:' + pos.y + 'px; left:' +
        pos.x + 'px; color:' + txtColor + '; position:absolute; font-size:' +
        txtSize + 'px; font-family:Arial,sans-serif; font-weight:bold');
    return style.join('');
};
/*
 OverlappingMarkerSpiderfier
https://github.com/jawj/OverlappingMarkerSpiderfier
Copyright (c) 2011 - 2017 George MacKerron
Released under the MIT licence: http://opensource.org/licenses/mit-license
Note: The Google Maps API v3 must be included *before* this code
*/

(function () {
    var callbackName, callbackRegEx, ref, ref1, scriptTag, tag,
        hasProp = {}.hasOwnProperty,
        slice = [].slice;

    this['OverlappingMarkerSpiderfier'] = (function () {
        var ge, gm, j, len, mt, p, ref, twoPi, x;

        p = _Class.prototype;

        ref = [_Class, p];
        for (j = 0, len = ref.length; j < len; j++) {
            x = ref[j];
            x['VERSION'] = '1.0.3';
        }

        twoPi = Math.PI * 2;

        gm = ge = mt = null;

        _Class['markerStatus'] = {
            'SPIDERFIED': 'SPIDERFIED',
            'SPIDERFIABLE': 'SPIDERFIABLE',
            'UNSPIDERFIABLE': 'UNSPIDERFIABLE',
            'UNSPIDERFIED': 'UNSPIDERFIED'
        };

        function _Class(map1, opts) {
            var k, lcH, lcU, v;
            this.map = map1;
            if (opts == null) {
                opts = {};
            }
            if (this.constructor.hasInitialized == null) {
                this.constructor.hasInitialized = true;
                gm = google.maps;
                ge = gm.event;
                mt = gm.MapTypeId;
                p['keepSpiderfied'] = false;
                p['ignoreMapClick'] = false;
                p['markersWontHide'] = false;
                p['markersWontMove'] = false;
                p['basicFormatEvents'] = false;
                p['nearbyDistance'] = 20;
                p['circleSpiralSwitchover'] = 9;
                p['circleFootSeparation'] = 23;
                p['circleStartAngle'] = twoPi / 12;
                p['spiralFootSeparation'] = 26;
                p['spiralLengthStart'] = 11;
                p['spiralLengthFactor'] = 4;
                p['spiderfiedZIndex'] = gm.Marker.MAX_ZINDEX + 20000;
                p['highlightedLegZIndex'] = gm.Marker.MAX_ZINDEX + 10000;
                p['usualLegZIndex'] = gm.Marker.MAX_ZINDEX + 1;
                p['legWeight'] = 1.5;
                p['legColors'] = {
                    'usual': {},
                    'highlighted': {}
                };
                lcU = p['legColors']['usual'];
                lcH = p['legColors']['highlighted'];
                lcU[mt.HYBRID] = lcU[mt.SATELLITE] = '#fff';
                lcH[mt.HYBRID] = lcH[mt.SATELLITE] = '#f00';
                lcU[mt.TERRAIN] = lcU[mt.ROADMAP] = '#444';
                lcH[mt.TERRAIN] = lcH[mt.ROADMAP] = '#f00';
                this.constructor.ProjHelper = function (map) {
                    return this.setMap(map);
                };
                this.constructor.ProjHelper.prototype = new gm.OverlayView();
                this.constructor.ProjHelper.prototype['draw'] = function () { };
            }
            for (k in opts) {
                if (!hasProp.call(opts, k)) continue;
                v = opts[k];
                this[k] = v;
            }
            this.projHelper = new this.constructor.ProjHelper(this.map);
            this.initMarkerArrays();
            this.listeners = {};
            this.formatIdleListener = this.formatTimeoutId = null;
            this.addListener('click', function (marker, e) {
                return ge.trigger(marker, 'spider_click', e);
            });
            this.addListener('format', function (marker, status) {
                return ge.trigger(marker, 'spider_format', status);
            });
            if (!this['ignoreMapClick']) {
                ge.addListener(this.map, 'click', (function (_this) {
                    return function () {
                        return _this['unspiderfy']();
                    };
                })(this));
            }
            ge.addListener(this.map, 'maptypeid_changed', (function (_this) {
                return function () {
                    return _this['unspiderfy']();
                };
            })(this));
            ge.addListener(this.map, 'zoom_changed', (function (_this) {
                return function () {
                    _this['unspiderfy']();
                    if (!_this['basicFormatEvents']) {
                        return _this.formatMarkers();
                    }
                };
            })(this));
        }

        p.initMarkerArrays = function () {
            this.markers = [];
            return this.markerListenerRefs = [];
        };

        p['addMarker'] = function (marker, spiderClickHandler) {
            marker.setMap(this.map);
            return this['trackMarker'](marker, spiderClickHandler);
        };

        p['trackMarker'] = function (marker, spiderClickHandler) {
            var listenerRefs;
            if (marker['_oms'] != null) {
                return this;
            }
            marker['_oms'] = true;
            listenerRefs = [
                ge.addListener(marker, 'click', (function (_this) {
                    return function (e) {
                        return _this.spiderListener(marker, e);
                    };
                })(this))
            ];
            if (!this['markersWontHide']) {
                listenerRefs.push(ge.addListener(marker, 'visible_changed', (function (_this) {
                    return function () {
                        return _this.markerChangeListener(marker, false);
                    };
                })(this)));
            }
            if (!this['markersWontMove']) {
                listenerRefs.push(ge.addListener(marker, 'position_changed', (function (_this) {
                    return function () {
                        return _this.markerChangeListener(marker, true);
                    };
                })(this)));
            }
            if (spiderClickHandler != null) {
                listenerRefs.push(ge.addListener(marker, 'spider_click', spiderClickHandler));
            }
            this.markerListenerRefs.push(listenerRefs);
            this.markers.push(marker);
            if (this['basicFormatEvents']) {
                this.trigger('format', marker, this.constructor['markerStatus']['UNSPIDERFIED']);
            } else {
                this.trigger('format', marker, this.constructor['markerStatus']['UNSPIDERFIABLE']);
                this.formatMarkers();
            }
            return this;
        };

        p.markerChangeListener = function (marker, positionChanged) {
            if (this.spiderfying || this.unspiderfying) {
                return;
            }
            if ((marker['_omsData'] != null) && (positionChanged || !marker.getVisible())) {
                this['unspiderfy'](positionChanged ? marker : null);
            }
            return this.formatMarkers();
        };

        p['getMarkers'] = function () {
            return this.markers.slice(0);
        };

        p['removeMarker'] = function (marker) {
            this['forgetMarker'](marker);
            return marker.setMap(null);
        };

        p['forgetMarker'] = function (marker) {
            var i, l, len1, listenerRef, listenerRefs;
            if (marker['_omsData'] != null) {
                this['unspiderfy']();
            }
            i = this.arrIndexOf(this.markers, marker);
            if (i < 0) {
                return this;
            }
            listenerRefs = this.markerListenerRefs.splice(i, 1)[0];
            for (l = 0, len1 = listenerRefs.length; l < len1; l++) {
                listenerRef = listenerRefs[l];
                ge.removeListener(listenerRef);
            }
            delete marker['_oms'];
            this.markers.splice(i, 1);
            this.formatMarkers();
            return this;
        };

        p['removeAllMarkers'] = p['clearMarkers'] = function () {
            var l, len1, marker, markers;
            markers = this['getMarkers']();
            this['forgetAllMarkers']();
            for (l = 0, len1 = markers.length; l < len1; l++) {
                marker = markers[l];
                marker.setMap(null);
            }
            return this;
        };

        p['forgetAllMarkers'] = function () {
            var i, l, len1, len2, listenerRef, listenerRefs, marker, n, ref1;
            this['unspiderfy']();
            ref1 = this.markers;
            for (i = l = 0, len1 = ref1.length; l < len1; i = ++l) {
                marker = ref1[i];
                listenerRefs = this.markerListenerRefs[i];
                for (n = 0, len2 = listenerRefs.length; n < len2; n++) {
                    listenerRef = listenerRefs[n];
                    ge.removeListener(listenerRef);
                }
                delete marker['_oms'];
            }
            this.initMarkerArrays();
            return this;
        };

        p['addListener'] = function (eventName, func) {
            var base;
            ((base = this.listeners)[eventName] != null ? base[eventName] : base[eventName] = []).push(func);
            return this;
        };

        p['removeListener'] = function (eventName, func) {
            var i;
            i = this.arrIndexOf(this.listeners[eventName], func);
            if (!(i < 0)) {
                this.listeners[eventName].splice(i, 1);
            }
            return this;
        };

        p['clearListeners'] = function (eventName) {
            this.listeners[eventName] = [];
            return this;
        };

        p.trigger = function () {
            var args, eventName, func, l, len1, ref1, ref2, results;
            eventName = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
            ref2 = (ref1 = this.listeners[eventName]) != null ? ref1 : [];
            results = [];
            for (l = 0, len1 = ref2.length; l < len1; l++) {
                func = ref2[l];
                results.push(func.apply(null, args));
            }
            return results;
        };

        p.generatePtsCircle = function (count, centerPt) {
            var angle, angleStep, circumference, i, l, legLength, ref1, results;
            circumference = this['circleFootSeparation'] * (2 + count);
            legLength = circumference / twoPi;
            angleStep = twoPi / count;
            results = [];
            for (i = l = 0, ref1 = count; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
                angle = this['circleStartAngle'] + i * angleStep;
                results.push(new gm.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle)));
            }
            return results;
        };

        p.generatePtsSpiral = function (count, centerPt) {
            var angle, i, l, legLength, pt, ref1, results;
            legLength = this['spiralLengthStart'];
            angle = 0;
            results = [];
            for (i = l = 0, ref1 = count; 0 <= ref1 ? l < ref1 : l > ref1; i = 0 <= ref1 ? ++l : --l) {
                angle += this['spiralFootSeparation'] / legLength + i * 0.0005;
                pt = new gm.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle));
                legLength += twoPi * this['spiralLengthFactor'] / angle;
                results.push(pt);
            }
            return results;
        };

        p.spiderListener = function (marker, e) {
            var l, len1, m, mPt, markerPt, markerSpiderfied, nDist, nearbyMarkerData, nonNearbyMarkers, pxSq, ref1;
            markerSpiderfied = marker['_omsData'] != null;
            if (!(markerSpiderfied && this['keepSpiderfied'])) {
                this['unspiderfy']();
            }
            if (markerSpiderfied || this.map.getStreetView().getVisible() || this.map.getMapTypeId() === 'GoogleEarthAPI') {
                return this.trigger('click', marker, e);
            } else {
                nearbyMarkerData = [];
                nonNearbyMarkers = [];
                nDist = this['nearbyDistance'];
                pxSq = nDist * nDist;
                markerPt = this.llToPt(marker.position);
                ref1 = this.markers;
                for (l = 0, len1 = ref1.length; l < len1; l++) {
                    m = ref1[l];
                    if (!((m.map != null) && m.getVisible())) {
                        continue;
                    }
                    mPt = this.llToPt(m.position);
                    if (this.ptDistanceSq(mPt, markerPt) < pxSq) {
                        nearbyMarkerData.push({
                            marker: m,
                            markerPt: mPt
                        });
                    } else {
                        nonNearbyMarkers.push(m);
                    }
                }
                if (nearbyMarkerData.length === 1) {
                    return this.trigger('click', marker, e);
                } else {
                    return this.spiderfy(nearbyMarkerData, nonNearbyMarkers);
                }
            }
        };

        p['markersNearMarker'] = function (marker, firstOnly) {
            var l, len1, m, mPt, markerPt, markers, nDist, pxSq, ref1, ref2, ref3;
            if (firstOnly == null) {
                firstOnly = false;
            }
            if (this.projHelper.getProjection() == null) {
                throw "Must wait for 'idle' event on map before calling markersNearMarker";
            }
            nDist = this['nearbyDistance'];
            pxSq = nDist * nDist;
            markerPt = this.llToPt(marker.position);
            markers = [];
            ref1 = this.markers;
            for (l = 0, len1 = ref1.length; l < len1; l++) {
                m = ref1[l];
                if (m === marker || (m.map == null) || !m.getVisible()) {
                    continue;
                }
                mPt = this.llToPt((ref2 = (ref3 = m['_omsData']) != null ? ref3.usualPosition : void 0) != null ? ref2 : m.position);
                if (this.ptDistanceSq(mPt, markerPt) < pxSq) {
                    markers.push(m);
                    if (firstOnly) {
                        break;
                    }
                }
            }
            return markers;
        };

        p.markerProximityData = function () {
            var i1, i2, l, len1, len2, m, m1, m1Data, m2, m2Data, mData, n, nDist, pxSq, ref1, ref2;
            if (this.projHelper.getProjection() == null) {
                throw "Must wait for 'idle' event on map before calling markersNearAnyOtherMarker";
            }
            nDist = this['nearbyDistance'];
            pxSq = nDist * nDist;
            mData = (function () {
                var l, len1, ref1, ref2, ref3, results;
                ref1 = this.markers;
                results = [];
                for (l = 0, len1 = ref1.length; l < len1; l++) {
                    m = ref1[l];
                    results.push({
                        pt: this.llToPt((ref2 = (ref3 = m['_omsData']) != null ? ref3.usualPosition : void 0) != null ? ref2 : m.position),
                        willSpiderfy: false
                    });
                }
                return results;
            }).call(this);
            ref1 = this.markers;
            for (i1 = l = 0, len1 = ref1.length; l < len1; i1 = ++l) {
                m1 = ref1[i1];
                if (!((m1.getMap() != null) && m1.getVisible())) {
                    continue;
                }
                m1Data = mData[i1];
                if (m1Data.willSpiderfy) {
                    continue;
                }
                ref2 = this.markers;
                for (i2 = n = 0, len2 = ref2.length; n < len2; i2 = ++n) {
                    m2 = ref2[i2];
                    if (i2 === i1) {
                        continue;
                    }
                    if (!((m2.getMap() != null) && m2.getVisible())) {
                        continue;
                    }
                    m2Data = mData[i2];
                    if (i2 < i1 && !m2Data.willSpiderfy) {
                        continue;
                    }
                    if (this.ptDistanceSq(m1Data.pt, m2Data.pt) < pxSq) {
                        m1Data.willSpiderfy = m2Data.willSpiderfy = true;
                        break;
                    }
                }
            }
            return mData;
        };

        p['markersNearAnyOtherMarker'] = function () {
            var i, l, len1, m, mData, ref1, results;
            mData = this.markerProximityData();
            ref1 = this.markers;
            results = [];
            for (i = l = 0, len1 = ref1.length; l < len1; i = ++l) {
                m = ref1[i];
                if (mData[i].willSpiderfy) {
                    results.push(m);
                }
            }
            return results;
        };

        p.setImmediate = function (func) {
            return window.setTimeout(func, 0);
        };

        p.formatMarkers = function () {
            if (this['basicFormatEvents']) {
                return;
            }
            if (this.formatTimeoutId != null) {
                return;
            }
            return this.formatTimeoutId = this.setImmediate((function (_this) {
                return function () {
                    _this.formatTimeoutId = null;
                    if (_this.projHelper.getProjection() != null) {
                        return _this._formatMarkers();
                    } else {
                        if (_this.formatIdleListener != null) {
                            return;
                        }
                        return _this.formatIdleListener = ge.addListenerOnce(_this.map, 'idle', function () {
                            return _this._formatMarkers();
                        });
                    }
                };
            })(this));
        };

        p._formatMarkers = function () {
            var i, l, len1, len2, marker, n, proximities, ref1, results, results1, status;
            if (this['basicFormatEvents']) {
                results = [];
                for (l = 0, len1 = markers.length; l < len1; l++) {
                    marker = markers[l];
                    status = marker['_omsData'] != null ? 'SPIDERFIED' : 'UNSPIDERFIED';
                    results.push(this.trigger('format', marker, this.constructor['markerStatus'][status]));
                }
                return results;
            } else {
                proximities = this.markerProximityData();
                ref1 = this.markers;
                results1 = [];
                for (i = n = 0, len2 = ref1.length; n < len2; i = ++n) {
                    marker = ref1[i];
                    status = marker['_omsData'] != null ? 'SPIDERFIED' : proximities[i].willSpiderfy ? 'SPIDERFIABLE' : 'UNSPIDERFIABLE';
                    results1.push(this.trigger('format', marker, this.constructor['markerStatus'][status]));
                }
                return results1;
            }
        };

        p.makeHighlightListenerFuncs = function (marker) {
            return {
                highlight: (function (_this) {
                    return function () {
                        return marker['_omsData'].leg.setOptions({
                            strokeColor: _this['legColors']['highlighted'][_this.map.mapTypeId],
                            zIndex: _this['highlightedLegZIndex']
                        });
                    };
                })(this),
                unhighlight: (function (_this) {
                    return function () {
                        return marker['_omsData'].leg.setOptions({
                            strokeColor: _this['legColors']['usual'][_this.map.mapTypeId],
                            zIndex: _this['usualLegZIndex']
                        });
                    };
                })(this)
            };
        };

        p.spiderfy = function (markerData, nonNearbyMarkers) {
            var bodyPt, footLl, footPt, footPts, highlightListenerFuncs, leg, marker, md, nearestMarkerDatum, numFeet, spiderfiedMarkers;
            this.spiderfying = true;
            numFeet = markerData.length;
            bodyPt = this.ptAverage((function () {
                var l, len1, results;
                results = [];
                for (l = 0, len1 = markerData.length; l < len1; l++) {
                    md = markerData[l];
                    results.push(md.markerPt);
                }
                return results;
            })());
            footPts = numFeet >= this['circleSpiralSwitchover'] ? this.generatePtsSpiral(numFeet, bodyPt).reverse() : this.generatePtsCircle(numFeet, bodyPt);
            spiderfiedMarkers = (function () {
                var l, len1, results;
                results = [];
                for (l = 0, len1 = footPts.length; l < len1; l++) {
                    footPt = footPts[l];
                    footLl = this.ptToLl(footPt);
                    nearestMarkerDatum = this.minExtract(markerData, (function (_this) {
                        return function (md) {
                            return _this.ptDistanceSq(md.markerPt, footPt);
                        };
                    })(this));
                    marker = nearestMarkerDatum.marker;
                    leg = new gm.Polyline({
                        map: this.map,
                        path: [marker.position, footLl],
                        strokeColor: this['legColors']['usual'][this.map.mapTypeId],
                        strokeWeight: this['legWeight'],
                        zIndex: this['usualLegZIndex']
                    });
                    marker['_omsData'] = {
                        usualPosition: marker.getPosition(),
                        usualZIndex: marker.getZIndex(),
                        leg: leg
                    };
                    if (this['legColors']['highlighted'][this.map.mapTypeId] !== this['legColors']['usual'][this.map.mapTypeId]) {
                        highlightListenerFuncs = this.makeHighlightListenerFuncs(marker);
                        marker['_omsData'].hightlightListeners = {
                            highlight: ge.addListener(marker, 'mouseover', highlightListenerFuncs.highlight),
                            unhighlight: ge.addListener(marker, 'mouseout', highlightListenerFuncs.unhighlight)
                        };
                    }
                    this.trigger('format', marker, this.constructor['markerStatus']['SPIDERFIED']);
                    marker.setPosition(footLl);
                    marker.setZIndex(Math.round(this['spiderfiedZIndex'] + footPt.y));
                    results.push(marker);
                }
                return results;
            }).call(this);
            delete this.spiderfying;
            this.spiderfied = true;
            return this.trigger('spiderfy', spiderfiedMarkers, nonNearbyMarkers);
        };

        p['unspiderfy'] = function (markerNotToMove) {
            var l, len1, listeners, marker, nonNearbyMarkers, ref1, status, unspiderfiedMarkers;
            if (markerNotToMove == null) {
                markerNotToMove = null;
            }
            if (this.spiderfied == null) {
                return this;
            }
            this.unspiderfying = true;
            unspiderfiedMarkers = [];
            nonNearbyMarkers = [];
            ref1 = this.markers;
            for (l = 0, len1 = ref1.length; l < len1; l++) {
                marker = ref1[l];
                if (marker['_omsData'] != null) {
                    marker['_omsData'].leg.setMap(null);
                    if (marker !== markerNotToMove) {
                        marker.setPosition(marker['_omsData'].usualPosition);
                    }
                    marker.setZIndex(marker['_omsData'].usualZIndex);
                    listeners = marker['_omsData'].hightlightListeners;
                    if (listeners != null) {
                        ge.removeListener(listeners.highlight);
                        ge.removeListener(listeners.unhighlight);
                    }
                    delete marker['_omsData'];
                    if (marker !== markerNotToMove) {
                        status = this['basicFormatEvents'] ? 'UNSPIDERFIED' : 'SPIDERFIABLE';
                        this.trigger('format', marker, this.constructor['markerStatus'][status]);
                    }
                    unspiderfiedMarkers.push(marker);
                } else {
                    nonNearbyMarkers.push(marker);
                }
            }
            delete this.unspiderfying;
            delete this.spiderfied;
            this.trigger('unspiderfy', unspiderfiedMarkers, nonNearbyMarkers);
            return this;
        };

        p.ptDistanceSq = function (pt1, pt2) {
            var dx, dy;
            dx = pt1.x - pt2.x;
            dy = pt1.y - pt2.y;
            return dx * dx + dy * dy;
        };

        p.ptAverage = function (pts) {
            var l, len1, numPts, pt, sumX, sumY;
            sumX = sumY = 0;
            for (l = 0, len1 = pts.length; l < len1; l++) {
                pt = pts[l];
                sumX += pt.x;
                sumY += pt.y;
            }
            numPts = pts.length;
            return new gm.Point(sumX / numPts, sumY / numPts);
        };

        p.llToPt = function (ll) {
            return this.projHelper.getProjection().fromLatLngToDivPixel(ll);
        };

        p.ptToLl = function (pt) {
            return this.projHelper.getProjection().fromDivPixelToLatLng(pt);
        };

        p.minExtract = function (set, func) {
            var bestIndex, bestVal, index, item, l, len1, val;
            for (index = l = 0, len1 = set.length; l < len1; index = ++l) {
                item = set[index];
                val = func(item);
                if ((typeof bestIndex === "undefined" || bestIndex === null) || val < bestVal) {
                    bestVal = val;
                    bestIndex = index;
                }
            }
            return set.splice(bestIndex, 1)[0];
        };

        p.arrIndexOf = function (arr, obj) {
            var i, l, len1, o;
            if (arr.indexOf != null) {
                return arr.indexOf(obj);
            }
            for (i = l = 0, len1 = arr.length; l < len1; i = ++l) {
                o = arr[i];
                if (o === obj) {
                    return i;
                }
            }
            return -1;
        };

        return _Class;

    })();

    callbackRegEx = /(\?.*(&|&amp;)|\?)spiderfier_callback=(\w+)/;

    scriptTag = document.currentScript;

    if (scriptTag == null) {
        scriptTag = ((function () {
            var j, len, ref, ref1, results;
            ref = document.getElementsByTagName('script');
            results = [];
            for (j = 0, len = ref.length; j < len; j++) {
                tag = ref[j];
                if ((ref1 = tag.getAttribute('src')) != null ? ref1.match(callbackRegEx) : void 0) {
                    results.push(tag);
                }
            }
            return results;
        })())[0];
    }

    if (scriptTag != null) {
        callbackName = (ref = scriptTag.getAttribute('src')) != null ? (ref1 = ref.match(callbackRegEx)) != null ? ref1[3] : void 0 : void 0;
        if (callbackName) {
            if (typeof window[callbackName] === "function") {
                window[callbackName]();
            }
        }
    }

    if (typeof window['spiderfier_callback'] === "function") {
        window['spiderfier_callback']();
    }

}).call(this);