text: import { Vector3 } from '../math/Vector3.js';
  import { Vector2 } from '../math/Vector2.js';
  import { Box3 } from '../math/Box3.js';
  import { EventDispatcher } from './EventDispatcher.js';
  import { BufferAttribute, Float32BufferAttribute, Uint16BufferAttribute, Uint32BufferAttribute } from './BufferAttribute.js';
  import { Sphere } from '../math/Sphere.js';
  import { Object3D } from './Object3D.js';
  import { Matrix4 } from '../math/Matrix4.js';
  import { Matrix3 } from '../math/Matrix3.js';
  import * as MathUtils from '../math/MathUtils.js';
  import { arrayMax } from '../utils.js';
  
  let _id = 0;
  
  const _m1 = /*@__PURE__*/ new Matrix4();
  const _obj = /*@__PURE__*/ new Object3D();
  const _offset = /*@__PURE__*/ new Vector3();
  const _box = /*@__PURE__*/ new Box3();
  const _boxMorphTargets = /*@__PURE__*/ new Box3();
  const _vector = /*@__PURE__*/ new Vector3();
  
  class BufferGeometry extends EventDispatcher {
  
  	constructor() {
  
  		super();
  
  		Object.defineProperty( this, 'id', { value: _id ++ } );
  
  		this.uuid = MathUtils.generateUUID();
  
  		this.name = '';
  		this.type = 'BufferGeometry';
  
  		this.index = null;
  		this.attributes = {};
  
  		this.morphAttributes = {};
  		this.morphTargetsRelative = false;
  
  		this.groups = [];
  
  		this.boundingBox = null;
  		this.boundingSphere = null;
  
  		this.drawRange = { start: 0, count: Infinity };
  
  		this.userData = {};
  
  	}
  
  	getIndex() {
  
  		return this.index;
  
  	}
  
  	setIndex( index ) {
  
  		if ( Array.isArray( index ) ) {
  
  			this.index = new ( arrayMax( index ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 );
  
  		} else {
  
  			this.index = index;
  
  		}
  
  		return this;
  
  	}
  
  	getAttribute( name ) {
  
  		return this.attributes[ name ];
  
  	}
  
  	setAttribute( name, attribute ) {
  
  		this.attributes[ name ] = attribute;
  
  		return this;
  
  	}
  
  	deleteAttribute( name ) {
  
  		delete this.attributes[ name ];
  
  		return this;
  
  	}
  
  	hasAttribute( name ) {
  
  		return this.attributes[ name ] !== undefined;
  
  	}
  
  	addGroup( start, count, materialIndex = 0 ) {
  
  		this.groups.push( {
  
  			start: start,
  			count: count,
  			materialIndex: materialIndex
  
  		} );
  
  	}
  
  	clearGroups() {
  
  		this.groups = [];
  
  	}
  
  	setDrawRange( start, count ) {
  
  		this.drawRange.start = start;
  		this.drawRange.count = count;
  
  	}
  
  	applyMatrix4( matrix ) {
  
  		const position = this.attributes.position;
  
  		if ( position !== undefined ) {
  
  			position.applyMatrix4( matrix );
  
  			position.needsUpdate = true;
  
  		}
  
  		const normal = this.attributes.normal;
  
  		if ( normal !== undefined ) {
  
  			const normalMatrix = new Matrix3().getNormalMatrix( matrix );
  
  			normal.applyNormalMatrix( normalMatrix );
  
  			normal.needsUpdate = true;
  
  		}
  
  		const tangent = this.attributes.tangent;
  
  		if ( tangent !== undefined ) {
  
  			tangent.transformDirection( matrix );
  
  			tangent.needsUpdate = true;
  
  		}
  
  		if ( this.boundingBox !== null ) {
  
  			this.computeBoundingBox();
  
  		}
  
  		if ( this.boundingSphere !== null ) {
  
  			this.computeBoundingSphere();
  
  		}
  
  		return this;
  
  	}
  
  	applyQuaternion( q ) {
  
  		_m1.makeRotationFromQuaternion( q );
  
  		this.applyMatrix4( _m1 );
  
  		return this;
  
  	}
  
  	rotateX( angle ) {
  
  		// rotate geometry around world x-axis
  
  		_m1.makeRotationX( angle );
  
  		this.applyMatrix4( _m1 );
  
  		return this;
  
  	}
  
  	rotateY( angle ) {
  
  		// rotate geometry around world y-axis
  
  		_m1.makeRotationY( angle );
  
  		this.applyMatrix4( _m1 );
  
  		return this;
  
  	}
  
  	rotateZ( angle ) {
  
  		// rotate geometry around world z-axis
  
  		_m1.makeRotationZ( angle );
  
  		this.applyMatrix4( _m1 );
  
  		return this;
  
  	}
  
  	translate( x, y, z ) {
  
  		// translate geometry
  
  		_m1.makeTranslation( x, y, z );
  
  		this.applyMatrix4( _m1 );
  
  		return this;
  
  	}
  
  	scale( x, y, z ) {
  
  		// scale geometry
  
  		_m1.makeScale( x, y, z );
  
  		this.applyMatrix4( _m1 );
  
  		return this;
  
  	}
  
  	lookAt( vector ) {
  
  		_obj.lookAt( vector );
  
  		_obj.updateMatrix();
  
  		this.applyMatrix4( _obj.matrix );
  
  		return this;
  
  	}
  
  	center() {
  
  		this.computeBoundingBox();
  
  		this.boundingBox.getCenter( _offset ).negate();
  
  		this.translate( _offset.x, _offset.y, _offset.z );
  
  		return this;
  
  	}
  
  	setFromPoints( points ) {
  
  		const position = [];
  
  		for ( let i = 0, l = points.length; i < l; i ++ ) {
  
  			const point = points[ i ];
  			position.push( point.x, point.y, point.z || 0 );
  
  		}
  
  		this.setAttribute( 'position', new Float32BufferAttribute( position, 3 ) );
  
  		return this;
  
  	}
  
  	computeBoundingBox() {
  
  		if ( this.boundingBox === null ) {
  
  			this.boundingBox = new Box3();
  
  		}
  
  		const position = this.attributes.position;
  		const morphAttributesPosition = this.morphAttributes.position;
  
  		if ( position && position.isGLBufferAttribute ) {
  
  			console.error( 'THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".', this );
  
  			this.boundingBox.set(
  				new Vector3( - Infinity, - Infinity, - Infinity ),
  				new Vector3( + Infinity, + Infinity, + Infinity )
  			);
  
  			return;
  
  		}
  
  		if ( position !== undefined ) {
  
  			this.boundingBox.setFromBufferAttribute( position );
  
  			// process morph attributes if present
  
  			if ( morphAttributesPosition ) {
  
  				for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {
  
  					const morphAttribute = morphAttributesPosition[ i ];
  					_box.setFromBufferAttribute( morphAttribute );
  
  					if ( this.morphTargetsRelative ) {
  
  						_vector.addVectors( this.boundingBox.min, _box.min );
  						this.boundingBox.expandByPoint( _vector );
  
  						_vector.addVectors( this.boundingBox.max, _box.max );
  						this.boundingBox.expandByPoint( _vector );
  
  					} else {
  
  						this.boundingBox.expandByPoint( _box.min );
  						this.boundingBox.expandByPoint( _box.max );
  
  					}
  
  				}
  
  			}
  
  		} else {
  
  			this.boundingBox.makeEmpty();
  
  		}
  
  		if ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {
  
  			console.error( 'THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this );
  
  		}
  
  	}
  
  	computeBoundingSphere() {
  
  		if ( this.boundingSphere === null ) {
  
  			this.boundingSphere = new Sphere();
  
  		}
  
  		const position = this.attributes.position;
  		const morphAttributesPosition = this.morphAttributes.position;
  
  		if ( position && position.isGLBufferAttribute ) {
  
  			console.error( 'THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".', this );
  
  			this.boundingSphere.set( new Vector3(), Infinity );
  
  			return;
  
  		}
  
  		if ( position ) {
  
  			// first, find the center of the bounding sphere
  
  			const center = this.boundingSphere.center;
  
  			_box.setFromBufferAttribute( position );
  
  			// process morph attributes if present
  
  			if ( morphAttributesPosition ) {
  
  				for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {
  
  					const morphAttribute = morphAttributesPosition[ i ];
  					_boxMorphTargets.setFromBufferAttribute( morphAttribute );
  
  					if ( this.morphTargetsRelative ) {
  
  						_vector.addVectors( _box.min, _boxMorphTargets.min );
  						_box.expandByPoint( _vector );
  
  						_vector.addVectors( _box.max, _boxMorphTargets.max );
  						_box.expandByPoint( _vector );
  
  					} else {
  
  						_box.expandByPoint( _boxMorphTargets.min );
  						_box.expandByPoint( _boxMorphTargets.max );
  
  					}
  
  				}
  
  			}
  
  			_box.getCenter( center );
  
  			// second, try to find a boundingSphere with a radius smaller than the
  			// boundingSphere of the boundingBox: sqrt(3) smaller in the best case
  
  			let maxRadiusSq = 0;
  
  			for ( let i = 0, il = position.count; i < il; i ++ ) {
  
  				_vector.fromBufferAttribute( position, i );
  
  				maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector ) );
  
  			}
  
  			// process morph attributes if present
  
  			if ( morphAttributesPosition ) {
  
  				for ( let i = 0, il = morphAttributesPosition.length; i < il; i ++ ) {
  
  					const morphAttribute = morphAttributesPosition[ i ];
  					const morphTargetsRelative = this.morphTargetsRelative;
  
  					for ( let j = 0, jl = morphAttribute.count; j < jl; j ++ ) {
  
  						_vector.fromBufferAttribute( morphAttribute, j );
  
  						if ( morphTargetsRelative ) {
  
  							_offset.fromBufferAttribute( position, j );
  							_vector.add( _offset );
  
  						}
  
  						maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector ) );
  
  					}
  
  				}
  
  			}
  
  			this.boundingSphere.radius = Math.sqrt( maxRadiusSq );
  
  			if ( isNaN( this.boundingSphere.radius ) ) {
  
  				console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this );
  
  			}
  
  		}
  
  	}
  
  	computeTangents() {
  
  		const index = this.index;
  		const attributes = this.attributes;
  
  		// based on http://www.terathon.com/code/tangent.html
  		// (per vertex tangents)
  
  		if ( index === null ||
  			 attributes.position === undefined ||
  			 attributes.normal === undefined ||
  			 attributes.uv === undefined ) {
  
  			console.error( 'THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)' );
  			return;
  
  		}
  
  		const indices = index.array;
  		const positions = attributes.position.array;
  		const normals = attributes.normal.array;
  		const uvs = attributes.uv.array;
  
  		const nVertices = positions.length / 3;
  
  		if ( attributes.tangent === undefined ) {
  
  			this.setAttribute( 'tangent', new BufferAttribute( new Float32Array( 4 * nVertices ), 4 ) );
  
  		}
  
  		const tangents = attributes.tangent.array;
  
  		const tan1 = [], tan2 = [];
  
  		for ( let i = 0; i < nVertices; i ++ ) {
  
  			tan1[ i ] = new Vector3();
  			tan2[ i ] = new Vector3();
  
  		}
  
  		const vA = new Vector3(),
  			vB = new Vector3(),
  			vC = new Vector3(),
  
  			uvA = new Vector2(),
  			uvB = new Vector2(),
  			uvC = new Vector2(),
  
  			sdir = new Vector3(),
  			tdir = new Vector3();
  
  		function handleTriangle( a, b, c ) {
  
  			vA.fromArray( positions, a * 3 );
  			vB.fromArray( positions, b * 3 );
  			vC.fromArray( positions, c * 3 );
  
  			uvA.fromArray( uvs, a * 2 );
  			uvB.fromArray( uvs, b * 2 );
  			uvC.fromArray( uvs, c * 2 );
  
  			vB.sub( vA );
  			vC.sub( vA );
  
  			uvB.sub( uvA );
  			uvC.sub( uvA );
  
  			const r = 1.0 / ( uvB.x * uvC.y - uvC.x * uvB.y );
  
  			// silently ignore degenerate uv triangles having coincident or colinear vertices
  
  			if ( ! isFinite( r ) ) return;
  
  			sdir.copy( vB ).multiplyScalar( uvC.y ).addScaledVector( vC, - uvB.y ).multiplyScalar( r );
  			tdir.copy( vC ).multiplyScalar( uvB.x ).addScaledVector( vB, - uvC.x ).multiplyScalar( r );
  
  			tan1[ a ].add( sdir );
  			tan1[ b ].add( sdir );
  			tan1[ c ].add( sdir );
  
  			tan2[ a ].add( tdir );
  			tan2[ b ].add( tdir );
  			tan2[ c ].add( tdir );
  
  		}
  
  		let groups = this.groups;
  
  		if ( groups.length === 0 ) {
  
  			groups = [ {
  				start: 0,
  				count: indices.length
  			} ];
  
  		}
  
  		for ( let i = 0, il = groups.length; i < il; ++ i ) {
  
  			const group = groups[ i ];
  
  			const start = group.start;
  			const count = group.count;
  
  			for ( let j = start, jl = start + count; j < jl; j += 3 ) {
  
  				handleTriangle(
  					indices[ j + 0 ],
  					indices[ j + 1 ],
  					indices[ j + 2 ]
  				);
  
  			}
  
  		}
  
  		const tmp = new Vector3(), tmp2 = new Vector3();
  		const n = new Vector3(), n2 = new Vector3();
  
  		function handleVertex( v ) {
  
  			n.fromArray( normals, v * 3 );
  			n2.copy( n );
  
  			const t = tan1[ v ];
  
  			// Gram-Schmidt orthogonalize
  
  			tmp.copy( t );
  			tmp.sub( n.multiplyScalar( n.dot( t ) ) ).normalize();
  
  			// Calculate handedness
  
  			tmp2.crossVectors( n2, t );
  			const test = tmp2.dot( tan2[ v ] );
  			const w = ( test < 0.0 ) ? - 1.0 : 1.0;
  
  			tangents[ v * 4 ] = tmp.x;
  			tangents[ v * 4 + 1 ] = tmp.y;
  			tangents[ v * 4 + 2 ] = tmp.z;
  			tangents[ v * 4 + 3 ] = w;
  
  		}
  
  		for ( let i = 0, il = groups.length; i < il; ++ i ) {
  
  			const group = groups[ i ];
  
  			const start = group.start;
  			const count = group.count;
  
  			for ( let j = start, jl = start + count; j < jl; j += 3 ) {
  
  				handleVertex( indices[ j + 0 ] );
  				handleVertex( indices[ j + 1 ] );
  				handleVertex( indices[ j + 2 ] );
  
  			}
  
  		}
  
  	}
  
  	computeVertexNormals() {
  
  		const index = this.index;
  		const positionAttribute = this.getAttribute( 'position' );
  
  		if ( positionAttribute !== undefined ) {
  
  			let normalAttribute = this.getAttribute( 'normal' );
  
  			if ( normalAttribute === undefined ) {
  
  				normalAttribute = new BufferAttribute( new Float32Array( positionAttribute.count * 3 ), 3 );
  				this.setAttribute( 'normal', normalAttribute );
  
  			} else {
  
  				// reset existing normals to zero
  
  				for ( let i = 0, il = normalAttribute.count; i < il; i ++ ) {
  
  					normalAttribute.setXYZ( i, 0, 0, 0 );
  
  				}
  
  			}
  
  			const pA = new Vector3(), pB = new Vector3(), pC = new Vector3();
  			const nA = new Vector3(), nB = new Vector3(), nC = new Vector3();
  			const cb = new Vector3(), ab = new Vector3();
  
  			// indexed elements
  
  			if ( index ) {
  
  				for ( let i = 0, il = index.count; i < il; i += 3 ) {
  
  					const vA = index.getX( i + 0 );
  					const vB = index.getX( i + 1 );
  					const vC = index.getX( i + 2 );
  
  					pA.fromBufferAttribute( positionAttribute, vA );
  					pB.fromBufferAttribute( positionAttribute, vB );
  					pC.fromBufferAttribute( positionAttribute, vC );
  
  					cb.subVectors( pC, pB );
  					ab.subVectors( pA, pB );
  					cb.cross( ab );
  
  					nA.fromBufferAttribute( normalAttribute, vA );
  					nB.fromBufferAttribute( normalAttribute, vB );
  					nC.fromBufferAttribute( normalAttribute, vC );
  
  					nA.add( cb );
  					nB.add( cb );
  					nC.add( cb );
  
  					normalAttribute.setXYZ( vA, nA.x, nA.y, nA.z );
  					normalAttribute.setXYZ( vB, nB.x, nB.y, nB.z );
  					normalAttribute.setXYZ( vC, nC.x, nC.y, nC.z );
  
  				}
  
  			} else {
  
  				// non-indexed elements (unconnected triangle soup)
  
  				for ( let i = 0, il = positionAttribute.count; i < il; i += 3 ) {
  
  					pA.fromBufferAttribute( positionAttribute, i + 0 );
  					pB.fromBufferAttribute( positionAttribute, i + 1 );
  					pC.fromBufferAttribute( positionAttribute, i + 2 );
  
  					cb.subVectors( pC, pB );
  					ab.subVectors( pA, pB );
  					cb.cross( ab );
  
  					normalAttribute.setXYZ( i + 0, cb.x, cb.y, cb.z );
  					normalAttribute.setXYZ( i + 1, cb.x, cb.y, cb.z );
  					normalAttribute.setXYZ( i + 2, cb.x, cb.y, cb.z );
  
  				}
  
  			}
  
  			this.normalizeNormals();
  
  			normalAttribute.needsUpdate = true;
  
  		}
  
  	}
  
  	merge( geometry, offset ) {
  
  		if ( ! ( geometry && geometry.isBufferGeometry ) ) {
  
  			console.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry );
  			return;
  
  		}
  
  		if ( offset === undefined ) {
  
  			offset = 0;
  
  			console.warn(
  				'THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. '
  				+ 'Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge.'
  			);
  
  		}
  
  		const attributes = this.attributes;
  
  		for ( const key in attributes ) {
  
  			if ( geometry.attributes[ key ] === undefined ) continue;
  
  			const attribute1 = attributes[ key ];
  			const attributeArray1 = attribute1.array;
  
  			const attribute2 = geometry.attributes[ key ];
  			const attributeArray2 = attribute2.array;
  
  			const attributeOffset = attribute2.itemSize * offset;
  			const length = Math.min( attributeArray2.length, attributeArray1.length - attributeOffset );
  
  			for ( let i = 0, j = attributeOffset; i < length; i ++, j ++ ) {
  
  				attributeArray1[ j ] = attributeArray2[ i ];
  
  			}
  
  		}
  
  		return this;
  
  	}
  
  	normalizeNormals() {
  
  		const normals = this.attributes.normal;
  
  		for ( let i = 0, il = normals.count; i < il; i ++ ) {
  
  			_vector.fromBufferAttribute( normals, i );
  
  			_vector.normalize();
  
  			normals.setXYZ( i, _vector.x, _vector.y, _vector.z );
  
  		}
  
  	}
  
  	toNonIndexed() {
  
  		function convertBufferAttribute( attribute, indices ) {
  
  			const array = attribute.array;
  			const itemSize = attribute.itemSize;
  			const normalized = attribute.normalized;
  
  			const array2 = new array.constructor( indices.length * itemSize );
  
  			let index = 0, index2 = 0;
  
  			for ( let i = 0, l = indices.length; i < l; i ++ ) {
  
  				if ( attribute.isInterleavedBufferAttribute ) {
  
  					index = indices[ i ] * attribute.data.stride + attribute.offset;
  
  				} else {
  
  					index = indices[ i ] * itemSize;
  
  				}
  
  				for ( let j = 0; j < itemSize; j ++ ) {
  
  					array2[ index2 ++ ] = array[ index ++ ];
  
  				}
  
  			}
  
  			return new BufferAttribute( array2, itemSize, normalized );
  
  		}
  
  		//
  
  		if ( this.index === null ) {
  
  			console.warn( 'THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed.' );
  			return this;
  
  		}
  
  		const geometry2 = new BufferGeometry();
  
  		const indices = this.index.array;
  		const attributes = this.attributes;
  
  		// attributes
  
  		for ( const name in attributes ) {
  
  			const attribute = attributes[ name ];
  
  			const newAttribute = convertBufferAttribute( attribute, indices );
  
  			geometry2.setAttribute( name, newAttribute );
  
  		}
  
  		// morph attributes
  
  		const morphAttributes = this.morphAttributes;
  
  		for ( const name in morphAttributes ) {
  
  			const morphArray = [];
  			const morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes
  
  			for ( let i = 0, il = morphAttribute.length; i < il; i ++ ) {
  
  				const attribute = morphAttribute[ i ];
  
  				const newAttribute = convertBufferAttribute( attribute, indices );
  
  				morphArray.push( newAttribute );
  
  			}
  
  			geometry2.morphAttributes[ name ] = morphArray;
  
  		}
  
  		geometry2.morphTargetsRelative = this.morphTargetsRelative;
  
  		// groups
  
  		const groups = this.groups;
  
  		for ( let i = 0, l = groups.length; i < l; i ++ ) {
  
  			const group = groups[ i ];
  			geometry2.addGroup( group.start, group.count, group.materialIndex );
  
  		}
  
  		return geometry2;
  
  	}
  
  	toJSON() {
  
  		const data = {
  			metadata: {
  				version: 4.5,
  				type: 'BufferGeometry',
  				generator: 'BufferGeometry.toJSON'
  			}
  		};
  
  		// standard BufferGeometry serialization
  
  		data.uuid = this.uuid;
  		data.type = this.type;
  		if ( this.name !== '' ) data.name = this.name;
  		if ( Object.keys( this.userData ).length > 0 ) data.userData = this.userData;
  
  		if ( this.parameters !== undefined ) {
  
  			const parameters = this.parameters;
  
  			for ( const key in parameters ) {
  
  				if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];
  
  			}
  
  			return data;
  
  		}
  
  		// for simplicity the code assumes attributes are not shared across geometries, see #15811
  
  		data.data = { attributes: {} };
  
  		const index = this.index;
  
  		if ( index !== null ) {
  
  			data.data.index = {
  				type: index.array.constructor.name,
  				array: Array.prototype.slice.call( index.array )
  			};
  
  		}
  
  		const attributes = this.attributes;
  
  		for ( const key in attributes ) {
  
  			const attribute = attributes[ key ];
  
  			data.data.attributes[ key ] = attribute.toJSON( data.data );
  
  		}
  
  		const morphAttributes = {};
  		let hasMorphAttributes = false;
  
  		for ( const key in this.morphAttributes ) {
  
  			const attributeArray = this.morphAttributes[ key ];
  
  			const array = [];
  
  			for ( let i = 0, il = attributeArray.length; i < il; i ++ ) {
  
  				const attribute = attributeArray[ i ];
  
  				array.push( attribute.toJSON( data.data ) );
  
  			}
  
  			if ( array.length > 0 ) {
  
  				morphAttributes[ key ] = array;
  
  				hasMorphAttributes = true;
  
  			}
  
  		}
  
  		if ( hasMorphAttributes ) {
  
  			data.data.morphAttributes = morphAttributes;
  			data.data.morphTargetsRelative = this.morphTargetsRelative;
  
  		}
  
  		const groups = this.groups;
  
  		if ( groups.length > 0 ) {
  
  			data.data.groups = JSON.parse( JSON.stringify( groups ) );
  
  		}
  
  		const boundingSphere = this.boundingSphere;
  
  		if ( boundingSphere !== null ) {
  
  			data.data.boundingSphere = {
  				center: boundingSphere.center.toArray(),
  				radius: boundingSphere.radius
  			};
  
  		}
  
  		return data;
  
  	}
  
  	clone() {
  
  		 return new this.constructor().copy( this );
  
  	}
  
  	copy( source ) {
  
  		// reset
  
  		this.index = null;
  		this.attributes = {};
  		this.morphAttributes = {};
  		this.groups = [];
  		this.boundingBox = null;
  		this.boundingSphere = null;
  
  		// used for storing cloned, shared data
  
  		const data = {};
  
  		// name
  
  		this.name = source.name;
  
  		// index
  
  		const index = source.index;
  
  		if ( index !== null ) {
  
  			this.setIndex( index.clone( data ) );
  
  		}
  
  		// attributes
  
  		const attributes = source.attributes;
  
  		for ( const name in attributes ) {
  
  			const attribute = attributes[ name ];
  			this.setAttribute( name, attribute.clone( data ) );
  
  		}
  
  		// morph attributes
  
  		const morphAttributes = source.morphAttributes;
  
  		for ( const name in morphAttributes ) {
  
  			const array = [];
  			const morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes
  
  			for ( let i = 0, l = morphAttribute.length; i < l; i ++ ) {
  
  				array.push( morphAttribute[ i ].clone( data ) );
  
  			}
  
  			this.morphAttributes[ name ] = array;
  
  		}
  
  		this.morphTargetsRelative = source.morphTargetsRelative;
  
  		// groups
  
  		const groups = source.groups;
  
  		for ( let i = 0, l = groups.length; i < l; i ++ ) {
  
  			const group = groups[ i ];
  			this.addGroup( group.start, group.count, group.materialIndex );
  
  		}
  
  		// bounding box
  
  		const boundingBox = source.boundingBox;
  
  		if ( boundingBox !== null ) {
  
  			this.boundingBox = boundingBox.clone();
  
  		}
  
  		// bounding sphere
  
  		const boundingSphere = source.boundingSphere;
  
  		if ( boundingSphere !== null ) {
  
  			this.boundingSphere = boundingSphere.clone();
  
  		}
  
  		// draw range
  
  		this.drawRange.start = source.drawRange.start;
  		this.drawRange.count = source.drawRange.count;
  
  		// user data
  
  		this.userData = source.userData;
  
  		// geometry generator parameters
  
  		if ( source.parameters !== undefined ) this.parameters = Object.assign( {}, source.parameters );
  
  		return this;
  
  	}
  
  	dispose() {
  
  		this.dispatchEvent( { type: 'dispose' } );
  
  	}
  
  }
  
  BufferGeometry.prototype.isBufferGeometry = true;
  
  export { BufferGeometry };
  