Fixing the "logo" :)
Added Stamen to copyright
Fix a spurious key repeat in arrow control.
Add comment to point-coordinate methods.
Cache reference to map.

This way, if the layer is removed from the map by the time loaded tiles arrive,
the map is still available for the purposes of projection.
Make a defensive copy of registered listeners.

This way, if a listener is removed while events are being dispatched, we won't
inadvertantly skip a listener.
Fix a bug in event dispatch.

If an event listener is removed during an event dispatch, it shouldn't receive
the active event. So now in addition to storing a defensive copy, we use a
wrapper object for the event handler to store an `on` boolean. This is set to
false when the listener is removed, preventing that handler from receiving the current event.
Improve performance of re-adding a layer.

Previously, when re-adding a layer to its map, the layer would be removed from
the map only to be immediately added back. This prevents the browser from
efficiently updating the display. Now we do the minimal amount of work, while
still guaranteeing that layers appear in the order they were added.
Fix zoom transforms with non-tiled layers.

Previously, if a zoom transform was used with a non-tiled layer, it could cause
no tiles to be displayed. Now we guarantee that at least one (world-size) tile
is visible.
Refine the tile scale & rounding logic.

We now apply the scale transform to the layer group elements, rather than to
each tile individually. In addition, rather than rounding each tile's position,
we round the tileCenter coordinate.
New layer `visible` property.

A layer's visibility can now be toggled without adding or removing the layer
from the map. This avoids inadvertantly changing the z-order of layers. In
addition to removing the tiles from the SVG image, the layer container's
visibility attribute is set to "hidden", such that if the user has extended the
layer with additional elements, they become hidden as well.
Rotation!

Maps can now be rotated using the `angle` property. For simplicity, the layer
implementation currently computes the bounding box to fill the rotated viewport;
in a future commit we will use a scanline fill algorithm to avoid loading tiles
outside the viewport.

This commit also fixes a bug in the `coordinatePoint` and `pointCoordinate`
methods, which were treating points pre-fractional zoom. Now points are always
considered to be in screen space (pixel coordinates), consistent with the
`locationPoint` and `pointLocation` methods. Note, however, that the
tile-specific projection used by layers is still pre-transform.
Set cursor to "move" while dragging.
Improve stability of mousewheel interaction.

Previously, the location under the mouse could drift as the mousewheel was used
to zoom in and out. Now we compute the location under the mouse on mousemove, so
that it does not drift when the map is zoomed. The location is specified as an
optional third argument to `map.zoomBy`.

The `map.panBy` method is reimplemented to be slightly faster and more accurate
by avoiding an extra point <-> location conversion.

Most importantly, the hash control now ignores the 'hashchange' event that it
generates when it changes the hash. Previously, this was causing noticeable
aliasing on smooth zoom as any movement of the map would be rounded to the
precision of the hash control.
Simplify overlay example using Layer.

We implement the static image overlay using a custom (but simple!) layer
implementation that creates an image tile.
Don't hardcode the number of Bing tile servers.
Improve stability of mousewheel interaction (again).

The previous fix suffered from two problems.

First, redundant hashchange events are occasionally dispatched by the browser,
and later events would not be ignored; thus the hash control would end up moving
the map on map move. We avoid this now by caching the location hash, and only
moving the map when the hash changes. This also allows us to ignore the
hashchange event when the map moves.

Second, the wheel control was caching the location under the mouse, and only
updating it when the mouse moves. However, the map can move independently of the
mouse, for example with arrow controls or animation. Thus, we now clear the
cached location when the map moves. (And, we're careful to preserve the cached
location when we zoom the map.)
Latitude clamping now considers map angle.
Use scanline algorithm to determine visible tiles.

Previously, if the map were rotated, we would compute the axis-aligned bounding
box to determine which tiles were visible. This is easy, but has the undesirable
property that it can load (and display) many tiles that are inside the bounding
box but outside the viewport.

Now we use the triangle scanline algorithm to determine exactly which tiles are
visible. The algorithm is modified slightly so that it displays any pixel (i.e.,
tile) that intersects the triangle.
Layer transforms!

Layers can now have associated affine transforms, affecting the layer's local
tile coordinates. For example, this allows an individual layer to be rotated,
scaled and translated within the map.