/*

 Copyright (c) 2010-2011, CloudMade, Vladimir Agafonkin

 Leaflet is a modern open-source JavaScript library for interactive maps.

 http://leaflet.cloudmade.com

*/

(function (root) {

	root.L = {

		VERSION: '0.3',

		ROOT_URL: root.L_ROOT_URL || (function () {

			var scripts = document.getElementsByTagName('script'),

				leafletRe = /\/?leaflet[\-\._]?([\w\-\._]*)\.js\??/;

			var i, len, src, matches;

			for (i = 0, len = scripts.length; i < len; i++) {

				src = scripts[i].src;

				matches = src.match(leafletRe);

				if (matches) {

					if (matches[1] === 'include') {

						return '../../dist/';

					}

					return src.replace(leafletRe, '') + '/';

				}

			}

			return '';

		}()),

		noConflict: function () {

			root.L = this._originalL;

			return this;

		},

		_originalL: root.L

	};

}(this));

/*

 * L.Util is a namespace for various utility functions.

 */

L.Util = {

	extend: function (/*Object*/ dest) /*-> Object*/ {	// merge src properties into dest

		var sources = Array.prototype.slice.call(arguments, 1);

		for (var j = 0, len = sources.length, src; j < len; j++) {

			src = sources[j] || {};

			for (var i in src) {

				if (src.hasOwnProperty(i)) {

					dest[i] = src[i];

				}

			}

		}

		return dest;

	},

	bind: function (/*Function*/ fn, /*Object*/ obj) /*-> Object*/ {

		return function () {

			return fn.apply(obj, arguments);

		};

	},

	stamp: (function () {

		var lastId = 0, key = '_leaflet_id';

		return function (/*Object*/ obj) {

			obj[key] = obj[key] || ++lastId;

			return obj[key];

		};

	}()),

	requestAnimFrame: (function () {

		function timeoutDefer(callback) {

			window.setTimeout(callback, 1000 / 60);

		}

		var requestFn = window.requestAnimationFrame ||

			window.webkitRequestAnimationFrame ||

			window.mozRequestAnimationFrame ||

			window.oRequestAnimationFrame ||

			window.msRequestAnimationFrame ||

			timeoutDefer;

		return function (callback, context, immediate, contextEl) {

			callback = context ? L.Util.bind(callback, context) : callback;

			if (immediate && requestFn === timeoutDefer) {

				callback();

			} else {

				requestFn(callback, contextEl);

			}

		};

	}()),

	limitExecByInterval: function (fn, time, context) {

		var lock, execOnUnlock, args;

		function exec() {

			lock = false;

			if (execOnUnlock) {

				args.callee.apply(context, args);

				execOnUnlock = false;

			}

		}

		return function () {

			args = arguments;

			if (!lock) {

				lock = true;

				setTimeout(exec, time);

				fn.apply(context, args);

			} else {

				execOnUnlock = true;

			}

		};

	},

	falseFn: function () {

		return false;

	},

	formatNum: function (num, digits) {

		var pow = Math.pow(10, digits || 5);

		return Math.round(num * pow) / pow;

	},

	setOptions: function (obj, options) {

		obj.options = L.Util.extend({}, obj.options, options);

	},

	getParamString: function (obj) {

		var params = [];

		for (var i in obj) {

			if (obj.hasOwnProperty(i)) {

				params.push(i + '=' + obj[i]);

			}

		}

		return '?' + params.join('&');

	},

	template: function (str, data) {

		return str.replace(/\{ *([\w_]+) *\}/g, function (str, key) {

			var value = data[key];

			if (!data.hasOwnProperty(key)) {

				throw new Error('No value provided for variable ' + str);

			}

			return value;

		});

	}

};

/*

 * Class powers the OOP facilities of the library. Thanks to John Resig and Dean Edwards for inspiration!

 */

L.Class = function () {};

