anchor.diff:  
   
   @JS("L.Map")
  -class LeafletMap {
  -  external LeafletMap(String id, [MapOptions options]);
  -}
  -
  +class Map {
  +  external Map(String id, [MapOptions options]);
  +
  +  /**
  +   * Removes the given layer from the map.
  +   */
  +  external Map removeLayer(ILayer layer);
  +
  +  /**
  +   * Sets a map view that contains the given geographical bounds with the maximum zoom level possible.
  +   */
  +  external Map fitBounds(LatLngBounds bounds, [FitBoundsOptions options]);
  +
  +  /**
  +   * Pans the map to the closest view that would lie inside the given bounds (if it's not already), controlling the animation using the options specific, if any.
  +   */
  +  external Map panInsideBounds(LatLngBounds bounds, [PanOptions options]);
  +}
   
   @JS()
   @anonymous
  
positive.code:   /**
     * Creates an icon instance with the given options.
     */
    external factory IconOptions(
       String iconUrl,
      {
        String iconRetinaUrl,
        LeafletPoint iconSize,
        LeafletPoint iconAnchor,
        String shadowUrl,
        String shadowRetinaUrl,
        LeafletPoint shadowSize,
        LeafletPoint shadowAnchor,
        LeafletPoint popupAnchor,
        String className
      });
  }
  
  @JS("L.point")
  class LeafletPoint {
    /**
     * Creates a Point object with the given x and y coordinates. If optional round is set to true, rounds the x and y values.
     */
    external factory LeafletPoint(num x, num y, [bool round]);
  }
negative.code:                               num minZoom, num maxZoom, LatLngBounds maxBounds});
  }
  
  @JS()
  @anonymous
  class ZoomPanOptions {
  
    external factory ZoomPanOptions({
      bool reset,
      PanOptions pan,
      ZoomOptions zoom,
      bool animate
    });
  }
  
  class PanOptions {
  
    external factory PanOptions({
      bool animate,
      num duration,
      num easeLinearity,
      bool noMoveStart
    });
  }
  
  
  class ZoomOptions {
    external factory ZoomOptions({
      bool animate
    });
  }
  
  
  @JS()
  @anonymous
  class FitBoundsOptions extends ZoomPanOptions {
    external factory FitBoundsOptions({
      bool reset,
      PanOptions pan,
      ZoomOptions zoom,
      bool animate,
      Point paddingTopLeft,
      Point paddingBottomRight,
      Point padding,
      num maxZoom});
  }
  
  
  @JS("L.latLngBounds")
  class LatLngBounds {
    /**
     * if [first] is LatLng creates a latLngBounds object by defining south-west and north-east corners of the rectangle.
     * if [first] is List<LatLng> creates a LatLngBounds object defined by the geographical points it contains. Very useful for zooming the map to fit a particular set of locations with fitBounds.
     */
    external factory LatLngBounds(dynamic first, [LatLng northEast]);
  
    /**
     * Extends the bounds to contain the given point or bounds.
     */
    external LatLngBounds extend(LatLng latlng);
  
    /**
     * Extends the bounds to contain the given point or bounds.
     */
    @JS("extend")
    external LatLngBounds extendBounds(LatLngBounds latlng);
  
    /**
     * Returns the south-west point of the bounds.
     */
    external LatLng getSouthWest();
  
    /**
     * Returns the north-east point of the bounds.
     */
    external LatLng getNorthEast();
  
    /**
     * Returns the north-west point of the bounds.
     */
    external LatLng getNorthWest();
  
    /**
     * Returns the south-east point of the bounds.
     */
    external LatLng getSouthEast();
  
    /**
     * Returns the west longitude of the bounds.
     */
    external num getWest();
  
    /**
     * Returns the south latitude of the bounds.
     */
    external num getSouth();
  
    /**
     * Returns the east latitude of the bounds.
     */
    external num getEast();
  
    /**
     * Returns the north latitude of the bounds.
     */
    external num getNorth();
  
    /**
     * Returns the center point of the bounds.
     */
    external LatLng getCenter();
  
    /**
     * Returns true if the rectangle contains the given point.
     */
    external bool contains(LatLng latlng);
  
    /**
     * Returns true if the rectangle contains the given one.
     */
    @JS("contains")
    external bool containsBounds(LatLngBounds otherBounds);
  
    /**
     * Returns true if the rectangle intersects the given bounds.
     */
    external bool intersects(LatLngBounds otherBounds);
  
    /**
     * Returns true if the rectangle is equivalent (within a small margin of error) to the given bounds.
     */
    external bool equals(LatLngBounds otherBounds);
  
    /**
     * Returns a string with bounding box coordinates in a 'southwest_lng,southwest_lat,northeast_lng,northeast_lat' format. Useful for sending requests to web services that return geo data.
     */
    external String toBBoxString();
  
    /**
     * Returns bigger bounds created by extending the current bounds by a given percentage in each direction.
     */
    external LatLngBounds pad(num bufferRatio);
  
    /**
     * Returns true if the bounds are properly initialized.
     */
    external bool isValid();
  }
  
  @JS("L.latLng")
  class LatLng {
    external LatLng(double latitude, double longitude);
  
    /**
     * Latitude in degrees.
     */
    external double get lat;
  
    /**
     * Longitude in degrees.
     */
    external double get lng;
    external set lat(double lat);
    external set lng(double lng);
  
    /**
     * Returns the distance (in meters) to the given LatLng calculated using the Haversine formula. See description on wikipedia.
     */
    external num distanceTo(LatLng otherLatlng);
  
    /**
     * Returns true if the given LatLng point is at the same position (within a small margin of error).
     */
    external bool equals(LatLng otherLatlng);
  
    /**
     * Returns a string representation of the point (for debugging purposes).
     */
    external String toString();
  
    /**
     * Returns a new LatLng object with the longitude wrapped around left and right boundaries (-180 to 180 by default).
     */
    external LatLng wrap(num left, num right);
  }
  
  @JS()
  class ILayer {
    external void onAdd(Map map);
    external void onRemove(Map map);
  }
  
  @JS("L.tileLayer")
  