text: import { Vector3 } from './Vector3.js';
  
  class Box3 {
  
  	constructor( min, max ) {
  
  		Object.defineProperty( this, 'isBox3', { value: true } );
  
  		this.min = ( min !== undefined ) ? min : new Vector3( + Infinity, + Infinity, + Infinity );
  		this.max = ( max !== undefined ) ? max : new Vector3( - Infinity, - Infinity, - Infinity );
  
  	}
  
  	set( min, max ) {
  
  		this.min.copy( min );
  		this.max.copy( max );
  
  		return this;
  
  	}
  
  	setFromArray( array ) {
  
  		let minX = + Infinity;
  		let minY = + Infinity;
  		let minZ = + Infinity;
  
  		let maxX = - Infinity;
  		let maxY = - Infinity;
  		let maxZ = - Infinity;
  
  		for ( let i = 0, l = array.length; i < l; i += 3 ) {
  
  			const x = array[ i ];
  			const y = array[ i + 1 ];
  			const z = array[ i + 2 ];
  
  			if ( x < minX ) minX = x;
  			if ( y < minY ) minY = y;
  			if ( z < minZ ) minZ = z;
  
  			if ( x > maxX ) maxX = x;
  			if ( y > maxY ) maxY = y;
  			if ( z > maxZ ) maxZ = z;
  
  		}
  
  		this.min.set( minX, minY, minZ );
  		this.max.set( maxX, maxY, maxZ );
  
  		return this;
  
  	}
  
  	setFromBufferAttribute( attribute ) {
  
  		let minX = + Infinity;
  		let minY = + Infinity;
  		let minZ = + Infinity;
  
  		let maxX = - Infinity;
  		let maxY = - Infinity;
  		let maxZ = - Infinity;
  
  		for ( let i = 0, l = attribute.count; i < l; i ++ ) {
  
  			const x = attribute.getX( i );
  			const y = attribute.getY( i );
  			const z = attribute.getZ( i );
  
  			if ( x < minX ) minX = x;
  			if ( y < minY ) minY = y;
  			if ( z < minZ ) minZ = z;
  
  			if ( x > maxX ) maxX = x;
  			if ( y > maxY ) maxY = y;
  			if ( z > maxZ ) maxZ = z;
  
  		}
  
  		this.min.set( minX, minY, minZ );
  		this.max.set( maxX, maxY, maxZ );
  
  		return this;
  
  	}
  
  	setFromPoints( points ) {
  
  		this.makeEmpty();
  
  		for ( let i = 0, il = points.length; i < il; i ++ ) {
  
  			this.expandByPoint( points[ i ] );
  
  		}
  
  		return this;
  
  	}
  
  	setFromCenterAndSize( center, size ) {
  
  		const halfSize = _vector.copy( size ).multiplyScalar( 0.5 );
  
  		this.min.copy( center ).sub( halfSize );
  		this.max.copy( center ).add( halfSize );
  
  		return this;
  
  	}
  
  	setFromObject( object ) {
  
  		this.makeEmpty();
  
  		return this.expandByObject( object );
  
  	}
  
  	clone() {
  
  		return new this.constructor().copy( this );
  
  	}
  
  	copy( box ) {
  
  		this.min.copy( box.min );
  		this.max.copy( box.max );
  
  		return this;
  
  	}
  
  	makeEmpty() {
  
  		this.min.x = this.min.y = this.min.z = + Infinity;
  		this.max.x = this.max.y = this.max.z = - Infinity;
  
  		return this;
  
  	}
  
  	isEmpty() {
  
  		// 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 ) || ( this.max.z < this.min.z );
  
  	}
  
  	getCenter( target ) {
  
  		if ( target === undefined ) {
  
  			console.warn( 'Box3: .getCenter() target is now required' );
  			target = new Vector3();
  
  		}
  
  		return this.isEmpty() ? target.set( 0, 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
  
  	}
  
  	getSize( target ) {
  
  		if ( target === undefined ) {
  
  			console.warn( 'Box3: .getSize() target is now required' );
  			target = new Vector3();
  
  		}
  
  		return this.isEmpty() ? target.set( 0, 0, 0 ) : target.subVectors( this.max, this.min );
  
  	}
  
  	expandByPoint( point ) {
  
  		this.min.min( point );
  		this.max.max( point );
  
  		return this;
  
  	}
  
  	expandByVector( vector ) {
  
  		this.min.sub( vector );
  		this.max.add( vector );
  
  		return this;
  
  	}
  
  	expandByScalar( scalar ) {
  
  		this.min.addScalar( - scalar );
  		this.max.addScalar( scalar );
  
  		return this;
  
  	}
  
  	expandByObject( object ) {
  
  		// Computes the world-axis-aligned bounding box of an object (including its children),
  		// accounting for both the object's, and children's, world transforms
  
  		object.updateWorldMatrix( false, false );
  
  		const geometry = object.geometry;
  
  		if ( geometry !== undefined ) {
  
  			if ( geometry.boundingBox === null ) {
  
  				geometry.computeBoundingBox();
  
  			}
  
  			_box.copy( geometry.boundingBox );
  			_box.applyMatrix4( object.matrixWorld );
  
  			this.union( _box );
  
  		}
  
  		const children = object.children;
  
  		for ( let i = 0, l = children.length; i < l; i ++ ) {
  
  			this.expandByObject( children[ i ] );
  
  		}
  
  		return this;
  
  	}
  
  	containsPoint( point ) {
  
  		return point.x < this.min.x || point.x > this.max.x ||
  			point.y < this.min.y || point.y > this.max.y ||
  			point.z < this.min.z || point.z > this.max.z ? false : true;
  
  	}
  
  	containsBox( box ) {
  
  		return this.min.x <= box.min.x && box.max.x <= this.max.x &&
  			this.min.y <= box.min.y && box.max.y <= this.max.y &&
  			this.min.z <= box.min.z && box.max.z <= this.max.z;
  
  	}
  
  	getParameter( point, target ) {
  
  		// This can potentially have a divide by zero if the box
  		// has a size dimension of 0.
  
  		if ( target === undefined ) {
  
  			console.warn( 'Box3: .getParameter() target is now required' );
  			target = new Vector3();
  
  		}
  
  		return target.set(
  			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
  			( point.y - this.min.y ) / ( this.max.y - this.min.y ),
  			( point.z - this.min.z ) / ( this.max.z - this.min.z )
  		);
  
  	}
  
  	intersectsBox( box ) {
  
  		// using 6 splitting planes to rule out intersections.
  		return box.max.x < this.min.x || box.min.x > this.max.x ||
  			box.max.y < this.min.y || box.min.y > this.max.y ||
  			box.max.z < this.min.z || box.min.z > this.max.z ? false : true;
  
  	}
  
  	intersectsSphere( sphere ) {
  
  		// Find the point on the AABB closest to the sphere center.
  		this.clampPoint( sphere.center, _vector );
  
  		// If that point is inside the sphere, the AABB and sphere intersect.
  		return _vector.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );
  
  	}
  
  	intersectsPlane( plane ) {
  
  		// We compute the minimum and maximum dot product values. If those values
  		// are on the same side (back or front) of the plane, then there is no intersection.
  
  		let min, max;
  
  		if ( plane.normal.x > 0 ) {
  
  			min = plane.normal.x * this.min.x;
  			max = plane.normal.x * this.max.x;
  
  		} else {
  
  			min = plane.normal.x * this.max.x;
  			max = plane.normal.x * this.min.x;
  
  		}
  
  		if ( plane.normal.y > 0 ) {
  
  			min += plane.normal.y * this.min.y;
  			max += plane.normal.y * this.max.y;
  
  		} else {
  
  			min += plane.normal.y * this.max.y;
  			max += plane.normal.y * this.min.y;
  
  		}
  
  		if ( plane.normal.z > 0 ) {
  
  			min += plane.normal.z * this.min.z;
  			max += plane.normal.z * this.max.z;
  
  		} else {
  
  			min += plane.normal.z * this.max.z;
  			max += plane.normal.z * this.min.z;
  
  		}
  
  		return ( min <= - plane.constant && max >= - plane.constant );
  
  	}
  
  	intersectsTriangle( triangle ) {
  
  		if ( this.isEmpty() ) {
  
  			return false;
  
  		}
  
  		// compute box center and extents
  		this.getCenter( _center );
  		_extents.subVectors( this.max, _center );
  
  		// translate triangle to aabb origin
  		_v0.subVectors( triangle.a, _center );
  		_v1.subVectors( triangle.b, _center );
  		_v2.subVectors( triangle.c, _center );
  
  		// compute edge vectors for triangle
  		_f0.subVectors( _v1, _v0 );
  		_f1.subVectors( _v2, _v1 );
  		_f2.subVectors( _v0, _v2 );
  
  		// test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
  		// make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
  		// axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
  		let axes = [
  			0, - _f0.z, _f0.y, 0, - _f1.z, _f1.y, 0, - _f2.z, _f2.y,
  			_f0.z, 0, - _f0.x, _f1.z, 0, - _f1.x, _f2.z, 0, - _f2.x,
  			- _f0.y, _f0.x, 0, - _f1.y, _f1.x, 0, - _f2.y, _f2.x, 0
  		];
  		if ( ! satForAxes( axes, _v0, _v1, _v2, _extents ) ) {
  
  			return false;
  
  		}
  
  		// test 3 face normals from the aabb
  		axes = [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ];
  		if ( ! satForAxes( axes, _v0, _v1, _v2, _extents ) ) {
  
  			return false;
  
  		}
  
  		// finally testing the face normal of the triangle
  		// use already existing triangle edge vectors here
  		_triangleNormal.crossVectors( _f0, _f1 );
  		axes = [ _triangleNormal.x, _triangleNormal.y, _triangleNormal.z ];
  
  		return satForAxes( axes, _v0, _v1, _v2, _extents );
  
  	}
  
  	clampPoint( point, target ) {
  
  		if ( target === undefined ) {
  
  			console.warn( 'Box3: .clampPoint() target is now required' );
  			target = new Vector3();
  
  		}
  
  		return target.copy( point ).clamp( this.min, this.max );
  
  	}
  
  	distanceToPoint( point ) {
  
  		const clampedPoint = _vector.copy( point ).clamp( this.min, this.max );
  
  		return clampedPoint.sub( point ).length();
  
  	}
  
  	getBoundingSphere( target ) {
  
  		if ( target === undefined ) {
  
  			console.error( 'Box3: .getBoundingSphere() target is now required' );
  			//target = new Sphere(); // removed to avoid cyclic dependency
  
  		}
  
  		this.getCenter( target.center );
  
  		target.radius = this.getSize( _vector ).length() * 0.5;
  
  		return target;
  
  	}
  
  	intersect( box ) {
  
  		this.min.max( box.min );
  		this.max.min( box.max );
  
  		// ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
  		if ( this.isEmpty() ) this.makeEmpty();
  
  		return this;
  
  	}
  
  	union( box ) {
  
  		this.min.min( box.min );
  		this.max.max( box.max );
  
  		return this;
  
  	}
  
  	applyMatrix4( matrix ) {
  
  		// transform of empty box is an empty box.
  		if ( this.isEmpty() ) return this;
  
  		// NOTE: I am using a binary pattern to specify all 2^3 combinations below
  		_points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000
  		_points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001
  		_points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010
  		_points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011
  		_points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100
  		_points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101
  		_points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110
  		_points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111
  
  		this.setFromPoints( _points );
  
  		return this;
  
  	}
  
  	translate( offset ) {
  
  		this.min.add( offset );
  		this.max.add( offset );
  
  		return this;
  
  	}
  
  	equals( box ) {
  
  		return box.min.equals( this.min ) && box.max.equals( this.max );
  
  	}
  
  }
  
  function satForAxes( axes, v0, v1, v2, extents ) {
  
  	for ( let i = 0, j = axes.length - 3; i <= j; i += 3 ) {
  
  		_testAxis.fromArray( axes, i );
  		// project the aabb onto the seperating axis
  		const r = extents.x * Math.abs( _testAxis.x ) + extents.y * Math.abs( _testAxis.y ) + extents.z * Math.abs( _testAxis.z );
  		// project all 3 vertices of the triangle onto the seperating axis
  		const p0 = v0.dot( _testAxis );
  		const p1 = v1.dot( _testAxis );
  		const p2 = v2.dot( _testAxis );
  		// actual test, basically see if either of the most extreme of the triangle points intersects r
  		if ( Math.max( - Math.max( p0, p1, p2 ), Math.min( p0, p1, p2 ) ) > r ) {
  
  			// points of the projected triangle are outside the projected half-length of the aabb
  			// the axis is seperating and we can exit
  			return false;
  
  		}
  
  	}
  
  	return true;
  
  }
  
  const _points = [
  	/*@__PURE__*/ new Vector3(),
  	/*@__PURE__*/ new Vector3(),
  	/*@__PURE__*/ new Vector3(),
  	/*@__PURE__*/ new Vector3(),
  	/*@__PURE__*/ new Vector3(),
  	/*@__PURE__*/ new Vector3(),
  	/*@__PURE__*/ new Vector3(),
  	/*@__PURE__*/ new Vector3()
  ];
  
  const _vector = /*@__PURE__*/ new Vector3();
  
  const _box = /*@__PURE__*/ new Box3();
  
  // triangle centered vertices
  
  const _v0 = /*@__PURE__*/ new Vector3();
  const _v1 = /*@__PURE__*/ new Vector3();
  const _v2 = /*@__PURE__*/ new Vector3();
  
  // triangle edge vectors
  
  const _f0 = /*@__PURE__*/ new Vector3();
  const _f1 = /*@__PURE__*/ new Vector3();
  const _f2 = /*@__PURE__*/ new Vector3();
  
  const _center = /*@__PURE__*/ new Vector3();
  const _extents = /*@__PURE__*/ new Vector3();
  const _triangleNormal = /*@__PURE__*/ new Vector3();
  const _testAxis = /*@__PURE__*/ new Vector3();
  
  
  export { Box3 };
  