L.Class.extend = function (/*Object*/ props) /*-> Class*/ {

	// extended class with the new prototype

	var NewClass = function () {

		if (this.initialize) {

			this.initialize.apply(this, arguments);

		}

	};

	// instantiate class without calling constructor

	var F = function () {};

	F.prototype = this.prototype;

	var proto = new F();

	proto.constructor = NewClass;

	NewClass.prototype = proto;

	// add superclass access

	NewClass.superclass = this.prototype;

	// add class name

	//proto.className = props;

	//inherit parent's statics

	for (var i in this) {

		if (this.hasOwnProperty(i) && i !== 'prototype' && i !== 'superclass') {

			NewClass[i] = this[i];

		}

	}

	// mix static properties into the class

	if (props.statics) {

		L.Util.extend(NewClass, props.statics);

		delete props.statics;

	}

	// mix includes into the prototype

	if (props.includes) {

		L.Util.extend.apply(null, [proto].concat(props.includes));

		delete props.includes;

	}

	// merge options

	if (props.options && proto.options) {

		props.options = L.Util.extend({}, proto.options, props.options);

	}

	// mix given properties into the prototype

	L.Util.extend(proto, props);

	// allow inheriting further

	NewClass.extend = L.Class.extend;

	// method for adding properties to prototype

	NewClass.include = function (props) {

		L.Util.extend(this.prototype, props);

	};

	return NewClass;

};

/*

 * L.Mixin.Events adds custom events functionality to Leaflet classes

 */

L.Mixin = {};

L.Mixin.Events = {

	addEventListener: function (/*String*/ type, /*Function*/ fn, /*(optional) Object*/ context) {

		var events = this._leaflet_events = this._leaflet_events || {};

		events[type] = events[type] || [];

		events[type].push({

			action: fn,

			context: context || this

		});

		return this;

	},

	hasEventListeners: function (/*String*/ type) /*-> Boolean*/ {

		var k = '_leaflet_events';

		return (k in this) && (type in this[k]) && (this[k][type].length > 0);

	},

	removeEventListener: function (/*String*/ type, /*Function*/ fn, /*(optional) Object*/ context) {

		if (!this.hasEventListeners(type)) {

			return this;

		}

		for (var i = 0, events = this._leaflet_events, len = events[type].length; i < len; i++) {

			if (

				(events[type][i].action === fn) &&

				(!context || (events[type][i].context === context))

			) {

				events[type].splice(i, 1);

				return this;

			}

		}

		return this;

	},

	fireEvent: function (/*String*/ type, /*(optional) Object*/ data) {

		if (!this.hasEventListeners(type)) {

			return this;

		}

		var event = L.Util.extend({

			type: type,

			target: this

		}, data);

		var listeners = this._leaflet_events[type].slice();

		for (var i = 0, len = listeners.length; i < len; i++) {

			listeners[i].action.call(listeners[i].context || this, event);

		}

		return this;

	}

};

L.Mixin.Events.on = L.Mixin.Events.addEventListener;

L.Mixin.Events.off = L.Mixin.Events.removeEventListener;

L.Mixin.Events.fire = L.Mixin.Events.fireEvent;

(function () {

	var ua = navigator.userAgent.toLowerCase(),

		ie = !!window.ActiveXObject,

		webkit = ua.indexOf("webkit") !== -1,

		mobile = typeof orientation !== 'undefined' ? true : false,

		android = ua.indexOf("android") !== -1,

		opera = window.opera;

	L.Browser = {

		ie: ie,

		ie6: ie && !window.XMLHttpRequest,

		webkit: webkit,

		webkit3d: webkit && ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()),

		gecko: ua.indexOf("gecko") !== -1,

		opera: opera,

		android: android,

		mobileWebkit: mobile && webkit,

		mobileOpera: mobile && opera,

		mobile: mobile,

		touch: (function () {

			var touchSupported = false,

				startName = 'ontouchstart';

			// WebKit, etc

			if (startName in document.documentElement) {

				return true;

			}

			// Firefox/Gecko

			var e = document.createElement('div');

			// If no support for basic event stuff, unlikely to have touch support

			if (!e.setAttribute || !e.removeAttribute) {

				return false;

			}

			e.setAttribute(startName, 'return;');

			if (typeof e[startName] === 'function') {

				touchSupported = true;

			}

			e.removeAttribute(startName);

			e = null;

			return touchSupported;

		}())

	};

}());

/*

 * L.Point represents a point with x and y coordinates.

 */

L.Point = function (/*Number*/ x, /*Number*/ y, /*Boolean*/ round) {

	this.x = (round ? Math.round(x) : x);

	this.y = (round ? Math.round(y) : y);

};

