text: //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  import { Quaternion } from './Quaternion.js'
  import { Vector3 } from './Vector3.js'
  import { Matrix4 } from './Matrix4.js'
  import { _Math } from './Math.js'
  function Euler( x, y, z, order ) {
  
  	this._x = x || 0;
  	this._y = y || 0;
  	this._z = z || 0;
  	this._order = order || Euler.DefaultOrder;
  
  }
  
  Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];
  
  Euler.DefaultOrder = 'XYZ';
  
  Object.defineProperties( Euler.prototype, {
  
  	x: {
  
  		get: function () {
  
  			return this._x;
  
  		},
  
  		set: function ( value ) {
  
  			this._x = value;
  			this.onChangeCallback();
  
  		}
  
  	},
  
  	y: {
  
  		get: function () {
  
  			return this._y;
  
  		},
  
  		set: function ( value ) {
  
  			this._y = value;
  			this.onChangeCallback();
  
  		}
  
  	},
  
  	z: {
  
  		get: function () {
  
  			return this._z;
  
  		},
  
  		set: function ( value ) {
  
  			this._z = value;
  			this.onChangeCallback();
  
  		}
  
  	},
  
  	order: {
  
  		get: function () {
  
  			return this._order;
  
  		},
  
  		set: function ( value ) {
  
  			this._order = value;
  			this.onChangeCallback();
  
  		}
  
  	}
  
  } );
  
  Object.assign( Euler.prototype, {
  
  	isEuler: true,
  
  	set: function ( x, y, z, order ) {
  
  		this._x = x;
  		this._y = y;
  		this._z = z;
  		this._order = order || this._order;
  
  		this.onChangeCallback();
  
  		return this;
  
  	},
  
  	clone: function () {
  
  		return new this.constructor( this._x, this._y, this._z, this._order );
  
  	},
  
  	copy: function ( euler ) {
  
  		this._x = euler._x;
  		this._y = euler._y;
  		this._z = euler._z;
  		this._order = euler._order;
  
  		this.onChangeCallback();
  
  		return this;
  
  	},
  
  	setFromRotationMatrix: function ( m, order, update ) {
  
  		var clamp = _Math.clamp;
  
  		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
  
  		var te = m.elements;
  		var m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];
  		var m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];
  		var m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
  
  		order = order || this._order;
  
  		if ( order === 'XYZ' ) {
  
  			this._y = Math.asin( clamp( m13, - 1, 1 ) );
  
  			if ( Math.abs( m13 ) < 0.99999 ) {
  
  				this._x = Math.atan2( - m23, m33 );
  				this._z = Math.atan2( - m12, m11 );
  
  			} else {
  
  				this._x = Math.atan2( m32, m22 );
  				this._z = 0;
  
  			}
  
  		} else if ( order === 'YXZ' ) {
  
  			this._x = Math.asin( - clamp( m23, - 1, 1 ) );
  
  			if ( Math.abs( m23 ) < 0.99999 ) {
  
  				this._y = Math.atan2( m13, m33 );
  				this._z = Math.atan2( m21, m22 );
  
  			} else {
  
  				this._y = Math.atan2( - m31, m11 );
  				this._z = 0;
  
  			}
  
  		} else if ( order === 'ZXY' ) {
  
  			this._x = Math.asin( clamp( m32, - 1, 1 ) );
  
  			if ( Math.abs( m32 ) < 0.99999 ) {
  
  				this._y = Math.atan2( - m31, m33 );
  				this._z = Math.atan2( - m12, m22 );
  
  			} else {
  
  				this._y = 0;
  				this._z = Math.atan2( m21, m11 );
  
  			}
  
  		} else if ( order === 'ZYX' ) {
  
  			this._y = Math.asin( - clamp( m31, - 1, 1 ) );
  
  			if ( Math.abs( m31 ) < 0.99999 ) {
  
  				this._x = Math.atan2( m32, m33 );
  				this._z = Math.atan2( m21, m11 );
  
  			} else {
  
  				this._x = 0;
  				this._z = Math.atan2( - m12, m22 );
  
  			}
  
  		} else if ( order === 'YZX' ) {
  
  			this._z = Math.asin( clamp( m21, - 1, 1 ) );
  
  			if ( Math.abs( m21 ) < 0.99999 ) {
  
  				this._x = Math.atan2( - m23, m22 );
  				this._y = Math.atan2( - m31, m11 );
  
  			} else {
  
  				this._x = 0;
  				this._y = Math.atan2( m13, m33 );
  
  			}
  
  		} else if ( order === 'XZY' ) {
  
  			this._z = Math.asin( - clamp( m12, - 1, 1 ) );
  
  			if ( Math.abs( m12 ) < 0.99999 ) {
  
  				this._x = Math.atan2( m32, m22 );
  				this._y = Math.atan2( m13, m11 );
  
  			} else {
  
  				this._x = Math.atan2( - m23, m33 );
  				this._y = 0;
  
  			}
  
  		} else {
  
  			console.warn( 'Euler: .setFromRotationMatrix() given unsupported order: ' + order );
  
  		}
  
  		this._order = order;
  
  		if ( update !== false ) this.onChangeCallback();
  
  		return this;
  
  	},
  
  	setFromQuaternion: function () {
  
  		var matrix = new Matrix4();
  
  		return function setFromQuaternion( q, order, update ) {
  
  			matrix.makeRotationFromQuaternion( q );
  
  			return this.setFromRotationMatrix( matrix, order, update );
  
  		};
  
  	}(),
  
  	setFromVector3: function ( v, order ) {
  
  		return this.set( v.x, v.y, v.z, order || this._order );
  
  	},
  
  	reorder: function () {
  
  		// WARNING: this discards revolution information -bhouston
  
  		var q = new Quaternion();
  
  		return function reorder( newOrder ) {
  
  			q.setFromEuler( this );
  
  			return this.setFromQuaternion( q, newOrder );
  
  		};
  
  	}(),
  
  	equals: function ( euler ) {
  
  		return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );
  
  	},
  
  	fromArray: function ( array ) {
  
  		this._x = array[ 0 ];
  		this._y = array[ 1 ];
  		this._z = array[ 2 ];
  		if ( array[ 3 ] !== undefined ) this._order = array[ 3 ];
  
  		this.onChangeCallback();
  
  		return this;
  
  	},
  
  	toArray: function ( array, offset ) {
  
  		if ( array === undefined ) array = [];
  		if ( offset === undefined ) offset = 0;
  
  		array[ offset ] = this._x;
  		array[ offset + 1 ] = this._y;
  		array[ offset + 2 ] = this._z;
  		array[ offset + 3 ] = this._order;
  
  		return array;
  
  	},
  
  	toVector3: function ( optionalResult ) {
  
  		if ( optionalResult ) {
  
  			return optionalResult.set( this._x, this._y, this._z );
  
  		} else {
  
  			return new Vector3( this._x, this._y, this._z );
  
  		}
  
  	},
  
  	onChange: function ( callback ) {
  
  		this.onChangeCallback = callback;
  
  		return this;
  
  	},
  
  	onChangeCallback: function () {}
  
  } );
  
  export { Euler }
  