text: import { Vector2 } from './Vector2';
  
  /**
   * @author bhouston / http://clara.io
   */
  
  function Box2 ( min, max ) {
  	this.isBox2 = true;
  
  	this.min = ( min !== undefined ) ? min : new Vector2( + Infinity, + Infinity );
  	this.max = ( max !== undefined ) ? max : new Vector2( - Infinity, - Infinity );
  
  };
  
  Box2.prototype = {
  
  	constructor: Box2,
  
  	set: function ( min, max ) {
  
  		this.min.copy( min );
  		this.max.copy( max );
  
  		return this;
  
  	},
  
  	setFromPoints: function ( points ) {
  
  		this.makeEmpty();
  
  		for ( var i = 0, il = points.length; i < il; i ++ ) {
  
  			this.expandByPoint( points[ i ] );
  
  		}
  
  		return this;
  
  	},
  
  	setFromCenterAndSize: function () {
  
  		var v1 = new Vector2();
  
  		return function setFromCenterAndSize( center, size ) {
  
  			var halfSize = v1.copy( size ).multiplyScalar( 0.5 );
  			this.min.copy( center ).sub( halfSize );
  			this.max.copy( center ).add( halfSize );
  
  			return this;
  
  		};
  
  	}(),
  
  	clone: function () {
  
  		return new this.constructor().copy( this );
  
  	},
  
  	copy: function ( box ) {
  
  		this.min.copy( box.min );
  		this.max.copy( box.max );
  
  		return this;
  
  	},
  
  	makeEmpty: function () {
  
  		this.min.x = this.min.y = + Infinity;
  		this.max.x = this.max.y = - Infinity;
  
  		return this;
  
  	},
  
  	isEmpty: function () {
  
  		// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
  
  		return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );
  
  	},
  
  	center: function ( optionalTarget ) {
  
  		var result = optionalTarget || new Vector2();
  		return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
  
  	},
  
  	size: function ( optionalTarget ) {
  
  		var result = optionalTarget || new Vector2();
  		return result.subVectors( this.max, this.min );
  
  	},
  
  	expandByPoint: function ( point ) {
  
  		this.min.min( point );
  		this.max.max( point );
  
  		return this;
  
  	},
  
  	expandByVector: function ( vector ) {
  
  		this.min.sub( vector );
  		this.max.add( vector );
  
  		return this;
  
  	},
  
  	expandByScalar: function ( scalar ) {
  
  		this.min.addScalar( - scalar );
  		this.max.addScalar( scalar );
  
  		return this;
  
  	},
  
  	containsPoint: function ( point ) {
  
  		if ( point.x < this.min.x || point.x > this.max.x ||
  		     point.y < this.min.y || point.y > this.max.y ) {
  
  			return false;
  
  		}
  
  		return true;
  
  	},
  
  	containsBox: function ( box ) {
  
  		if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) &&
  		     ( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) ) {
  
  			return true;
  
  		}
  
  		return false;
  
  	},
  
  	getParameter: function ( point, optionalTarget ) {
  
  		// This can potentially have a divide by zero if the box
  		// has a size dimension of 0.
  
  		var result = optionalTarget || new Vector2();
  
  		return result.set(
  			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
  			( point.y - this.min.y ) / ( this.max.y - this.min.y )
  		);
  
  	},
  
  	intersectsBox: function ( box ) {
  
  		// using 6 splitting planes to rule out intersections.
  
  		if ( box.max.x < this.min.x || box.min.x > this.max.x ||
  		     box.max.y < this.min.y || box.min.y > this.max.y ) {
  
  			return false;
  
  		}
  
  		return true;
  
  	},
  
  	clampPoint: function ( point, optionalTarget ) {
  
  		var result = optionalTarget || new Vector2();
  		return result.copy( point ).clamp( this.min, this.max );
  
  	},
  
  	distanceToPoint: function () {
  
  		var v1 = new Vector2();
  
  		return function distanceToPoint( point ) {
  
  			var clampedPoint = v1.copy( point ).clamp( this.min, this.max );
  			return clampedPoint.sub( point ).length();
  
  		};
  
  	}(),
  
  	intersect: function ( box ) {
  
  		this.min.max( box.min );
  		this.max.min( box.max );
  
  		return this;
  
  	},
  
  	union: function ( box ) {
  
  		this.min.min( box.min );
  		this.max.max( box.max );
  
  		return this;
  
  	},
  
  	translate: function ( offset ) {
  
  		this.min.add( offset );
  		this.max.add( offset );
  
  		return this;
  
  	},
  
  	equals: function ( box ) {
  
  		return box.min.equals( this.min ) && box.max.equals( this.max );
  
  	}
  
  };
  
  
  export { Box2 };