L.Point.prototype = {

	add: function (point) {

		return this.clone()._add(point);

	},

	_add: function (point) {

		this.x += point.x;

		this.y += point.y;

		return this;

	},

	subtract: function (point) {

		return this.clone()._subtract(point);

	},

	// destructive subtract (faster)

	_subtract: function (point) {

		this.x -= point.x;

		this.y -= point.y;

		return this;

	},

	divideBy: function (num, round) {

		return new L.Point(this.x / num, this.y / num, round);

	},

	multiplyBy: function (num) {

		return new L.Point(this.x * num, this.y * num);

	},

	distanceTo: function (point) {

		var x = point.x - this.x,

			y = point.y - this.y;

		return Math.sqrt(x * x + y * y);

	},

	round: function () {

		return this.clone()._round();

	},

	// destructive round

	_round: function () {

		this.x = Math.round(this.x);

		this.y = Math.round(this.y);

		return this;

	},

	clone: function () {

		return new L.Point(this.x, this.y);

	},

	toString: function () {

		return 'Point(' +

				L.Util.formatNum(this.x) + ', ' +

				L.Util.formatNum(this.y) + ')';

	}

};

/*

 * L.Bounds represents a rectangular area on the screen in pixel coordinates.

 */

L.Bounds = L.Class.extend({

	initialize: function (min, max) {	//(Point, Point) or Point[]

		if (!min) {

			return;

		}

		var points = (min instanceof Array ? min : [min, max]);

		for (var i = 0, len = points.length; i < len; i++) {

			this.extend(points[i]);

		}

	},

	// extend the bounds to contain the given point

	extend: function (/*Point*/ point) {

		if (!this.min && !this.max) {

			this.min = new L.Point(point.x, point.y);

			this.max = new L.Point(point.x, point.y);

		} else {

			this.min.x = Math.min(point.x, this.min.x);

			this.max.x = Math.max(point.x, this.max.x);

			this.min.y = Math.min(point.y, this.min.y);

			this.max.y = Math.max(point.y, this.max.y);

		}

	},

	getCenter: function (round)/*->Point*/ {

		return new L.Point(

				(this.min.x + this.max.x) / 2,

				(this.min.y + this.max.y) / 2, round);

	},

	contains: function (/*Bounds or Point*/ obj)/*->Boolean*/ {

		var min, max;

		if (obj instanceof L.Bounds) {

			min = obj.min;

			max = obj.max;

		} else {

			min = max = obj;

		}

		return (min.x >= this.min.x) &&

				(max.x <= this.max.x) &&

				(min.y >= this.min.y) &&

				(max.y <= this.max.y);

	},

	intersects: function (/*Bounds*/ bounds) {

		var min = this.min,

			max = this.max,

			min2 = bounds.min,

			max2 = bounds.max;

		var xIntersects = (max2.x >= min.x) && (min2.x <= max.x),

			yIntersects = (max2.y >= min.y) && (min2.y <= max.y);

		return xIntersects && yIntersects;

	}

});

/*

 * L.Transformation is an utility class to perform simple point transformations through a 2d-matrix.

 */

L.Transformation = L.Class.extend({

	initialize: function (/*Number*/ a, /*Number*/ b, /*Number*/ c, /*Number*/ d) {

		this._a = a;

		this._b = b;

		this._c = c;

		this._d = d;

	},

	transform: function (point, scale) {

		return this._transform(point.clone(), scale);

	},

	// destructive transform (faster)

	_transform: function (/*Point*/ point, /*Number*/ scale) /*-> Point*/ {

		scale = scale || 1;

		point.x = scale * (this._a * point.x + this._b);

		point.y = scale * (this._c * point.y + this._d);

		return point;

	},

	untransform: function (/*Point*/ point, /*Number*/ scale) /*-> Point*/ {

		scale = scale || 1;

		return new L.Point(

			(point.x / scale - this._b) / this._a,

			(point.y / scale - this._d) / this._c);

	}

});

/*

 * L.DomUtil contains various utility functions for working with DOM

 */

L.DomUtil = {

	get: function (id) {

		return (typeof id === 'string' ? document.getElementById(id) : id);

	},

	getStyle: function (el, style) {

		var value = el.style[style];

		if (!value && el.currentStyle) {

			value = el.currentStyle[style];

		}

		if (!value || value === 'auto') {

			var css = document.defaultView.getComputedStyle(el, null);

			value = css ? css[style] : null;

		}

		return (value === 'auto' ? null : value);

	},

	getViewportOffset: function (element) {

		var top = 0,

			left = 0,

			el = element,

			docBody = document.body;