diff --git a/google-map-directions.html b/google-map-directions.html
index c55af11..47e1ebd 100644
--- a/google-map-directions.html
+++ b/google-map-directions.html
@@ -40,174 +40,178 @@
     </google-maps-api>
   </template>
   <script>
-    Polymer({
-      is: 'google-map-directions',
-
-      /**
-       * Fired whenever the directions service returns a result.
-       *
-       * @event google-map-response
-       * @param {{response: Object}} detail
-       */
-
-      /**
-       * Polymer properties for the google-map-directions custom element.
-       */
-      properties: {
-        /**
-         * A Maps API key. To obtain an API key, see developers.google.com/maps/documentation/javascript/tutorial#api_key.
-         */
-        apiKey: String,
+    (function() {
+      'use strict';
 
-        /**
-         * Overrides the origin the Maps API is loaded from. Defaults to `https://maps.googleapis.com`.
-         */
-        mapsUrl: {
-          type: String
-          // Initial value set in google-maps-api.
-        },
+      Polymer({
+        is: 'google-map-directions',
 
         /**
-         * The Google map object.
+         * Fired whenever the directions service returns a result.
          *
-         * @type google.maps.Map
+         * @event google-map-response
+         * @param {{response: Object}} detail
          */
-        map: {
-          type: Object,
-          observer: '_mapChanged'
-        },
 
         /**
-         * Start address or latlng to get directions from.
-         *
-         * @type string|google.maps.LatLng
+         * Polymer properties for the google-map-directions custom element.
          */
-        startAddress: {
-          type: String,
-          value: null
+        properties: {
+          /**
+           * A Maps API key. To obtain an API key, see developers.google.com/maps/documentation/javascript/tutorial#api_key.
+           */
+          apiKey: String,
+
+          /**
+           * Overrides the origin the Maps API is loaded from. Defaults to `https://maps.googleapis.com`.
+           */
+          mapsUrl: {
+            type: String
+            // Initial value set in google-maps-api.
+          },
+
+          /**
+           * The Google map object.
+           *
+           * @type google.maps.Map
+           */
+          map: {
+            type: Object,
+            observer: '_mapChanged'
+          },
+
+          /**
+           * Start address or latlng to get directions from.
+           *
+           * @type string|google.maps.LatLng
+           */
+          startAddress: {
+            type: String,
+            value: null
+          },
+
+          /**
+           * End address or latlng for directions to end.
+           *
+           * @type string|google.maps.LatLng
+           */
+          endAddress: {
+            type: String,
+            value: null
+          },
+
+          /**
+           * Travel mode to use.  One of 'DRIVING', 'WALKING', 'BICYCLING', 'TRANSIT'.
+           */
+          travelMode: {
+            type: String,
+            value: 'DRIVING'
+          },
+
+          /**
+           * Array of intermediate waypoints. Directions will be calculated
+           * from the origin to the destination by way of each waypoint in this array.
+           * The maximum allowed waypoints is 8, plus the origin, and destination.
+           * Maps API for Business customers are allowed 23 waypoints,
+           * plus the origin, and destination.
+           * Waypoints are not supported for transit directions. Optional.
+           *
+           * @type Array<google.maps.DirectionsWaypoint>
+           */
+           waypoints: {
+             type: Array,
+             value: function() { return []; }
+           },
+
+          /**
+           * The localized language to load the Maps API with. For more information
+           * see https://developers.google.com/maps/documentation/javascript/basics#Language
+           *
+           * Note: the Maps API defaults to the preffered language setting of the browser.
+           * Use this parameter to override that behavior.
+           */
+          language: {
+            type: String,
+            value: null
+          },
+
+          /**
+           * Options for the display of results
+           */
+          rendererOptions: {
+            type: Object,
+            value: function() { return {}; }
+          },
+
+          /**
+           * The response from the directions service.
+           *
+           */
+          response: {
+            type: Object,
+            observer: '_responseChanged',
+            notify: true
+          }
         },
 
-        /**
-         * End address or latlng for directions to end.
-         *
-         * @type string|google.maps.LatLng
-         */
-        endAddress: {
-          type: String,
-          value: null
-        },
+        observers: [
+          '_route(startAddress, endAddress, travelMode, waypoints.*)'
+        ],
 
-        /**
-         * Travel mode to use.  One of 'DRIVING', 'WALKING', 'BICYCLING', 'TRANSIT'.
-         */
-        travelMode: {
-          type: String,
-          value: 'DRIVING'
+        _mapApiLoaded: function() {
+          this._route();
         },
 
-        /**
-         * Array of intermediate waypoints. Directions will be calculated
-         * from the origin to the destination by way of each waypoint in this array.
-         * The maximum allowed waypoints is 8, plus the origin, and destination.
-         * Maps API for Business customers are allowed 23 waypoints,
-         * plus the origin, and destination.
-         * Waypoints are not supported for transit directions. Optional.
-         *
-         * @type Array<google.maps.DirectionsWaypoint>
-         */
-         waypoints: {
-           type: Array,
-           value: function() { return []; }
-         },
-
-        /**
-         * The localized language to load the Maps API with. For more information
-         * see https://developers.google.com/maps/documentation/javascript/basics#Language
-         *
-         * Note: the Maps API defaults to the preffered language setting of the browser.
-         * Use this parameter to override that behavior.
-         */
-        language: {
-          type: String,
-          value: null
+        _responseChanged: function() {
+          if (this.directionsRenderer && this.response) {
+            this.directionsRenderer.setDirections(this.response);
+          }
         },
 
-        /**
-         * Options for the display of results
-         */
-        rendererOptions: {
-          type: Object,
-          value: function() { return {}; }
+        _mapChanged: function() {
+          if (this.map && this.map instanceof google.maps.Map) {
+            if (!this.directionsRenderer) {
+              this.directionsRenderer = new google.maps.DirectionsRenderer(this.rendererOptions);
+            }
+            this.directionsRenderer.setMap(this.map);
+            this._responseChanged();
+          } else {
+            // If there is no more map, remove the directionsRenderer from the map and delete it.
+            if (this.directionsRenderer) {
+              this.directionsRenderer.setMap(null);
+              this.directionsRenderer = null;
+            }
+          }
         },
 
-        /**
-         * The response from the directions service.
-         *
-         */
-        response: {
-          type: Object,
-          observer: '_responseChanged',
-          notify: true
-        }
-      },
-
-      observers: [
-        '_route(startAddress, endAddress, travelMode, waypoints.*)'
-      ],
-
-      _mapApiLoaded: function() {
-        this._route();
-      },
-
-      _responseChanged: function() {
-        if (this.directionsRenderer && this.response) {
-          this.directionsRenderer.setDirections(this.response);
-        }
-      },
-
-      _mapChanged: function() {
-        if (this.map && this.map instanceof google.maps.Map) {
-          if (!this.directionsRenderer) {
-            this.directionsRenderer = new google.maps.DirectionsRenderer(this.rendererOptions);
+        _route: function() {
+          // Abort attempts to _route if the API is not available yet or the
+          // required attributes are blank.
+          if (typeof google == 'undefined' || typeof google.maps == 'undefined' ||
+              !this.startAddress || !this.endAddress) {
+            return;
           }
-          this.directionsRenderer.setMap(this.map);
-          this._responseChanged();
-        } else {
-          // If there is no more map, remove the directionsRenderer from the map and delete it.
-          if (this.directionsRenderer) {
-            this.directionsRenderer.setMap(null);
-            this.directionsRenderer = null;
+
+          // Construct a directionsService if necessary.
+          // Wait until here where the maps api has loaded and directions are actually needed.
+          if (!this.directionsService) {
+            this.directionsService = new google.maps.DirectionsService();
           }
-        }
-      },
-
-      _route: function() {
-        // Abort attempts to _route if the API is not available yet or the
-        // required attributes are blank.
-        if (typeof google == 'undefined' || typeof google.maps == 'undefined' ||
-            !this.startAddress || !this.endAddress) {
-          return;
-        }
 
-        // Construct a directionsService if necessary.
-        // Wait until here where the maps api has loaded and directions are actually needed.
-        if (!this.directionsService) {
-          this.directionsService = new google.maps.DirectionsService();
+          var request = {
+            origin: this.startAddress,
+            destination: this.endAddress,
+            travelMode: this.travelMode,
+            waypoints: this.waypoints
+          };
+          this.directionsService.route(request, function(response, status) {
+            if (status == google.maps.DirectionsStatus.OK) {
+              this.response = response;
+              this.fire('google-map-response', {response: response});
+            }
+          }.bind(this));
         }
-
-        var request = {
-          origin: this.startAddress,
-          destination: this.endAddress,
-          travelMode: this.travelMode,
-          waypoints: this.waypoints
-        };
-        this.directionsService.route(request, function(response, status) {
-          if (status == google.maps.DirectionsStatus.OK) {
-            this.response = response;
-            this.fire('google-map-response', {response: response});
-          }
-        }.bind(this));
-      }
-    });
+      });
+    })();
   </script>
 </dom-module>
diff --git a/google-map-marker.html b/google-map-marker.html
index fb789a3..1900fa3 100644
--- a/google-map-marker.html
+++ b/google-map-marker.html
@@ -45,6 +45,11 @@
   <script>
     (function() {
 
+
+      /**
+       * @this {GoogleMapMarkerElement} This function is called  with .bind(this) in the map
+       * marker element below.
+       */
       function setupDragHandler_() {
         if (this.draggable) {
           this.dragHandler_ = google.maps.event.addListener(
@@ -55,6 +60,10 @@
         }
       }
 
+      /**
+       * @this {GoogleMapMarkerElement} This function is called with .bind(this) in setupDragHandler
+       *_above.
+       */
       function onDragEnd_(e, details, sender) {
         this.latitude = e.latLng.lat();
         this.longitude = e.latLng.lng();
diff --git a/google-map-point.html b/google-map-point.html
index f6bfd73..b3c7026 100644
--- a/google-map-point.html
+++ b/google-map-point.html
@@ -19,36 +19,40 @@
 -->
 
 <script>
-  Polymer({
-    is: 'google-map-point',
-
-    hostAttributes: {hidden: true},
-
-    properties: {
-      /**
-       * The point's longitude coordinate.
-       */
-      longitude: {
-        type: Number,
-        value: null
+  (function() {
+    'use strict';
+
+    Polymer({
+      is: 'google-map-point',
+
+      hostAttributes: {hidden: true},
+
+      properties: {
+        /**
+         * The point's longitude coordinate.
+         */
+        longitude: {
+          type: Number,
+          value: null
+        },
+
+        /**
+         * The point's latitude coordinate.
+         */
+        latitude: {
+          type: Number,
+          value: null
+        }
       },
 
       /**
-       * The point's latitude coordinate.
+       * Returns the point as a Google Maps LatLng object.
+       *
+       * @return {google.maps.LatLng} The LatLng object.
        */
-      latitude: {
-        type: Number,
-        value: null
+      getPosition: function() {
+        return new google.maps.LatLng(this.latitude, this.longitude);
       }
-    },
-
-    /**
-     * Returns the point as a Google Maps LatLng object.
-     *
-     * @return {google.maps.LatLng} The LatLng object.
-     */
-    getPosition: function() {
-      return new google.maps.LatLng(this.latitude, this.longitude);
-    }
-  });
+    });
+  })();
 </script>
diff --git a/google-map-search.html b/google-map-search.html
index daf1832..a2f374a 100644
--- a/google-map-search.html
+++ b/google-map-search.html
@@ -27,188 +27,192 @@ <h2>{{marker.name}}</h2>
  -->
 
 <script>
-  Polymer({
-    is: 'google-map-search',
-
-    properties: {
-      /**
-       * The Google map object.
-       *
-       * @type google.maps.Map
-       */
-      map: {
-        type: Object,
-        value: null
+  (function() {
+    'use strict';
+
+    Polymer({
+      is: 'google-map-search',
+
+      properties: {
+        /**
+         * The Google map object.
+         *
+         * @type google.maps.Map
+         */
+        map: {
+          type: Object,
+          value: null
+        },
+
+        /**
+         * The search query.
+         */
+        query: {
+          type: String,
+          value: null
+        },
+
+        /**
+         * Latitude of the center of the search area.
+         * Ignored if `globalSearch` is true.
+         */
+        latitude: {
+          type: Number,
+          value: null
+        },
+
+        /**
+         * Longitude of the center of the search area.
+         * Ignored if `globalSearch` is true.
+         */
+        longitude: {
+          type: Number,
+          value: null
+        },
+
+        /**
+         * Search radius, in meters.
+         * If `latitude` and `longitude` are not specified,
+         * the center of the currently visible map area is used.
+         *
+         * If not set, search will be restricted to the currently visible
+         * map area, unless `globalSearch` is set to true.
+         */
+        radius: {
+          type: Number,
+          value: null
+        },
+
+        /**
+         * By default, search is restricted to the currently visible map area.
+         * Set this to true to search everywhere.
+         *
+         * Ignored if `radius` is set.
+         */
+        globalSearch: {
+          type: Boolean,
+          value: false
+        },
+
+        /**
+         * Space-separated list of result types.
+         * The search will only return results of the listed types.
+         * See https://developers.google.com/places/documentation/supported_types
+         * for a list of supported types.
+         * Leave empty or null to search for all result types.
+         */
+        types: {
+          type: String,
+          value: null
+        },
+
+        /**
+         * The search results.
+         */
+        results: {
+          type: Array,
+          value: function() { return []; },
+          notify: true
+        },
+
+        /**
+         * The lat/lng location.
+         */
+        location: {
+          type: Object,
+          value: null,
+          readOnly: true
+        }
       },
 
-      /**
-       * The search query.
-       */
-      query: {
-        type: String,
-        value: null
-      },
+      observers: [
+        'search(query,map,location,radius,types,globalSearch)',
+        '_updateLocation(latitude,longitude)'
+      ],
 
       /**
-       * Latitude of the center of the search area.
-       * Ignored if `globalSearch` is true.
+       * Fired when the details of a place are returned.
+       *
+       * @event google-map-search-place-detail
+       * @param {google.maps.MarkerPlace} detail The place details.
        */
-      latitude: {
-        type: Number,
-        value: null
-      },
 
       /**
-       * Longitude of the center of the search area.
-       * Ignored if `globalSearch` is true.
+       * Fired when the search element returns a result.
+       *
+       * @event google-map-search-results
+       * @param {Array<{latitude: number, longitude: number}>} detail An array of search results
        */
-      longitude: {
-        type: Number,
-        value: null
-      },
 
       /**
-       * Search radius, in meters.
-       * If `latitude` and `longitude` are not specified,
-       * the center of the currently visible map area is used.
-       *
-       * If not set, search will be restricted to the currently visible
-       * map area, unless `globalSearch` is set to true.
+       * Perform a search using for `query` for the search term.
        */
-      radius: {
-        type: Number,
-        value: null
+      search: function() {
+        if (this.query && this.map) {
+          var places = new google.maps.places.PlacesService(this.map);
+
+          if (this.types && typeof this.types == 'string') {
+            var types = this.types.split(' ');
+          }
+          if (this.radius) {
+            var radius = this.radius;
+            var location = this.location ? this.location : this.map.getCenter();
+          } else if (!this.globalSearch) {
+            var bounds = this.map.getBounds();
+          }
+          places.textSearch({
+            query: this.query,
+            types: types,
+            bounds: bounds,
+            radius: radius,
+            location: location
+          }, this._gotResults.bind(this));
+        }
       },
 
       /**
-       * By default, search is restricted to the currently visible map area.
-       * Set this to true to search everywhere.
+       * Fetches details for a given place.
        *
-       * Ignored if `radius` is set.
+       * @param {String} placeId The place id.
+       * @return {Promise} place The place information.
        */
-      globalSearch: {
-        type: Boolean,
-        value: false
-      },
+      getDetails: function(placeId) {
+        var places = new google.maps.places.PlacesService(this.map);
 
-      /**
-       * Space-separated list of result types.
-       * The search will only return results of the listed types.
-       * See https://developers.google.com/places/documentation/supported_types
-       * for a list of supported types.
-       * Leave empty or null to search for all result types.
-       */
-      types: {
-        type: String,
-        value: null
+        return new Promise(function(resolve, reject) {
+          places.getDetails({placeId: placeId}, function(place, status) {
+            if (status === google.maps.places.PlacesServiceStatus.OK) {
+              resolve(place);
+              this.fire('google-map-search-place-detail', place);
+            } else {
+              reject(status);
+            }
+          }.bind(this));
+        }.bind(this));
       },
 
-      /**
-       * The search results.
-       */
-      results: {
-        type: Array,
-        value: function() { return []; },
-        notify: true
+      _gotResults: function(results, status) {
+        this.results = results.map(function(result) {
+          // obtain lat/long from geometry
+          result.latitude  = result.geometry.location.lat();
+          result.longitude = result.geometry.location.lng();
+          return result;
+        });
+        this.fire('google-map-search-results', this.results);
       },
 
-      /**
-       * The lat/lng location.
-       */
-      location: {
-        type: Object,
-        value: null,
-        readOnly: true
-      }
-    },
-
-    observers: [
-      'search(query,map,location,radius,types,globalSearch)',
-      '_updateLocation(latitude,longitude)'
-    ],
-
-    /**
-     * Fired when the details of a place are returned.
-     *
-     * @event google-map-search-place-detail
-     * @param {google.maps.MarkerPlace} detail The place details.
-     */
-
-    /**
-     * Fired when the search element returns a result.
-     *
-     * @event google-map-search-results
-     * @param {Array<{latitude: number, longitude: number}>} detail An array of search results
-     */
-
-    /**
-     * Perform a search using for `query` for the search term.
-     */
-    search: function() {
-      if (this.query && this.map) {
-        var places = new google.maps.places.PlacesService(this.map);
-
-        if (this.types && typeof this.types == 'string') {
-          var types = this.types.split(' ');
+      _updateLocation: function() {
+        if (!this.map) {
+          return;
+        } else if (typeof this.latitude !== 'number' || isNaN(this.latitude)) {
+          throw new TypeError('latitude must be a number');
+        } else if (typeof this.longitude !== 'number' || isNaN(this.longitude)) {
+          throw new TypeError('longitude must be a number');
         }
-        if (this.radius) {
-          var radius = this.radius;
-          var location = this.location ? this.location : this.map.getCenter();
-        } else if (!this.globalSearch) {
-          var bounds = this.map.getBounds();
-        }
-        places.textSearch({
-          query: this.query,
-          types: types,
-          bounds: bounds,
-          radius: radius,
-          location: location
-        }, this._gotResults.bind(this));
-      }
-    },
-
-    /**
-     * Fetches details for a given place.
-     *
-     * @param {String} placeId The place id.
-     * @return {Promise} place The place information.
-     */
-    getDetails: function(placeId) {
-      var places = new google.maps.places.PlacesService(this.map);
-
-      return new Promise(function(resolve, reject) {
-        places.getDetails({placeId: placeId}, function(place, status) {
-          if (status === google.maps.places.PlacesServiceStatus.OK) {
-            resolve(place);
-            this.fire('google-map-search-place-detail', place);
-          } else {
-            reject(status);
-          }
-        }.bind(this));
-      }.bind(this));
-    },
-
-    _gotResults: function(results, status) {
-      this.results = results.map(function(result) {
-        // obtain lat/long from geometry
-        result.latitude  = result.geometry.location.lat();
-        result.longitude = result.geometry.location.lng();
-        return result;
-      });
-      this.fire('google-map-search-results', this.results);
-    },
-
-    _updateLocation: function() {
-      if (!this.map) {
-        return;
-      } else if (typeof this.latitude !== 'number' || isNaN(this.latitude)) {
-        throw new TypeError('latitude must be a number');
-      } else if (typeof this.longitude !== 'number' || isNaN(this.longitude)) {
-        throw new TypeError('longitude must be a number');
-      }
 
-      // Update location. This will trigger a new search.
-      this._setLocation({lat: this.latitude, lng: this.longitude});
-    }
-  });
+        // Update location. This will trigger a new search.
+        this._setLocation({lat: this.latitude, lng: this.longitude});
+      }
+    });
+  })();
 </script>
diff --git a/google-map.html b/google-map.html
index 833897a..e887373 100644
--- a/google-map.html
+++ b/google-map.html
@@ -103,757 +103,761 @@
     <slot id="objects"></slot>
   </template>
   <script>
-    Polymer({
-      is: 'google-map',
-
-      /**
-       * Fired when the Maps API has fully loaded.
-       *
-       * @event google-map-ready
-       */
-
-      /**
-       * Fired when the user clicks on the map (but not when they click on a marker, infowindow, or
-       * other object). Requires the clickEvents attribute to be true.
-       *
-       * @event google-map-click
-       * @param {google.maps.MouseEvent} event The mouse event.
-       */
-
-      /**
-       * Fired when the user double-clicks on the map. Note that the google-map-click event will also fire,
-       * right before this one. Requires the clickEvents attribute to be true.
-       *
-       * @event google-map-dblclick
-       * @param {google.maps.MouseEvent} event The mouse event.
-       */
-
-      /**
-       * Fired repeatedly while the user drags the map. Requires the dragEvents attribute to be true.
-       *
-       * @event google-map-drag
-       */
-
-      /**
-       * Fired when the user stops dragging the map. Requires the dragEvents attribute to be true.
-       *
-       * @event google-map-dragend
-       */
-
-      /**
-       * Fired when the user starts dragging the map. Requires the dragEvents attribute to be true.
-       *
-       * @event google-map-dragstart
-       */
-
-      /**
-       * Fired whenever the user's mouse moves over the map container. Requires the mouseEvents attribute to
-       * be true.
-       *
-       * @event google-map-mousemove
-       * @param {google.maps.MouseEvent} event The mouse event.
-       */
-
-      /**
-       * Fired when the user's mouse exits the map container. Requires the mouseEvents attribute to be true.
-       *
-       * @event google-map-mouseout
-       * @param {google.maps.MouseEvent} event The mouse event.
-       */
-
-      /**
-       * Fired when the user's mouse enters the map container. Requires the mouseEvents attribute to be true.
-       *
-       * @event google-map-mouseover
-       * @param {google.maps.MouseEvent} event The mouse event.
-       */
-
-      /**
-       * Fired when the DOM `contextmenu` event is fired on the map container. Requires the clickEvents
-       * attribute to be true.
-       *
-       * @event google-map-rightclick
-       * @param {google.maps.MouseEvent} event The mouse event.
-       */
-
-      /**
-       * Fired when the map becomes idle after panning or zooming.
-       *
-       * @event google-map-idle
-       */
-
-      /**
-       * Polymer properties for the google-map custom element.
-       */
-      properties: {
-        /**
-         * A Maps API key. To obtain an API key, see https://developers.google.com/maps/documentation/javascript/tutorial#api_key.
-         */
-        apiKey: String,
+    (function() {
+      'use strict';
+
+      Polymer({
+        is: 'google-map',
 
         /**
-         * Overrides the origin the Maps API is loaded from. Defaults to `https://maps.googleapis.com`.
+         * Fired when the Maps API has fully loaded.
+         *
+         * @event google-map-ready
          */
-        mapsUrl: {
-          type: String
-          // Initial value set in google-maps-api.
-        },
 
         /**
-         * A Maps API for Business Client ID. To obtain a Maps API for Business Client ID, see https://developers.google.com/maps/documentation/business/.
-         * If set, a Client ID will take precedence over an API Key.
+         * Fired when the user clicks on the map (but not when they click on a marker, infowindow, or
+         * other object). Requires the clickEvents attribute to be true.
+         *
+         * @event google-map-click
+         * @param {google.maps.MouseEvent} event The mouse event.
          */
-        clientId: String,
 
         /**
-         * A latitude to center the map on.
+         * Fired when the user double-clicks on the map. Note that the google-map-click event will also fire,
+         * right before this one. Requires the clickEvents attribute to be true.
+         *
+         * @event google-map-dblclick
+         * @param {google.maps.MouseEvent} event The mouse event.
          */
-        latitude: {
-          type: Number,
-          value: 37.77493,
-          notify: true,
-          reflectToAttribute: true
-        },
 
         /**
-         * A Maps API object.
+         * Fired repeatedly while the user drags the map. Requires the dragEvents attribute to be true.
+         *
+         * @event google-map-drag
          */
-        map: {
-          type: Object,
-          notify: true,
-          value: null
-        },
 
         /**
-         * A longitude to center the map on.
+         * Fired when the user stops dragging the map. Requires the dragEvents attribute to be true.
+         *
+         * @event google-map-dragend
          */
-        longitude: {
-          type: Number,
-          value: -122.41942,
-          notify: true,
-          reflectToAttribute: true
-        },
 
         /**
-         * A kml file to load.
+         * Fired when the user starts dragging the map. Requires the dragEvents attribute to be true.
+         *
+         * @event google-map-dragstart
          */
-        kml: {
-          type: String,
-          value: null,
-          observer: '_loadKml'
-        },
 
         /**
-         * A zoom level to set the map to.
+         * Fired whenever the user's mouse moves over the map container. Requires the mouseEvents attribute to
+         * be true.
+         *
+         * @event google-map-mousemove
+         * @param {google.maps.MouseEvent} event The mouse event.
          */
-        zoom: {
-          type: Number,
-          value: 10,
-          observer: '_zoomChanged',
-          notify: true
-        },
 
         /**
-         * When set, prevents the map from tilting (when the zoom level and viewport supports it).
+         * Fired when the user's mouse exits the map container. Requires the mouseEvents attribute to be true.
+         *
+         * @event google-map-mouseout
+         * @param {google.maps.MouseEvent} event The mouse event.
          */
-        noAutoTilt: {
-          type: Boolean,
-          value: false
-        },
 
         /**
-         * Map type to display. One of 'roadmap', 'satellite', 'hybrid', 'terrain'.
+         * Fired when the user's mouse enters the map container. Requires the mouseEvents attribute to be true.
+         *
+         * @event google-map-mouseover
+         * @param {google.maps.MouseEvent} event The mouse event.
          */
-        mapType: {
-          type: String,
-          value: 'roadmap', // roadmap, satellite, hybrid, terrain,
-          observer: '_mapTypeChanged',
-          notify: true
-        },
 
         /**
-         * Version of the Google Maps API to use.
+         * Fired when the DOM `contextmenu` event is fired on the map container. Requires the clickEvents
+         * attribute to be true.
+         *
+         * @event google-map-rightclick
+         * @param {google.maps.MouseEvent} event The mouse event.
          */
-        version: {
-          type: String,
-          value: '3.exp'
-        },
 
         /**
-         * If set, removes the map's default UI controls.
+         * Fired when the map becomes idle after panning or zooming.
+         *
+         * @event google-map-idle
          */
-        disableDefaultUi: {
-          type: Boolean,
-          value: false,
-          observer: '_disableDefaultUiChanged'
-        },
 
         /**
-         * If set, removes the map's 'map type' UI controls.
+         * Polymer properties for the google-map custom element.
          */
-        disableMapTypeControl: {
-          type: Boolean,
-          value: false,
-          observer: '_disableMapTypeControlChanged'
+        properties: {
+          /**
+           * A Maps API key. To obtain an API key, see https://developers.google.com/maps/documentation/javascript/tutorial#api_key.
+           */
+          apiKey: String,
+
+          /**
+           * Overrides the origin the Maps API is loaded from. Defaults to `https://maps.googleapis.com`.
+           */
+          mapsUrl: {
+            type: String
+            // Initial value set in google-maps-api.
+          },
+
+          /**
+           * A Maps API for Business Client ID. To obtain a Maps API for Business Client ID, see https://developers.google.com/maps/documentation/business/.
+           * If set, a Client ID will take precedence over an API Key.
+           */
+          clientId: String,
+
+          /**
+           * A latitude to center the map on.
+           */
+          latitude: {
+            type: Number,
+            value: 37.77493,
+            notify: true,
+            reflectToAttribute: true
+          },
+
+          /**
+           * A Maps API object.
+           */
+          map: {
+            type: Object,
+            notify: true,
+            value: null
+          },
+
+          /**
+           * A longitude to center the map on.
+           */
+          longitude: {
+            type: Number,
+            value: -122.41942,
+            notify: true,
+            reflectToAttribute: true
+          },
+
+          /**
+           * A kml file to load.
+           */
+          kml: {
+            type: String,
+            value: null,
+            observer: '_loadKml'
+          },
+
+          /**
+           * A zoom level to set the map to.
+           */
+          zoom: {
+            type: Number,
+            value: 10,
+            observer: '_zoomChanged',
+            notify: true
+          },
+
+          /**
+           * When set, prevents the map from tilting (when the zoom level and viewport supports it).
+           */
+          noAutoTilt: {
+            type: Boolean,
+            value: false
+          },
+
+          /**
+           * Map type to display. One of 'roadmap', 'satellite', 'hybrid', 'terrain'.
+           */
+          mapType: {
+            type: String,
+            value: 'roadmap', // roadmap, satellite, hybrid, terrain,
+            observer: '_mapTypeChanged',
+            notify: true
+          },
+
+          /**
+           * Version of the Google Maps API to use.
+           */
+          version: {
+            type: String,
+            value: '3.exp'
+          },
+
+          /**
+           * If set, removes the map's default UI controls.
+           */
+          disableDefaultUi: {
+            type: Boolean,
+            value: false,
+            observer: '_disableDefaultUiChanged'
+          },
+
+          /**
+           * If set, removes the map's 'map type' UI controls.
+           */
+          disableMapTypeControl: {
+            type: Boolean,
+            value: false,
+            observer: '_disableMapTypeControlChanged'
+          },
+
+          /**
+           * If set, removes the map's 'street view' UI controls.
+           */
+          disableStreetViewControl: {
+            type: Boolean,
+            value: false,
+            observer: '_disableStreetViewControlChanged'
+          },
+
+          /**
+           * If set, the zoom level is set such that all markers (google-map-marker children) are brought into view.
+           */
+          fitToMarkers: {
+            type: Boolean,
+            value: false,
+            observer: '_fitToMarkersChanged'
+          },
+
+          /**
+           * If true, prevent the user from zooming the map interactively.
+           */
+          disableZoom: {
+            type: Boolean,
+            value: false,
+            observer: '_disableZoomChanged'
+          },
+
+          /**
+           * If set, custom styles can be applied to the map.
+           * For style documentation see https://developers.google.com/maps/documentation/javascript/reference#MapTypeStyle
+           */
+          styles: {
+            type: Object,
+            value: function() { return {}; }
+          },
+
+          /**
+           * A maximum zoom level which will be displayed on the map.
+           */
+          maxZoom: {
+            type: Number,
+            observer: '_maxZoomChanged'
+          },
+
+          /**
+           * A minimum zoom level which will be displayed on the map.
+           */
+          minZoom: {
+            type: Number,
+            observer: '_minZoomChanged'
+          },
+
+          /**
+           * If true, sign-in is enabled.
+           * See https://developers.google.com/maps/documentation/javascript/signedin#enable_sign_in
+           */
+          signedIn: {
+            type: Boolean,
+            value: false
+          },
+
+          /**
+           * The localized language to load the Maps API with. For more information
+           * see https://developers.google.com/maps/documentation/javascript/basics#Language
+           *
+           * Note: the Maps API defaults to the preffered language setting of the browser.
+           * Use this parameter to override that behavior.
+           */
+          language: {
+            type: String
+          },
+
+          /**
+           * When true, map *click events are automatically registered.
+           */
+          clickEvents: {
+            type: Boolean,
+            value: false,
+            observer: '_clickEventsChanged'
+          },
+
+          /**
+           * When true, map drag* events are automatically registered.
+           */
+          dragEvents: {
+            type: Boolean,
+            value: false,
+            observer: '_dragEventsChanged'
+          },
+
+          /**
+           * When true, map mouse* events are automatically registered.
+           */
+          mouseEvents: {
+            type: Boolean,
+            value: false,
+            observer: '_mouseEventsChanged'
+          },
+
+          /**
+           * Additional map options for google.maps.Map constructor.
+           * Use to specify additional options we do not expose as
+           * properties.
+           * Ex: `<google-map additional-map-options='{"mapTypeId":"satellite"}'>`
+           *
+           * Note, you can't use API enums like `google.maps.ControlPosition.TOP_RIGHT`
+           * when using this property as an HTML attribute. Instead, use the actual
+           * value (e.g. `3`) or set `.additionalMapOptions` in JS rather than using
+           * the attribute.
+           */
+          additionalMapOptions: {
+            type: Object,
+            value: function() { return {}; }
+          },
+
+          /**
+           * The markers on the map.
+           */
+          markers: {
+            type: Array,
+            value: function() { return []; },
+            readOnly: true
+          },
+
+          /**
+           * The non-marker objects on the map.
+           */
+          objects: {
+            type: Array,
+            value: function() { return []; },
+            readOnly: true
+          },
+
+          /**
+           * If set, all other info windows on markers are closed when opening a new one.
+           */
+          singleInfoWindow: {
+            type: Boolean,
+            value: false
+          }
         },
 
-        /**
-         * If set, removes the map's 'street view' UI controls.
-         */
-        disableStreetViewControl: {
-          type: Boolean,
-          value: false,
-          observer: '_disableStreetViewControlChanged'
+        behaviors: [
+          Polymer.IronResizableBehavior
+        ],
+
+        listeners: {
+          'iron-resize': 'resize'
         },
 
-        /**
-         * If set, the zoom level is set such that all markers (google-map-marker children) are brought into view.
-         */
-        fitToMarkers: {
-          type: Boolean,
-          value: false,
-          observer: '_fitToMarkersChanged'
+        observers: [
+          '_debounceUpdateCenter(latitude, longitude)'
+        ],
+
+        attached: function() {
+          this._initGMap();
         },
 
-        /**
-         * If true, prevent the user from zooming the map interactively.
-         */
-        disableZoom: {
-          type: Boolean,
-          value: false,
-          observer: '_disableZoomChanged'
+        detached: function() {
+          if (this._markersChildrenListener) {
+            this.unlisten(this.$.selector, 'items-changed', '_updateMarkers');
+            this._markersChildrenListener = null;
+          }
+          if (this._objectsMutationObserver) {
+            this._objectsMutationObserver.disconnect();
+            this._objectsMutationObserver = null;
+          }
         },
 
-        /**
-         * If set, custom styles can be applied to the map.
-         * For style documentation see https://developers.google.com/maps/documentation/javascript/reference#MapTypeStyle
-         */
-        styles: {
-          type: Object,
-          value: function() { return {}; }
+        _initGMap: function() {
+          if (this.map) {
+            return; // already initialized
+          }
+          if (this.$.api.libraryLoaded !== true) {
+            return; // api not loaded
+          }
+          if (!this.isAttached) {
+            return; // not attached
+          }
+
+          this.map = new google.maps.Map(this.$.map, this._getMapOptions());
+          this._listeners = {};
+          this._updateCenter();
+          this._loadKml();
+          this._updateMarkers();
+          this._updateObjects();
+          this._addMapListeners();
+          this.fire('google-map-ready');
         },
 
-        /**
-         * A maximum zoom level which will be displayed on the map.
-         */
-        maxZoom: {
-          type: Number,
-          observer: '_maxZoomChanged'
+        _mapApiLoaded: function() {
+          this._initGMap();
         },
 
-        /**
-         * A minimum zoom level which will be displayed on the map.
-         */
-        minZoom: {
-          type: Number,
-          observer: '_minZoomChanged'
+        _getMapOptions: function() {
+          var mapOptions = {
+            zoom: this.zoom,
+            tilt: this.noAutoTilt ? 0 : 45,
+            mapTypeId: this.mapType,
+            disableDefaultUI: this.disableDefaultUi,
+            mapTypeControl: !this.disableDefaultUi && !this.disableMapTypeControl,
+            streetViewControl: !this.disableDefaultUi && !this.disableStreetViewControl,
+            disableDoubleClickZoom: this.disableZoom,
+            scrollwheel: !this.disableZoom,
+            styles: this.styles,
+            maxZoom: Number(this.maxZoom),
+            minZoom: Number(this.minZoom)
+          };
+
+          // Only override the default if set.
+          // We use getAttribute here because the default value of this.draggable = false even when not set.
+          if (this.getAttribute('draggable') != null) {
+            mapOptions.draggable = this.draggable
+          }
+          for (var p in this.additionalMapOptions)
+            mapOptions[p] = this.additionalMapOptions[p];
+
+          return mapOptions;
         },
 
-        /**
-         * If true, sign-in is enabled.
-         * See https://developers.google.com/maps/documentation/javascript/signedin#enable_sign_in
-         */
-        signedIn: {
-          type: Boolean,
-          value: false
+        _attachChildrenToMap: function(children) {
+          if (this.map) {
+            for (var i = 0, child; child = children[i]; ++i) {
+              child.map = this.map;
+            }
+          }
         },
 
-        /**
-         * The localized language to load the Maps API with. For more information
-         * see https://developers.google.com/maps/documentation/javascript/basics#Language
-         *
-         * Note: the Maps API defaults to the preffered language setting of the browser.
-         * Use this parameter to override that behavior.
-         */
-        language: {
-          type: String
+        // watch for future updates to marker objects
+        _observeMarkers: function() {
+          // Watch for future updates.
+          if (this._markersChildrenListener) {
+            return;
+          }
+          this._markersChildrenListener = this.listen(this.$.selector, 'items-changed', '_updateMarkers');
         },
 
-        /**
-         * When true, map *click events are automatically registered.
-         */
-        clickEvents: {
-          type: Boolean,
-          value: false,
-          observer: '_clickEventsChanged'
+        _updateMarkers: function() {
+          var newMarkers = Array.prototype.slice.call(
+              Polymer.dom(this.$.markers).getDistributedNodes());
+
+          // do not recompute if markers have not been added or removed
+          if (newMarkers.length === this.markers.length) {
+            var added = newMarkers.filter(function(m) {
+              return this.markers && this.markers.indexOf(m) === -1;
+            }.bind(this));
+            if (added.length === 0) {
+              // set up observer first time around
+              if (!this._markersChildrenListener) {
+                this._observeMarkers();
+              }
+              return;
+            }
+          }
+
+          this._observeMarkers();
+
+          this.markers = this._setMarkers(newMarkers);
+
+          // Set the map on each marker and zoom viewport to ensure they're in view.
+          this._attachChildrenToMap(this.markers);
+          if (this.fitToMarkers) {
+            this._fitToMarkersChanged();
+          }
         },
 
-        /**
-         * When true, map drag* events are automatically registered.
-         */
-        dragEvents: {
-          type: Boolean,
-          value: false,
-          observer: '_dragEventsChanged'
+        // watch for future updates to non-marker objects
+        _observeObjects: function() {
+          if (this._objectsMutationObserver) {
+            return;
+          }
+          this._objectsMutationObserver = new MutationObserver(this._updateObjects.bind(this));
+          this._objectsMutationObserver.observe(this, {
+            childList: true
+          });
         },
 
-        /**
-         * When true, map mouse* events are automatically registered.
-         */
-        mouseEvents: {
-          type: Boolean,
-          value: false,
-          observer: '_mouseEventsChanged'
+        _updateObjects: function() {
+          var newObjects = Array.prototype.slice.call(
+              Polymer.dom(this.$.objects).getDistributedNodes());
+
+          // Do not recompute if objects have not been added or removed.
+          if (newObjects.length === this.objects.length) {
+            var added = newObjects.filter(function(o) {
+              return this.objects.indexOf(o) === -1;
+            }.bind(this));
+            if (added.length === 0) {
+              // Set up observer first time around.
+              this._observeObjects();
+              return;
+            }
+          }
+
+          this._observeObjects();
+          this._setObjects(newObjects);
+          this._attachChildrenToMap(this.objects);
         },
 
         /**
-         * Additional map options for google.maps.Map constructor.
-         * Use to specify additional options we do not expose as
-         * properties.
-         * Ex: `<google-map additional-map-options='{"mapTypeId":"satellite"}'>`
+         * Clears all markers from the map.
          *
-         * Note, you can't use API enums like `google.maps.ControlPosition.TOP_RIGHT`
-         * when using this property as an HTML attribute. Instead, use the actual
-         * value (e.g. `3`) or set `.additionalMapOptions` in JS rather than using
-         * the attribute.
+         * @method clear
          */
-        additionalMapOptions: {
-          type: Object,
-          value: function() { return {}; }
+        clear: function() {
+          for (var i = 0, m; m = this.markers[i]; ++i) {
+            m.marker.setMap(null);
+          }
         },
 
         /**
-         * The markers on the map.
+         * Explicitly resizes the map, updating its center. This is useful if the
+         * map does not show after you have unhidden it.
+         *
+         * @method resize
          */
-        markers: {
-          type: Array,
-          value: function() { return []; },
-          readOnly: true
+        resize: function() {
+          if (this.map) {
+
+            // saves and restores latitude/longitude because resize can move the center
+            var oldLatitude = this.latitude;
+            var oldLongitude = this.longitude;
+            google.maps.event.trigger(this.map, 'resize');
+            this.latitude = oldLatitude;  // restore because resize can move our center
+            this.longitude = oldLongitude;
+
+            if (this.fitToMarkers) { // we might not have a center if we are doing fit-to-markers
+              this._fitToMarkersChanged();
+            }
+          }
         },
 
-        /**
-         * The non-marker objects on the map.
-         */
-        objects: {
-          type: Array,
-          value: function() { return []; },
-          readOnly: true
+        _loadKml: function() {
+          if (this.map && this.kml) {
+            var kmlfile = new google.maps.KmlLayer({
+              url: this.kml,
+              map: this.map
+            });
+          }
         },
 
-        /**
-         * If set, all other info windows on markers are closed when opening a new one.
-         */
-        singleInfoWindow: {
-          type: Boolean,
-          value: false
-        }
-      },
-
-      behaviors: [
-        Polymer.IronResizableBehavior
-      ],
-
-      listeners: {
-        'iron-resize': 'resize'
-      },
+        _debounceUpdateCenter: function() {
+          this.debounce('updateCenter', this._updateCenter);
+        },
 
-      observers: [
-        '_debounceUpdateCenter(latitude, longitude)'
-      ],
+        _updateCenter: function() {
+          this.cancelDebouncer('updateCenter');
 
-      attached: function() {
-        this._initGMap();
-      },
+          if (this.map && this.latitude !== undefined && this.longitude !== undefined) {
+            // allow for latitude and longitude to be String-typed, but still Number valued
+            var lati = Number(this.latitude);
+            if (isNaN(lati)) {
+              throw new TypeError('latitude must be a number');
+            }
+            var longi = Number(this.longitude);
+            if (isNaN(longi)) {
+              throw new TypeError('longitude must be a number');
+            }
 
-      detached: function() {
-        if (this._markersChildrenListener) {
-          this.unlisten(this.$.selector, 'items-changed', '_updateMarkers');
-          this._markersChildrenListener = null;
-        }
-        if (this._objectsMutationObserver) {
-          this._objectsMutationObserver.disconnect();
-          this._objectsMutationObserver = null;
-        }
-      },
+            var newCenter = new google.maps.LatLng(lati, longi);
+            var oldCenter = this.map.getCenter();
 
-      _initGMap: function() {
-        if (this.map) {
-          return; // already initialized
-        }
-        if (this.$.api.libraryLoaded !== true) {
-          return; // api not loaded
-        }
-        if (!this.isAttached) {
-          return; // not attached
-        }
+            if (!oldCenter) {
+              // If the map does not have a center, set it right away.
+              this.map.setCenter(newCenter);
+            } else {
+              // Using google.maps.LatLng returns corrected lat/lngs.
+              oldCenter = new google.maps.LatLng(oldCenter.lat(), oldCenter.lng());
 
-        this.map = new google.maps.Map(this.$.map, this._getMapOptions());
-        this._listeners = {};
-        this._updateCenter();
-        this._loadKml();
-        this._updateMarkers();
-        this._updateObjects();
-        this._addMapListeners();
-        this.fire('google-map-ready');
-      },
-
-      _mapApiLoaded: function() {
-        this._initGMap();
-      },
-
-      _getMapOptions: function() {
-        var mapOptions = {
-          zoom: this.zoom,
-          tilt: this.noAutoTilt ? 0 : 45,
-          mapTypeId: this.mapType,
-          disableDefaultUI: this.disableDefaultUi,
-          mapTypeControl: !this.disableDefaultUi && !this.disableMapTypeControl,
-          streetViewControl: !this.disableDefaultUi && !this.disableStreetViewControl,
-          disableDoubleClickZoom: this.disableZoom,
-          scrollwheel: !this.disableZoom,
-          styles: this.styles,
-          maxZoom: Number(this.maxZoom),
-          minZoom: Number(this.minZoom)
-        };
-
-        // Only override the default if set.
-        // We use getAttribute here because the default value of this.draggable = false even when not set.
-        if (this.getAttribute('draggable') != null) {
-          mapOptions.draggable = this.draggable
-        }
-        for (var p in this.additionalMapOptions)
-          mapOptions[p] = this.additionalMapOptions[p];
+              // If the map currently has a center, slowly pan to the new one.
+              if (!oldCenter.equals(newCenter)) {
+                this.map.panTo(newCenter);
+              }
+            }
+          }
+        },
 
-        return mapOptions;
-      },
+        _zoomChanged: function() {
+          if (this.map) {
+            this.map.setZoom(Number(this.zoom));
+          }
+        },
 
-      _attachChildrenToMap: function(children) {
-        if (this.map) {
-          for (var i = 0, child; child = children[i]; ++i) {
-            child.map = this.map;
+        _idleEvent: function() {
+          if (this.map) {
+            this._forwardEvent('idle');
+          } else {
+            this._clearListener('idle');
           }
-        }
-      },
+        },
 
-      // watch for future updates to marker objects
-      _observeMarkers: function() {
-        // Watch for future updates.
-        if (this._markersChildrenListener) {
-          return;
-        }
-        this._markersChildrenListener = this.listen(this.$.selector, 'items-changed', '_updateMarkers');
-      },
+        _clickEventsChanged: function() {
+          if (this.map) {
+            if (this.clickEvents) {
+              this._forwardEvent('click');
+              this._forwardEvent('dblclick');
+              this._forwardEvent('rightclick');
+            } else {
+              this._clearListener('click');
+              this._clearListener('dblclick');
+              this._clearListener('rightclick');
+            }
+          }
+        },
 
-      _updateMarkers: function() {
-        var newMarkers = Array.prototype.slice.call(
-            Polymer.dom(this.$.markers).getDistributedNodes());
+        _dragEventsChanged: function() {
+          if (this.map) {
+            if (this.dragEvents) {
+              this._forwardEvent('drag');
+              this._forwardEvent('dragend');
+              this._forwardEvent('dragstart');
+            } else {
+              this._clearListener('drag');
+              this._clearListener('dragend');
+              this._clearListener('dragstart');
+            }
+          }
+        },
 
-        // do not recompute if markers have not been added or removed
-        if (newMarkers.length === this.markers.length) {
-          var added = newMarkers.filter(function(m) {
-            return this.markers && this.markers.indexOf(m) === -1;
-          }.bind(this));
-          if (added.length === 0) {
-            // set up observer first time around
-            if (!this._markersChildrenListener) {
-              this._observeMarkers();
+        _mouseEventsChanged: function() {
+          if (this.map) {
+            if (this.mouseEvents) {
+              this._forwardEvent('mousemove');
+              this._forwardEvent('mouseout');
+              this._forwardEvent('mouseover');
+            } else {
+              this._clearListener('mousemove');
+              this._clearListener('mouseout');
+              this._clearListener('mouseover');
             }
-            return;
           }
-        }
+        },
 
-        this._observeMarkers();
+        _maxZoomChanged: function() {
+          if (this.map) {
+            this.map.setOptions({maxZoom: Number(this.maxZoom)});
+          }
+        },
 
-        this.markers = this._setMarkers(newMarkers);
+        _minZoomChanged: function() {
+          if (this.map) {
+            this.map.setOptions({minZoom: Number(this.minZoom)});
+          }
+        },
 
-        // Set the map on each marker and zoom viewport to ensure they're in view.
-        this._attachChildrenToMap(this.markers);
-        if (this.fitToMarkers) {
-          this._fitToMarkersChanged();
-        }
-      },
+        _mapTypeChanged: function() {
+          if (this.map) {
+            this.map.setMapTypeId(this.mapType);
+          }
+        },
 
-      // watch for future updates to non-marker objects
-      _observeObjects: function() {
-        if (this._objectsMutationObserver) {
-          return;
-        }
-        this._objectsMutationObserver = new MutationObserver(this._updateObjects.bind(this));
-        this._objectsMutationObserver.observe(this, {
-          childList: true
-        });
-      },
-
-      _updateObjects: function() {
-        var newObjects = Array.prototype.slice.call(
-            Polymer.dom(this.$.objects).getDistributedNodes());
-
-        // Do not recompute if objects have not been added or removed.
-        if (newObjects.length === this.objects.length) {
-          var added = newObjects.filter(function(o) {
-            return this.objects.indexOf(o) === -1;
-          }.bind(this));
-          if (added.length === 0) {
-            // Set up observer first time around.
-            this._observeObjects();
+        _disableDefaultUiChanged: function() {
+          if (!this.map) {
             return;
           }
-        }
+          this.map.setOptions({disableDefaultUI: this.disableDefaultUi});
+        },
 
-        this._observeObjects();
-        this._setObjects(newObjects);
-        this._attachChildrenToMap(this.objects);
-      },
-
-      /**
-       * Clears all markers from the map.
-       *
-       * @method clear
-       */
-      clear: function() {
-        for (var i = 0, m; m = this.markers[i]; ++i) {
-          m.marker.setMap(null);
-        }
-      },
-
-      /**
-       * Explicitly resizes the map, updating its center. This is useful if the
-       * map does not show after you have unhidden it.
-       *
-       * @method resize
-       */
-      resize: function() {
-        if (this.map) {
-
-          // saves and restores latitude/longitude because resize can move the center
-          var oldLatitude = this.latitude;
-          var oldLongitude = this.longitude;
-          google.maps.event.trigger(this.map, 'resize');
-          this.latitude = oldLatitude;  // restore because resize can move our center
-          this.longitude = oldLongitude;
-
-          if (this.fitToMarkers) { // we might not have a center if we are doing fit-to-markers
-            this._fitToMarkersChanged();
+        _disableMapTypeControlChanged: function() {
+          if (!this.map) {
+            return;
           }
-        }
-      },
-
-      _loadKml: function() {
-        if (this.map && this.kml) {
-          var kmlfile = new google.maps.KmlLayer({
-            url: this.kml,
-            map: this.map
-          });
-        }
-      },
+          this.map.setOptions({mapTypeControl: !this.disableMapTypeControl});
+        },
 
-      _debounceUpdateCenter: function() {
-        this.debounce('updateCenter', this._updateCenter);
-      },
+        _disableStreetViewControlChanged: function() {
+          if (!this.map) {
+            return;
+          }
+          this.map.setOptions({streetViewControl: !this.disableStreetViewControl});
+        },
 
-      _updateCenter: function() {
-        this.cancelDebouncer('updateCenter');
+        _disableZoomChanged: function() {
+          if (!this.map) {
+            return;
+          }
+          this.map.setOptions({
+            disableDoubleClickZoom: this.disableZoom,
+            scrollwheel: !this.disableZoom
+          });
+        },
 
-        if (this.map && this.latitude !== undefined && this.longitude !== undefined) {
-          // allow for latitude and longitude to be String-typed, but still Number valued
-          var lati = Number(this.latitude);
-          if (isNaN(lati)) {
-            throw new TypeError('latitude must be a number');
+        attributeChanged: function(attrName) {
+          if (!this.map) {
+            return;
           }
-          var longi = Number(this.longitude);
-          if (isNaN(longi)) {
-            throw new TypeError('longitude must be a number');
+          // Cannot use *Changed watchers for native properties.
+          switch (attrName) {
+            case 'draggable':
+              this.map.setOptions({draggable: this.draggable});
+              break;
           }
+        },
 
-          var newCenter = new google.maps.LatLng(lati, longi);
-          var oldCenter = this.map.getCenter();
-
-          if (!oldCenter) {
-            // If the map does not have a center, set it right away.
-            this.map.setCenter(newCenter);
-          } else {
-            // Using google.maps.LatLng returns corrected lat/lngs.
-            oldCenter = new google.maps.LatLng(oldCenter.lat(), oldCenter.lng());
+        _fitToMarkersChanged: function() {
+          // TODO(ericbidelman): respect user's zoom level.
 
-            // If the map currently has a center, slowly pan to the new one.
-            if (!oldCenter.equals(newCenter)) {
-              this.map.panTo(newCenter);
+          if (this.map && this.fitToMarkers && this.markers.length > 0) {
+            var latLngBounds = new google.maps.LatLngBounds();
+            for (var i = 0, m; m = this.markers[i]; ++i) {
+              latLngBounds.extend(
+                  new google.maps.LatLng(m.latitude, m.longitude));
             }
-          }
-        }
-      },
 
-      _zoomChanged: function() {
-        if (this.map) {
-          this.map.setZoom(Number(this.zoom));
-        }
-      },
+            // For one marker, don't alter zoom, just center it.
+            if (this.markers.length > 1) {
+              this.map.fitBounds(latLngBounds);
+            }
 
-      _idleEvent: function() {
-        if (this.map) {
-          this._forwardEvent('idle');
-        } else {
-          this._clearListener('idle');
-        }
-      },
-
-      _clickEventsChanged: function() {
-        if (this.map) {
-          if (this.clickEvents) {
-            this._forwardEvent('click');
-            this._forwardEvent('dblclick');
-            this._forwardEvent('rightclick');
-          } else {
-            this._clearListener('click');
-            this._clearListener('dblclick');
-            this._clearListener('rightclick');
+            this.map.setCenter(latLngBounds.getCenter());
           }
-        }
-      },
-
-      _dragEventsChanged: function() {
-        if (this.map) {
-          if (this.dragEvents) {
-            this._forwardEvent('drag');
-            this._forwardEvent('dragend');
-            this._forwardEvent('dragstart');
-          } else {
-            this._clearListener('drag');
-            this._clearListener('dragend');
-            this._clearListener('dragstart');
-          }
-        }
-      },
-
-      _mouseEventsChanged: function() {
-        if (this.map) {
-          if (this.mouseEvents) {
-            this._forwardEvent('mousemove');
-            this._forwardEvent('mouseout');
-            this._forwardEvent('mouseover');
-          } else {
-            this._clearListener('mousemove');
-            this._clearListener('mouseout');
-            this._clearListener('mouseover');
-          }
-        }
-      },
-
-      _maxZoomChanged: function() {
-        if (this.map) {
-          this.map.setOptions({maxZoom: Number(this.maxZoom)});
-        }
-      },
-
-      _minZoomChanged: function() {
-        if (this.map) {
-          this.map.setOptions({minZoom: Number(this.minZoom)});
-        }
-      },
+        },
 
-      _mapTypeChanged: function() {
-        if (this.map) {
-          this.map.setMapTypeId(this.mapType);
-        }
-      },
+        _addMapListeners: function() {
+          google.maps.event.addListener(this.map, 'center_changed', function() {
+            var center = this.map.getCenter();
+            this.latitude = center.lat();
+            this.longitude = center.lng();
+          }.bind(this));
 
-      _disableDefaultUiChanged: function() {
-        if (!this.map) {
-          return;
-        }
-        this.map.setOptions({disableDefaultUI: this.disableDefaultUi});
-      },
+          google.maps.event.addListener(this.map, 'zoom_changed', function() {
+            this.zoom = this.map.getZoom();
+          }.bind(this));
 
-      _disableMapTypeControlChanged: function() {
-        if (!this.map) {
-          return;
-        }
-        this.map.setOptions({mapTypeControl: !this.disableMapTypeControl});
-      },
+          google.maps.event.addListener(this.map, 'maptypeid_changed', function() {
+            this.mapType = this.map.getMapTypeId();
+          }.bind(this));
 
-      _disableStreetViewControlChanged: function() {
-        if (!this.map) {
-          return;
-        }
-        this.map.setOptions({streetViewControl: !this.disableStreetViewControl});
-      },
+          this._clickEventsChanged();
+          this._dragEventsChanged();
+          this._mouseEventsChanged();
+          this._idleEvent();
+        },
 
-      _disableZoomChanged: function() {
-        if (!this.map) {
-          return;
-        }
-        this.map.setOptions({
-          disableDoubleClickZoom: this.disableZoom,
-          scrollwheel: !this.disableZoom
-        });
-      },
-
-      attributeChanged: function(attrName) {
-        if (!this.map) {
-          return;
-        }
-        // Cannot use *Changed watchers for native properties.
-        switch (attrName) {
-          case 'draggable':
-            this.map.setOptions({draggable: this.draggable});
-            break;
-        }
-      },
+        _clearListener: function(name) {
+          if (this._listeners[name]) {
+            google.maps.event.removeListener(this._listeners[name]);
+            this._listeners[name] = null;
+          }
+        },
 
-      _fitToMarkersChanged: function() {
-        // TODO(ericbidelman): respect user's zoom level.
+        _forwardEvent: function(name) {
+          this._listeners[name] = google.maps.event.addListener(this.map, name, function(event) {
+            this.fire('google-map-' + name, event);
+          }.bind(this));
+        },
 
-        if (this.map && this.fitToMarkers && this.markers.length > 0) {
-          var latLngBounds = new google.maps.LatLngBounds();
-          for (var i = 0, m; m = this.markers[i]; ++i) {
-            latLngBounds.extend(
-                new google.maps.LatLng(m.latitude, m.longitude));
-          }
+        _deselectMarker: function(e, detail) {
+          // If singleInfoWindow is set, update iron-selector's selected attribute to be null.
+          // Else remove the marker from iron-selector's selected array.
+          var markerIndex = this.$.selector.indexOf(e.target);
 
-          // For one marker, don't alter zoom, just center it.
-          if (this.markers.length > 1) {
-            this.map.fitBounds(latLngBounds);
+          if (this.singleInfoWindow) {
+            this.$.selector.selected = null;
+          } else if (this.$.selector.selectedValues) {
+            this.$.selector.selectedValues = this.$.selector.selectedValues.filter(function(i) {return i !== markerIndex});
           }
-
-          this.map.setCenter(latLngBounds.getCenter());
-        }
-      },
-
-      _addMapListeners: function() {
-        google.maps.event.addListener(this.map, 'center_changed', function() {
-          var center = this.map.getCenter();
-          this.latitude = center.lat();
-          this.longitude = center.lng();
-        }.bind(this));
-
-        google.maps.event.addListener(this.map, 'zoom_changed', function() {
-          this.zoom = this.map.getZoom();
-        }.bind(this));
-
-        google.maps.event.addListener(this.map, 'maptypeid_changed', function() {
-          this.mapType = this.map.getMapTypeId();
-        }.bind(this));
-
-        this._clickEventsChanged();
-        this._dragEventsChanged();
-        this._mouseEventsChanged();
-        this._idleEvent();
-      },
-
-      _clearListener: function(name) {
-        if (this._listeners[name]) {
-          google.maps.event.removeListener(this._listeners[name]);
-          this._listeners[name] = null;
-        }
-      },
-
-      _forwardEvent: function(name) {
-        this._listeners[name] = google.maps.event.addListener(this.map, name, function(event) {
-          this.fire('google-map-' + name, event);
-        }.bind(this));
-      },
-
-      _deselectMarker: function(e, detail) {
-        // If singleInfoWindow is set, update iron-selector's selected attribute to be null.
-        // Else remove the marker from iron-selector's selected array.
-        var markerIndex = this.$.selector.indexOf(e.target);
-
-        if (this.singleInfoWindow) {
-          this.$.selector.selected = null;
-        } else if (this.$.selector.selectedValues) {
-          this.$.selector.selectedValues = this.$.selector.selectedValues.filter(function(i) {return i !== markerIndex});
         }
-      }
-    });
+      });
+    })();
   </script>
 </dom-module>