Ran npm run lint -- --fix

src/Three.Legacy.d.ts

@@ -8,6 +8,6 @@ export namespace SceneUtils {
     geometry: Geometry,
     materials: Material[]
   ): Object3D;
-  export function detach(child: Object3D, parent: Object3D, scene: Scene): void;
-  export function attach(child: Object3D, scene: Scene, parent: Object3D): void;
+  export function detach( child: Object3D, parent: Object3D, scene: Scene ): void;
+  export function attach( child: Object3D, scene: Scene, parent: Object3D ): void;
 }

src/animation/AnimationAction.d.ts

@@ -4,6 +4,7 @@ import { AnimationActionLoopStyles } from '../constants';
 // Animation ////////////////////////////////////////////////////////////////////////////////////////
 
 export class AnimationAction {
+
   loop: AnimationActionLoopStyles;
   time: number;
   timeScale: number;
@@ -20,15 +21,15 @@ export class AnimationAction {
   reset(): AnimationAction;
   isRunning(): boolean;
   isScheduled(): boolean;
-  startAt(time: number): AnimationAction;
+  startAt( time: number ): AnimationAction;
   setLoop(
     mode: AnimationActionLoopStyles,
     repetitions: number
   ): AnimationAction;
-  setEffectiveWeight(weight: number): AnimationAction;
+  setEffectiveWeight( weight: number ): AnimationAction;
   getEffectiveWeight(): number;
-  fadeIn(duration: number): AnimationAction;
-  fadeOut(duration: number): AnimationAction;
+  fadeIn( duration: number ): AnimationAction;
+  fadeOut( duration: number ): AnimationAction;
   crossFadeFrom(
     fadeOutAction: AnimationAction,
     duration: number,
@@ -40,11 +41,11 @@ export class AnimationAction {
     warp: boolean
   ): AnimationAction;
   stopFading(): AnimationAction;
-  setEffectiveTimeScale(timeScale: number): AnimationAction;
+  setEffectiveTimeScale( timeScale: number ): AnimationAction;
   getEffectiveTimeScale(): number;
-  setDuration(duration: number): AnimationAction;
-  syncWith(action: AnimationAction): AnimationAction;
-  halt(duration: number): AnimationAction;
+  setDuration( duration: number ): AnimationAction;
+  syncWith( action: AnimationAction ): AnimationAction;
+  halt( duration: number ): AnimationAction;
   warp(
     statTimeScale: number,
     endTimeScale: number,
@@ -54,4 +55,5 @@ export class AnimationAction {
   getMixer(): AnimationMixer;
   getClip(): AnimationClip;
   getRoot(): any;
+
 }

src/animation/AnimationClip.d.ts

@@ -3,7 +3,8 @@ import { Bone } from './../objects/Bone';
 import { MorphTarget } from '../core/Geometry';
 
 export class AnimationClip {
-  constructor(name?: string, duration?: number, tracks?: KeyframeTrack[]);
+
+	constructor( name?: string, duration?: number, tracks?: KeyframeTrack[] );
 
   name: string;
   tracks: KeyframeTrack[];
@@ -21,17 +22,18 @@ export class AnimationClip {
     fps: number,
     noLoop: boolean
   ): AnimationClip;
-  static findByName(clipArray: AnimationClip[], name: string): AnimationClip;
+  static findByName( clipArray: AnimationClip[], name: string ): AnimationClip;
   static CreateClipsFromMorphTargetSequences(
     morphTargets: MorphTarget[],
     fps: number,
     noLoop: boolean
   ): AnimationClip[];
-  static parse(json: any): AnimationClip;
+  static parse( json: any ): AnimationClip;
   static parseAnimation(
     animation: any,
     bones: Bone[],
     nodeName: string
   ): AnimationClip;
   static toJSON(): any;
+
 }

src/animation/AnimationMixer.d.ts

@@ -3,17 +3,19 @@ import { AnimationAction } from './AnimationAction';
 import { EventDispatcher } from './../core/EventDispatcher';
 
 export class AnimationMixer extends EventDispatcher {
-  constructor(root: any);
+
+	constructor( root: any );
 
   time: number;
   timeScale: number;
 
-  clipAction(clip: AnimationClip, root?: any): AnimationAction;
-  existingAction(clip: AnimationClip, root?: any): AnimationAction;
+  clipAction( clip: AnimationClip, root?: any ): AnimationAction;
+  existingAction( clip: AnimationClip, root?: any ): AnimationAction;
   stopAllAction(): AnimationMixer;
-  update(deltaTime: number): AnimationMixer;
+  update( deltaTime: number ): AnimationMixer;
   getRoot(): any;
-  uncacheClip(clip: AnimationClip): void;
-  uncacheRoot(root: any): void;
-  uncacheAction(clip: AnimationClip, root?: any): void;
+  uncacheClip( clip: AnimationClip ): void;
+  uncacheRoot( root: any ): void;
+  uncacheAction( clip: AnimationClip, root?: any ): void;
+
 }

src/animation/AnimationObjectGroup.d.ts

@@ -1,5 +1,6 @@
 export class AnimationObjectGroup {
-  constructor(...args: any[]);
+
+	constructor( ...args: any[] );
 
   uuid: string;
   stats: {
@@ -10,7 +11,8 @@ export class AnimationObjectGroup {
     };
   };
 
-  add(...args: any[]): void;
-  remove(...args: any[]): void;
-  uncache(...args: any[]): void;
+  add( ...args: any[] ): void;
+  remove( ...args: any[] ): void;
+  uncache( ...args: any[] ): void;
+
 }

src/animation/AnimationUtils.d.ts

@@ -1,8 +1,8 @@
 export namespace AnimationUtils {
-  export function arraySlice(array: any, from: number, to: number): any;
-  export function convertArray(array: any, type: any, forceClone: boolean): any;
-  export function isTypedArray(object: any): boolean;
-  export function getKeyFrameOrder(times: number): number[];
+  export function arraySlice( array: any, from: number, to: number ): any;
+  export function convertArray( array: any, type: any, forceClone: boolean ): any;
+  export function isTypedArray( object: any ): boolean;
+  export function getKeyFrameOrder( times: number ): number[];
   export function sortedArray(
     values: any[],
     stride: number,

src/animation/KeyframeTrack.d.ts

@@ -4,7 +4,8 @@ import { CubicInterpolant } from './../math/interpolants/CubicInterpolant';
 import { InterpolationModes } from '../constants';
 
 export class KeyframeTrack {
-  constructor(
+
+	constructor(
     name: string,
     times: any[],
     values: any[],
@@ -21,21 +22,22 @@ export class KeyframeTrack {
 
   DefaultInterpolation: InterpolationModes;
 
-  InterpolantFactoryMethodDiscrete(result: any): DiscreteInterpolant;
-  InterpolantFactoryMethodLinear(result: any): LinearInterpolant;
-  InterpolantFactoryMethodSmooth(result: any): CubicInterpolant;
+  InterpolantFactoryMethodDiscrete( result: any ): DiscreteInterpolant;
+  InterpolantFactoryMethodLinear( result: any ): LinearInterpolant;
+  InterpolantFactoryMethodSmooth( result: any ): CubicInterpolant;
 
-  setInterpolation(interpolation: InterpolationModes): void;
+  setInterpolation( interpolation: InterpolationModes ): void;
   getInterpolation(): InterpolationModes;
 
   getValuesize(): number;
 
-  shift(timeOffset: number): KeyframeTrack;
-  scale(timeScale: number): KeyframeTrack;
-  trim(startTime: number, endTime: number): KeyframeTrack;
+  shift( timeOffset: number ): KeyframeTrack;
+  scale( timeScale: number ): KeyframeTrack;
+  trim( startTime: number, endTime: number ): KeyframeTrack;
   validate(): boolean;
   optimize(): KeyframeTrack;
 
-  static parse(json: any): KeyframeTrack;
-  static toJSON(track: KeyframeTrack): any;
+  static parse( json: any ): KeyframeTrack;
+  static toJSON( track: KeyframeTrack ): any;
+
 }

src/animation/PropertyBinding.d.ts

@@ -1,13 +1,14 @@
 export class PropertyBinding {
-  constructor(rootNode: any, path: string, parsedPath?: any);
+
+	constructor( rootNode: any, path: string, parsedPath?: any );
 
   path: string;
   parsedPath: any;
   node: any;
   rootNode: any;
 
-  getValue(targetArray: any, offset: number): any;
-  setValue(sourceArray: any, offset: number): void;
+  getValue( targetArray: any, offset: number ): any;
+  setValue( sourceArray: any, offset: number ): void;
   bind(): void;
   unbind(): void;
 
@@ -22,17 +23,20 @@ export class PropertyBinding {
     path: any,
     parsedPath?: any
   ): PropertyBinding | PropertyBinding.Composite;
-  static parseTrackName(trackName: string): any;
-  static findNode(root: any, nodeName: string): any;
+  static parseTrackName( trackName: string ): any;
+  static findNode( root: any, nodeName: string ): any;
+
 }
 
 export namespace PropertyBinding {
   export class Composite {
-    constructor(targetGroup: any, path: any, parsedPath?: any);
 
-    getValue(array: any, offset: number): any;
-    setValue(array: any, offset: number): void;
-    bind(): void;
-    unbind(): void;
+  	constructor( targetGroup: any, path: any, parsedPath?: any );
+
+  	getValue( array: any, offset: number ): any;
+  	setValue( array: any, offset: number ): void;
+  	bind(): void;
+  	unbind(): void;
+
   }
 }

src/animation/PropertyMixer.d.ts

@@ -1,5 +1,6 @@
 export class PropertyMixer {
-  constructor(binding: any, typeName: string, valueSize: number);
+
+	constructor( binding: any, typeName: string, valueSize: number );
 
   binding: any;
   valueSize: number;
@@ -8,8 +9,9 @@ export class PropertyMixer {
   useCount: number;
   referenceCount: number;
 
-  accumulate(accuIndex: number, weight: number): void;
-  apply(accuIndex: number): void;
+  accumulate( accuIndex: number, weight: number ): void;
+  apply( accuIndex: number ): void;
   saveOriginalState(): void;
   restoreOriginalState(): void;
+
 }

src/animation/tracks/BooleanKeyframeTrack.d.ts

@@ -1,5 +1,7 @@
 import { KeyframeTrack } from './../KeyframeTrack';
 
 export class BooleanKeyframeTrack extends KeyframeTrack {
-  constructor(name: string, times: any[], values: any[]);
+
+	constructor( name: string, times: any[], values: any[] );
+
 }

src/animation/tracks/ColorKeyframeTrack.d.ts

@@ -2,10 +2,12 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class ColorKeyframeTrack extends KeyframeTrack {
-  constructor(
+
+	constructor(
     name: string,
     times: any[],
     values: any[],
     interpolation?: InterpolationModes
   );
+
 }

src/animation/tracks/NumberKeyframeTrack.d.ts

@@ -2,10 +2,12 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class NumberKeyframeTrack extends KeyframeTrack {
-  constructor(
+
+	constructor(
     name: string,
     times: any[],
     values: any[],
     interpolation?: InterpolationModes
   );
+
 }

src/animation/tracks/QuaternionKeyframeTrack.d.ts

@@ -2,10 +2,12 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class QuaternionKeyframeTrack extends KeyframeTrack {
-  constructor(
+
+	constructor(
     name: string,
     times: any[],
     values: any[],
     interpolation?: InterpolationModes
   );
+
 }

src/animation/tracks/StringKeyframeTrack.d.ts

@@ -2,10 +2,12 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class StringKeyframeTrack extends KeyframeTrack {
-  constructor(
+
+	constructor(
     name: string,
     times: any[],
     values: any[],
     interpolation?: InterpolationModes
   );
+
 }

src/animation/tracks/VectorKeyframeTrack.d.ts

@@ -2,10 +2,12 @@ import { KeyframeTrack } from './../KeyframeTrack';
 import { InterpolationModes } from '../../constants';
 
 export class VectorKeyframeTrack extends KeyframeTrack {
-  constructor(
+
+	constructor(
     name: string,
     times: any[],
     values: any[],
     interpolation?: InterpolationModes
   );
+
 }

src/audio/Audio.d.ts

@@ -5,7 +5,8 @@ import { AudioContext } from './AudioContext';
 // Extras / Audio /////////////////////////////////////////////////////////////////////
 
 export class Audio extends Object3D {
-	constructor(listener: AudioListener);
+
+	constructor( listener: AudioListener );
 	type: 'Audio';
 
 	context: AudioContext;
@@ -24,40 +25,43 @@ export class Audio extends Object3D {
 	filters: any[];
 
 	getOutput(): GainNode;
-	setNodeSource(audioNode: AudioBufferSourceNode): this;
-	setMediaElementSource(mediaElement: MediaElementAudioSourceNode): this;
-	setBuffer(audioBuffer: AudioBuffer): this;
+	setNodeSource( audioNode: AudioBufferSourceNode ): this;
+	setMediaElementSource( mediaElement: MediaElementAudioSourceNode ): this;
+	setBuffer( audioBuffer: AudioBuffer ): this;
 	play(): this;
 	onEnded(): void;
 	pause(): this;
 	stop(): this;
 	connect(): this;
 	disconnect(): this;
-	setDetune(value: number): this;
+	setDetune( value: number ): this;
 	getDetune(): number;
 	getFilters(): any[];
-	setFilter(value: any[]): this;
+	setFilter( value: any[] ): this;
 	getFilter(): any;
-	setFilter(filter: any): this;
-	setPlaybackRate(value: number): this;
+	setFilter( filter: any ): this;
+	setPlaybackRate( value: number ): this;
 	getPlaybackRate(): number;
 	getLoop(): boolean;
-	setLoop(value: boolean): void;
+	setLoop( value: boolean ): void;
 	getVolume(): number;
-	setVolume(value: number): this;
+	setVolume( value: number ): this;
 	/**
 	 * @deprecated Use {@link AudioLoader} instead.
 	 */
-	load(file: string): Audio;
+	load( file: string ): Audio;
+
 }
 
 export class AudioBuffer {
-	constructor(context: any);
+
+	constructor( context: any );
 
 	context: any;
 	ready: boolean;
 	readyCallbacks: Function[];
 
-	load(file: string): AudioBuffer;
-	onReady(callback: Function): void;
+	load( file: string ): AudioBuffer;
+	onReady( callback: Function ): void;
+
 }

src/audio/AudioAnalyser.d.ts

@@ -1,5 +1,6 @@
 export class AudioAnalyser {
-  constructor(audio: any, fftSize: number);
+
+	constructor( audio: any, fftSize: number );
 
   analyser: any;
   data: Uint8Array;
@@ -10,5 +11,6 @@ export class AudioAnalyser {
   /**
    * @deprecated Use {@link AudioAnalyser#getFrequencyData .getFrequencyData()} instead.
    */
-  getData(file: any): any;
+  getData( file: any ): any;
+
 }

src/audio/AudioListener.d.ts

@@ -2,7 +2,8 @@ import { Object3D } from './../core/Object3D';
 import { AudioContext } from './AudioContext';
 
 export class AudioListener extends Object3D {
-  constructor();
+
+	constructor();
 
   type: 'AudioListener';
   context: AudioContext;
@@ -11,9 +12,10 @@ export class AudioListener extends Object3D {
 
   getInput(): GainNode;
   removeFilter(): void;
-  setFilter(value: any): void;
+  setFilter( value: any ): void;
   getFilter(): any;
-  setMasterVolume(value: number): void;
+  setMasterVolume( value: number ): void;
   getMasterVolume(): number;
-  updateMatrixWorld(force?: boolean): void;
+  updateMatrixWorld( force?: boolean ): void;
+
 }

src/audio/PositionalAudio.d.ts

@@ -2,21 +2,23 @@ import { AudioListener } from './AudioListener';
 import { Audio } from './Audio';
 
 export class PositionalAudio extends Audio {
-	constructor(listener: AudioListener);
+
+	constructor( listener: AudioListener );
 
 	panner: PannerNode;
 
-	setRefDistance(value: number): this;
+	setRefDistance( value: number ): this;
 	getRefDistance(): number;
-	setRolloffFactor(value: number): this;
+	setRolloffFactor( value: number ): this;
 	getRolloffFactor(): number;
-	setDistanceModel(value: string): this;
+	setDistanceModel( value: string ): this;
 	getDistanceModel(): string;
-	setMaxDistance(value: number): this;
+	setMaxDistance( value: number ): this;
 	getMaxDistance(): number;
 	setDirectionalCone(
 		coneInnerAngle: number,
 		coneOuterAngle: number,
 		coneOuterGain: number
 	): this;
+
 }

src/cameras/ArrayCamera.d.ts

@@ -1,8 +1,10 @@
 import { PerspectiveCamera } from './PerspectiveCamera';
 
 export class ArrayCamera extends PerspectiveCamera {
-  constructor(cameras?: PerspectiveCamera[]);
+
+	constructor( cameras?: PerspectiveCamera[] );
 
   cameras: PerspectiveCamera[];
   isArrayCamera: true;
+
 }

src/cameras/Camera.d.ts

@@ -8,10 +8,11 @@ import { Object3D } from './../core/Object3D';
  * Abstract base class for cameras. This class should always be inherited when you build a new camera.
  */
 export class Camera extends Object3D {
-  /**
+
+	/**
    * This constructor sets following properties to the correct type: matrixWorldInverse, projectionMatrix and projectionMatrixInverse.
    */
-  constructor();
+	constructor();
 
   /**
    * This is the inverse of matrixWorld. MatrixWorld contains the Matrix which has the world transform of the Camera.
@@ -25,9 +26,10 @@ export class Camera extends Object3D {
 
   isCamera: true;
 
-  copy(source: Camera, recursive?: boolean): this;
+  copy( source: Camera, recursive?: boolean ): this;
+
+  getWorldDirection( target: Vector3 ): Vector3;
 
-  getWorldDirection(target: Vector3): Vector3;
+  updateMatrixWorld( force?: boolean ): void;
 
-  updateMatrixWorld(force?: boolean): void;
 }

src/cameras/CubeCamera.d.ts

@@ -4,7 +4,8 @@ import { WebGLRenderer } from './../renderers/WebGLRenderer';
 import { Object3D } from './../core/Object3D';
 
 export class CubeCamera extends Object3D {
-  constructor(near?: number, far?: number, cubeResolution?: number);
+
+	constructor( near?: number, far?: number, cubeResolution?: number );
 
   type: 'CubeCamera';
 
@@ -15,5 +16,6 @@ export class CubeCamera extends Object3D {
    */
   //updateCubeMap(renderer: Renderer, scene: Scene): void;
 
-  update(renderer: WebGLRenderer, scene: Scene): void;
+  update( renderer: WebGLRenderer, scene: Scene ): void;
+
 }

src/cameras/OrthographicCamera.d.ts

@@ -10,7 +10,8 @@ import { Camera } from './Camera';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/cameras/OrthographicCamera.js">src/cameras/OrthographicCamera.js</a>
  */
 export class OrthographicCamera extends Camera {
-  /**
+
+	/**
    * @param left Camera frustum left plane.
    * @param right Camera frustum right plane.
    * @param top Camera frustum top plane.
@@ -18,7 +19,7 @@ export class OrthographicCamera extends Camera {
    * @param near Camera frustum near plane.
    * @param far Camera frustum far plane.
    */
-  constructor(
+	constructor(
     left: number,
     right: number,
     top: number,
@@ -85,5 +86,6 @@ export class OrthographicCamera extends Camera {
     height: number
   ): void;
   clearViewOffset(): void;
-  toJSON(meta?: any): any;
+  toJSON( meta?: any ): any;
+
 }

src/cameras/PerspectiveCamera.d.ts

@@ -10,13 +10,14 @@ import { Camera } from './Camera';
  * @source https://github.com/mrdoob/three.js/blob/master/src/cameras/PerspectiveCamera.js
  */
 export class PerspectiveCamera extends Camera {
-  /**
+
+	/**
    * @param fov Camera frustum vertical field of view. Default value is 50.
    * @param aspect Camera frustum aspect ratio. Default value is 1.
    * @param near Camera frustum near plane. Default value is 0.1.
    * @param far Camera frustum far plane. Default value is 2000.
    */
-  constructor(fov?: number, aspect?: number, near?: number, far?: number);
+	constructor( fov?: number, aspect?: number, near?: number, far?: number );
 
   type: 'PerspectiveCamera';
 
@@ -57,7 +58,7 @@ export class PerspectiveCamera extends Camera {
   filmGauge: number;
   filmOffset: number;
 
-  setFocalLength(focalLength: number): void;
+  setFocalLength( focalLength: number ): void;
   getFocalLength(): number;
   getEffectiveFOV(): number;
   getFilmWidth(): number;
@@ -114,10 +115,11 @@ export class PerspectiveCamera extends Camera {
    * Updates the camera projection matrix. Must be called after change of parameters.
    */
   updateProjectionMatrix(): void;
-  toJSON(meta?: any): any;
+  toJSON( meta?: any ): any;
 
   /**
    * @deprecated Use {@link PerspectiveCamera#setFocalLength .setFocalLength()} and {@link PerspectiveCamera#filmGauge .filmGauge} instead.
    */
-  setLens(focalLength: number, frameHeight?: number): void;
+  setLens( focalLength: number, frameHeight?: number ): void;
+
 }

src/cameras/StereoCamera.d.ts

@@ -2,7 +2,8 @@ import { PerspectiveCamera } from './PerspectiveCamera';
 import { Camera } from './Camera';
 
 export class StereoCamera extends Camera {
-  constructor();
+
+	constructor();
 
   type: 'StereoCamera';
 
@@ -11,5 +12,6 @@ export class StereoCamera extends Camera {
   cameraL: PerspectiveCamera;
   cameraR: PerspectiveCamera;
 
-  update(camera: PerspectiveCamera): void;
+  update( camera: PerspectiveCamera ): void;
+
 }

src/core/BufferAttribute.d.ts

@@ -2,7 +2,8 @@
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js">src/core/BufferAttribute.js</a>
  */
 export class BufferAttribute {
-  constructor(array: ArrayLike<number>, itemSize: number, normalized?: boolean); // array parameter should be TypedArray.
+
+	constructor( array: ArrayLike<number>, itemSize: number, normalized?: boolean ); // array parameter should be TypedArray.
 
   uuid: string;
   array: ArrayLike<number>;
@@ -15,20 +16,20 @@ export class BufferAttribute {
   count: number;
   onUpload: Function;
 
-  setArray(array?: ArrayBufferView): void;
-  setDynamic(dynamic: boolean): BufferAttribute;
+  setArray( array?: ArrayBufferView ): void;
+  setDynamic( dynamic: boolean ): BufferAttribute;
   clone(): this;
-  copy(source: BufferAttribute): this;
+  copy( source: BufferAttribute ): this;
   copyAt(
     index1: number,
     attribute: BufferAttribute,
     index2: number
   ): BufferAttribute;
-  copyArray(array: ArrayLike<number>): BufferAttribute;
+  copyArray( array: ArrayLike<number> ): BufferAttribute;
   copyColorsArray(
     colors: { r: number; g: number; b: number }[]
   ): BufferAttribute;
-  copyVector2sArray(vectors: { x: number; y: number }[]): BufferAttribute;
+  copyVector2sArray( vectors: { x: number; y: number }[] ): BufferAttribute;
   copyVector3sArray(
     vectors: { x: number; y: number; z: number }[]
   ): BufferAttribute;
@@ -39,16 +40,16 @@ export class BufferAttribute {
     value: ArrayLike<number> | ArrayBufferView,
     offset?: number
   ): BufferAttribute;
-  getX(index: number): number;
-  setX(index: number, x: number): BufferAttribute;
-  getY(index: number): number;
-  setY(index: number, y: number): BufferAttribute;
-  getZ(index: number): number;
-  setZ(index: number, z: number): BufferAttribute;
-  getW(index: number): number;
-  setW(index: number, z: number): BufferAttribute;
-  setXY(index: number, x: number, y: number): BufferAttribute;
-  setXYZ(index: number, x: number, y: number, z: number): BufferAttribute;
+  getX( index: number ): number;
+  setX( index: number, x: number ): BufferAttribute;
+  getY( index: number ): number;
+  setY( index: number, y: number ): BufferAttribute;
+  getZ( index: number ): number;
+  setZ( index: number, z: number ): BufferAttribute;
+  getW( index: number ): number;
+  setW( index: number, z: number ): BufferAttribute;
+  setXY( index: number, x: number, y: number ): BufferAttribute;
+  setXYZ( index: number, x: number, y: number, z: number ): BufferAttribute;
   setXYZW(
     index: number,
     x: number,
@@ -60,139 +61,176 @@ export class BufferAttribute {
    * @deprecated Use {@link BufferAttribute#count .count} instead.
    */
   length: number;
+
 }
 
 /**
  * @deprecated THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.
  */
 export class Int8Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.
  */
 export class Uint8Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.
  */
 export class Uint8ClampedAttribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.
  */
 export class Int16Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.
  */
 export class Uint16Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.
  */
 export class Int32Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.
  */
 export class Uint32Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.
  */
 export class Float32Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 /**
  * @deprecated THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.
  */
 export class Float64Attribute extends BufferAttribute {
-  constructor(array: any, itemSize: number);
+
+	constructor( array: any, itemSize: number );
+
 }
 
 export class Int8BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Uint8BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Uint8ClampedBufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Int16BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Uint16BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Int32BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Uint32BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Float32BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }
 
 export class Float64BufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
     itemSize: number,
     normalized?: boolean
   );
+
 }

src/core/BufferGeometry.d.ts

@@ -18,10 +18,11 @@ import { InterleavedBufferAttribute } from './InterleavedBufferAttribute';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/BufferGeometry.js">src/core/BufferGeometry.js</a>
  */
 export class BufferGeometry extends EventDispatcher {
-  /**
+
+	/**
    * This creates a new BufferGeometry. It also sets several properties to an default value.
    */
-  constructor();
+	constructor();
 
   static MaxIndex: number;
 
@@ -44,42 +45,42 @@ export class BufferGeometry extends EventDispatcher {
   userData: {[key: string]: any};
 
   getIndex(): BufferAttribute;
-  setIndex(index: BufferAttribute | number[]): void;
+  setIndex( index: BufferAttribute | number[] ): void;
 
   addAttribute(
     name: string,
     attribute: BufferAttribute | InterleavedBufferAttribute
   ): BufferGeometry;
 
-  getAttribute(name: string): BufferAttribute | InterleavedBufferAttribute;
-  removeAttribute(name: string): BufferGeometry;
+  getAttribute( name: string ): BufferAttribute | InterleavedBufferAttribute;
+  removeAttribute( name: string ): BufferGeometry;
 
-  addGroup(start: number, count: number, materialIndex?: number): void;
+  addGroup( start: number, count: number, materialIndex?: number ): void;
   clearGroups(): void;
 
-  setDrawRange(start: number, count: number): void;
+  setDrawRange( start: number, count: number ): void;
 
   /**
    * Bakes matrix transform directly into vertex coordinates.
    */
-  applyMatrix(matrix: Matrix4): BufferGeometry;
+  applyMatrix( matrix: Matrix4 ): BufferGeometry;
 
-  rotateX(angle: number): BufferGeometry;
-  rotateY(angle: number): BufferGeometry;
-  rotateZ(angle: number): BufferGeometry;
-  translate(x: number, y: number, z: number): BufferGeometry;
-  scale(x: number, y: number, z: number): BufferGeometry;
-  lookAt(v: Vector3): void;
+  rotateX( angle: number ): BufferGeometry;
+  rotateY( angle: number ): BufferGeometry;
+  rotateZ( angle: number ): BufferGeometry;
+  translate( x: number, y: number, z: number ): BufferGeometry;
+  scale( x: number, y: number, z: number ): BufferGeometry;
+  lookAt( v: Vector3 ): void;
 
   center(): BufferGeometry;
 
-  setFromObject(object: Object3D): BufferGeometry;
-  setFromPoints(points: Vector3[] | Vector2[]): BufferGeometry;
-  updateFromObject(object: Object3D): void;
+  setFromObject( object: Object3D ): BufferGeometry;
+  setFromPoints( points: Vector3[] | Vector2[] ): BufferGeometry;
+  updateFromObject( object: Object3D ): void;
 
-  fromGeometry(geometry: Geometry, settings?: any): BufferGeometry;
+  fromGeometry( geometry: Geometry, settings?: any ): BufferGeometry;
 
-  fromDirectGeometry(geometry: DirectGeometry): BufferGeometry;
+  fromDirectGeometry( geometry: DirectGeometry ): BufferGeometry;
 
   /**
    * Computes bounding box of the geometry, updating Geometry.boundingBox attribute.
@@ -98,14 +99,14 @@ export class BufferGeometry extends EventDispatcher {
    */
   computeVertexNormals(): void;
 
-  merge(geometry: BufferGeometry, offset: number): BufferGeometry;
+  merge( geometry: BufferGeometry, offset: number ): BufferGeometry;
   normalizeNormals(): void;
 
   toNonIndexed(): BufferGeometry;
 
   toJSON(): any;
   clone(): this;
-  copy(source: BufferGeometry): this;
+  copy( source: BufferGeometry ): this;
 
   /**
    * Disposes the object from memory.
@@ -126,17 +127,18 @@ export class BufferGeometry extends EventDispatcher {
   /**
    * @deprecated Use {@link BufferGeometry#setIndex .setIndex()} instead.
    */
-  addIndex(index: any): void;
+  addIndex( index: any ): void;
 
   /**
    * @deprecated Use {@link BufferGeometry#addGroup .addGroup()} instead.
    */
-  addDrawCall(start: any, count: any, indexOffset?: any): void;
+  addDrawCall( start: any, count: any, indexOffset?: any ): void;
 
   /**
    * @deprecated Use {@link BufferGeometry#clearGroups .clearGroups()} instead.
    */
   clearDrawCalls(): void;
 
-  addAttribute(name: any, array: any, itemSize: any): any;
+  addAttribute( name: any, array: any, itemSize: any ): any;
+
 }

src/core/Clock.d.ts

@@ -4,10 +4,11 @@
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/Clock.js">src/core/Clock.js</a>
  */
 export class Clock {
-  /**
+
+	/**
    * @param autoStart Automatically start the clock.
    */
-  constructor(autoStart?: boolean);
+	constructor( autoStart?: boolean );
 
   /**
    * If set, starts the clock automatically when the first update is called.
@@ -56,4 +57,5 @@ export class Clock {
    * Get the seconds passed since the last call to this method.
    */
   getDelta(): number;
+
 }

src/core/DirectGeometry.d.ts

@@ -12,7 +12,8 @@ import { MorphTarget } from './Geometry';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/DirectGeometry.js">src/core/DirectGeometry.js</a>
  */
 export class DirectGeometry extends EventDispatcher {
-  constructor();
+
+	constructor();
 
   id: number;
   uuid: string;
@@ -38,13 +39,14 @@ export class DirectGeometry extends EventDispatcher {
 
   computeBoundingBox(): void;
   computeBoundingSphere(): void;
-  computeGroups(geometry: Geometry): void;
-  fromGeometry(geometry: Geometry): DirectGeometry;
+  computeGroups( geometry: Geometry ): void;
+  fromGeometry( geometry: Geometry ): DirectGeometry;
   dispose(): void;
 
   // EventDispatcher mixins
-  addEventListener(type: string, listener: (event: Event) => void): void;
-  hasEventListener(type: string, listener: (event: Event) => void): boolean;
-  removeEventListener(type: string, listener: (event: Event) => void): void;
-  dispatchEvent(event: { type: string; [attachment: string]: any }): void;
+  addEventListener( type: string, listener: ( event: Event ) => void ): void;
+  hasEventListener( type: string, listener: ( event: Event ) => void ): boolean;
+  removeEventListener( type: string, listener: ( event: Event ) => void ): void;
+  dispatchEvent( event: { type: string; [attachment: string]: any } ): void;
+
 }

src/core/EventDispatcher.d.ts

@@ -26,35 +26,37 @@ import { Event } from './Face3';
  * @source src/core/EventDispatcher.js
  */
 export class EventDispatcher {
-  /**
+
+	/**
    * Creates eventDispatcher object. It needs to be call with '.call' to add the functionality to an object.
    */
-  constructor();
+	constructor();
 
-  /**
+	/**
    * Adds a listener to an event type.
    * @param type The type of event to listen to.
    * @param listener The function that gets called when the event is fired.
    */
-  addEventListener(type: string, listener: (event: Event) => void): void;
+	addEventListener( type: string, listener: ( event: Event ) => void ): void;
 
-  /**
+	/**
    * Checks if listener is added to an event type.
    * @param type The type of event to listen to.
    * @param listener The function that gets called when the event is fired.
    */
-  hasEventListener(type: string, listener: (event: Event) => void): boolean;
+	hasEventListener( type: string, listener: ( event: Event ) => void ): boolean;
 
-  /**
+	/**
    * Removes a listener from an event type.
    * @param type The type of the listener that gets removed.
    * @param listener The listener function that gets removed.
    */
-  removeEventListener(type: string, listener: (event: Event) => void): void;
+	removeEventListener( type: string, listener: ( event: Event ) => void ): void;
 
-  /**
+	/**
    * Fire an event type.
    * @param type The type of event that gets fired.
    */
-  dispatchEvent(event: { type: string; [attachment: string]: any }): void;
+	dispatchEvent( event: { type: string; [attachment: string]: any } ): void;
+
 }

src/core/Face3.d.ts

@@ -18,7 +18,8 @@ export interface Event {
  * @source https://github.com/mrdoob/three.js/blob/master/src/core/Face3.js
  */
 export class Face3 {
-  /**
+
+	/**
    * @param a Vertex A index.
    * @param b Vertex B index.
    * @param c Vertex C index.
@@ -26,7 +27,7 @@ export class Face3 {
    * @param color Face color or array of vertex colors.
    * @param materialIndex Material index.
    */
-  constructor(
+	constructor(
     a: number,
     b: number,
     c: number,
@@ -34,7 +35,7 @@ export class Face3 {
     color?: Color,
     materialIndex?: number
   );
-  constructor(
+	constructor(
     a: number,
     b: number,
     c: number,
@@ -42,7 +43,7 @@ export class Face3 {
     vertexColors?: Color[],
     materialIndex?: number
   );
-  constructor(
+	constructor(
     a: number,
     b: number,
     c: number,
@@ -50,7 +51,7 @@ export class Face3 {
     color?: Color,
     materialIndex?: number
   );
-  constructor(
+	constructor(
     a: number,
     b: number,
     c: number,
@@ -100,5 +101,6 @@ export class Face3 {
   materialIndex: number;
 
   clone(): this;
-  copy(source: Face3): this;
+  copy( source: Face3 ): this;
+
 }

src/core/Geometry.d.ts

@@ -48,7 +48,8 @@ export let GeometryIdCount: number;
  * @see https://github.com/mrdoob/three.js/blob/master/src/core/Geometry.js
  */
 export class Geometry extends EventDispatcher {
-  constructor();
+
+	constructor();
 
   /**
    * Unique number of this geometry instance
@@ -171,17 +172,17 @@ export class Geometry extends EventDispatcher {
   /**
    * Bakes matrix transform directly into vertex coordinates.
    */
-  applyMatrix(matrix: Matrix4): Geometry;
+  applyMatrix( matrix: Matrix4 ): Geometry;
 
-  rotateX(angle: number): Geometry;
-  rotateY(angle: number): Geometry;
-  rotateZ(angle: number): Geometry;
+  rotateX( angle: number ): Geometry;
+  rotateY( angle: number ): Geometry;
+  rotateZ( angle: number ): Geometry;
 
-  translate(x: number, y: number, z: number): Geometry;
-  scale(x: number, y: number, z: number): Geometry;
-  lookAt(vector: Vector3): void;
+  translate( x: number, y: number, z: number ): Geometry;
+  scale( x: number, y: number, z: number ): Geometry;
+  lookAt( vector: Vector3 ): void;
 
-  fromBufferGeometry(geometry: BufferGeometry): Geometry;
+  fromBufferGeometry( geometry: BufferGeometry ): Geometry;
 
   center(): Geometry;
 
@@ -196,7 +197,7 @@ export class Geometry extends EventDispatcher {
    * Computes vertex normals by averaging face normals.
    * Face normals must be existing / computed beforehand.
    */
-  computeVertexNormals(areaWeighted?: boolean): void;
+  computeVertexNormals( areaWeighted?: boolean ): void;
 
   /**
    * Compute vertex normals, but duplicating face normals.
@@ -225,7 +226,7 @@ export class Geometry extends EventDispatcher {
     materialIndexOffset?: number
   ): void;
 
-  mergeMesh(mesh: Mesh): void;
+  mergeMesh( mesh: Mesh ): void;
 
   /**
    * Checks for duplicate vertices using hashmap.
@@ -233,7 +234,7 @@ export class Geometry extends EventDispatcher {
    */
   mergeVertices(): number;
 
-  setFromPoints(points: Array<Vector2> | Array<Vector3>): this;
+  setFromPoints( points: Array<Vector2> | Array<Vector3> ): this;
 
   sortFacesByMaterialIndex(): void;
 
@@ -244,7 +245,7 @@ export class Geometry extends EventDispatcher {
    */
   clone(): this;
 
-  copy(source: Geometry): this;
+  copy( source: Geometry ): this;
 
   /**
    * Removes The object from memory.
@@ -258,8 +259,9 @@ export class Geometry extends EventDispatcher {
   animations: AnimationClip[];
 
   // EventDispatcher mixins
-  addEventListener(type: string, listener: (event: Event) => void): void;
-  hasEventListener(type: string, listener: (event: Event) => void): boolean;
-  removeEventListener(type: string, listener: (event: Event) => void): void;
-  dispatchEvent(event: { type: string; [attachment: string]: any }): void;
+  addEventListener( type: string, listener: ( event: Event ) => void ): void;
+  hasEventListener( type: string, listener: ( event: Event ) => void ): boolean;
+  removeEventListener( type: string, listener: ( event: Event ) => void ): void;
+  dispatchEvent( event: { type: string; [attachment: string]: any } ): void;
+
 }

src/core/InstancedBufferAttribute.d.ts

@@ -8,7 +8,7 @@ export namespace BufferGeometryUtils {
   export function mergeBufferGeometries(
     geometries: BufferGeometry[]
   ): BufferGeometry;
-  export function computeTangents(geometry: BufferGeometry): null;
+  export function computeTangents( geometry: BufferGeometry ): null;
   export function mergeBufferAttributes(
     attributes: BufferAttribute[]
   ): BufferAttribute;
@@ -29,14 +29,15 @@ export namespace GeometryUtils {
   /**
    * @deprecated Use {@link Geometry#center geometry.center()} instead.
    */
-  export function center(geometry: any): any;
+  export function center( geometry: any ): any;
 }
 
 /**
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferAttribute.js">src/core/InstancedBufferAttribute.js</a>
  */
 export class InstancedBufferAttribute extends BufferAttribute {
-  constructor(
+
+	constructor(
     array: ArrayLike<number>,
     itemSize: number,
     normalized?: boolean,
@@ -44,4 +45,5 @@ export class InstancedBufferAttribute extends BufferAttribute {
   );
 
   meshPerAttribute: number;
+
 }

src/core/InstancedBufferGeometry.d.ts

@@ -4,10 +4,12 @@ import { BufferGeometry } from './BufferGeometry';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InstancedBufferGeometry.js">src/core/InstancedBufferGeometry.js</a>
  */
 export class InstancedBufferGeometry extends BufferGeometry {
-  constructor();
+
+	constructor();
 
   groups: { start: number; count: number; instances: number }[];
   maxInstancedCount: number;
 
-  addGroup(start: number, count: number, instances: number): void;
+  addGroup( start: number, count: number, instances: number ): void;
+
 }

src/core/InstancedInterleavedBuffer.d.ts

@@ -4,11 +4,13 @@ import { InterleavedBuffer } from './InterleavedBuffer';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InstancedInterleavedBuffer.js">src/core/InstancedInterleavedBuffer.js</a>
  */
 export class InstancedInterleavedBuffer extends InterleavedBuffer {
-  constructor(
+
+	constructor(
     array: ArrayLike<number>,
     stride: number,
     meshPerAttribute?: number
   );
 
   meshPerAttribute: number;
+
 }

src/core/InterleavedBuffer.d.ts

@@ -4,7 +4,8 @@ import { InterleavedBufferAttribute } from './InterleavedBufferAttribute';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBuffer.js">src/core/InterleavedBuffer.js</a>
  */
 export class InterleavedBuffer {
-  constructor(array: ArrayLike<number>, stride: number);
+
+	constructor( array: ArrayLike<number>, stride: number );
 
   array: ArrayLike<number>;
   stride: number;
@@ -15,14 +16,15 @@ export class InterleavedBuffer {
   count: number;
   needsUpdate: boolean;
 
-  setArray(array?: ArrayBufferView): void;
-  setDynamic(dynamic: boolean): InterleavedBuffer;
+  setArray( array?: ArrayBufferView ): void;
+  setDynamic( dynamic: boolean ): InterleavedBuffer;
   clone(): this;
-  copy(source: InterleavedBuffer): this;
+  copy( source: InterleavedBuffer ): this;
   copyAt(
     index1: number,
     attribute: InterleavedBufferAttribute,
     index2: number
   ): InterleavedBuffer;
-  set(value: ArrayLike<number>, index: number): InterleavedBuffer;
+  set( value: ArrayLike<number>, index: number ): InterleavedBuffer;
+
 }

src/core/InterleavedBufferAttribute.d.ts

@@ -3,7 +3,8 @@ import { InterleavedBuffer } from './InterleavedBuffer';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/src/core/InterleavedBufferAttribute.js">src/core/InterleavedBufferAttribute.js</a>
  */
 export class InterleavedBufferAttribute {
-  constructor(
+
+	constructor(
     interleavedBuffer: InterleavedBuffer,
     itemSize: number,
     offset: number,
@@ -18,15 +19,15 @@ export class InterleavedBufferAttribute {
   normalized: boolean;
   array: any[];
 
-  getX(index: number): number;
-  setX(index: number, x: number): InterleavedBufferAttribute;
-  getY(index: number): number;
-  setY(index: number, y: number): InterleavedBufferAttribute;
-  getZ(index: number): number;
-  setZ(index: number, z: number): InterleavedBufferAttribute;
-  getW(index: number): number;
-  setW(index: number, z: number): InterleavedBufferAttribute;
-  setXY(index: number, x: number, y: number): InterleavedBufferAttribute;
+  getX( index: number ): number;
+  setX( index: number, x: number ): InterleavedBufferAttribute;
+  getY( index: number ): number;
+  setY( index: number, y: number ): InterleavedBufferAttribute;
+  getZ( index: number ): number;
+  setZ( index: number, z: number ): InterleavedBufferAttribute;
+  getW( index: number ): number;
+  setW( index: number, z: number ): InterleavedBufferAttribute;
+  setXY( index: number, x: number, y: number ): InterleavedBufferAttribute;
   setXYZ(
     index: number,
     x: number,
@@ -44,4 +45,5 @@ export class InterleavedBufferAttribute {
    * @deprecated Use {@link InterleavedBufferAttribute#count .count} instead.
    */
   length: number;
+
 }

src/core/Layers.d.ts

@@ -1,11 +1,13 @@
 export class Layers {
-  constructor();
+
+	constructor();
 
   mask: number;
 
-  set(channel: number): void;
-  enable(channel: number): void;
-  toggle(channel: number): void;
-  disable(channel: number): void;
-  test(layers: Layers): boolean;
+  set( channel: number ): void;
+  enable( channel: number ): void;
+  toggle( channel: number ): void;
+  disable( channel: number ): void;
+  test( layers: Layers ): boolean;
+
 }

src/core/Object3D.d.ts

@@ -21,7 +21,8 @@ export let Object3DIdCount: number;
  * Base class for scene graph objects
  */
 export class Object3D extends EventDispatcher {
-  constructor();
+
+	constructor();
 
   /**
    * Unique number of this object instance.
@@ -179,145 +180,145 @@ export class Object3D extends EventDispatcher {
   /**
    * This updates the position, rotation and scale with the matrix.
    */
-  applyMatrix(matrix: Matrix4): void;
+  applyMatrix( matrix: Matrix4 ): void;
 
-  applyQuaternion(quaternion: Quaternion): this;
+  applyQuaternion( quaternion: Quaternion ): this;
 
   /**
    *
    */
-  setRotationFromAxisAngle(axis: Vector3, angle: number): void;
+  setRotationFromAxisAngle( axis: Vector3, angle: number ): void;
 
   /**
    *
    */
-  setRotationFromEuler(euler: Euler): void;
+  setRotationFromEuler( euler: Euler ): void;
 
   /**
    *
    */
-  setRotationFromMatrix(m: Matrix4): void;
+  setRotationFromMatrix( m: Matrix4 ): void;
 
   /**
    *
    */
-  setRotationFromQuaternion(q: Quaternion): void;
+  setRotationFromQuaternion( q: Quaternion ): void;
 
   /**
    * Rotate an object along an axis in object space. The axis is assumed to be normalized.
    * @param axis  A normalized vector in object space.
    * @param angle  The angle in radians.
    */
-  rotateOnAxis(axis: Vector3, angle: number): this;
+  rotateOnAxis( axis: Vector3, angle: number ): this;
 
   /**
    * Rotate an object along an axis in world space. The axis is assumed to be normalized. Method Assumes no rotated parent.
    * @param axis  A normalized vector in object space.
    * @param angle  The angle in radians.
    */
-  rotateOnWorldAxis(axis: Vector3, angle: number): this;
+  rotateOnWorldAxis( axis: Vector3, angle: number ): this;
 
   /**
    *
    * @param angle
    */
-  rotateX(angle: number): this;
+  rotateX( angle: number ): this;
 
   /**
    *
    * @param angle
    */
-  rotateY(angle: number): this;
+  rotateY( angle: number ): this;
 
   /**
    *
    * @param angle
    */
-  rotateZ(angle: number): this;
+  rotateZ( angle: number ): this;
 
   /**
    * @param axis  A normalized vector in object space.
    * @param distance  The distance to translate.
    */
-  translateOnAxis(axis: Vector3, distance: number): this;
+  translateOnAxis( axis: Vector3, distance: number ): this;
 
   /**
    * Translates object along x axis by distance.
    * @param distance Distance.
    */
-  translateX(distance: number): this;
+  translateX( distance: number ): this;
 
   /**
    * Translates object along y axis by distance.
    * @param distance Distance.
    */
-  translateY(distance: number): this;
+  translateY( distance: number ): this;
 
   /**
    * Translates object along z axis by distance.
    * @param distance Distance.
    */
-  translateZ(distance: number): this;
+  translateZ( distance: number ): this;
 
   /**
    * Updates the vector from local space to world space.
    * @param vector A local vector.
    */
-  localToWorld(vector: Vector3): Vector3;
+  localToWorld( vector: Vector3 ): Vector3;
 
   /**
    * Updates the vector from world space to local space.
    * @param vector A world vector.
    */
-  worldToLocal(vector: Vector3): Vector3;
+  worldToLocal( vector: Vector3 ): Vector3;
 
   /**
    * Rotates object to face point in space.
    * @param vector A world vector to look at.
    */
-  lookAt(vector: Vector3 | number, y?: number, z?: number): void;
+  lookAt( vector: Vector3 | number, y?: number, z?: number ): void;
 
   /**
    * Adds object as child of this object.
    */
-  add(...object: Object3D[]): this;
+  add( ...object: Object3D[] ): this;
 
   /**
    * Removes object as child of this object.
    */
-  remove(...object: Object3D[]): this;
+  remove( ...object: Object3D[] ): this;
 
   /**
    * Adds object as a child of this, while maintaining the object's world transform.
    */
-  attach(object: Object3D): this;
+  attach( object: Object3D ): this;
 
   /**
    * Searches through the object's children and returns the first with a matching id.
    * @param id  Unique number of the object instance
    */
-  getObjectById(id: number): Object3D | undefined;
+  getObjectById( id: number ): Object3D | undefined;
 
   /**
    * Searches through the object's children and returns the first with a matching name.
    * @param name  String to match to the children's Object3d.name property.
    */
-  getObjectByName(name: string): Object3D | undefined;
+  getObjectByName( name: string ): Object3D | undefined;
 
-  getObjectByProperty(name: string, value: string): Object3D | undefined;
+  getObjectByProperty( name: string, value: string ): Object3D | undefined;
 
-  getWorldPosition(target: Vector3): Vector3;
-  getWorldQuaternion(target: Quaternion): Quaternion;
-  getWorldScale(target: Vector3): Vector3;
-  getWorldDirection(target: Vector3): Vector3;
+  getWorldPosition( target: Vector3 ): Vector3;
+  getWorldQuaternion( target: Quaternion ): Quaternion;
+  getWorldScale( target: Vector3 ): Vector3;
+  getWorldDirection( target: Vector3 ): Vector3;
 
-  raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+  raycast( raycaster: Raycaster, intersects: Intersection[] ): void;
 
-  traverse(callback: (object: Object3D) => any): void;
+  traverse( callback: ( object: Object3D ) => any ): void;
 
-  traverseVisible(callback: (object: Object3D) => any): void;
+  traverseVisible( callback: ( object: Object3D ) => any ): void;
 
-  traverseAncestors(callback: (object: Object3D) => any): void;
+  traverseAncestors( callback: ( object: Object3D ) => any ): void;
 
   /**
    * Updates local transform.
@@ -327,23 +328,24 @@ export class Object3D extends EventDispatcher {
   /**
    * Updates global transform of the object and its children.
    */
-  updateMatrixWorld(force?: boolean): void;
+  updateMatrixWorld( force?: boolean ): void;
 
-  updateWorldMatrix(updateParents: boolean, updateChildren: boolean): void;
+  updateWorldMatrix( updateParents: boolean, updateChildren: boolean ): void;
 
-  toJSON(meta?: {
+  toJSON( meta?: {
     geometries: any;
     materials: any;
     textures: any;
     images: any;
-  }): any;
+  } ): any;
 
-  clone(recursive?: boolean): this;
+  clone( recursive?: boolean ): this;
 
   /**
    *
    * @param object
    * @param recursive
    */
-  copy(source: Object3D, recursive?: boolean): this;
+  copy( source: Object3D, recursive?: boolean ): this;
+
 }

src/core/Raycaster.d.ts

@@ -25,14 +25,15 @@ export interface RaycasterParameters {
 }
 
 export class Raycaster {
-  /**
+
+	/**
    * This creates a new raycaster object.
    * @param origin The origin vector where the ray casts from.
    * @param direction The direction vector that gives direction to the ray. Should be normalized.
    * @param near All results returned are further away than near. Near can't be negative. Default value is 0.
    * @param far All results returned are closer then far. Far can't be lower then near . Default value is Infinity.
    */
-  constructor(
+	constructor(
     origin?: Vector3,
     direction?: Vector3,
     near?: number,
@@ -66,14 +67,14 @@ export class Raycaster {
    * @param origin The origin vector where the ray casts from.
    * @param direction The normalized direction vector that gives direction to the ray.
    */
-  set(origin: Vector3, direction: Vector3): void;
+  set( origin: Vector3, direction: Vector3 ): void;
 
   /**
    * Updates the ray with a new origin and direction.
    * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
    * @param camera camera from which the ray should originate
    */
-  setFromCamera(coords: { x: number; y: number }, camera: Camera): void;
+  setFromCamera( coords: { x: number; y: number }, camera: Camera ): void;
 
   /**
    * Checks all intersection between the ray and the object with or without the descendants. Intersections are returned sorted by distance, closest first.
@@ -98,4 +99,5 @@ export class Raycaster {
     recursive?: boolean,
     optionalTarget?: Intersection[]
   ): Intersection[];
+
 }

src/core/Uniform.d.ts

@@ -1,9 +1,10 @@
 export class Uniform {
-  constructor(value: any);
-  /**
+
+	constructor( value: any );
+	/**
    * @deprecated
    */
-  constructor(type: string, value: any);
+	constructor( type: string, value: any );
   /**
    * @deprecated
    */
@@ -18,5 +19,6 @@ export class Uniform {
   /**
    * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
    */
-  onUpdate(callback: Function): Uniform;
+  onUpdate( callback: Function ): Uniform;
+
 }

src/extras/ImageUtils.d.ts

@@ -18,8 +18,8 @@ export namespace ImageUtils {
   export function loadTexture(
     url: string,
     mapping?: Mapping,
-    onLoad?: (texture: Texture) => void,
-    onError?: (message: string) => void
+    onLoad?: ( texture: Texture ) => void,
+    onError?: ( message: string ) => void
   ): Texture;
 
   /**
@@ -28,7 +28,7 @@ export namespace ImageUtils {
   export function loadTextureCube(
     array: string[],
     mapping?: Mapping,
-    onLoad?: (texture: Texture) => void,
-    onError?: (message: string) => void
+    onLoad?: ( texture: Texture ) => void,
+    onError?: ( message: string ) => void
   ): Texture;
 }

src/extras/ShapeUtils.d.ts

@@ -4,8 +4,8 @@ interface Vec2 {
 }
 
 export namespace ShapeUtils {
-  export function area(contour: Vec2[]): number;
-  export function triangulate(contour: Vec2[], indices: boolean): number[];
-  export function triangulateShape(contour: Vec2[], holes: Vec2[]): number[][];
-  export function isClockWise(pts: Vec2[]): boolean;
+  export function area( contour: Vec2[] ): number;
+  export function triangulate( contour: Vec2[], indices: boolean ): number[];
+  export function triangulateShape( contour: Vec2[], holes: Vec2[] ): number[][];
+  export function isClockWise( pts: Vec2[] ): boolean;
 }

src/extras/core/Curve.d.ts

@@ -7,6 +7,7 @@ import { Vector } from './../../math/Vector2';
  * class Curve<T extends Vector>
  */
 export class Curve<T extends Vector> {
+
   /**
    * This value determines the amount of divisions when calculating the cumulative segment lengths of a curve via .getLengths.
    * To ensure precision when using methods like .getSpacedPoints, it is recommended to increase .arcLengthDivisions if the curve is very large.
@@ -18,25 +19,25 @@ export class Curve<T extends Vector> {
    * Returns a vector for point t of the curve where t is between 0 and 1
    * getPoint(t: number): T;
    */
-  getPoint(t: number, optionalTarget?: T): T;
+  getPoint( t: number, optionalTarget?: T ): T;
 
   /**
    * Returns a vector for point at relative position in curve according to arc length
    * getPointAt(u: number): T;
    */
-  getPointAt(u: number, optionalTarget?: T): T;
+  getPointAt( u: number, optionalTarget?: T ): T;
 
   /**
    * Get sequence of points using getPoint( t )
    * getPoints(divisions?: number): T[];
    */
-  getPoints(divisions?: number): T[];
+  getPoints( divisions?: number ): T[];
 
   /**
    * Get sequence of equi-spaced points using getPointAt( u )
    * getSpacedPoints(divisions?: number): T[];
    */
-  getSpacedPoints(divisions?: number): T[];
+  getSpacedPoints( divisions?: number ): T[];
 
   /**
    * Get total curve arc length
@@ -46,7 +47,7 @@ export class Curve<T extends Vector> {
   /**
    * Get list of cumulative segment lengths
    */
-  getLengths(divisions?: number): number[];
+  getLengths( divisions?: number ): number[];
 
   /**
    * Update the cumlative segment distance cache
@@ -56,22 +57,23 @@ export class Curve<T extends Vector> {
   /**
    * Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equi distance
    */
-  getUtoTmapping(u: number, distance: number): number;
+  getUtoTmapping( u: number, distance: number ): number;
 
   /**
    * Returns a unit vector tangent at t. If the subclassed curve do not implement its tangent derivation, 2 points a small delta apart will be used to find its gradient which seems to give a reasonable approximation
    * getTangent(t: number): T;
    */
-  getTangent(t: number): T;
+  getTangent( t: number ): T;
 
   /**
    * Returns tangent at equidistance point u on the curve
    * getTangentAt(u: number): T;
    */
-  getTangentAt(u: number): T;
+  getTangentAt( u: number ): T;
 
   /**
    * @deprecated since r84.
    */
-  static create(constructorFunc: Function, getPointFunc: Function): Function;
+  static create( constructorFunc: Function, getPointFunc: Function ): Function;
+
 }

src/extras/core/CurvePath.d.ts

@@ -3,31 +3,33 @@ import { Geometry } from './../../core/Geometry';
 import { Vector } from './../../math/Vector2';
 
 export class CurvePath<T extends Vector> extends Curve<T> {
-  constructor();
+
+	constructor();
 
   curves: Curve<T>[];
   autoClose: boolean;
 
-  add(curve: Curve<T>): void;
+  add( curve: Curve<T> ): void;
   checkConnection(): boolean;
   closePath(): void;
-  getPoint(t: number): T;
+  getPoint( t: number ): T;
   getLength(): number;
   updateArcLengths(): void;
   getCurveLengths(): number[];
-  getSpacedPoints(divisions?: number): T[];
-  getPoints(divisions?: number): T[];
+  getSpacedPoints( divisions?: number ): T[];
+  getPoints( divisions?: number ): T[];
 
   /**
    * @deprecated Use {@link Geometry#setFromPoints new THREE.Geometry().setFromPoints( points )} instead.
    */
-  createPointsGeometry(divisions: number): Geometry;
+  createPointsGeometry( divisions: number ): Geometry;
   /**
    * @deprecated Use {@link Geometry#setFromPoints new THREE.Geometry().setFromPoints( points )} instead.
    */
-  createSpacedPointsGeometry(divisions: number): Geometry;
+  createSpacedPointsGeometry( divisions: number ): Geometry;
   /**
    * @deprecated Use {@link Geometry#setFromPoints new THREE.Geometry().setFromPoints( points )} instead.
    */
-  createGeometry(points: T[]): Geometry;
+  createGeometry( points: T[] ): Geometry;
+
 }

src/extras/core/Font.d.ts

@@ -1,7 +1,9 @@
 export class Font {
-  constructor(jsondata: any);
+
+	constructor( jsondata: any );
 
   data: string;
 
-  generateShapes(text: string, size: number, divisions: number): any[];
+  generateShapes( text: string, size: number, divisions: number ): any[];
+
 }

src/extras/core/Interpolations.d.ts

@@ -1,5 +1,5 @@
 export namespace Interpolations {
-	export function CatmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number;
-	export function QuadraticBezier(t: number, p0: number, p1: number, p2: number): number;
-	export function CubicBezier(t: number, p0: number, p1: number, p2: number, p3: number): number;
+	export function CatmullRom( t: number, p0: number, p1: number, p2: number, p3: number ): number;
+	export function QuadraticBezier( t: number, p0: number, p1: number, p2: number ): number;
+	export function CubicBezier( t: number, p0: number, p1: number, p2: number, p3: number ): number;
 }

src/extras/core/Path.d.ts

@@ -20,18 +20,19 @@ export interface PathAction {
  * a 2d path representation, comprising of points, lines, and cubes, similar to the html5 2d canvas api. It extends CurvePath.
  */
 export class Path extends CurvePath<Vector2> {
-  constructor(points?: Vector2[]);
+
+	constructor( points?: Vector2[] );
 
   currentPoint: Vector2;
 
   /**
    * @deprecated Use {@link Path#setFromPoints .setFromPoints()} instead.
    */
-  fromPoints(vectors: Vector2[]): void;
-  setFromPoints(vectors: Vector2[]): void;
-  moveTo(x: number, y: number): void;
-  lineTo(x: number, y: number): void;
-  quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): void;
+  fromPoints( vectors: Vector2[] ): void;
+  setFromPoints( vectors: Vector2[] ): void;
+  moveTo( x: number, y: number ): void;
+  lineTo( x: number, y: number ): void;
+  quadraticCurveTo( aCPx: number, aCPy: number, aX: number, aY: number ): void;
   bezierCurveTo(
     aCP1x: number,
     aCP1y: number,
@@ -40,7 +41,7 @@ export class Path extends CurvePath<Vector2> {
     aX: number,
     aY: number
   ): void;
-  splineThru(pts: Vector2[]): void;
+  splineThru( pts: Vector2[] ): void;
   arc(
     aX: number,
     aY: number,
@@ -77,4 +78,5 @@ export class Path extends CurvePath<Vector2> {
     aClockwise: boolean,
     aRotation: number
   ): void;
+
 }

src/extras/core/Shape.d.ts

@@ -7,20 +7,21 @@ import { ShapeGeometry } from './../../geometries/ShapeGeometry';
  * Defines a 2d shape plane using paths.
  */
 export class Shape extends Path {
-  constructor(points?: Vector2[]);
+
+	constructor( points?: Vector2[] );
 
   holes: Path[];
 
   /**
    * @deprecated Use {@link ExtrudeGeometry ExtrudeGeometry()} instead.
    */
-  extrude(options?: any): ExtrudeGeometry;
+  extrude( options?: any ): ExtrudeGeometry;
 
   /**
    * @deprecated Use {@link ShapeGeometry ShapeGeometry()} instead.
    */
-  makeGeometry(options?: any): ShapeGeometry;
-  getPointsHoles(divisions: number): Vector2[][];
+  makeGeometry( options?: any ): ShapeGeometry;
+  getPointsHoles( divisions: number ): Vector2[][];
 
   /**
    * @deprecated Use {@link Shape#extractPoints .extractPoints()} instead.
@@ -31,5 +32,6 @@ export class Shape extends Path {
     shape: Vector2[];
     holes: Vector2[][];
   };
-  extractPoints(divisions: number): Vector2[];
+  extractPoints( divisions: number ): Vector2[];
+
 }

src/extras/core/ShapePath.d.ts

@@ -2,14 +2,15 @@ import { Vector2 } from './../../math/Vector2';
 import { Shape } from './Shape';
 
 export class ShapePath {
-  constructor();
+
+	constructor();
 
   subPaths: any[];
   currentPath: any;
 
-  moveTo(x: number, y: number): void;
-  lineTo(x: number, y: number): void;
-  quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): void;
+  moveTo( x: number, y: number ): void;
+  lineTo( x: number, y: number ): void;
+  quadraticCurveTo( aCPx: number, aCPy: number, aX: number, aY: number ): void;
   bezierCurveTo(
     aCP1x: number,
     aCP1y: number,
@@ -18,6 +19,7 @@ export class ShapePath {
     aX: number,
     aY: number
   ): void;
-  splineThru(pts: Vector2[]): void;
-  toShapes(isCCW: boolean, noHoles: any): Shape[];
+  splineThru( pts: Vector2[] ): void;
+  toShapes( isCCW: boolean, noHoles: any ): Shape[];
+
 }

src/extras/curves/ArcCurve.d.ts

@@ -1,6 +1,7 @@
 import { EllipseCurve } from './EllipseCurve';
 export class ArcCurve extends EllipseCurve {
-  constructor(
+
+	constructor(
     aX: number,
     aY: number,
     aRadius: number,
@@ -8,4 +9,5 @@ export class ArcCurve extends EllipseCurve {
     aEndAngle: number,
     aClockwise: boolean
   );
+
 }

src/extras/curves/CatmullRomCurve3.d.ts

@@ -33,7 +33,8 @@ export namespace CurveUtils {
 }
 
 export class CatmullRomCurve3 extends Curve<Vector3> {
-  constructor(
+
+	constructor(
     points?: Vector3[],
     closed?: boolean,
     curveType?: string,
@@ -42,5 +43,6 @@ export class CatmullRomCurve3 extends Curve<Vector3> {
 
   points: Vector3[];
 
-  getPoint(t: number): Vector3;
+  getPoint( t: number ): Vector3;
+
 }

src/extras/curves/CubicBezierCurve.d.ts

@@ -2,10 +2,12 @@ import { Vector2 } from './../../math/Vector2';
 import { Curve } from './../core/Curve';
 
 export class CubicBezierCurve extends Curve<Vector2> {
-  constructor(v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2);
+
+	constructor( v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2 );
 
   v0: Vector2;
   v1: Vector2;
   v2: Vector2;
   v3: Vector2;
+
 }

src/extras/curves/CubicBezierCurve3.d.ts

@@ -2,12 +2,14 @@ import { Vector3 } from './../../math/Vector3';
 import { Curve } from './../core/Curve';
 
 export class CubicBezierCurve3 extends Curve<Vector3> {
-  constructor(v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3);
+
+	constructor( v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3 );
 
   v0: Vector3;
   v1: Vector3;
   v2: Vector3;
   v3: Vector3;
 
-  getPoint(t: number): Vector3;
+  getPoint( t: number ): Vector3;
+
 }

src/extras/curves/EllipseCurve.d.ts

@@ -2,7 +2,8 @@ import { Curve } from './../core/Curve';
 import { Vector2 } from '../../math/Vector2';
 
 export class EllipseCurve extends Curve<Vector2> {
-  constructor(
+
+	constructor(
     aX: number,
     aY: number,
     xRadius: number,
@@ -21,4 +22,5 @@ export class EllipseCurve extends Curve<Vector2> {
   aEndAngle: number;
   aClockwise: boolean;
   aRotation: number;
+
 }

src/extras/curves/LineCurve.d.ts

@@ -2,8 +2,10 @@ import { Vector2 } from './../../math/Vector2';
 import { Curve } from './../core/Curve';
 
 export class LineCurve extends Curve<Vector2> {
-  constructor(v1: Vector2, v2: Vector2);
+
+	constructor( v1: Vector2, v2: Vector2 );
 
   v1: Vector2;
   v2: Vector2;
+
 }

src/extras/curves/LineCurve3.d.ts

@@ -2,10 +2,12 @@ import { Vector3 } from './../../math/Vector3';
 import { Curve } from './../core/Curve';
 
 export class LineCurve3 extends Curve<Vector3> {
-  constructor(v1: Vector3, v2: Vector3);
+
+	constructor( v1: Vector3, v2: Vector3 );
 
   v1: Vector3;
   v2: Vector3;
 
-  getPoint(t: number): Vector3;
+  getPoint( t: number ): Vector3;
+
 }

src/extras/curves/QuadraticBezierCurve.d.ts

@@ -2,9 +2,11 @@ import { Vector2 } from './../../math/Vector2';
 import { Curve } from './../core/Curve';
 
 export class QuadraticBezierCurve extends Curve<Vector2> {
-  constructor(v0: Vector2, v1: Vector2, v2: Vector2);
+
+	constructor( v0: Vector2, v1: Vector2, v2: Vector2 );
 
   v0: Vector2;
   v1: Vector2;
   v2: Vector2;
+
 }

src/extras/curves/QuadraticBezierCurve3.d.ts

@@ -2,11 +2,13 @@ import { Vector3 } from './../../math/Vector3';
 import { Curve } from './../core/Curve';
 
 export class QuadraticBezierCurve3 extends Curve<Vector3> {
-  constructor(v0: Vector3, v1: Vector3, v2: Vector3);
+
+	constructor( v0: Vector3, v1: Vector3, v2: Vector3 );
 
   v0: Vector3;
   v1: Vector3;
   v2: Vector3;
 
-  getPoint(t: number): Vector3;
+  getPoint( t: number ): Vector3;
+
 }

src/extras/curves/SplineCurve.d.ts

@@ -2,7 +2,9 @@ import { Vector2 } from './../../math/Vector2';
 import { Curve } from './../core/Curve';
 
 export class SplineCurve extends Curve<Vector2> {
-  constructor(points?: Vector2[]);
+
+	constructor( points?: Vector2[] );
 
   points: Vector2[];
+
 }

src/extras/objects/ImmediateRenderObject.d.ts

@@ -11,8 +11,10 @@ import { Material } from './../../materials/Material';
 // Extras / Objects /////////////////////////////////////////////////////////////////////
 
 export class ImmediateRenderObject extends Object3D {
-  constructor(material: Material);
+
+	constructor( material: Material );
 
   material: Material;
-  render(renderCallback: Function): void;
+  render( renderCallback: Function ): void;
+
 }

src/geometries/BoxGeometry.d.ts

@@ -5,7 +5,8 @@ import { Vector3 } from '../math/Vector3';
 
 // Extras / Geometries /////////////////////////////////////////////////////////////////////
 export class BoxBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     width?: number,
     height?: number,
     depth?: number,
@@ -22,13 +23,15 @@ export class BoxBufferGeometry extends BufferGeometry {
     heightSegments: number;
     depthSegments: number;
   };
+
 }
 
 /**
  * BoxGeometry is the quadrilateral primitive geometry class. It is typically used for creating a cube or irregular quadrilateral of the dimensions provided within the (optional) 'width', 'height', & 'depth' constructor arguments.
  */
 export class BoxGeometry extends Geometry {
-  /**
+
+	/**
    * @param width — Width of the sides on the X axis.
    * @param height — Height of the sides on the Y axis.
    * @param depth — Depth of the sides on the Z axis.
@@ -36,7 +39,7 @@ export class BoxGeometry extends Geometry {
    * @param heightSegments — Number of segmented faces along the height of the sides.
    * @param depthSegments — Number of segmented faces along the depth of the sides.
    */
-  constructor(
+	constructor(
     width?: number,
     height?: number,
     depth?: number,
@@ -53,4 +56,5 @@ export class BoxGeometry extends Geometry {
     heightSegments: number;
     depthSegments: number;
   };
+
 }

src/geometries/CircleGeometry.d.ts

@@ -5,7 +5,8 @@ import { BufferGeometry } from '../core/BufferGeometry';
  * @deprecated Use {@link BoxGeometry} instead.
  */
 export class CircleBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     radius?: number,
     segments?: number,
     thetaStart?: number,
@@ -18,10 +19,12 @@ export class CircleBufferGeometry extends BufferGeometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }
 
 export class CircleGeometry extends Geometry {
-  constructor(
+
+	constructor(
     radius?: number,
     segments?: number,
     thetaStart?: number,
@@ -34,4 +37,5 @@ export class CircleGeometry extends Geometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }

src/geometries/ConeGeometry.d.ts

@@ -3,7 +3,8 @@ import { CylinderBufferGeometry } from './CylinderGeometry';
 import { BufferGeometry } from '../core/BufferGeometry';
 
 export class ConeBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     radius?: number,
     height?: number,
     radialSegment?: number,
@@ -12,10 +13,12 @@ export class ConeBufferGeometry extends BufferGeometry {
     thetaStart?: number,
     thetaLength?: number
   );
+
 }
 
 export class ConeGeometry extends CylinderGeometry {
-  constructor(
+
+	constructor(
     radius?: number,
     height?: number,
     radialSegment?: number,
@@ -24,4 +27,5 @@ export class ConeGeometry extends CylinderGeometry {
     thetaStart?: number,
     thetaLength?: number
   );
+
 }

src/geometries/CylinderGeometry.d.ts

@@ -2,7 +2,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from '../core/BufferGeometry';
 
 export class CylinderBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     radiusTop?: number,
     radiusBottom?: number,
     height?: number,
@@ -23,10 +24,12 @@ export class CylinderBufferGeometry extends BufferGeometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }
 
 export class CylinderGeometry extends Geometry {
-  /**
+
+	/**
    * @param radiusTop — Radius of the cylinder at the top.
    * @param radiusBottom — Radius of the cylinder at the bottom.
    * @param height — Height of the cylinder.
@@ -34,7 +37,7 @@ export class CylinderGeometry extends Geometry {
    * @param heightSegments — Number of rows of faces along the height of the cylinder.
    * @param openEnded - A Boolean indicating whether or not to cap the ends of the cylinder.
    */
-  constructor(
+	constructor(
     radiusTop?: number,
     radiusBottom?: number,
     height?: number,
@@ -55,4 +58,5 @@ export class CylinderGeometry extends Geometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }

src/geometries/DodecahedronGeometry.d.ts

@@ -2,14 +2,18 @@ import { Geometry } from './../core/Geometry';
 import { PolyhedronBufferGeometry } from './PolyhedronGeometry';
 
 export class DodecahedronBufferGeometry extends PolyhedronBufferGeometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
+
 }
 
 export class DodecahedronGeometry extends Geometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
 
   parameters: {
     radius: number;
     detail: number;
   };
+
 }

src/geometries/EdgesGeometry.d.ts

@@ -2,5 +2,7 @@ import { BufferGeometry } from '../core/BufferGeometry';
 import { Geometry } from '../core/Geometry';
 
 export class EdgesGeometry extends BufferGeometry {
-  constructor(geometry: BufferGeometry | Geometry, thresholdAngle?: number);
+
+	constructor( geometry: BufferGeometry | Geometry, thresholdAngle?: number );
+
 }

src/geometries/ExtrudeGeometry.d.ts

@@ -38,19 +38,23 @@ export interface UVGenerator {
 }
 
 export class ExtrudeBufferGeometry extends BufferGeometry {
-  constructor(shapes: Shape | Shape[], options?: ExtrudeGeometryOptions);
+
+	constructor( shapes: Shape | Shape[], options?: ExtrudeGeometryOptions );
 
   static WorldUVGenerator: UVGenerator;
 
-  addShapeList(shapes: Shape[], options?: any): void;
-  addShape(shape: Shape, options?: any): void;
+  addShapeList( shapes: Shape[], options?: any ): void;
+  addShape( shape: Shape, options?: any ): void;
+
 }
 
 export class ExtrudeGeometry extends Geometry {
-  constructor(shapes: Shape | Shape[], options?: ExtrudeGeometryOptions);
+
+	constructor( shapes: Shape | Shape[], options?: ExtrudeGeometryOptions );
 
   static WorldUVGenerator: UVGenerator;
 
-  addShapeList(shapes: Shape[], options?: any): void;
-  addShape(shape: Shape, options?: any): void;
+  addShapeList( shapes: Shape[], options?: any ): void;
+  addShape( shape: Shape, options?: any ): void;
+
 }

src/geometries/IcosahedronGeometry.d.ts

@@ -1,14 +1,18 @@
 import { Shape } from './../extras/core/Shape';
 import { UVGenerator } from './ExtrudeGeometry';
 import {
-  PolyhedronGeometry,
-  PolyhedronBufferGeometry,
+	PolyhedronGeometry,
+	PolyhedronBufferGeometry,
 } from './PolyhedronGeometry';
 
 export class IcosahedronBufferGeometry extends PolyhedronBufferGeometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
+
 }
 
 export class IcosahedronGeometry extends PolyhedronGeometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
+
 }

src/geometries/LatheGeometry.d.ts

@@ -3,7 +3,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class LatheBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     points: Vector2[],
     segments?: number,
     phiStart?: number,
@@ -16,10 +17,12 @@ export class LatheBufferGeometry extends BufferGeometry {
     phiStart: number;
     phiLength: number;
   };
+
 }
 
 export class LatheGeometry extends Geometry {
-  constructor(
+
+	constructor(
     points: Vector2[],
     segments?: number,
     phiStart?: number,
@@ -32,4 +35,5 @@ export class LatheGeometry extends Geometry {
     phiStart: number;
     phiLength: number;
   };
+
 }

src/geometries/OctahedronGeometry.d.ts

@@ -1,12 +1,16 @@
 import {
-  PolyhedronGeometry,
-  PolyhedronBufferGeometry,
+	PolyhedronGeometry,
+	PolyhedronBufferGeometry,
 } from './PolyhedronGeometry';
 
 export class OctahedronBufferGeometry extends PolyhedronBufferGeometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
+
 }
 
 export class OctahedronGeometry extends PolyhedronGeometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
+
 }

src/geometries/ParametricGeometry.d.ts

@@ -3,29 +3,33 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class ParametricBufferGeometry extends BufferGeometry {
-  constructor(
-    func: (u: number, v: number, dest: Vector3) => void,
+
+	constructor(
+    func: ( u: number, v: number, dest: Vector3 ) => void,
     slices: number,
     stacks: number
   );
 
   parameters: {
-    func: (u: number, v: number, dest: Vector3) => void;
+    func: ( u: number, v: number, dest: Vector3 ) => void;
     slices: number;
     stacks: number;
   };
+
 }
 
 export class ParametricGeometry extends Geometry {
-  constructor(
-    func: (u: number, v: number, dest: Vector3) => void,
+
+	constructor(
+    func: ( u: number, v: number, dest: Vector3 ) => void,
     slices: number,
     stacks: number
   );
 
   parameters: {
-    func: (u: number, v: number, dest: Vector3) => void;
+    func: ( u: number, v: number, dest: Vector3 ) => void;
     slices: number;
     stacks: number;
   };
+
 }

src/geometries/PlaneGeometry.d.ts

@@ -2,7 +2,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class PlaneBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     width?: number,
     height?: number,
     widthSegments?: number,
@@ -15,10 +16,12 @@ export class PlaneBufferGeometry extends BufferGeometry {
     widthSegments: number;
     heightSegments: number;
   };
+
 }
 
 export class PlaneGeometry extends Geometry {
-  constructor(
+
+	constructor(
     width?: number,
     height?: number,
     widthSegments?: number,
@@ -31,4 +34,5 @@ export class PlaneGeometry extends Geometry {
     widthSegments: number;
     heightSegments: number;
   };
+
 }

src/geometries/PolyhedronGeometry.d.ts

@@ -3,7 +3,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class PolyhedronBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     vertices: number[],
     indices: number[],
     radius?: number,
@@ -16,10 +17,12 @@ export class PolyhedronBufferGeometry extends BufferGeometry {
     radius: number;
     detail: number;
   };
+
 }
 
 export class PolyhedronGeometry extends Geometry {
-  constructor(
+
+	constructor(
     vertices: number[],
     indices: number[],
     radius?: number,
@@ -33,4 +36,5 @@ export class PolyhedronGeometry extends Geometry {
     detail: number;
   };
   boundingSphere: Sphere;
+
 }

src/geometries/RingGeometry.d.ts

@@ -2,7 +2,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class RingBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     innerRadius?: number,
     outerRadius?: number,
     thetaSegments?: number,
@@ -19,10 +20,12 @@ export class RingBufferGeometry extends BufferGeometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }
 
 export class RingGeometry extends Geometry {
-  constructor(
+
+	constructor(
     innerRadius?: number,
     outerRadius?: number,
     thetaSegments?: number,
@@ -39,4 +42,5 @@ export class RingGeometry extends Geometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }

src/geometries/ShapeGeometry.d.ts

@@ -3,12 +3,16 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class ShapeBufferGeometry extends BufferGeometry {
-  constructor(shapes: Shape | Shape[], curveSegments?: number);
+
+	constructor( shapes: Shape | Shape[], curveSegments?: number );
+
 }
 
 export class ShapeGeometry extends Geometry {
-  constructor(shapes: Shape | Shape[], curveSegments?: number);
 
-  addShapeList(shapes: Shape[], options: any): ShapeGeometry;
-  addShape(shape: Shape, options?: any): void;
+	constructor( shapes: Shape | Shape[], curveSegments?: number );
+
+	addShapeList( shapes: Shape[], options: any ): ShapeGeometry;
+	addShape( shape: Shape, options?: any ): void;
+
 }

src/geometries/SphereGeometry.d.ts

@@ -3,7 +3,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class SphereBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     radius?: number,
     widthSegments?: number,
     heightSegments?: number,
@@ -22,13 +23,15 @@ export class SphereBufferGeometry extends BufferGeometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }
 
 /**
  * A class for generating sphere geometries
  */
 export class SphereGeometry extends Geometry {
-  /**
+
+	/**
    * The geometry is created by sweeping and calculating vertexes around the Y axis (horizontal sweep) and the Z axis (vertical sweep). Thus, incomplete spheres (akin to 'sphere slices') can be created through the use of different values of phiStart, phiLength, thetaStart and thetaLength, in order to define the points in which we start (or end) calculating those vertices.
    *
    * @param radius — sphere radius. Default is 50.
@@ -39,7 +42,7 @@ export class SphereGeometry extends Geometry {
    * @param thetaStart — specify vertical starting angle. Default is 0.
    * @param thetaLength — specify vertical sweep angle size. Default is Math.PI.
    */
-  constructor(
+	constructor(
     radius?: number,
     widthSegments?: number,
     heightSegments?: number,
@@ -58,4 +61,5 @@ export class SphereGeometry extends Geometry {
     thetaStart: number;
     thetaLength: number;
   };
+
 }

src/geometries/TetrahedronGeometry.d.ts

@@ -3,9 +3,13 @@ import { BufferGeometry } from './../core/BufferGeometry';
 import { PolyhedronBufferGeometry } from './PolyhedronGeometry';
 
 export class TetrahedronBufferGeometry extends PolyhedronBufferGeometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
+
 }
 
 export class TetrahedronGeometry extends PolyhedronGeometry {
-  constructor(radius?: number, detail?: number);
+
+	constructor( radius?: number, detail?: number );
+
 }

src/geometries/TextGeometry.d.ts

@@ -15,7 +15,8 @@ export interface TextGeometryParameters {
 }
 
 export class TextBufferGeometry extends ExtrudeBufferGeometry {
-  constructor(text: string, parameters?: TextGeometryParameters);
+
+	constructor( text: string, parameters?: TextGeometryParameters );
 
   parameters: {
     font: Font;
@@ -28,10 +29,12 @@ export class TextBufferGeometry extends ExtrudeBufferGeometry {
     bevelOffset: number;
     bevelSegments: number;
   };
+
 }
 
 export class TextGeometry extends ExtrudeGeometry {
-  constructor(text: string, parameters?: TextGeometryParameters);
+
+	constructor( text: string, parameters?: TextGeometryParameters );
 
   parameters: {
     font: Font;
@@ -44,4 +47,5 @@ export class TextGeometry extends ExtrudeGeometry {
     bevelOffset: number;
     bevelSegments: number;
   };
+
 }

src/geometries/TorusGeometry.d.ts

@@ -4,7 +4,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class TorusBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     radius?: number,
     tube?: number,
     radialSegments?: number,
@@ -19,10 +20,12 @@ export class TorusBufferGeometry extends BufferGeometry {
     tubularSegments: number;
     arc: number;
   };
+
 }
 
 export class TorusGeometry extends Geometry {
-  constructor(
+
+	constructor(
     radius?: number,
     tube?: number,
     radialSegments?: number,
@@ -37,4 +40,5 @@ export class TorusGeometry extends Geometry {
     tubularSegments: number;
     arc: number;
   };
+
 }

src/geometries/TorusKnotGeometry.d.ts

@@ -2,7 +2,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class TorusKnotBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     radius?: number,
     tube?: number,
     tubularSegments?: number,
@@ -20,10 +21,12 @@ export class TorusKnotBufferGeometry extends BufferGeometry {
     q: number;
     heightScale: number;
   };
+
 }
 
 export class TorusKnotGeometry extends Geometry {
-  constructor(
+
+	constructor(
     radius?: number,
     tube?: number,
     tubularSegments?: number,
@@ -41,4 +44,5 @@ export class TorusKnotGeometry extends Geometry {
     q: number;
     heightScale: number;
   };
+
 }

src/geometries/TubeGeometry.d.ts

@@ -4,7 +4,8 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class TubeBufferGeometry extends BufferGeometry {
-  constructor(
+
+	constructor(
     path: Curve<Vector3>,
     tubularSegments?: number,
     radius?: number,
@@ -22,10 +23,12 @@ export class TubeBufferGeometry extends BufferGeometry {
   tangents: Vector3[];
   normals: Vector3[];
   binormals: Vector3[];
+
 }
 
 export class TubeGeometry extends Geometry {
-  constructor(
+
+	constructor(
     path: Curve<Vector3>,
     tubularSegments?: number,
     radius?: number,
@@ -43,4 +46,5 @@ export class TubeGeometry extends Geometry {
   tangents: Vector3[];
   normals: Vector3[];
   binormals: Vector3[];
+
 }

src/geometries/WireframeGeometry.d.ts

@@ -4,5 +4,7 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export class WireframeGeometry extends BufferGeometry {
-  constructor(geometry: Geometry | BufferGeometry);
+
+	constructor( geometry: Geometry | BufferGeometry );
+
 }

src/helpers/ArrowHelper.d.ts

@@ -7,7 +7,8 @@ import { Object3D } from './../core/Object3D';
 // Extras / Helpers /////////////////////////////////////////////////////////////////////
 
 export class ArrowHelper extends Object3D {
-  constructor(
+
+	constructor(
     dir: Vector3,
     origin?: Vector3,
     length?: number,
@@ -19,7 +20,8 @@ export class ArrowHelper extends Object3D {
   line: Line;
   cone: Mesh;
 
-  setDirection(dir: Vector3): void;
-  setLength(length: number, headLength?: number, headWidth?: number): void;
-  setColor(color: Color): void;
+  setDirection( dir: Vector3 ): void;
+  setLength( length: number, headLength?: number, headWidth?: number ): void;
+  setColor( color: Color ): void;
+
 }

src/helpers/AxesHelper.d.ts

@@ -1,5 +1,7 @@
 import { LineSegments } from './../objects/LineSegments';
 
 export class AxesHelper extends LineSegments {
-  constructor(size?: number);
+
+	constructor( size?: number );
+
 }

src/helpers/Box3Helper.d.ts

@@ -4,8 +4,10 @@ import { Color } from './../math/Color';
 import { LineSegments } from './../objects/LineSegments';
 
 export class Box3Helper {
-  constructor(object?: Object3D, color?: Color);
+
+	constructor( object?: Object3D, color?: Color );
 
   type: string;
   box: Box3;
+
 }

src/helpers/BoxHelper.d.ts

@@ -16,7 +16,9 @@ import { LineSegments } from './../objects/LineSegments';
 // }
 
 export class BoxHelper extends LineSegments {
-  constructor(object?: Object3D, color?: Color);
 
-  update(object?: Object3D): void;
+	constructor( object?: Object3D, color?: Color );
+
+	update( object?: Object3D ): void;
+
 }

src/helpers/CameraHelper.d.ts

@@ -2,10 +2,12 @@ import { Camera } from './../cameras/Camera';
 import { LineSegments } from './../objects/LineSegments';
 
 export class CameraHelper extends LineSegments {
-  constructor(camera: Camera);
+
+	constructor( camera: Camera );
 
   camera: Camera;
   pointMap: { [id: string]: number[] };
 
   update(): void;
+
 }

src/helpers/DirectionalLightHelper.d.ts

@@ -5,7 +5,8 @@ import { Matrix4 } from './../math/Matrix4';
 import { Object3D } from './../core/Object3D';
 
 export class DirectionalLightHelper extends Object3D {
-  constructor(
+
+	constructor(
     light: DirectionalLight,
     size?: number,
     color?: Color | string | number
@@ -20,4 +21,5 @@ export class DirectionalLightHelper extends Object3D {
 
   dispose(): void;
   update(): void;
+
 }

src/helpers/FaceNormalsHelper.d.ts

@@ -9,7 +9,8 @@ import { LineSegments } from './../objects/LineSegments';
 // }
 
 export class FaceNormalsHelper extends LineSegments {
-  constructor(
+
+	constructor(
     object: Object3D,
     size?: number,
     hex?: number,
@@ -19,5 +20,6 @@ export class FaceNormalsHelper extends LineSegments {
   object: Object3D;
   size: number;
 
-  update(object?: Object3D): void;
+  update( object?: Object3D ): void;
+
 }

src/helpers/GridHelper.d.ts

@@ -2,7 +2,8 @@ import { Color } from './../math/Color';
 import { LineSegments } from './../objects/LineSegments';
 
 export class GridHelper extends LineSegments {
-  constructor(
+
+	constructor(
     size: number,
     divisions: number,
     color1?: Color | number,
@@ -11,5 +12,6 @@ export class GridHelper extends LineSegments {
   /**
    * @deprecated Colors should be specified in the constructor.
    */
-  setColors(color1?: Color | number, color2?: Color | number): void;
+	setColors( color1?: Color | number, color2?: Color | number ): void;
+
 }

src/helpers/HemisphereLightHelper.d.ts

@@ -5,7 +5,8 @@ import { MeshBasicMaterial } from './../materials/MeshBasicMaterial';
 import { Object3D } from './../core/Object3D';
 
 export class HemisphereLightHelper extends Object3D {
-  constructor(
+
+	constructor(
     light: HemisphereLight,
     size: number,
     color?: Color | number | string
@@ -20,4 +21,5 @@ export class HemisphereLightHelper extends Object3D {
 
   dispose(): void;
   update(): void;
+
 }

src/helpers/PlaneHelper.d.ts

@@ -2,10 +2,12 @@ import { Plane } from './../math/Plane';
 import { LineSegments } from './../objects/LineSegments';
 
 export class PlaneHelper extends LineSegments {
-  constructor(plane: Plane, size?: number, hex?: number);
+
+	constructor( plane: Plane, size?: number, hex?: number );
 
   plane: Plane;
   size: number;
 
-  updateMatrixWorld(force?: boolean): void;
+  updateMatrixWorld( force?: boolean ): void;
+
 }

src/helpers/PointLightHelper.d.ts

@@ -4,7 +4,8 @@ import { Matrix4 } from './../math/Matrix4';
 import { Object3D } from './../core/Object3D';
 
 export class PointLightHelper extends Object3D {
-  constructor(
+
+	constructor(
     light: PointLight,
     sphereSize?: number,
     color?: Color | string | number
@@ -17,4 +18,5 @@ export class PointLightHelper extends Object3D {
 
   dispose(): void;
   update(): void;
+
 }

src/helpers/PolarGridHelper.d.ts

@@ -6,7 +6,8 @@ import { BufferGeometry } from '../core/BufferGeometry';
 import { Color } from '../math/Color';
 
 export class PolarGridHelper {
-  constructor(
+
+	constructor(
     radius: number,
     radials: number,
     circles: number,
@@ -14,4 +15,5 @@ export class PolarGridHelper {
     color1: Color | string | number | undefined,
     color2: Color | string | number | undefined
   );
+
 }

src/helpers/PositionalAudioHelper.d.ts

@@ -2,7 +2,8 @@ import { PositionalAudio } from './../audio/PositionalAudio';
 import { Line } from './../objects/Line';
 
 export class PositionalAudioHelper extends Line {
-  constructor(audio: PositionalAudio, range?: number, divisionsInnerAngle?: number, divisionsOuterAngle?: number);
+
+	constructor( audio: PositionalAudio, range?: number, divisionsInnerAngle?: number, divisionsOuterAngle?: number );
 
   audio: PositionalAudio;
   range: number;
@@ -11,4 +12,5 @@ export class PositionalAudioHelper extends Line {
 
   dispose(): void;
   update(): void;
+
 }

src/helpers/RectAreaLightHelper.d.ts

@@ -4,8 +4,10 @@ import { Color } from './../math/Color';
 //import { Object3D } from './../core/Object3D';
 
 export class RectAreaLightHelper {
-  constructor(light: RectAreaLight, color?: Color | string | number);
+
+	constructor( light: RectAreaLight, color?: Color | string | number );
 
   light: RectAreaLight;
   color: Color | string | number | undefined;
+
 }

src/helpers/SkeletonHelper.d.ts

@@ -3,11 +3,13 @@ import { Bone } from './../objects/Bone';
 import { LineSegments } from './../objects/LineSegments';
 
 export class SkeletonHelper extends LineSegments {
-  constructor(bone: Object3D);
+
+	constructor( bone: Object3D );
 
   bones: Bone[];
   root: Object3D;
 
-  getBoneList(object: Object3D): Bone[];
+  getBoneList( object: Object3D ): Bone[];
   update(): void;
+
 }

src/helpers/SpotLightHelper.d.ts

@@ -4,7 +4,8 @@ import { Matrix4 } from './../math/Matrix4';
 import { Object3D } from './../core/Object3D';
 
 export class SpotLightHelper extends Object3D {
-  constructor(light: Light, color?: Color | string | number);
+
+	constructor( light: Light, color?: Color | string | number );
 
   light: Light;
   matrix: Matrix4;
@@ -13,4 +14,5 @@ export class SpotLightHelper extends Object3D {
 
   dispose(): void;
   update(): void;
+
 }

src/helpers/VertexNormalsHelper.d.ts

@@ -2,7 +2,8 @@ import { Object3D } from './../core/Object3D';
 import { LineSegments } from './../objects/LineSegments';
 
 export class VertexNormalsHelper extends LineSegments {
-  constructor(
+
+	constructor(
     object: Object3D,
     size?: number,
     hex?: number,
@@ -12,5 +13,6 @@ export class VertexNormalsHelper extends LineSegments {
   object: Object3D;
   size: number;
 
-  update(object?: Object3D): void;
+  update( object?: Object3D ): void;
+
 }