text: /*
   * L.Point represents a point with x and y coordinates.
   */
  
  L.Point = function (x, y, round) {
  	this.x = (round ? Math.round(x) : x);
  	this.y = (round ? Math.round(y) : y);
  };
  
  L.Point.prototype = {
  
  	clone: function () {
  		return new L.Point(this.x, this.y);
  	},
  
  	// non-destructive, returns a new point
  	add: function (point) {
  		return this.clone()._add(L.point(point));
  	},
  
  	// destructive, used directly for performance in situations where it's safe to modify existing point
  	_add: function (point) {
  		this.x += point.x;
  		this.y += point.y;
  		return this;
  	},
  
  	subtract: function (point) {
  		return this.clone()._subtract(L.point(point));
  	},
  
  	_subtract: function (point) {
  		this.x -= point.x;
  		this.y -= point.y;
  		return this;
  	},
  
  	divideBy: function (num) {
  		return this.clone()._divideBy(num);
  	},
  
  	_divideBy: function (num) {
  		this.x /= num;
  		this.y /= num;
  		return this;
  	},
  
  	multiplyBy: function (num) {
  		return this.clone()._multiplyBy(num);
  	},
  
  	_multiplyBy: function (num) {
  		this.x *= num;
  		this.y *= num;
  		return this;
  	},
  
  	scaleBy: function (point) {
  		return new L.Point(this.x * point.x, this.y * point.y);
  	},
  
  	unscaleBy: function (point) {
  		return new L.Point(this.x / point.x, this.y / point.y);
  	},
  
  	round: function () {
  		return this.clone()._round();
  	},
  
  	_round: function () {
  		this.x = Math.round(this.x);
  		this.y = Math.round(this.y);
  		return this;
  	},
  
  	floor: function () {
  		return this.clone()._floor();
  	},
  
  	_floor: function () {
  		this.x = Math.floor(this.x);
  		this.y = Math.floor(this.y);
  		return this;
  	},
  
  	ceil: function () {
  		return this.clone()._ceil();
  	},
  
  	_ceil: function () {
  		this.x = Math.ceil(this.x);
  		this.y = Math.ceil(this.y);
  		return this;
  	},
  
  	distanceTo: function (point) {
  		point = L.point(point);
  
  		var x = point.x - this.x,
  		    y = point.y - this.y;
  
  		return Math.sqrt(x * x + y * y);
  	},
  
  	equals: function (point) {
  		point = L.point(point);
  
  		return point.x === this.x &&
  		       point.y === this.y;
  	},
  
  	contains: function (point) {
  		point = L.point(point);
  
  		return Math.abs(point.x) <= Math.abs(this.x) &&
  		       Math.abs(point.y) <= Math.abs(this.y);
  	},
  
  	toString: function () {
  		return 'Point(' +
  		        L.Util.formatNum(this.x) + ', ' +
  		        L.Util.formatNum(this.y) + ')';
  	}
  };
  
  L.point = function (x, y, round) {
  	if (x instanceof L.Point) {
  		return x;
  	}
  	if (L.Util.isArray(x)) {
  		return new L.Point(x[0], x[1]);
  	}
  	if (x === undefined || x === null) {
  		return x;
  	}
  	return new L.Point(x, y, round);
  };
  