Ran npm run lint -- --fix

src/Three.Legacy.d.ts

@@ -4,10 +4,10 @@ import { Object3D } from './core/Object3D';
 import { Scene } from './scenes/Scene';
 
 export namespace SceneUtils {
-  export function createMultiMaterialObject(
-    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 createMultiMaterialObject(
+		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;
 }

src/animation/AnimationAction.d.ts

@@ -5,55 +5,55 @@ import { AnimationActionLoopStyles } from '../constants';
 
 export class AnimationAction {
 
-  loop: AnimationActionLoopStyles;
-  time: number;
-  timeScale: number;
-  weight: number;
-  repetitions: number;
-  paused: boolean;
-  enabled: boolean;
-  clampWhenFinished: boolean;
-  zeroSlopeAtStart: boolean;
-  zeroSlopeAtEnd: boolean;
+	loop: AnimationActionLoopStyles;
+	time: number;
+	timeScale: number;
+	weight: number;
+	repetitions: number;
+	paused: boolean;
+	enabled: boolean;
+	clampWhenFinished: boolean;
+	zeroSlopeAtStart: boolean;
+	zeroSlopeAtEnd: boolean;
 
-  play(): AnimationAction;
-  stop(): AnimationAction;
-  reset(): AnimationAction;
-  isRunning(): boolean;
-  isScheduled(): boolean;
-  startAt( time: number ): AnimationAction;
-  setLoop(
-    mode: AnimationActionLoopStyles,
-    repetitions: number
-  ): AnimationAction;
-  setEffectiveWeight( weight: number ): AnimationAction;
-  getEffectiveWeight(): number;
-  fadeIn( duration: number ): AnimationAction;
-  fadeOut( duration: number ): AnimationAction;
-  crossFadeFrom(
-    fadeOutAction: AnimationAction,
-    duration: number,
-    warp: boolean
-  ): AnimationAction;
-  crossFadeTo(
-    fadeInAction: AnimationAction,
-    duration: number,
-    warp: boolean
-  ): AnimationAction;
-  stopFading(): AnimationAction;
-  setEffectiveTimeScale( timeScale: number ): AnimationAction;
-  getEffectiveTimeScale(): number;
-  setDuration( duration: number ): AnimationAction;
-  syncWith( action: AnimationAction ): AnimationAction;
-  halt( duration: number ): AnimationAction;
-  warp(
-    statTimeScale: number,
-    endTimeScale: number,
-    duration: number
-  ): AnimationAction;
-  stopWarping(): AnimationAction;
-  getMixer(): AnimationMixer;
-  getClip(): AnimationClip;
-  getRoot(): any;
+	play(): AnimationAction;
+	stop(): AnimationAction;
+	reset(): AnimationAction;
+	isRunning(): boolean;
+	isScheduled(): boolean;
+	startAt( time: number ): AnimationAction;
+	setLoop(
+		mode: AnimationActionLoopStyles,
+		repetitions: number
+	): AnimationAction;
+	setEffectiveWeight( weight: number ): AnimationAction;
+	getEffectiveWeight(): number;
+	fadeIn( duration: number ): AnimationAction;
+	fadeOut( duration: number ): AnimationAction;
+	crossFadeFrom(
+		fadeOutAction: AnimationAction,
+		duration: number,
+		warp: boolean
+	): AnimationAction;
+	crossFadeTo(
+		fadeInAction: AnimationAction,
+		duration: number,
+		warp: boolean
+	): AnimationAction;
+	stopFading(): AnimationAction;
+	setEffectiveTimeScale( timeScale: number ): AnimationAction;
+	getEffectiveTimeScale(): number;
+	setDuration( duration: number ): AnimationAction;
+	syncWith( action: AnimationAction ): AnimationAction;
+	halt( duration: number ): AnimationAction;
+	warp(
+		statTimeScale: number,
+		endTimeScale: number,
+		duration: number
+	): AnimationAction;
+	stopWarping(): AnimationAction;
+	getMixer(): AnimationMixer;
+	getClip(): AnimationClip;
+	getRoot(): any;
 
 }

src/animation/AnimationClip.d.ts

@@ -6,34 +6,34 @@ export class AnimationClip {
 
 	constructor( name?: string, duration?: number, tracks?: KeyframeTrack[] );
 
-  name: string;
-  tracks: KeyframeTrack[];
-  duration: number;
-  uuid: string;
-  results: any[];
+	name: string;
+	tracks: KeyframeTrack[];
+	duration: number;
+	uuid: string;
+	results: any[];
 
-  resetDuration(): void;
-  trim(): AnimationClip;
-  optimize(): AnimationClip;
+	resetDuration(): void;
+	trim(): AnimationClip;
+	optimize(): AnimationClip;
 
-  static CreateFromMorphTargetSequence(
-    name: string,
-    morphTargetSequence: MorphTarget[],
-    fps: number,
-    noLoop: boolean
-  ): AnimationClip;
-  static findByName( clipArray: AnimationClip[], name: string ): AnimationClip;
-  static CreateClipsFromMorphTargetSequences(
-    morphTargets: MorphTarget[],
-    fps: number,
-    noLoop: boolean
-  ): AnimationClip[];
-  static parse( json: any ): AnimationClip;
-  static parseAnimation(
-    animation: any,
-    bones: Bone[],
-    nodeName: string
-  ): AnimationClip;
-  static toJSON(): any;
+	static CreateFromMorphTargetSequence(
+		name: string,
+		morphTargetSequence: MorphTarget[],
+		fps: number,
+		noLoop: boolean
+	): AnimationClip;
+	static findByName( clipArray: AnimationClip[], name: string ): AnimationClip;
+	static CreateClipsFromMorphTargetSequences(
+		morphTargets: MorphTarget[],
+		fps: number,
+		noLoop: boolean
+	): AnimationClip[];
+	static parse( json: any ): AnimationClip;
+	static parseAnimation(
+		animation: any,
+		bones: Bone[],
+		nodeName: string
+	): AnimationClip;
+	static toJSON(): any;
 
 }

src/animation/AnimationMixer.d.ts

@@ -6,16 +6,16 @@ export class AnimationMixer extends EventDispatcher {
 
 	constructor( root: any );
 
-  time: number;
-  timeScale: number;
+	time: number;
+	timeScale: number;
 
-  clipAction( clip: AnimationClip, root?: any ): AnimationAction;
-  existingAction( clip: AnimationClip, root?: any ): AnimationAction;
-  stopAllAction(): AnimationMixer;
-  update( deltaTime: number ): AnimationMixer;
-  getRoot(): any;
-  uncacheClip( clip: AnimationClip ): void;
-  uncacheRoot( root: any ): void;
-  uncacheAction( clip: AnimationClip, root?: any ): void;
+	clipAction( clip: AnimationClip, root?: any ): AnimationAction;
+	existingAction( clip: AnimationClip, root?: any ): AnimationAction;
+	stopAllAction(): AnimationMixer;
+	update( deltaTime: number ): AnimationMixer;
+	getRoot(): any;
+	uncacheClip( clip: AnimationClip ): void;
+	uncacheRoot( root: any ): void;
+	uncacheAction( clip: AnimationClip, root?: any ): void;
 
 }

src/animation/AnimationObjectGroup.d.ts

@@ -2,17 +2,17 @@ export class AnimationObjectGroup {
 
 	constructor( ...args: any[] );
 
-  uuid: string;
-  stats: {
-    bindingsPerObject: number;
-    objects: {
-      total: number;
-      inUse: number;
-    };
-  };
+	uuid: string;
+	stats: {
+		bindingsPerObject: number;
+		objects: {
+			total: number;
+			inUse: number;
+		};
+	};
 
-  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,17 +1,17 @@
 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 sortedArray(
-    values: any[],
-    stride: number,
-    order: number[]
-  ): any[];
-  export function flattenJSON(
-    jsonKeys: string[],
-    times: any[],
-    values: any[],
-    valuePropertyName: string
-  ): void;
+	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,
+		order: number[]
+	): any[];
+	export function flattenJSON(
+		jsonKeys: string[],
+		times: any[],
+		values: any[],
+		valuePropertyName: string
+	): void;
 }

src/animation/KeyframeTrack.d.ts

@@ -6,38 +6,38 @@ import { InterpolationModes } from '../constants';
 export class KeyframeTrack {
 
 	constructor(
-    name: string,
-    times: any[],
-    values: any[],
-    interpolation?: InterpolationModes
-  );
+		name: string,
+		times: any[],
+		values: any[],
+		interpolation?: InterpolationModes
+	);
 
-  name: string;
-  times: any[];
-  values: any[];
+	name: string;
+	times: any[];
+	values: any[];
 
-  ValueTypeName: string;
-  TimeBufferType: Float32Array;
-  ValueBufferType: Float32Array;
+	ValueTypeName: string;
+	TimeBufferType: Float32Array;
+	ValueBufferType: Float32Array;
 
-  DefaultInterpolation: InterpolationModes;
+	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;
-  getInterpolation(): InterpolationModes;
+	setInterpolation( interpolation: InterpolationModes ): void;
+	getInterpolation(): InterpolationModes;
 
-  getValuesize(): number;
+	getValuesize(): number;
 
-  shift( timeOffset: number ): KeyframeTrack;
-  scale( timeScale: number ): KeyframeTrack;
-  trim( startTime: number, endTime: number ): KeyframeTrack;
-  validate(): boolean;
-  optimize(): 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

@@ -2,34 +2,34 @@ export class PropertyBinding {
 
 	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;
-  bind(): void;
-  unbind(): void;
-
-  BindingType: { [bindingType: string]: number };
-  Versioning: { [versioning: string]: number };
-
-  GetterByBindingType: Function[];
-  SetterByBindingTypeAndVersioning: Array<Function[]>;
-
-  static create(
-    root: any,
-    path: any,
-    parsedPath?: any
-  ): PropertyBinding | PropertyBinding.Composite;
-  static parseTrackName( trackName: string ): any;
-  static findNode( root: any, nodeName: string ): any;
+	path: string;
+	parsedPath: any;
+	node: any;
+	rootNode: any;
+
+	getValue( targetArray: any, offset: number ): any;
+	setValue( sourceArray: any, offset: number ): void;
+	bind(): void;
+	unbind(): void;
+
+	BindingType: { [bindingType: string]: number };
+	Versioning: { [versioning: string]: number };
+
+	GetterByBindingType: Function[];
+	SetterByBindingTypeAndVersioning: Array<Function[]>;
+
+	static create(
+		root: any,
+		path: any,
+		parsedPath?: any
+	): PropertyBinding | PropertyBinding.Composite;
+	static parseTrackName( trackName: string ): any;
+	static findNode( root: any, nodeName: string ): any;
 
 }
 
 export namespace PropertyBinding {
-  export class Composite {
+	export class Composite {
 
   	constructor( targetGroup: any, path: any, parsedPath?: any );
 
@@ -38,5 +38,5 @@ export namespace PropertyBinding {
   	bind(): void;
   	unbind(): void;
 
-  }
+	}
 }

src/animation/PropertyMixer.d.ts

@@ -2,16 +2,16 @@ export class PropertyMixer {
 
 	constructor( binding: any, typeName: string, valueSize: number );
 
-  binding: any;
-  valueSize: number;
-  buffer: any;
-  cumulativeWeight: number;
-  useCount: number;
-  referenceCount: number;
+	binding: any;
+	valueSize: number;
+	buffer: any;
+	cumulativeWeight: number;
+	useCount: number;
+	referenceCount: number;
 
-  accumulate( accuIndex: number, weight: number ): void;
-  apply( accuIndex: number ): void;
-  saveOriginalState(): void;
-  restoreOriginalState(): void;
+	accumulate( accuIndex: number, weight: number ): void;
+	apply( accuIndex: number ): void;
+	saveOriginalState(): void;
+	restoreOriginalState(): void;
 
 }

src/animation/tracks/ColorKeyframeTrack.d.ts

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

src/animation/tracks/NumberKeyframeTrack.d.ts

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

src/animation/tracks/QuaternionKeyframeTrack.d.ts

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

src/animation/tracks/StringKeyframeTrack.d.ts

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

src/animation/tracks/VectorKeyframeTrack.d.ts

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

src/audio/AudioAnalyser.d.ts

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

src/audio/AudioListener.d.ts

@@ -5,17 +5,17 @@ export class AudioListener extends Object3D {
 
 	constructor();
 
-  type: 'AudioListener';
-  context: AudioContext;
-  gain: GainNode;
-  filter: null | any;
+	type: 'AudioListener';
+	context: AudioContext;
+	gain: GainNode;
+	filter: null | any;
 
-  getInput(): GainNode;
-  removeFilter(): void;
-  setFilter( value: any ): void;
-  getFilter(): any;
-  setMasterVolume( value: number ): void;
-  getMasterVolume(): number;
-  updateMatrixWorld( force?: boolean ): void;
+	getInput(): GainNode;
+	removeFilter(): void;
+	setFilter( value: any ): void;
+	getFilter(): any;
+	setMasterVolume( value: number ): void;
+	getMasterVolume(): number;
+	updateMatrixWorld( force?: boolean ): void;
 
 }

src/cameras/ArrayCamera.d.ts

@@ -4,7 +4,7 @@ export class ArrayCamera extends PerspectiveCamera {
 
 	constructor( cameras?: PerspectiveCamera[] );
 
-  cameras: PerspectiveCamera[];
-  isArrayCamera: true;
+	cameras: PerspectiveCamera[];
+	isArrayCamera: true;
 
 }

src/cameras/Camera.d.ts

@@ -14,22 +14,22 @@ export class Camera extends Object3D {
    */
 	constructor();
 
-  /**
+	/**
    * This is the inverse of matrixWorld. MatrixWorld contains the Matrix which has the world transform of the Camera.
    */
-  matrixWorldInverse: Matrix4;
+	matrixWorldInverse: Matrix4;
 
-  /**
+	/**
    * This is the matrix which contains the projection.
    */
-  projectionMatrix: Matrix4;
+	projectionMatrix: Matrix4;
 
-  isCamera: true;
+	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

@@ -7,15 +7,15 @@ export class CubeCamera extends Object3D {
 
 	constructor( near?: number, far?: number, cubeResolution?: number );
 
-  type: 'CubeCamera';
+	type: 'CubeCamera';
 
-  renderTarget: WebGLRenderTargetCube;
+	renderTarget: WebGLRenderTargetCube;
 
-  /**
+	/**
    * @deprecated Use {@link CubeCamera#update .update()} instead
    */
-  //updateCubeMap(renderer: Renderer, scene: Scene): void;
+	//updateCubeMap(renderer: Renderer, scene: Scene): void;
 
-  update( renderer: WebGLRenderer, scene: Scene ): void;
+	update( renderer: WebGLRenderer, scene: Scene ): void;
 
 }

src/cameras/OrthographicCamera.d.ts

@@ -20,72 +20,72 @@ export class OrthographicCamera extends Camera {
    * @param far Camera frustum far plane.
    */
 	constructor(
-    left: number,
-    right: number,
-    top: number,
-    bottom: number,
-    near?: number,
-    far?: number
-  );
+		left: number,
+		right: number,
+		top: number,
+		bottom: number,
+		near?: number,
+		far?: number
+	);
 
-  type: 'OrthographicCamera';
+	type: 'OrthographicCamera';
 
-  isOrthographicCamera: true;
+	isOrthographicCamera: true;
 
-  zoom: number;
-  view: null | {
-    enabled: boolean;
-    fullWidth: number;
-    fullHeight: number;
-    offsetX: number;
-    offsetY: number;
-    width: number;
-    height: number;
-  };
+	zoom: number;
+	view: null | {
+		enabled: boolean;
+		fullWidth: number;
+		fullHeight: number;
+		offsetX: number;
+		offsetY: number;
+		width: number;
+		height: number;
+	};
 
-  /**
+	/**
    * Camera frustum left plane.
    */
-  left: number;
+	left: number;
 
-  /**
+	/**
    * Camera frustum right plane.
    */
-  right: number;
+	right: number;
 
-  /**
+	/**
    * Camera frustum top plane.
    */
-  top: number;
+	top: number;
 
-  /**
+	/**
    * Camera frustum bottom plane.
    */
-  bottom: number;
+	bottom: number;
 
-  /**
+	/**
    * Camera frustum near plane.
    */
-  near: number;
+	near: number;
 
-  /**
+	/**
    * Camera frustum far plane.
    */
-  far: number;
+	far: number;
 
-  /**
+	/**
    * Updates the camera projection matrix. Must be called after change of parameters.
    */
-  updateProjectionMatrix(): void;
-  setViewOffset(
-    fullWidth: number,
-    fullHeight: number,
-    offsetX: number,
-    offsetY: number,
-    width: number,
-    height: number
-  ): void;
-  clearViewOffset(): void;
-  toJSON( meta?: any ): any;
+	updateProjectionMatrix(): void;
+	setViewOffset(
+		fullWidth: number,
+		fullHeight: number,
+		offsetX: number,
+		offsetY: number,
+		width: number,
+		height: number
+	): void;
+	clearViewOffset(): void;
+	toJSON( meta?: any ): any;
 
 }

src/cameras/PerspectiveCamera.d.ts

@@ -19,52 +19,52 @@ export class PerspectiveCamera extends Camera {
    */
 	constructor( fov?: number, aspect?: number, near?: number, far?: number );
 
-  type: 'PerspectiveCamera';
+	type: 'PerspectiveCamera';
 
-  isPerspectiveCamera: true;
+	isPerspectiveCamera: true;
 
-  zoom: number;
+	zoom: number;
 
-  /**
+	/**
    * Camera frustum vertical field of view, from bottom to top of view, in degrees.
    */
-  fov: number;
+	fov: number;
 
-  /**
+	/**
    * Camera frustum aspect ratio, window width divided by window height.
    */
-  aspect: number;
+	aspect: number;
 
-  /**
+	/**
    * Camera frustum near plane.
    */
-  near: number;
+	near: number;
 
-  /**
+	/**
    * Camera frustum far plane.
    */
-  far: number;
+	far: number;
 
-  focus: number;
-  view: null | {
-    enabled: boolean;
-    fullWidth: number;
-    fullHeight: number;
-    offsetX: number;
-    offsetY: number;
-    width: number;
-    height: number;
-  };
-  filmGauge: number;
-  filmOffset: number;
+	focus: number;
+	view: null | {
+		enabled: boolean;
+		fullWidth: number;
+		fullHeight: number;
+		offsetX: number;
+		offsetY: number;
+		width: number;
+		height: number;
+	};
+	filmGauge: number;
+	filmOffset: number;
 
-  setFocalLength( focalLength: number ): void;
-  getFocalLength(): number;
-  getEffectiveFOV(): number;
-  getFilmWidth(): number;
-  getFilmHeight(): number;
+	setFocalLength( focalLength: number ): void;
+	getFocalLength(): number;
+	getEffectiveFOV(): number;
+	getFilmWidth(): number;
+	getFilmHeight(): number;
 
-  /**
+	/**
    * Sets an offset in a larger frustum. This is useful for multi-window or multi-monitor/multi-machine setups.
    * For example, if you have 3x2 monitors and each monitor is 1920x1080 and the monitors are in grid like this:
    *
@@ -101,25 +101,25 @@ export class PerspectiveCamera extends Camera {
    * @param width width of subcamera
    * @param height height of subcamera
    */
-  setViewOffset(
-    fullWidth: number,
-    fullHeight: number,
-    x: number,
-    y: number,
-    width: number,
-    height: number
-  ): void;
-  clearViewOffset(): void;
+	setViewOffset(
+		fullWidth: number,
+		fullHeight: number,
+		x: number,
+		y: number,
+		width: number,
+		height: number
+	): void;
+	clearViewOffset(): void;
 
-  /**
+	/**
    * Updates the camera projection matrix. Must be called after change of parameters.
    */
-  updateProjectionMatrix(): void;
-  toJSON( meta?: any ): any;
+	updateProjectionMatrix(): void;
+	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

@@ -5,13 +5,13 @@ export class StereoCamera extends Camera {
 
 	constructor();
 
-  type: 'StereoCamera';
+	type: 'StereoCamera';
 
-  aspect: number;
-  eyeSep: number;
-  cameraL: PerspectiveCamera;
-  cameraR: PerspectiveCamera;
+	aspect: number;
+	eyeSep: number;
+	cameraL: PerspectiveCamera;
+	cameraR: PerspectiveCamera;
 
-  update( camera: PerspectiveCamera ): void;
+	update( camera: PerspectiveCamera ): void;
 
 }

src/constants.d.ts

@@ -2,9 +2,9 @@ export const REVISION: string;
 
 // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.button
 export enum MOUSE {
-  LEFT,
-  MIDDLE,
-  RIGHT,
+	LEFT,
+	MIDDLE,
+	RIGHT,
 }
 
 // GL STATE CONSTANTS

src/core/BufferAttribute.d.ts

@@ -5,62 +5,62 @@ export class BufferAttribute {
 
 	constructor( array: ArrayLike<number>, itemSize: number, normalized?: boolean ); // array parameter should be TypedArray.
 
-  uuid: string;
-  array: ArrayLike<number>;
-  itemSize: number;
-  dynamic: boolean;
-  updateRange: { offset: number; count: number };
-  version: number;
-  normalized: boolean;
-  needsUpdate: boolean;
-  count: number;
-  onUpload: Function;
-
-  setArray( array?: ArrayBufferView ): void;
-  setDynamic( dynamic: boolean ): BufferAttribute;
-  clone(): this;
-  copy( source: BufferAttribute ): this;
-  copyAt(
-    index1: number,
-    attribute: BufferAttribute,
-    index2: number
-  ): BufferAttribute;
-  copyArray( array: ArrayLike<number> ): BufferAttribute;
-  copyColorsArray(
-    colors: { r: number; g: number; b: number }[]
-  ): BufferAttribute;
-  copyVector2sArray( vectors: { x: number; y: number }[] ): BufferAttribute;
-  copyVector3sArray(
-    vectors: { x: number; y: number; z: number }[]
-  ): BufferAttribute;
-  copyVector4sArray(
-    vectors: { x: number; y: number; z: number; w: number }[]
-  ): BufferAttribute;
-  set(
-    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;
-  setXYZW(
-    index: number,
-    x: number,
-    y: number,
-    z: number,
-    w: number
-  ): BufferAttribute;
-  /**
+	uuid: string;
+	array: ArrayLike<number>;
+	itemSize: number;
+	dynamic: boolean;
+	updateRange: { offset: number; count: number };
+	version: number;
+	normalized: boolean;
+	needsUpdate: boolean;
+	count: number;
+	onUpload: Function;
+
+	setArray( array?: ArrayBufferView ): void;
+	setDynamic( dynamic: boolean ): BufferAttribute;
+	clone(): this;
+	copy( source: BufferAttribute ): this;
+	copyAt(
+		index1: number,
+		attribute: BufferAttribute,
+		index2: number
+	): BufferAttribute;
+	copyArray( array: ArrayLike<number> ): BufferAttribute;
+	copyColorsArray(
+		colors: { r: number; g: number; b: number }[]
+	): BufferAttribute;
+	copyVector2sArray( vectors: { x: number; y: number }[] ): BufferAttribute;
+	copyVector3sArray(
+		vectors: { x: number; y: number; z: number }[]
+	): BufferAttribute;
+	copyVector4sArray(
+		vectors: { x: number; y: number; z: number; w: number }[]
+	): BufferAttribute;
+	set(
+		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;
+	setXYZW(
+		index: number,
+		x: number,
+		y: number,
+		z: number,
+		w: number
+	): BufferAttribute;
+	/**
    * @deprecated Use {@link BufferAttribute#count .count} instead.
    */
-  length: number;
+	length: number;
 
 }
 
@@ -148,89 +148,89 @@ export class Float64Attribute extends BufferAttribute {
 export class Int8BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Uint8BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Uint8ClampedBufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Int16BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Uint16BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Int32BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Uint32BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Float32BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }
 
 export class Float64BufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
-    itemSize: number,
-    normalized?: boolean
-  );
+		array: Iterable<number> | ArrayLike<number> | ArrayBuffer,
+		itemSize: number,
+		normalized?: boolean
+	);
 
 }

src/core/BufferGeometry.d.ts

@@ -24,121 +24,121 @@ export class BufferGeometry extends EventDispatcher {
    */
 	constructor();
 
-  static MaxIndex: number;
+	static MaxIndex: number;
 
-  /**
+	/**
    * Unique number of this buffergeometry instance
    */
-  id: number;
-  uuid: string;
-  name: string;
-  type: string;
-  index: BufferAttribute;
-  attributes: {
-    [name: string]: BufferAttribute | InterleavedBufferAttribute;
-  };
-  morphAttributes: any;
-  groups: { start: number; count: number; materialIndex?: number }[];
-  boundingBox: Box3;
-  boundingSphere: Sphere;
-  drawRange: { start: number; count: number };
-  userData: {[key: string]: any};
-
-  getIndex(): BufferAttribute;
-  setIndex( index: BufferAttribute | number[] ): void;
-
-  addAttribute(
-    name: string,
-    attribute: BufferAttribute | InterleavedBufferAttribute
-  ): BufferGeometry;
-
-  getAttribute( name: string ): BufferAttribute | InterleavedBufferAttribute;
-  removeAttribute( name: string ): BufferGeometry;
-
-  addGroup( start: number, count: number, materialIndex?: number ): void;
-  clearGroups(): void;
-
-  setDrawRange( start: number, count: number ): void;
-
-  /**
+	id: number;
+	uuid: string;
+	name: string;
+	type: string;
+	index: BufferAttribute;
+	attributes: {
+		[name: string]: BufferAttribute | InterleavedBufferAttribute;
+	};
+	morphAttributes: any;
+	groups: { start: number; count: number; materialIndex?: number }[];
+	boundingBox: Box3;
+	boundingSphere: Sphere;
+	drawRange: { start: number; count: number };
+	userData: {[key: string]: any};
+
+	getIndex(): BufferAttribute;
+	setIndex( index: BufferAttribute | number[] ): void;
+
+	addAttribute(
+		name: string,
+		attribute: BufferAttribute | InterleavedBufferAttribute
+	): BufferGeometry;
+
+	getAttribute( name: string ): BufferAttribute | InterleavedBufferAttribute;
+	removeAttribute( name: string ): BufferGeometry;
+
+	addGroup( start: number, count: number, materialIndex?: number ): void;
+	clearGroups(): 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;
+	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.
    * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are null.
    */
-  computeBoundingBox(): void;
+	computeBoundingBox(): void;
 
-  /**
+	/**
    * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.
    * Bounding spheres aren't' computed by default. They need to be explicitly computed, otherwise they are null.
    */
-  computeBoundingSphere(): void;
+	computeBoundingSphere(): void;
 
-  /**
+	/**
    * Computes vertex normals by averaging face normals.
    */
-  computeVertexNormals(): void;
+	computeVertexNormals(): void;
 
-  merge( geometry: BufferGeometry, offset: number ): BufferGeometry;
-  normalizeNormals(): void;
+	merge( geometry: BufferGeometry, offset: number ): BufferGeometry;
+	normalizeNormals(): void;
 
-  toNonIndexed(): BufferGeometry;
+	toNonIndexed(): BufferGeometry;
 
-  toJSON(): any;
-  clone(): this;
-  copy( source: BufferGeometry ): this;
+	toJSON(): any;
+	clone(): this;
+	copy( source: BufferGeometry ): this;
 
-  /**
+	/**
    * Disposes the object from memory.
    * You need to call this when you want the bufferGeometry removed while the application is running.
    */
-  dispose(): void;
+	dispose(): void;
 
-  /**
+	/**
    * @deprecated Use {@link BufferGeometry#groups .groups} instead.
    */
-  drawcalls: any;
+	drawcalls: any;
 
-  /**
+	/**
    * @deprecated Use {@link BufferGeometry#groups .groups} instead.
    */
-  offsets: any;
+	offsets: any;
 
-  /**
+	/**
    * @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;
+	clearDrawCalls(): void;
 
-  addAttribute( name: any, array: any, itemSize: any ): any;
+	addAttribute( name: any, array: any, itemSize: any ): any;
 
 }

src/core/Clock.d.ts

@@ -10,52 +10,52 @@ export class Clock {
    */
 	constructor( autoStart?: boolean );
 
-  /**
+	/**
    * If set, starts the clock automatically when the first update is called.
    */
-  autoStart: boolean;
+	autoStart: boolean;
 
-  /**
+	/**
    * When the clock is running, It holds the starttime of the clock.
    * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
    */
-  startTime: number;
+	startTime: number;
 
-  /**
+	/**
    * When the clock is running, It holds the previous time from a update.
    * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
    */
-  oldTime: number;
+	oldTime: number;
 
-  /**
+	/**
    * When the clock is running, It holds the time elapsed between the start of the clock to the previous update.
    * This parameter is in seconds of three decimal places.
    */
-  elapsedTime: number;
+	elapsedTime: number;
 
-  /**
+	/**
    * This property keeps track whether the clock is running or not.
    */
-  running: boolean;
+	running: boolean;
 
-  /**
+	/**
    * Starts clock.
    */
-  start(): void;
+	start(): void;
 
-  /**
+	/**
    * Stops clock.
    */
-  stop(): void;
+	stop(): void;
 
-  /**
+	/**
    * Get the seconds passed since the clock started.
    */
-  getElapsedTime(): number;
+	getElapsedTime(): number;
 
-  /**
+	/**
    * Get the seconds passed since the last call to this method.
    */
-  getDelta(): number;
+	getDelta(): number;
 
 }

src/core/DirectGeometry.d.ts

@@ -15,38 +15,38 @@ export class DirectGeometry extends EventDispatcher {
 
 	constructor();
 
-  id: number;
-  uuid: string;
-  name: string;
-  type: string;
-  indices: number[];
-  vertices: Vector3[];
-  normals: Vector3[];
-  colors: Color[];
-  uvs: Vector2[];
-  uvs2: Vector2[];
-  groups: { start: number; materialIndex: number }[];
-  morphTargets: MorphTarget[];
-  skinWeights: Vector4[];
-  skinIndices: Vector4[];
-  boundingBox: Box3;
-  boundingSphere: Sphere;
-  verticesNeedUpdate: boolean;
-  normalsNeedUpdate: boolean;
-  colorsNeedUpdate: boolean;
-  uvsNeedUpdate: boolean;
-  groupsNeedUpdate: boolean;
+	id: number;
+	uuid: string;
+	name: string;
+	type: string;
+	indices: number[];
+	vertices: Vector3[];
+	normals: Vector3[];
+	colors: Color[];
+	uvs: Vector2[];
+	uvs2: Vector2[];
+	groups: { start: number; materialIndex: number }[];
+	morphTargets: MorphTarget[];
+	skinWeights: Vector4[];
+	skinIndices: Vector4[];
+	boundingBox: Box3;
+	boundingSphere: Sphere;
+	verticesNeedUpdate: boolean;
+	normalsNeedUpdate: boolean;
+	colorsNeedUpdate: boolean;
+	uvsNeedUpdate: boolean;
+	groupsNeedUpdate: boolean;
 
-  computeBoundingBox(): void;
-  computeBoundingSphere(): void;
-  computeGroups( geometry: Geometry ): void;
-  fromGeometry( geometry: Geometry ): DirectGeometry;
-  dispose(): void;
+	computeBoundingBox(): void;
+	computeBoundingSphere(): void;
+	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;
+	// 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;
 
 }

src/core/Face3.d.ts

@@ -2,9 +2,9 @@ import { Vector3 } from './../math/Vector3';
 import { Color } from './../math/Color';
 
 export interface Event {
-  type: string;
-  target?: any;
-  [attachment: string]: any;
+	type: string;
+	target?: any;
+	[attachment: string]: any;
 }
 
 /**
@@ -28,79 +28,79 @@ export class Face3 {
    * @param materialIndex Material index.
    */
 	constructor(
-    a: number,
-    b: number,
-    c: number,
-    normal?: Vector3,
-    color?: Color,
-    materialIndex?: number
-  );
+		a: number,
+		b: number,
+		c: number,
+		normal?: Vector3,
+		color?: Color,
+		materialIndex?: number
+	);
 	constructor(
-    a: number,
-    b: number,
-    c: number,
-    normal?: Vector3,
-    vertexColors?: Color[],
-    materialIndex?: number
-  );
+		a: number,
+		b: number,
+		c: number,
+		normal?: Vector3,
+		vertexColors?: Color[],
+		materialIndex?: number
+	);
 	constructor(
-    a: number,
-    b: number,
-    c: number,
-    vertexNormals?: Vector3[],
-    color?: Color,
-    materialIndex?: number
-  );
+		a: number,
+		b: number,
+		c: number,
+		vertexNormals?: Vector3[],
+		color?: Color,
+		materialIndex?: number
+	);
 	constructor(
-    a: number,
-    b: number,
-    c: number,
-    vertexNormals?: Vector3[],
-    vertexColors?: Color[],
-    materialIndex?: number
-  );
+		a: number,
+		b: number,
+		c: number,
+		vertexNormals?: Vector3[],
+		vertexColors?: Color[],
+		materialIndex?: number
+	);
 
-  /**
+	/**
    * Vertex A index.
    */
-  a: number;
+	a: number;
 
-  /**
+	/**
    * Vertex B index.
    */
-  b: number;
+	b: number;
 
-  /**
+	/**
    * Vertex C index.
    */
-  c: number;
+	c: number;
 
-  /**
+	/**
    * Face normal.
    */
-  normal: Vector3;
+	normal: Vector3;
 
-  /**
+	/**
    * Array of 4 vertex normals.
    */
-  vertexNormals: Vector3[];
+	vertexNormals: Vector3[];
 
-  /**
+	/**
    * Face color.
    */
-  color: Color;
+	color: Color;
 
-  /**
+	/**
    * Array of 4 vertex normals.
    */
-  vertexColors: Color[];
+	vertexColors: Color[];
 
-  /**
+	/**
    * Material index (points to {@link Geometry.materials}).
    */
-  materialIndex: number;
+	materialIndex: number;
 
-  clone(): this;
-  copy( source: Face3 ): this;
+	clone(): this;
+	copy( source: Face3 ): this;
 
 }

src/core/Geometry.d.ts

@@ -18,18 +18,18 @@ import { EventDispatcher } from './EventDispatcher';
  */
 
 export interface MorphTarget {
-  name: string;
-  vertices: Vector3[];
+	name: string;
+	vertices: Vector3[];
 }
 
 export interface MorphColor {
-  name: string;
-  colors: Color[];
+	name: string;
+	colors: Color[];
 }
 
 export interface MorphNormals {
-  name: string;
-  normals: Vector3[];
+	name: string;
+	normals: Vector3[];
 }
 
 export let GeometryIdCount: number;
@@ -51,217 +51,217 @@ export class Geometry extends EventDispatcher {
 
 	constructor();
 
-  /**
+	/**
    * Unique number of this geometry instance
    */
-  id: number;
+	id: number;
 
-  uuid: string;
+	uuid: string;
 
-  /**
+	/**
    * Name for this geometry. Default is an empty string.
    */
-  name: string;
+	name: string;
 
-  type: string;
+	type: string;
 
-  /**
+	/**
    * The array of vertices hold every position of points of the model.
    * To signal an update in this array, Geometry.verticesNeedUpdate needs to be set to true.
    */
-  vertices: Vector3[];
+	vertices: Vector3[];
 
-  /**
+	/**
    * Array of vertex colors, matching number and order of vertices.
    * Used in ParticleSystem, Line and Ribbon.
    * Meshes use per-face-use-of-vertex colors embedded directly in faces.
    * To signal an update in this array, Geometry.colorsNeedUpdate needs to be set to true.
    */
-  colors: Color[];
+	colors: Color[];
 
-  /**
+	/**
    * Array of triangles or/and quads.
    * The array of faces describe how each vertex in the model is connected with each other.
    * To signal an update in this array, Geometry.elementsNeedUpdate needs to be set to true.
    */
-  faces: Face3[];
+	faces: Face3[];
 
-  /**
+	/**
    * Array of face UV layers.
    * Each UV layer is an array of UV matching order and number of vertices in faces.
    * To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true.
    */
-  faceVertexUvs: Vector2[][][];
+	faceVertexUvs: Vector2[][][];
 
-  /**
+	/**
    * Array of morph targets. Each morph target is a Javascript object:
    *
    *     { name: "targetName", vertices: [ new THREE.Vector3(), ... ] }
    *
    * Morph vertices match number and order of primary vertices.
    */
-  morphTargets: MorphTarget[];
+	morphTargets: MorphTarget[];
 
-  /**
+	/**
    * Array of morph normals. Morph normals have similar structure as morph targets, each normal set is a Javascript object:
    *
    *     morphNormal = { name: "NormalName", normals: [ new THREE.Vector3(), ... ] }
    */
-  morphNormals: MorphNormals[];
+	morphNormals: MorphNormals[];
 
-  /**
+	/**
    * Array of skinning weights, matching number and order of vertices.
    */
-  skinWeights: Vector4[];
+	skinWeights: Vector4[];
 
-  /**
+	/**
    * Array of skinning indices, matching number and order of vertices.
    */
-  skinIndices: Vector4[];
+	skinIndices: Vector4[];
 
-  /**
+	/**
    *
    */
-  lineDistances: number[];
+	lineDistances: number[];
 
-  /**
+	/**
    * Bounding box.
    */
-  boundingBox: Box3;
+	boundingBox: Box3;
 
-  /**
+	/**
    * Bounding sphere.
    */
-  boundingSphere: Sphere;
+	boundingSphere: Sphere;
 
-  /**
+	/**
    * Set to true if the vertices array has been updated.
    */
-  verticesNeedUpdate: boolean;
+	verticesNeedUpdate: boolean;
 
-  /**
+	/**
    * Set to true if the faces array has been updated.
    */
-  elementsNeedUpdate: boolean;
+	elementsNeedUpdate: boolean;
 
-  /**
+	/**
    * Set to true if the uvs array has been updated.
    */
-  uvsNeedUpdate: boolean;
+	uvsNeedUpdate: boolean;
 
-  /**
+	/**
    * Set to true if the normals array has been updated.
    */
-  normalsNeedUpdate: boolean;
+	normalsNeedUpdate: boolean;
 
-  /**
+	/**
    * Set to true if the colors array has been updated.
    */
-  colorsNeedUpdate: boolean;
+	colorsNeedUpdate: boolean;
 
-  /**
+	/**
    * Set to true if the linedistances array has been updated.
    */
-  lineDistancesNeedUpdate: boolean;
+	lineDistancesNeedUpdate: boolean;
 
-  /**
+	/**
    *
    */
-  groupsNeedUpdate: boolean;
+	groupsNeedUpdate: boolean;
 
-  /**
+	/**
    * 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;
+	center(): Geometry;
 
-  normalize(): Geometry;
+	normalize(): Geometry;
 
-  /**
+	/**
    * Computes face normals.
    */
-  computeFaceNormals(): void;
+	computeFaceNormals(): void;
 
-  /**
+	/**
    * 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.
    */
-  computeFlatVertexNormals(): void;
+	computeFlatVertexNormals(): void;
 
-  /**
+	/**
    * Computes morph normals.
    */
-  computeMorphNormals(): void;
+	computeMorphNormals(): void;
 
-  /**
+	/**
    * Computes bounding box of the geometry, updating {@link Geometry.boundingBox} attribute.
    */
-  computeBoundingBox(): void;
+	computeBoundingBox(): void;
 
-  /**
+	/**
    * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.
    * Neither bounding boxes or bounding spheres are computed by default. They need to be explicitly computed, otherwise they are null.
    */
-  computeBoundingSphere(): void;
+	computeBoundingSphere(): void;
 
-  merge(
-    geometry: Geometry,
-    matrix?: Matrix,
-    materialIndexOffset?: number
-  ): void;
+	merge(
+		geometry: Geometry,
+		matrix?: Matrix,
+		materialIndexOffset?: number
+	): void;
 
-  mergeMesh( mesh: Mesh ): void;
+	mergeMesh( mesh: Mesh ): void;
 
-  /**
+	/**
    * Checks for duplicate vertices using hashmap.
    * Duplicated vertices are removed and faces' vertices are updated.
    */
-  mergeVertices(): number;
+	mergeVertices(): number;
 
-  setFromPoints( points: Array<Vector2> | Array<Vector3> ): this;
+	setFromPoints( points: Array<Vector2> | Array<Vector3> ): this;
 
-  sortFacesByMaterialIndex(): void;
+	sortFacesByMaterialIndex(): void;
 
-  toJSON(): any;
+	toJSON(): any;
 
-  /**
+	/**
    * Creates a new clone of the Geometry.
    */
-  clone(): this;
+	clone(): this;
 
-  copy( source: Geometry ): this;
+	copy( source: Geometry ): this;
 
-  /**
+	/**
    * Removes The object from memory.
    * Don't forget to call this method when you remove an geometry because it can cuase meomory leaks.
    */
-  dispose(): void;
-
-  // These properties do not exist in a normal Geometry class, but if you use the instance that was passed by JSONLoader, it will be added.
-  bones: Bone[];
-  animation: AnimationClip;
-  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;
+	dispose(): void;
+
+	// These properties do not exist in a normal Geometry class, but if you use the instance that was passed by JSONLoader, it will be added.
+	bones: Bone[];
+	animation: AnimationClip;
+	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;
 
 }

src/core/InstancedBufferAttribute.d.ts

@@ -5,31 +5,31 @@ import { BufferAttribute } from './BufferAttribute';
  * @see <a href="https://github.com/mrdoob/three.js/blob/master/examples/js/BufferGeometryUtils.js">examples/js/BufferGeometryUtils.js</a>
  */
 export namespace BufferGeometryUtils {
-  export function mergeBufferGeometries(
-    geometries: BufferGeometry[]
-  ): BufferGeometry;
-  export function computeTangents( geometry: BufferGeometry ): null;
-  export function mergeBufferAttributes(
-    attributes: BufferAttribute[]
-  ): BufferAttribute;
+	export function mergeBufferGeometries(
+		geometries: BufferGeometry[]
+	): BufferGeometry;
+	export function computeTangents( geometry: BufferGeometry ): null;
+	export function mergeBufferAttributes(
+		attributes: BufferAttribute[]
+	): BufferAttribute;
 }
 
 /**
  * @deprecated
  */
 export namespace GeometryUtils {
-  /**
+	/**
    * @deprecated Use {@link Geometry#merge geometry.merge( geometry2, matrix, materialIndexOffset )} instead.
    */
-  export function merge(
-    geometry1: any,
-    geometry2: any,
-    materialIndexOffset?: any
-  ): any;
-  /**
+	export function merge(
+		geometry1: any,
+		geometry2: any,
+		materialIndexOffset?: any
+	): any;
+	/**
    * @deprecated Use {@link Geometry#center geometry.center()} instead.
    */
-  export function center( geometry: any ): any;
+	export function center( geometry: any ): any;
 }
 
 /**
@@ -38,12 +38,12 @@ export namespace GeometryUtils {
 export class InstancedBufferAttribute extends BufferAttribute {
 
 	constructor(
-    array: ArrayLike<number>,
-    itemSize: number,
-    normalized?: boolean,
-    meshPerAttribute?: number
-  );
+		array: ArrayLike<number>,
+		itemSize: number,
+		normalized?: boolean,
+		meshPerAttribute?: number
+	);
 
-  meshPerAttribute: number;
+	meshPerAttribute: number;
 
 }

src/core/InstancedBufferGeometry.d.ts

@@ -7,9 +7,9 @@ export class InstancedBufferGeometry extends BufferGeometry {
 
 	constructor();
 
-  groups: { start: number; count: number; instances: number }[];
-  maxInstancedCount: number;
+	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

@@ -6,11 +6,11 @@ import { InterleavedBuffer } from './InterleavedBuffer';
 export class InstancedInterleavedBuffer extends InterleavedBuffer {
 
 	constructor(
-    array: ArrayLike<number>,
-    stride: number,
-    meshPerAttribute?: number
-  );
+		array: ArrayLike<number>,
+		stride: number,
+		meshPerAttribute?: number
+	);
 
-  meshPerAttribute: number;
+	meshPerAttribute: number;
 
 }

src/core/InterleavedBuffer.d.ts

@@ -7,24 +7,24 @@ export class InterleavedBuffer {
 
 	constructor( array: ArrayLike<number>, stride: number );
 
-  array: ArrayLike<number>;
-  stride: number;
-  dynamic: boolean;
-  updateRange: { offset: number; count: number };
-  version: number;
-  length: number;
-  count: number;
-  needsUpdate: boolean;
+	array: ArrayLike<number>;
+	stride: number;
+	dynamic: boolean;
+	updateRange: { offset: number; count: number };
+	version: number;
+	length: number;
+	count: number;
+	needsUpdate: boolean;
 
-  setArray( array?: ArrayBufferView ): void;
-  setDynamic( dynamic: boolean ): InterleavedBuffer;
-  clone(): this;
-  copy( source: InterleavedBuffer ): this;
-  copyAt(
-    index1: number,
-    attribute: InterleavedBufferAttribute,
-    index2: number
-  ): InterleavedBuffer;
-  set( value: ArrayLike<number>, index: number ): InterleavedBuffer;
+	setArray( array?: ArrayBufferView ): void;
+	setDynamic( dynamic: boolean ): InterleavedBuffer;
+	clone(): this;
+	copy( source: InterleavedBuffer ): this;
+	copyAt(
+		index1: number,
+		attribute: InterleavedBufferAttribute,
+		index2: number
+	): InterleavedBuffer;
+	set( value: ArrayLike<number>, index: number ): InterleavedBuffer;
 
 }

src/core/InterleavedBufferAttribute.d.ts

@@ -5,45 +5,45 @@ import { InterleavedBuffer } from './InterleavedBuffer';
 export class InterleavedBufferAttribute {
 
 	constructor(
-    interleavedBuffer: InterleavedBuffer,
-    itemSize: number,
-    offset: number,
-    normalized?: boolean
-  );
+		interleavedBuffer: InterleavedBuffer,
+		itemSize: number,
+		offset: number,
+		normalized?: boolean
+	);
 
-  uuid: string;
-  data: InterleavedBuffer;
-  itemSize: number;
-  offset: number;
-  count: number;
-  normalized: boolean;
-  array: any[];
+	uuid: string;
+	data: InterleavedBuffer;
+	itemSize: number;
+	offset: number;
+	count: number;
+	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;
-  setXYZ(
-    index: number,
-    x: number,
-    y: number,
-    z: number
-  ): InterleavedBufferAttribute;
-  setXYZW(
-    index: number,
-    x: number,
-    y: number,
-    z: number,
-    w: 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,
+		y: number,
+		z: number
+	): InterleavedBufferAttribute;
+	setXYZW(
+		index: number,
+		x: number,
+		y: number,
+		z: number,
+		w: number
+	): InterleavedBufferAttribute;
+	/**
    * @deprecated Use {@link InterleavedBufferAttribute#count .count} instead.
    */
-  length: number;
+	length: number;
 
 }

src/core/Layers.d.ts

@@ -2,12 +2,12 @@ export class Layers {
 
 	constructor();
 
-  mask: number;
+	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

@@ -24,328 +24,328 @@ export class Object3D extends EventDispatcher {
 
 	constructor();
 
-  /**
+	/**
    * Unique number of this object instance.
    */
-  id: number;
+	id: number;
 
-  /**
+	/**
    *
    */
-  uuid: string;
+	uuid: string;
 
-  /**
+	/**
    * Optional name of the object (doesn't need to be unique).
    */
-  name: string;
+	name: string;
 
-  type: string;
+	type: string;
 
-  /**
+	/**
    * Object's parent in the scene graph.
    */
-  parent: Object3D | null;
+	parent: Object3D | null;
 
-  /**
+	/**
    * Array with object's children.
    */
-  children: Object3D[];
+	children: Object3D[];
 
-  /**
+	/**
    * Up direction.
    */
-  up: Vector3;
+	up: Vector3;
 
-  /**
+	/**
    * Object's local position.
    */
-  position: Vector3;
+	position: Vector3;
 
-  /**
+	/**
    * Object's local rotation (Euler angles), in radians.
    */
-  rotation: Euler;
+	rotation: Euler;
 
-  /**
+	/**
    * Global rotation.
    */
-  quaternion: Quaternion;
+	quaternion: Quaternion;
 
-  /**
+	/**
    * Object's local scale.
    */
-  scale: Vector3;
+	scale: Vector3;
 
-  modelViewMatrix: Matrix4;
+	modelViewMatrix: Matrix4;
 
-  normalMatrix: Matrix3;
+	normalMatrix: Matrix3;
 
-  /**
+	/**
    * Local transform.
    */
-  matrix: Matrix4;
+	matrix: Matrix4;
 
-  /**
+	/**
    * The global transform of the object. If the Object3d has no parent, then it's identical to the local transform.
    */
-  matrixWorld: Matrix4;
+	matrixWorld: Matrix4;
 
-  /**
+	/**
    * When this is set, it calculates the matrix of position, (rotation or quaternion) and scale every frame and also recalculates the matrixWorld property.
    */
-  matrixAutoUpdate: boolean;
+	matrixAutoUpdate: boolean;
 
-  /**
+	/**
    * When this is set, it calculates the matrixWorld in that frame and resets this property to false.
    */
-  matrixWorldNeedsUpdate: boolean;
+	matrixWorldNeedsUpdate: boolean;
 
-  layers: Layers;
-  /**
+	layers: Layers;
+	/**
    * Object gets rendered if true.
    */
-  visible: boolean;
+	visible: boolean;
 
-  /**
+	/**
    * Gets rendered into shadow map.
    */
-  castShadow: boolean;
+	castShadow: boolean;
 
-  /**
+	/**
    * Material gets baked in shadow receiving.
    */
-  receiveShadow: boolean;
+	receiveShadow: boolean;
 
-  /**
+	/**
    * When this is set, it checks every frame if the object is in the frustum of the camera. Otherwise the object gets drawn every frame even if it isn't visible.
    */
-  frustumCulled: boolean;
+	frustumCulled: boolean;
 
-  /**
+	/**
    * Overrides the default rendering order of scene graph objects, from lowest to highest renderOrder. Opaque and transparent objects remain sorted independently though. When this property is set for an instance of Group, all descendants objects will be sorted and rendered together.
    */
-  renderOrder: number;
+	renderOrder: number;
 
-  /**
+	/**
    * An object that can be used to store custom data about the Object3d. It should not hold references to functions as these will not be cloned.
    */
-  userData: { [key: string]: any };
+	userData: { [key: string]: any };
 
-  /**
+	/**
    * Custom depth material to be used when rendering to the depth map. Can only be used in context of meshes.
    * When shadow-casting with a DirectionalLight or SpotLight, if you are (a) modifying vertex positions in
    * the vertex shader, (b) using a displacement map, (c) using an alpha map with alphaTest, or (d) using a
    * transparent texture with alphaTest, you must specify a customDepthMaterial for proper shadows.
    */
-  customDepthMaterial: Material;
+	customDepthMaterial: Material;
 
-  /**
+	/**
    * Same as customDepthMaterial, but used with PointLight.
    */
-  customDistanceMaterial: Material;
+	customDistanceMaterial: Material;
 
-  /**
+	/**
    * Used to check whether this or derived classes are Object3Ds. Default is true.
    * You should not change this, as it is used internally for optimisation.
    */
-  isObject3D: true;
+	isObject3D: true;
 
-  /**
+	/**
    * Calls before rendering object
    */
-  onBeforeRender: (
-    renderer: WebGLRenderer,
-    scene: Scene,
-    camera: Camera,
-    geometry: Geometry | BufferGeometry,
-    material: Material,
-    group: Group
-  ) => void;
+	onBeforeRender: (
+		renderer: WebGLRenderer,
+		scene: Scene,
+		camera: Camera,
+		geometry: Geometry | BufferGeometry,
+		material: Material,
+		group: Group
+	) => void;
 
-  /**
+	/**
    * Calls after rendering object
    */
-  onAfterRender: (
-    renderer: WebGLRenderer,
-    scene: Scene,
-    camera: Camera,
-    geometry: Geometry | BufferGeometry,
-    material: Material,
-    group: Group
-  ) => void;
+	onAfterRender: (
+		renderer: WebGLRenderer,
+		scene: Scene,
+		camera: Camera,
+		geometry: Geometry | BufferGeometry,
+		material: Material,
+		group: Group
+	) => void;
 
-  static DefaultUp: Vector3;
-  static DefaultMatrixAutoUpdate: boolean;
+	static DefaultUp: Vector3;
+	static DefaultMatrixAutoUpdate: boolean;
 
-  /**
+	/**
    * 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.
    */
-  updateMatrix(): void;
+	updateMatrix(): void;
 
-  /**
+	/**
    * 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?: {
-    geometries: any;
-    materials: any;
-    textures: any;
-    images: any;
-  } ): any;
+	toJSON( meta?: {
+		geometries: any;
+		materials: any;
+		textures: any;
+		images: 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

@@ -6,22 +6,22 @@ import { Ray } from './../math/Ray';
 import { Camera } from './../cameras/Camera';
 
 export interface Intersection {
-  distance: number;
-  distanceToRay?: number;
-  point: Vector3;
-  index?: number;
-  face?: Face3 | null;
-  faceIndex?: number;
-  object: Object3D;
-  uv?: Vector2;
+	distance: number;
+	distanceToRay?: number;
+	point: Vector3;
+	index?: number;
+	face?: Face3 | null;
+	faceIndex?: number;
+	object: Object3D;
+	uv?: Vector2;
 }
 
 export interface RaycasterParameters {
-  Mesh?: any;
-  Line?: any;
-  LOD?: any;
-  Points?: { threshold: number };
-  Sprite?: any;
+	Mesh?: any;
+	Line?: any;
+	LOD?: any;
+	Points?: { threshold: number };
+	Sprite?: any;
 }
 
 export class Raycaster {
@@ -34,70 +34,70 @@ export class Raycaster {
    * @param far All results returned are closer then far. Far can't be lower then near . Default value is Infinity.
    */
 	constructor(
-    origin?: Vector3,
-    direction?: Vector3,
-    near?: number,
-    far?: number
-  );
+		origin?: Vector3,
+		direction?: Vector3,
+		near?: number,
+		far?: number
+	);
 
-  /** The Ray used for the raycasting. */
-  ray: Ray;
+	/** The Ray used for the raycasting. */
+	ray: Ray;
 
-  /**
+	/**
    * The near factor of the raycaster. This value indicates which objects can be discarded based on the
    * distance. This value shouldn't be negative and should be smaller than the far property.
    */
-  near: number;
+	near: number;
 
-  /**
+	/**
    * The far factor of the raycaster. This value indicates which objects can be discarded based on the
    * distance. This value shouldn't be negative and should be larger than the near property.
    */
-  far: number;
+	far: number;
 
-  params: RaycasterParameters;
+	params: RaycasterParameters;
 
-  /**
+	/**
    * The precision factor of the raycaster when intersecting Line objects.
    */
-  linePrecision: number;
+	linePrecision: number;
 
-  /**
+	/**
    * Updates the ray with a new origin and direction.
    * @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.
    * @param object The object to check for intersection with the ray.
    * @param recursive If true, it also checks all descendants. Otherwise it only checks intersecton with the object. Default is false.
    * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
    */
-  intersectObject(
-    object: Object3D,
-    recursive?: boolean,
-    optionalTarget?: Intersection[]
-  ): Intersection[];
+	intersectObject(
+		object: Object3D,
+		recursive?: boolean,
+		optionalTarget?: Intersection[]
+	): Intersection[];
 
-  /**
+	/**
    * Checks all intersection between the ray and the objects with or without the descendants. Intersections are returned sorted by distance, closest first. Intersections are of the same form as those returned by .intersectObject.
    * @param objects The objects to check for intersection with the ray.
    * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersecton with the objects. Default is false.
    * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
    */
-  intersectObjects(
-    objects: Object3D[],
-    recursive?: boolean,
-    optionalTarget?: Intersection[]
-  ): Intersection[];
+	intersectObjects(
+		objects: Object3D[],
+		recursive?: boolean,
+		optionalTarget?: Intersection[]
+	): Intersection[];
 
 }

src/core/Uniform.d.ts

@@ -5,20 +5,20 @@ export class Uniform {
    * @deprecated
    */
 	constructor( type: string, value: any );
-  /**
+	/**
    * @deprecated
    */
-  type: string;
-  value: any;
-  /**
+	type: string;
+	value: any;
+	/**
    * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
    */
-  dynamic: boolean;
-  onUpdateCallback: Function;
+	dynamic: boolean;
+	onUpdateCallback: Function;
 
-  /**
+	/**
    * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
    */
-  onUpdate( callback: Function ): Uniform;
+	onUpdate( callback: Function ): Uniform;
 
 }

src/extras/ImageUtils.d.ts

@@ -7,28 +7,28 @@ import { Texture } from '../textures/Texture';
  * @deprecated Use {@link TextureLoader} instead.
  */
 export namespace ImageUtils {
-  /**
+	/**
    * @deprecated
    */
-  export let crossOrigin: string;
+	export let crossOrigin: string;
 
-  /**
+	/**
    * @deprecated Use {@link TextureLoader THREE.TextureLoader()} instead.
    */
-  export function loadTexture(
-    url: string,
-    mapping?: Mapping,
-    onLoad?: ( texture: Texture ) => void,
-    onError?: ( message: string ) => void
-  ): Texture;
+	export function loadTexture(
+		url: string,
+		mapping?: Mapping,
+		onLoad?: ( texture: Texture ) => void,
+		onError?: ( message: string ) => void
+	): Texture;
 
-  /**
+	/**
    * @deprecated Use {@link CubeTextureLoader THREE.CubeTextureLoader()} instead.
    */
-  export function loadTextureCube(
-    array: string[],
-    mapping?: Mapping,
-    onLoad?: ( texture: Texture ) => void,
-    onError?: ( message: string ) => void
-  ): Texture;
+	export function loadTextureCube(
+		array: string[],
+		mapping?: Mapping,
+		onLoad?: ( texture: Texture ) => void,
+		onError?: ( message: string ) => void
+	): Texture;
 }

src/extras/ShapeUtils.d.ts

@@ -1,11 +1,11 @@
 interface Vec2 {
-  x: number;
-  y: number;
+	x: number;
+	y: number;
 }
 
 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

@@ -8,72 +8,72 @@ import { Vector } from './../../math/Vector2';
  */
 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.
    * Default is 200.
    */
-  arcLengthDivisions: number;
+	arcLengthDivisions: number;
 
-  /**
+	/**
    * 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
    */
-  getLength(): number;
+	getLength(): number;
 
-  /**
+	/**
    * Get list of cumulative segment lengths
    */
-  getLengths( divisions?: number ): number[];
+	getLengths( divisions?: number ): number[];
 
-  /**
+	/**
    * Update the cumlative segment distance cache
    */
-  updateArcLengths(): void;
+	updateArcLengths(): void;
 
-  /**
+	/**
    * 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

@@ -6,30 +6,30 @@ export class CurvePath<T extends Vector> extends Curve<T> {
 
 	constructor();
 
-  curves: Curve<T>[];
-  autoClose: boolean;
+	curves: Curve<T>[];
+	autoClose: boolean;
 
-  add( curve: Curve<T> ): void;
-  checkConnection(): boolean;
-  closePath(): void;
-  getPoint( t: number ): T;
-  getLength(): number;
-  updateArcLengths(): void;
-  getCurveLengths(): number[];
-  getSpacedPoints( divisions?: number ): T[];
-  getPoints( divisions?: number ): T[];
+	add( curve: Curve<T> ): void;
+	checkConnection(): boolean;
+	closePath(): void;
+	getPoint( t: number ): T;
+	getLength(): number;
+	updateArcLengths(): void;
+	getCurveLengths(): number[];
+	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

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

src/extras/core/Path.d.ts

@@ -2,18 +2,18 @@ import { Vector2 } from './../../math/Vector2';
 import { CurvePath } from './CurvePath';
 
 export enum PathActions {
-  MOVE_TO,
-  LINE_TO,
-  QUADRATIC_CURVE_TO, // Bezier quadratic curve
-  BEZIER_CURVE_TO, // Bezier cubic curve
-  CSPLINE_THRU, // Catmull-rom spline
-  ARC, // Circle
-  ELLIPSE,
+	MOVE_TO,
+	LINE_TO,
+	QUADRATIC_CURVE_TO, // Bezier quadratic curve
+	BEZIER_CURVE_TO, // Bezier cubic curve
+	CSPLINE_THRU, // Catmull-rom spline
+	ARC, // Circle
+	ELLIPSE,
 }
 
 export interface PathAction {
-  action: PathActions;
-  args: any;
+	action: PathActions;
+	args: any;
 }
 
 /**
@@ -23,60 +23,60 @@ export class Path extends CurvePath<Vector2> {
 
 	constructor( points?: Vector2[] );
 
-  currentPoint: 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;
-  bezierCurveTo(
-    aCP1x: number,
-    aCP1y: number,
-    aCP2x: number,
-    aCP2y: number,
-    aX: number,
-    aY: number
-  ): void;
-  splineThru( pts: Vector2[] ): void;
-  arc(
-    aX: number,
-    aY: number,
-    aRadius: number,
-    aStartAngle: number,
-    aEndAngle: number,
-    aClockwise: boolean
-  ): void;
-  absarc(
-    aX: number,
-    aY: number,
-    aRadius: number,
-    aStartAngle: number,
-    aEndAngle: number,
-    aClockwise: boolean
-  ): void;
-  ellipse(
-    aX: number,
-    aY: number,
-    xRadius: number,
-    yRadius: number,
-    aStartAngle: number,
-    aEndAngle: number,
-    aClockwise: boolean,
-    aRotation: number
-  ): void;
-  absellipse(
-    aX: number,
-    aY: number,
-    xRadius: number,
-    yRadius: number,
-    aStartAngle: number,
-    aEndAngle: number,
-    aClockwise: boolean,
-    aRotation: 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,
+		aCP2x: number,
+		aCP2y: number,
+		aX: number,
+		aY: number
+	): void;
+	splineThru( pts: Vector2[] ): void;
+	arc(
+		aX: number,
+		aY: number,
+		aRadius: number,
+		aStartAngle: number,
+		aEndAngle: number,
+		aClockwise: boolean
+	): void;
+	absarc(
+		aX: number,
+		aY: number,
+		aRadius: number,
+		aStartAngle: number,
+		aEndAngle: number,
+		aClockwise: boolean
+	): void;
+	ellipse(
+		aX: number,
+		aY: number,
+		xRadius: number,
+		yRadius: number,
+		aStartAngle: number,
+		aEndAngle: number,
+		aClockwise: boolean,
+		aRotation: number
+	): void;
+	absellipse(
+		aX: number,
+		aY: number,
+		xRadius: number,
+		yRadius: number,
+		aStartAngle: number,
+		aEndAngle: number,
+		aClockwise: boolean,
+		aRotation: number
+	): void;
 
 }

src/extras/core/Shape.d.ts

@@ -10,28 +10,28 @@ export class Shape extends Path {
 
 	constructor( points?: Vector2[] );
 
-  holes: Path[];
+	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.
    */
-  extractAllPoints(
-    divisions: number
-  ): {
-    shape: Vector2[];
-    holes: Vector2[][];
-  };
-  extractPoints( divisions: number ): Vector2[];
+	extractAllPoints(
+		divisions: number
+	): {
+		shape: Vector2[];
+		holes: Vector2[][];
+	};
+	extractPoints( divisions: number ): Vector2[];
 
 }

src/extras/core/ShapePath.d.ts

@@ -5,21 +5,21 @@ export class ShapePath {
 
 	constructor();
 
-  subPaths: any[];
-  currentPath: any;
+	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;
-  bezierCurveTo(
-    aCP1x: number,
-    aCP1y: number,
-    aCP2x: number,
-    aCP2y: number,
-    aX: number,
-    aY: number
-  ): void;
-  splineThru( pts: Vector2[] ): void;
-  toShapes( isCCW: boolean, noHoles: any ): Shape[];
+	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,
+		aCP2x: number,
+		aCP2y: number,
+		aX: number,
+		aY: number
+	): void;
+	splineThru( pts: Vector2[] ): void;
+	toShapes( isCCW: boolean, noHoles: any ): Shape[];
 
 }

src/extras/curves/ArcCurve.d.ts

@@ -2,12 +2,12 @@ import { EllipseCurve } from './EllipseCurve';
 export class ArcCurve extends EllipseCurve {
 
 	constructor(
-    aX: number,
-    aY: number,
-    aRadius: number,
-    aStartAngle: number,
-    aEndAngle: number,
-    aClockwise: boolean
-  );
+		aX: number,
+		aY: number,
+		aRadius: number,
+		aStartAngle: number,
+		aEndAngle: number,
+		aClockwise: boolean
+	);
 
 }

src/extras/curves/CatmullRomCurve3.d.ts

@@ -3,46 +3,46 @@ import { Curve } from './../core/Curve';
 
 // Extras / Curves /////////////////////////////////////////////////////////////////////
 export namespace CurveUtils {
-  export function tangentQuadraticBezier(
-    t: number,
-    p0: number,
-    p1: number,
-    p2: number
-  ): number;
-  export function tangentCubicBezier(
-    t: number,
-    p0: number,
-    p1: number,
-    p2: number,
-    p3: number
-  ): number;
-  export function tangentSpline(
-    t: number,
-    p0: number,
-    p1: number,
-    p2: number,
-    p3: number
-  ): number;
-  export function interpolate(
-    p0: number,
-    p1: number,
-    p2: number,
-    p3: number,
-    t: number
-  ): number;
+	export function tangentQuadraticBezier(
+		t: number,
+		p0: number,
+		p1: number,
+		p2: number
+	): number;
+	export function tangentCubicBezier(
+		t: number,
+		p0: number,
+		p1: number,
+		p2: number,
+		p3: number
+	): number;
+	export function tangentSpline(
+		t: number,
+		p0: number,
+		p1: number,
+		p2: number,
+		p3: number
+	): number;
+	export function interpolate(
+		p0: number,
+		p1: number,
+		p2: number,
+		p3: number,
+		t: number
+	): number;
 }
 
 export class CatmullRomCurve3 extends Curve<Vector3> {
 
 	constructor(
-    points?: Vector3[],
-    closed?: boolean,
-    curveType?: string,
-    tension?: number
-  );
+		points?: Vector3[],
+		closed?: boolean,
+		curveType?: string,
+		tension?: number
+	);
 
-  points: Vector3[];
+	points: Vector3[];
 
-  getPoint( t: number ): Vector3;
+	getPoint( t: number ): Vector3;
 
 }

src/extras/curves/CubicBezierCurve.d.ts

@@ -5,9 +5,9 @@ export class CubicBezierCurve extends Curve<Vector2> {
 
 	constructor( v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2 );
 
-  v0: Vector2;
-  v1: Vector2;
-  v2: Vector2;
-  v3: Vector2;
+	v0: Vector2;
+	v1: Vector2;
+	v2: Vector2;
+	v3: Vector2;
 
 }

src/extras/curves/CubicBezierCurve3.d.ts

@@ -5,11 +5,11 @@ export class CubicBezierCurve3 extends Curve<Vector3> {
 
 	constructor( v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3 );
 
-  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

@@ -4,23 +4,23 @@ import { Vector2 } from '../../math/Vector2';
 export class EllipseCurve extends Curve<Vector2> {
 
 	constructor(
-    aX: number,
-    aY: number,
-    xRadius: number,
-    yRadius: number,
-    aStartAngle: number,
-    aEndAngle: number,
-    aClockwise: boolean,
-    aRotation: number
-  );
+		aX: number,
+		aY: number,
+		xRadius: number,
+		yRadius: number,
+		aStartAngle: number,
+		aEndAngle: number,
+		aClockwise: boolean,
+		aRotation: number
+	);
 
-  aX: number;
-  aY: number;
-  xRadius: number;
-  yRadius: number;
-  aStartAngle: number;
-  aEndAngle: number;
-  aClockwise: boolean;
-  aRotation: number;
+	aX: number;
+	aY: number;
+	xRadius: number;
+	yRadius: number;
+	aStartAngle: number;
+	aEndAngle: number;
+	aClockwise: boolean;
+	aRotation: number;
 
 }

src/extras/curves/LineCurve.d.ts

@@ -5,7 +5,7 @@ export class LineCurve extends Curve<Vector2> {
 
 	constructor( v1: Vector2, v2: Vector2 );
 
-  v1: Vector2;
-  v2: Vector2;
+	v1: Vector2;
+	v2: Vector2;
 
 }

src/extras/curves/LineCurve3.d.ts

@@ -5,9 +5,9 @@ export class LineCurve3 extends Curve<Vector3> {
 
 	constructor( v1: Vector3, v2: Vector3 );
 
-  v1: Vector3;
-  v2: Vector3;
+	v1: Vector3;
+	v2: Vector3;
 
-  getPoint( t: number ): Vector3;
+	getPoint( t: number ): Vector3;
 
 }

src/extras/curves/QuadraticBezierCurve.d.ts

@@ -5,8 +5,8 @@ export class QuadraticBezierCurve extends Curve<Vector2> {
 
 	constructor( v0: Vector2, v1: Vector2, v2: Vector2 );
 
-  v0: Vector2;
-  v1: Vector2;
-  v2: Vector2;
+	v0: Vector2;
+	v1: Vector2;
+	v2: Vector2;
 
 }

src/extras/curves/QuadraticBezierCurve3.d.ts

@@ -5,10 +5,10 @@ export class QuadraticBezierCurve3 extends Curve<Vector3> {
 
 	constructor( v0: Vector3, v1: Vector3, v2: Vector3 );
 
-  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

@@ -5,6 +5,6 @@ export class SplineCurve extends Curve<Vector2> {
 
 	constructor( points?: Vector2[] );
 
-  points: Vector2[];
+	points: Vector2[];
 
 }

src/extras/objects/ImmediateRenderObject.d.ts

@@ -14,7 +14,7 @@ export class ImmediateRenderObject extends Object3D {
 
 	constructor( material: Material );
 
-  material: Material;
-  render( renderCallback: Function ): void;
+	material: Material;
+	render( renderCallback: Function ): void;
 
 }

src/geometries/BoxGeometry.d.ts

@@ -5,22 +5,22 @@ import { BufferGeometry } from '../core/BufferGeometry';
 export class BoxBufferGeometry extends BufferGeometry {
 
 	constructor(
-    width?: number,
-    height?: number,
-    depth?: number,
-    widthSegments?: number,
-    heightSegments?: number,
-    depthSegments?: number
-  );
-
-  parameters: {
-    width: number;
-    height: number;
-    depth: number;
-    widthSegments: number;
-    heightSegments: number;
-    depthSegments: number;
-  };
+		width?: number,
+		height?: number,
+		depth?: number,
+		widthSegments?: number,
+		heightSegments?: number,
+		depthSegments?: number
+	);
+
+	parameters: {
+		width: number;
+		height: number;
+		depth: number;
+		widthSegments: number;
+		heightSegments: number;
+		depthSegments: number;
+	};
 
 }
 
@@ -38,21 +38,21 @@ export class BoxGeometry extends Geometry {
    * @param depthSegments — Number of segmented faces along the depth of the sides.
    */
 	constructor(
-    width?: number,
-    height?: number,
-    depth?: number,
-    widthSegments?: number,
-    heightSegments?: number,
-    depthSegments?: number
-  );
-
-  parameters: {
-    width: number;
-    height: number;
-    depth: number;
-    widthSegments: number;
-    heightSegments: number;
-    depthSegments: number;
-  };
+		width?: number,
+		height?: number,
+		depth?: number,
+		widthSegments?: number,
+		heightSegments?: number,
+		depthSegments?: number
+	);
+
+	parameters: {
+		width: number;
+		height: number;
+		depth: number;
+		widthSegments: number;
+		heightSegments: number;
+		depthSegments: number;
+	};
 
 }

src/geometries/CircleGeometry.d.ts

@@ -7,35 +7,35 @@ import { BufferGeometry } from '../core/BufferGeometry';
 export class CircleBufferGeometry extends BufferGeometry {
 
 	constructor(
-    radius?: number,
-    segments?: number,
-    thetaStart?: number,
-    thetaLength?: number
-  );
-
-  parameters: {
-    radius: number;
-    segments: number;
-    thetaStart: number;
-    thetaLength: number;
-  };
+		radius?: number,
+		segments?: number,
+		thetaStart?: number,
+		thetaLength?: number
+	);
+
+	parameters: {
+		radius: number;
+		segments: number;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }
 
 export class CircleGeometry extends Geometry {
 
 	constructor(
-    radius?: number,
-    segments?: number,
-    thetaStart?: number,
-    thetaLength?: number
-  );
-
-  parameters: {
-    radius: number;
-    segments: number;
-    thetaStart: number;
-    thetaLength: number;
-  };
+		radius?: number,
+		segments?: number,
+		thetaStart?: number,
+		thetaLength?: number
+	);
+
+	parameters: {
+		radius: number;
+		segments: number;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }

src/geometries/ConeGeometry.d.ts

@@ -4,27 +4,27 @@ import { CylinderBufferGeometry } from './CylinderGeometry';
 export class ConeBufferGeometry extends CylinderBufferGeometry {
 
 	constructor(
-    radius?: number,
-    height?: number,
-    radialSegment?: number,
-    heightSegment?: number,
-    openEnded?: boolean,
-    thetaStart?: number,
-    thetaLength?: number
-  );
+		radius?: number,
+		height?: number,
+		radialSegment?: number,
+		heightSegment?: number,
+		openEnded?: boolean,
+		thetaStart?: number,
+		thetaLength?: number
+	);
 
 }
 
 export class ConeGeometry extends CylinderGeometry {
 
 	constructor(
-    radius?: number,
-    height?: number,
-    radialSegment?: number,
-    heightSegment?: number,
-    openEnded?: boolean,
-    thetaStart?: number,
-    thetaLength?: number
-  );
+		radius?: number,
+		height?: number,
+		radialSegment?: number,
+		heightSegment?: number,
+		openEnded?: boolean,
+		thetaStart?: number,
+		thetaLength?: number
+	);
 
 }

src/geometries/CylinderGeometry.d.ts

@@ -4,26 +4,26 @@ import { BufferGeometry } from '../core/BufferGeometry';
 export class CylinderBufferGeometry extends BufferGeometry {
 
 	constructor(
-    radiusTop?: number,
-    radiusBottom?: number,
-    height?: number,
-    radialSegments?: number,
-    heightSegments?: number,
-    openEnded?: boolean,
-    thetaStart?: number,
-    thetaLength?: number
-  );
-
-  parameters: {
-    radiusTop: number;
-    radiusBottom: number;
-    height: number;
-    radialSegments: number;
-    heightSegments: number;
-    openEnded: boolean;
-    thetaStart: number;
-    thetaLength: number;
-  };
+		radiusTop?: number,
+		radiusBottom?: number,
+		height?: number,
+		radialSegments?: number,
+		heightSegments?: number,
+		openEnded?: boolean,
+		thetaStart?: number,
+		thetaLength?: number
+	);
+
+	parameters: {
+		radiusTop: number;
+		radiusBottom: number;
+		height: number;
+		radialSegments: number;
+		heightSegments: number;
+		openEnded: boolean;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }
 
@@ -38,25 +38,25 @@ export class CylinderGeometry extends Geometry {
    * @param openEnded - A Boolean indicating whether or not to cap the ends of the cylinder.
    */
 	constructor(
-    radiusTop?: number,
-    radiusBottom?: number,
-    height?: number,
-    radiusSegments?: number,
-    heightSegments?: number,
-    openEnded?: boolean,
-    thetaStart?: number,
-    thetaLength?: number
-  );
-
-  parameters: {
-    radiusTop: number;
-    radiusBottom: number;
-    height: number;
-    radialSegments: number;
-    heightSegments: number;
-    openEnded: boolean;
-    thetaStart: number;
-    thetaLength: number;
-  };
+		radiusTop?: number,
+		radiusBottom?: number,
+		height?: number,
+		radiusSegments?: number,
+		heightSegments?: number,
+		openEnded?: boolean,
+		thetaStart?: number,
+		thetaLength?: number
+	);
+
+	parameters: {
+		radiusTop: number;
+		radiusBottom: number;
+		height: number;
+		radialSegments: number;
+		heightSegments: number;
+		openEnded: boolean;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }

src/geometries/DodecahedronGeometry.d.ts

@@ -11,9 +11,9 @@ export class DodecahedronGeometry extends Geometry {
 
 	constructor( radius?: number, detail?: number );
 
-  parameters: {
-    radius: number;
-    detail: number;
-  };
+	parameters: {
+		radius: number;
+		detail: number;
+	};
 
 }

src/geometries/ExtrudeGeometry.d.ts

@@ -7,44 +7,44 @@ import { Geometry } from './../core/Geometry';
 import { BufferGeometry } from './../core/BufferGeometry';
 
 export interface ExtrudeGeometryOptions {
-  curveSegments?: number;
-  steps?: number;
-  depth?: number;
-  bevelEnabled?: boolean;
-  bevelThickness?: number;
-  bevelSize?: number;
-  bevelOffset?: number;
-  bevelSegments?: number;
-  extrudePath?: CurvePath<Vector3>;
-  UVGenerator?: UVGenerator;
+	curveSegments?: number;
+	steps?: number;
+	depth?: number;
+	bevelEnabled?: boolean;
+	bevelThickness?: number;
+	bevelSize?: number;
+	bevelOffset?: number;
+	bevelSegments?: number;
+	extrudePath?: CurvePath<Vector3>;
+	UVGenerator?: UVGenerator;
 }
 
 export interface UVGenerator {
-  generateTopUV(
-    geometry: ExtrudeBufferGeometry,
-    vertices: number[],
-    indexA: number,
-    indexB: number,
-    indexC: number
-  ): Vector2[];
-  generateSideWallUV(
-    geometry: ExtrudeBufferGeometry,
-    vertices: number[],
-    indexA: number,
-    indexB: number,
-    indexC: number,
-    indexD: number
-  ): Vector2[];
+	generateTopUV(
+		geometry: ExtrudeBufferGeometry,
+		vertices: number[],
+		indexA: number,
+		indexB: number,
+		indexC: number
+	): Vector2[];
+	generateSideWallUV(
+		geometry: ExtrudeBufferGeometry,
+		vertices: number[],
+		indexA: number,
+		indexB: number,
+		indexC: number,
+		indexD: number
+	): Vector2[];
 }
 
 export class ExtrudeBufferGeometry extends BufferGeometry {
 
 	constructor( shapes: Shape | Shape[], options?: ExtrudeGeometryOptions );
 
-  static WorldUVGenerator: UVGenerator;
+	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;
 
 }
 
@@ -52,9 +52,9 @@ export class ExtrudeGeometry extends Geometry {
 
 	constructor( shapes: Shape | Shape[], options?: ExtrudeGeometryOptions );
 
-  static WorldUVGenerator: UVGenerator;
+	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/LatheGeometry.d.ts

@@ -5,35 +5,35 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class LatheBufferGeometry extends BufferGeometry {
 
 	constructor(
-    points: Vector2[],
-    segments?: number,
-    phiStart?: number,
-    phiLength?: number
-  );
-
-  parameters: {
-    points: Vector2[];
-    segments: number;
-    phiStart: number;
-    phiLength: number;
-  };
+		points: Vector2[],
+		segments?: number,
+		phiStart?: number,
+		phiLength?: number
+	);
+
+	parameters: {
+		points: Vector2[];
+		segments: number;
+		phiStart: number;
+		phiLength: number;
+	};
 
 }
 
 export class LatheGeometry extends Geometry {
 
 	constructor(
-    points: Vector2[],
-    segments?: number,
-    phiStart?: number,
-    phiLength?: number
-  );
-
-  parameters: {
-    points: Vector2[];
-    segments: number;
-    phiStart: number;
-    phiLength: number;
-  };
+		points: Vector2[],
+		segments?: number,
+		phiStart?: number,
+		phiLength?: number
+	);
+
+	parameters: {
+		points: Vector2[];
+		segments: number;
+		phiStart: number;
+		phiLength: number;
+	};
 
 }

src/geometries/ParametricGeometry.d.ts

@@ -5,31 +5,31 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class ParametricBufferGeometry extends BufferGeometry {
 
 	constructor(
-    func: ( u: number, v: number, dest: Vector3 ) => void,
-    slices: number,
-    stacks: number
-  );
+		func: ( u: number, v: number, dest: Vector3 ) => void,
+		slices: number,
+		stacks: number
+	);
 
-  parameters: {
-    func: ( u: number, v: number, dest: Vector3 ) => void;
-    slices: number;
-    stacks: number;
-  };
+	parameters: {
+		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,
-    slices: number,
-    stacks: number
-  );
-
-  parameters: {
-    func: ( u: number, v: number, dest: Vector3 ) => void;
-    slices: number;
-    stacks: number;
-  };
+		func: ( u: number, v: number, dest: Vector3 ) => void,
+		slices: number,
+		stacks: number
+	);
+
+	parameters: {
+		func: ( u: number, v: number, dest: Vector3 ) => void;
+		slices: number;
+		stacks: number;
+	};
 
 }

src/geometries/PlaneGeometry.d.ts

@@ -4,35 +4,35 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class PlaneBufferGeometry extends BufferGeometry {
 
 	constructor(
-    width?: number,
-    height?: number,
-    widthSegments?: number,
-    heightSegments?: number
-  );
-
-  parameters: {
-    width: number;
-    height: number;
-    widthSegments: number;
-    heightSegments: number;
-  };
+		width?: number,
+		height?: number,
+		widthSegments?: number,
+		heightSegments?: number
+	);
+
+	parameters: {
+		width: number;
+		height: number;
+		widthSegments: number;
+		heightSegments: number;
+	};
 
 }
 
 export class PlaneGeometry extends Geometry {
 
 	constructor(
-    width?: number,
-    height?: number,
-    widthSegments?: number,
-    heightSegments?: number
-  );
-
-  parameters: {
-    width: number;
-    height: number;
-    widthSegments: number;
-    heightSegments: number;
-  };
+		width?: number,
+		height?: number,
+		widthSegments?: number,
+		heightSegments?: number
+	);
+
+	parameters: {
+		width: number;
+		height: number;
+		widthSegments: number;
+		heightSegments: number;
+	};
 
 }

src/geometries/PolyhedronGeometry.d.ts

@@ -5,36 +5,36 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class PolyhedronBufferGeometry extends BufferGeometry {
 
 	constructor(
-    vertices: number[],
-    indices: number[],
-    radius?: number,
-    detail?: number
-  );
-
-  parameters: {
-    vertices: number[];
-    indices: number[];
-    radius: number;
-    detail: number;
-  };
+		vertices: number[],
+		indices: number[],
+		radius?: number,
+		detail?: number
+	);
+
+	parameters: {
+		vertices: number[];
+		indices: number[];
+		radius: number;
+		detail: number;
+	};
 
 }
 
 export class PolyhedronGeometry extends Geometry {
 
 	constructor(
-    vertices: number[],
-    indices: number[],
-    radius?: number,
-    detail?: number
-  );
-
-  parameters: {
-    vertices: number[];
-    indices: number[];
-    radius: number;
-    detail: number;
-  };
-  boundingSphere: Sphere;
+		vertices: number[],
+		indices: number[],
+		radius?: number,
+		detail?: number
+	);
+
+	parameters: {
+		vertices: number[];
+		indices: number[];
+		radius: number;
+		detail: number;
+	};
+	boundingSphere: Sphere;
 
 }

src/geometries/RingGeometry.d.ts

@@ -4,43 +4,43 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class RingBufferGeometry extends BufferGeometry {
 
 	constructor(
-    innerRadius?: number,
-    outerRadius?: number,
-    thetaSegments?: number,
-    phiSegments?: number,
-    thetaStart?: number,
-    thetaLength?: number
-  );
-
-  parameters: {
-    innerRadius: number;
-    outerRadius: number;
-    thetaSegments: number;
-    phiSegments: number;
-    thetaStart: number;
-    thetaLength: number;
-  };
+		innerRadius?: number,
+		outerRadius?: number,
+		thetaSegments?: number,
+		phiSegments?: number,
+		thetaStart?: number,
+		thetaLength?: number
+	);
+
+	parameters: {
+		innerRadius: number;
+		outerRadius: number;
+		thetaSegments: number;
+		phiSegments: number;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }
 
 export class RingGeometry extends Geometry {
 
 	constructor(
-    innerRadius?: number,
-    outerRadius?: number,
-    thetaSegments?: number,
-    phiSegments?: number,
-    thetaStart?: number,
-    thetaLength?: number
-  );
-
-  parameters: {
-    innerRadius: number;
-    outerRadius: number;
-    thetaSegments: number;
-    phiSegments: number;
-    thetaStart: number;
-    thetaLength: number;
-  };
+		innerRadius?: number,
+		outerRadius?: number,
+		thetaSegments?: number,
+		phiSegments?: number,
+		thetaStart?: number,
+		thetaLength?: number
+	);
+
+	parameters: {
+		innerRadius: number;
+		outerRadius: number;
+		thetaSegments: number;
+		phiSegments: number;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }

src/geometries/SphereGeometry.d.ts

@@ -4,24 +4,24 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class SphereBufferGeometry extends BufferGeometry {
 
 	constructor(
-    radius?: number,
-    widthSegments?: number,
-    heightSegments?: number,
-    phiStart?: number,
-    phiLength?: number,
-    thetaStart?: number,
-    thetaLength?: number
-  );
+		radius?: number,
+		widthSegments?: number,
+		heightSegments?: number,
+		phiStart?: number,
+		phiLength?: number,
+		thetaStart?: number,
+		thetaLength?: number
+	);
 
-  parameters: {
-    radius: number;
-    widthSegments: number;
-    heightSegments: number;
-    phiStart: number;
-    phiLength: number;
-    thetaStart: number;
-    thetaLength: number;
-  };
+	parameters: {
+		radius: number;
+		widthSegments: number;
+		heightSegments: number;
+		phiStart: number;
+		phiLength: number;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }
 
@@ -42,23 +42,23 @@ export class SphereGeometry extends Geometry {
    * @param thetaLength — specify vertical sweep angle size. Default is Math.PI.
    */
 	constructor(
-    radius?: number,
-    widthSegments?: number,
-    heightSegments?: number,
-    phiStart?: number,
-    phiLength?: number,
-    thetaStart?: number,
-    thetaLength?: number
-  );
+		radius?: number,
+		widthSegments?: number,
+		heightSegments?: number,
+		phiStart?: number,
+		phiLength?: number,
+		thetaStart?: number,
+		thetaLength?: number
+	);
 
-  parameters: {
-    radius: number;
-    widthSegments: number;
-    heightSegments: number;
-    phiStart: number;
-    phiLength: number;
-    thetaStart: number;
-    thetaLength: number;
-  };
+	parameters: {
+		radius: number;
+		widthSegments: number;
+		heightSegments: number;
+		phiStart: number;
+		phiLength: number;
+		thetaStart: number;
+		thetaLength: number;
+	};
 
 }

src/geometries/TextGeometry.d.ts

@@ -2,32 +2,32 @@ import { Font } from './../extras/core/Font';
 import { ExtrudeGeometry, ExtrudeBufferGeometry } from './ExtrudeGeometry';
 
 export interface TextGeometryParameters {
-  font?: Font;
-  size?: number;
-  height?: number;
-  curveSegments?: number;
-  bevelEnabled?: boolean;
-  bevelThickness?: number;
-  bevelSize?: number;
-  bevelOffset?: number;
-  bevelSegments?: number;
+	font?: Font;
+	size?: number;
+	height?: number;
+	curveSegments?: number;
+	bevelEnabled?: boolean;
+	bevelThickness?: number;
+	bevelSize?: number;
+	bevelOffset?: number;
+	bevelSegments?: number;
 }
 
 export class TextBufferGeometry extends ExtrudeBufferGeometry {
 
 	constructor( text: string, parameters?: TextGeometryParameters );
 
-  parameters: {
-    font: Font;
-    size: number;
-    height: number;
-    curveSegments: number;
-    bevelEnabled: boolean;
-    bevelThickness: number;
-    bevelSize: number;
-    bevelOffset: number;
-    bevelSegments: number;
-  };
+	parameters: {
+		font: Font;
+		size: number;
+		height: number;
+		curveSegments: number;
+		bevelEnabled: boolean;
+		bevelThickness: number;
+		bevelSize: number;
+		bevelOffset: number;
+		bevelSegments: number;
+	};
 
 }
 
@@ -35,16 +35,16 @@ export class TextGeometry extends ExtrudeGeometry {
 
 	constructor( text: string, parameters?: TextGeometryParameters );
 
-  parameters: {
-    font: Font;
-    size: number;
-    height: number;
-    curveSegments: number;
-    bevelEnabled: boolean;
-    bevelThickness: number;
-    bevelSize: number;
-    bevelOffset: number;
-    bevelSegments: number;
-  };
+	parameters: {
+		font: Font;
+		size: number;
+		height: number;
+		curveSegments: number;
+		bevelEnabled: boolean;
+		bevelThickness: number;
+		bevelSize: number;
+		bevelOffset: number;
+		bevelSegments: number;
+	};
 
 }

src/geometries/TorusGeometry.d.ts

@@ -4,39 +4,39 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class TorusBufferGeometry extends BufferGeometry {
 
 	constructor(
-    radius?: number,
-    tube?: number,
-    radialSegments?: number,
-    tubularSegments?: number,
-    arc?: number
-  );
-
-  parameters: {
-    radius: number;
-    tube: number;
-    radialSegments: number;
-    tubularSegments: number;
-    arc: number;
-  };
+		radius?: number,
+		tube?: number,
+		radialSegments?: number,
+		tubularSegments?: number,
+		arc?: number
+	);
+
+	parameters: {
+		radius: number;
+		tube: number;
+		radialSegments: number;
+		tubularSegments: number;
+		arc: number;
+	};
 
 }
 
 export class TorusGeometry extends Geometry {
 
 	constructor(
-    radius?: number,
-    tube?: number,
-    radialSegments?: number,
-    tubularSegments?: number,
-    arc?: number
-  );
-
-  parameters: {
-    radius: number;
-    tube: number;
-    radialSegments: number;
-    tubularSegments: number;
-    arc: number;
-  };
+		radius?: number,
+		tube?: number,
+		radialSegments?: number,
+		tubularSegments?: number,
+		arc?: number
+	);
+
+	parameters: {
+		radius: number;
+		tube: number;
+		radialSegments: number;
+		tubularSegments: number;
+		arc: number;
+	};
 
 }

src/geometries/TorusKnotGeometry.d.ts

@@ -4,45 +4,45 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class TorusKnotBufferGeometry extends BufferGeometry {
 
 	constructor(
-    radius?: number,
-    tube?: number,
-    tubularSegments?: number,
-    radialSegments?: number,
-    p?: number,
-    q?: number
-  );
-
-  parameters: {
-    radius: number;
-    tube: number;
-    tubularSegments: number;
-    radialSegments: number;
-    p: number;
-    q: number;
-    heightScale: number;
-  };
+		radius?: number,
+		tube?: number,
+		tubularSegments?: number,
+		radialSegments?: number,
+		p?: number,
+		q?: number
+	);
+
+	parameters: {
+		radius: number;
+		tube: number;
+		tubularSegments: number;
+		radialSegments: number;
+		p: number;
+		q: number;
+		heightScale: number;
+	};
 
 }
 
 export class TorusKnotGeometry extends Geometry {
 
 	constructor(
-    radius?: number,
-    tube?: number,
-    tubularSegments?: number,
-    radialSegments?: number,
-    p?: number,
-    q?: number
-  );
-
-  parameters: {
-    radius: number;
-    tube: number;
-    tubularSegments: number;
-    radialSegments: number;
-    p: number;
-    q: number;
-    heightScale: number;
-  };
+		radius?: number,
+		tube?: number,
+		tubularSegments?: number,
+		radialSegments?: number,
+		p?: number,
+		q?: number
+	);
+
+	parameters: {
+		radius: number;
+		tube: number;
+		tubularSegments: number;
+		radialSegments: number;
+		p: number;
+		q: number;
+		heightScale: number;
+	};
 
 }

src/geometries/TubeGeometry.d.ts

@@ -6,45 +6,45 @@ import { BufferGeometry } from './../core/BufferGeometry';
 export class TubeBufferGeometry extends BufferGeometry {
 
 	constructor(
-    path: Curve<Vector3>,
-    tubularSegments?: number,
-    radius?: number,
-    radiusSegments?: number,
-    closed?: boolean
-  );
-
-  parameters: {
-    path: Curve<Vector3>;
-    tubularSegments: number;
-    radius: number;
-    radialSegments: number;
-    closed: boolean;
-  };
-  tangents: Vector3[];
-  normals: Vector3[];
-  binormals: Vector3[];
+		path: Curve<Vector3>,
+		tubularSegments?: number,
+		radius?: number,
+		radiusSegments?: number,
+		closed?: boolean
+	);
+
+	parameters: {
+		path: Curve<Vector3>;
+		tubularSegments: number;
+		radius: number;
+		radialSegments: number;
+		closed: boolean;
+	};
+	tangents: Vector3[];
+	normals: Vector3[];
+	binormals: Vector3[];
 
 }
 
 export class TubeGeometry extends Geometry {
 
 	constructor(
-    path: Curve<Vector3>,
-    tubularSegments?: number,
-    radius?: number,
-    radiusSegments?: number,
-    closed?: boolean
-  );
-
-  parameters: {
-    path: Curve<Vector3>;
-    tubularSegments: number;
-    radius: number;
-    radialSegments: number;
-    closed: boolean;
-  };
-  tangents: Vector3[];
-  normals: Vector3[];
-  binormals: Vector3[];
+		path: Curve<Vector3>,
+		tubularSegments?: number,
+		radius?: number,
+		radiusSegments?: number,
+		closed?: boolean
+	);
+
+	parameters: {
+		path: Curve<Vector3>;
+		tubularSegments: number;
+		radius: number;
+		radialSegments: number;
+		closed: boolean;
+	};
+	tangents: Vector3[];
+	normals: Vector3[];
+	binormals: Vector3[];
 
 }

src/helpers/ArrowHelper.d.ts

@@ -9,19 +9,19 @@ import { Object3D } from './../core/Object3D';
 export class ArrowHelper extends Object3D {
 
 	constructor(
-    dir: Vector3,
-    origin?: Vector3,
-    length?: number,
-    hex?: number,
-    headLength?: number,
-    headWidth?: number
-  );
+		dir: Vector3,
+		origin?: Vector3,
+		length?: number,
+		hex?: number,
+		headLength?: number,
+		headWidth?: number
+	);
 
-  line: Line;
-  cone: Mesh;
+	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/Box3Helper.d.ts

@@ -7,6 +7,6 @@ export class Box3Helper extends LineSegments {
 
 	constructor( object?: Object3D, color?: Color );
 
-  box: Box3;
+	box: Box3;
 
 }

src/helpers/CameraHelper.d.ts

@@ -5,9 +5,9 @@ export class CameraHelper extends LineSegments {
 
 	constructor( camera: Camera );
 
-  camera: Camera;
-  pointMap: { [id: string]: number[] };
+	camera: Camera;
+	pointMap: { [id: string]: number[] };
 
-  update(): void;
+	update(): void;
 
 }

src/helpers/DirectionalLightHelper.d.ts

@@ -7,19 +7,19 @@ import { Object3D } from './../core/Object3D';
 export class DirectionalLightHelper extends Object3D {
 
 	constructor(
-    light: DirectionalLight,
-    size?: number,
-    color?: Color | string | number
-  );
+		light: DirectionalLight,
+		size?: number,
+		color?: Color | string | number
+	);
 
-  light: DirectionalLight;
-  lightPlane: Line;
-  targetPlane: Line;
-  color: Color | string | number | undefined;
-  matrix: Matrix4;
-  matrixAutoUpdate: boolean;
+	light: DirectionalLight;
+	lightPlane: Line;
+	targetPlane: Line;
+	color: Color | string | number | undefined;
+	matrix: Matrix4;
+	matrixAutoUpdate: boolean;
 
-  dispose(): void;
-  update(): void;
+	dispose(): void;
+	update(): void;
 
 }

src/helpers/FaceNormalsHelper.d.ts

@@ -11,15 +11,15 @@ import { LineSegments } from './../objects/LineSegments';
 export class FaceNormalsHelper extends LineSegments {
 
 	constructor(
-    object: Object3D,
-    size?: number,
-    hex?: number,
-    linewidth?: number
-  );
+		object: Object3D,
+		size?: number,
+		hex?: number,
+		linewidth?: number
+	);
 
-  object: Object3D;
-  size: number;
+	object: Object3D;
+	size: number;
 
-  update( object?: Object3D ): void;
+	update( object?: Object3D ): void;
 
 }

src/helpers/GridHelper.d.ts

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

src/helpers/HemisphereLightHelper.d.ts

@@ -7,19 +7,19 @@ import { Object3D } from './../core/Object3D';
 export class HemisphereLightHelper extends Object3D {
 
 	constructor(
-    light: HemisphereLight,
-    size: number,
-    color?: Color | number | string
-  );
+		light: HemisphereLight,
+		size: number,
+		color?: Color | number | string
+	);
 
-  light: HemisphereLight;
-  matrix: Matrix4;
-  matrixAutoUpdate: boolean;
-  material: MeshBasicMaterial;
+	light: HemisphereLight;
+	matrix: Matrix4;
+	matrixAutoUpdate: boolean;
+	material: MeshBasicMaterial;
 
-  color: Color | string | number | undefined;
+	color: Color | string | number | undefined;
 
-  dispose(): void;
-  update(): void;
+	dispose(): void;
+	update(): void;
 
 }

src/helpers/PlaneHelper.d.ts

@@ -5,9 +5,9 @@ export class PlaneHelper extends LineSegments {
 
 	constructor( plane: Plane, size?: number, hex?: number );
 
-  plane: Plane;
-  size: number;
+	plane: Plane;
+	size: number;
 
-  updateMatrixWorld( force?: boolean ): void;
+	updateMatrixWorld( force?: boolean ): void;
 
 }

src/helpers/PointLightHelper.d.ts

@@ -6,17 +6,17 @@ import { Object3D } from './../core/Object3D';
 export class PointLightHelper extends Object3D {
 
 	constructor(
-    light: PointLight,
-    sphereSize?: number,
-    color?: Color | string | number
-  );
+		light: PointLight,
+		sphereSize?: number,
+		color?: Color | string | number
+	);
 
-  light: PointLight;
-  color: Color | string | number | undefined;
-  matrix: Matrix4;
-  matrixAutoUpdate: boolean;
+	light: PointLight;
+	color: Color | string | number | undefined;
+	matrix: Matrix4;
+	matrixAutoUpdate: boolean;
 
-  dispose(): void;
-  update(): void;
+	dispose(): void;
+	update(): void;
 
 }

src/helpers/PolarGridHelper.d.ts

@@ -4,12 +4,12 @@ import { Color } from '../math/Color';
 export class PolarGridHelper extends LineSegments {
 
 	constructor(
-    radius: number,
-    radials: number,
-    circles: number,
-    divisions: number,
-    color1: Color | string | number | undefined,
-    color2: Color | string | number | undefined
-  );
+		radius: number,
+		radials: number,
+		circles: number,
+		divisions: number,
+		color1: Color | string | number | undefined,
+		color2: Color | string | number | undefined
+	);
 
 }

src/helpers/PositionalAudioHelper.d.ts

@@ -5,12 +5,12 @@ export class PositionalAudioHelper extends Line {
 
 	constructor( audio: PositionalAudio, range?: number, divisionsInnerAngle?: number, divisionsOuterAngle?: number );
 
-  audio: PositionalAudio;
-  range: number;
-  divisionsInnerAngle: number;
-  divisionsOuterAngle: number;
+	audio: PositionalAudio;
+	range: number;
+	divisionsInnerAngle: number;
+	divisionsOuterAngle: number;
 
-  dispose(): void;
-  update(): void;
+	dispose(): void;
+	update(): void;
 
 }

src/helpers/RectAreaLightHelper.d.ts

@@ -7,7 +7,7 @@ export class RectAreaLightHelper {
 
 	constructor( light: RectAreaLight, color?: Color | string | number );
 
-  light: RectAreaLight;
-  color: Color | string | number | undefined;
+	light: RectAreaLight;
+	color: Color | string | number | undefined;
 
 }

src/helpers/SkeletonHelper.d.ts

@@ -6,10 +6,10 @@ export class SkeletonHelper extends LineSegments {
 
 	constructor( bone: Object3D );
 
-  bones: Bone[];
-  root: Object3D;
+	bones: Bone[];
+	root: Object3D;
 
-  getBoneList( object: Object3D ): Bone[];
-  update(): void;
+	getBoneList( object: Object3D ): Bone[];
+	update(): void;
 
 }

src/helpers/SpotLightHelper.d.ts

@@ -7,12 +7,12 @@ export class SpotLightHelper extends Object3D {
 
 	constructor( light: Light, color?: Color | string | number );
 
-  light: Light;
-  matrix: Matrix4;
-  matrixAutoUpdate: boolean;
-  color: Color | string | number | undefined;
+	light: Light;
+	matrix: Matrix4;
+	matrixAutoUpdate: boolean;
+	color: Color | string | number | undefined;
 
-  dispose(): void;
-  update(): void;
+	dispose(): void;
+	update(): void;
 
 }

src/helpers/VertexNormalsHelper.d.ts

@@ -4,15 +4,15 @@ import { LineSegments } from './../objects/LineSegments';
 export class VertexNormalsHelper extends LineSegments {
 
 	constructor(
-    object: Object3D,
-    size?: number,
-    hex?: number,
-    linewidth?: number
-  );
+		object: Object3D,
+		size?: number,
+		hex?: number,
+		linewidth?: number
+	);
 
-  object: Object3D;
-  size: number;
+	object: Object3D;
+	size: number;
 
-  update( object?: Object3D ): void;
+	update( object?: Object3D ): void;
 
 }

src/lights/AmbientLight.d.ts

@@ -18,6 +18,6 @@ export class AmbientLight extends Light {
    */
 	constructor( color?: Color | string | number, intensity?: number );
 
-  castShadow: boolean;
+	castShadow: boolean;
 
 }

src/lights/DirectionalLight.d.ts

@@ -18,17 +18,17 @@ export class DirectionalLight extends Light {
 
 	constructor( color?: Color | string | number, intensity?: number );
 
-  /**
+	/**
    * Target used for shadow camera orientation.
    */
-  target: Object3D;
+	target: Object3D;
 
-  /**
+	/**
    * Light's intensity.
    * Default — 1.0.
    */
-  intensity: number;
+	intensity: number;
 
-  shadow: DirectionalLightShadow;
+	shadow: DirectionalLightShadow;
 
 }

src/lights/DirectionalLightShadow.d.ts

@@ -3,6 +3,6 @@ import { LightShadow } from './LightShadow';
 
 export class DirectionalLightShadow extends LightShadow {
 
-  camera: OrthographicCamera;
+	camera: OrthographicCamera;
 
 }

src/lights/HemisphereLight.d.ts

@@ -4,13 +4,13 @@ import { Light } from './Light';
 export class HemisphereLight extends Light {
 
 	constructor(
-    skyColor?: Color | string | number,
-    groundColor?: Color | string | number,
-    intensity?: number
-  );
+		skyColor?: Color | string | number,
+		groundColor?: Color | string | number,
+		intensity?: number
+	);
 
-  skyColor: Color;
-  groundColor: Color;
-  intensity: number;
+	skyColor: Color;
+	groundColor: Color;
+	intensity: number;
 
 }

src/lights/Light.d.ts

@@ -11,50 +11,50 @@ export class Light extends Object3D {
 
 	constructor( hex?: number | string, intensity?: number );
 
-  color: Color;
-  intensity: number;
-  isLight: true;
-  receiveShadow: boolean;
-  shadow: LightShadow;
-  /**
+	color: Color;
+	intensity: number;
+	isLight: true;
+	receiveShadow: boolean;
+	shadow: LightShadow;
+	/**
    * @deprecated Use shadow.camera.fov instead.
    */
-  shadowCameraFov: any;
-  /**
+	shadowCameraFov: any;
+	/**
    * @deprecated Use shadow.camera.left instead.
    */
-  shadowCameraLeft: any;
-  /**
+	shadowCameraLeft: any;
+	/**
    * @deprecated Use shadow.camera.right instead.
    */
-  shadowCameraRight: any;
-  /**
+	shadowCameraRight: any;
+	/**
    * @deprecated Use shadow.camera.top instead.
    */
-  shadowCameraTop: any;
-  /**
+	shadowCameraTop: any;
+	/**
    * @deprecated Use shadow.camera.bottom instead.
    */
-  shadowCameraBottom: any;
-  /**
+	shadowCameraBottom: any;
+	/**
    * @deprecated Use shadow.camera.near instead.
    */
-  shadowCameraNear: any;
-  /**
+	shadowCameraNear: any;
+	/**
    * @deprecated Use shadow.camera.far instead.
    */
-  shadowCameraFar: any;
-  /**
+	shadowCameraFar: any;
+	/**
    * @deprecated Use shadow.bias instead.
    */
-  shadowBias: any;
-  /**
+	shadowBias: any;
+	/**
    * @deprecated Use shadow.mapSize.width instead.
    */
-  shadowMapWidth: any;
-  /**
+	shadowMapWidth: any;
+	/**
    * @deprecated Use shadow.mapSize.height instead.
    */
-  shadowMapHeight: any;
+	shadowMapHeight: any;
 
 }

src/lights/LightShadow.d.ts

@@ -7,15 +7,15 @@ export class LightShadow {
 
 	constructor( camera: Camera );
 
-  camera: Camera;
-  bias: number;
-  radius: number;
-  mapSize: Vector2;
-  map: RenderTarget;
-  matrix: Matrix4;
+	camera: Camera;
+	bias: number;
+	radius: number;
+	mapSize: Vector2;
+	map: RenderTarget;
+	matrix: Matrix4;
 
-  copy( source: LightShadow ): this;
-  clone( recursive?: boolean ): this;
-  toJSON(): any;
+	copy( source: LightShadow ): this;
+	clone( recursive?: boolean ): this;
+	toJSON(): any;
 
 }

src/lights/PointLight.d.ts

@@ -5,7 +5,7 @@ import { LightShadow } from './LightShadow';
 
 export class PointLightShadow extends LightShadow {
 
-  camera: PerspectiveCamera;
+	camera: PerspectiveCamera;
 
 }
 
@@ -20,26 +20,26 @@ export class PointLightShadow extends LightShadow {
 export class PointLight extends Light {
 
 	constructor(
-    color?: Color | string | number,
-    intensity?: number,
-    distance?: number,
-    decay?: number
-  );
+		color?: Color | string | number,
+		intensity?: number,
+		distance?: number,
+		decay?: number
+	);
 
-  /*
+	/*
    * Light's intensity.
    * Default - 1.0.
    */
-  intensity: number;
+	intensity: number;
 
-  /**
+	/**
    * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance.
    * Default — 0.0.
    */
-  distance: number;
+	distance: number;
 
-  decay: number;
-  shadow: PointLightShadow;
-  power: number;
+	decay: number;
+	shadow: PointLightShadow;
+	power: number;
 
 }

src/lights/RectAreaLight.d.ts

@@ -4,15 +4,15 @@ import { Color } from './../math/Color';
 export class RectAreaLight extends Light {
 
 	constructor(
-    color?: Color | string | number,
-    intensity?: number,
-    width?: number,
-    height?: number
-  );
+		color?: Color | string | number,
+		intensity?: number,
+		width?: number,
+		height?: number
+	);
 
-  type: string;
-  width: number;
-  height: number;
-  intensity: number;
+	type: string;
+	width: number;
+	height: number;
+	intensity: number;
 
 }

src/lights/SpotLight.d.ts

@@ -9,47 +9,47 @@ import { Light } from './Light';
 export class SpotLight extends Light {
 
 	constructor(
-    color?: Color | string | number,
-    intensity?: number,
-    distance?: number,
-    angle?: number,
-    exponent?: number,
-    decay?: number
-  );
-
-  /**
+		color?: Color | string | number,
+		intensity?: number,
+		distance?: number,
+		angle?: number,
+		exponent?: number,
+		decay?: number
+	);
+
+	/**
    * Spotlight focus points at target.position.
    * Default position — (0,0,0).
    */
-  target: Object3D;
+	target: Object3D;
 
-  /**
+	/**
    * Light's intensity.
    * Default — 1.0.
    */
-  intensity: number;
+	intensity: number;
 
-  /**
+	/**
    * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance.
    * Default — 0.0.
    */
-  distance: number;
+	distance: number;
 
-  /*
+	/*
    * Maximum extent of the spotlight, in radians, from its direction.
    * Default — Math.PI/2.
    */
-  angle: number;
+	angle: number;
 
-  /**
+	/**
    * Rapidity of the falloff of light from its target direction.
    * Default — 10.0.
    */
-  exponent: number;
+	exponent: number;
 
-  decay: number;
-  shadow: SpotLightShadow;
-  power: number;
-  penumbra: number;
+	decay: number;
+	shadow: SpotLightShadow;
+	power: number;
+	penumbra: number;
 
 }

src/lights/SpotLightShadow.d.ts

@@ -4,7 +4,7 @@ import { LightShadow } from './LightShadow';
 
 export class SpotLightShadow extends LightShadow {
 
-  camera: PerspectiveCamera;
-  update( light: Light ): void;
+	camera: PerspectiveCamera;
+	update( light: Light ): void;
 
 }

src/loaders/AnimationLoader.d.ts

@@ -5,15 +5,15 @@ export class AnimationLoader {
 
 	constructor( manager?: LoadingManager );
 
-  manager: LoadingManager;
+	manager: LoadingManager;
 
-  load(
-    url: string,
-    onLoad?: ( response: string | ArrayBuffer ) => void,
-    onProgress?: ( request: ProgressEvent ) => void,
-    onError?: ( event: ErrorEvent ) => void
-  ): any;
-  parse( json: any ): AnimationClip[];
-  setPath( path: string ): AnimationLoader;
+	load(
+		url: string,
+		onLoad?: ( response: string | ArrayBuffer ) => void,
+		onProgress?: ( request: ProgressEvent ) => void,
+		onError?: ( event: ErrorEvent ) => void
+	): any;
+	parse( json: any ): AnimationClip[];
+	setPath( path: string ): AnimationLoader;
 
 }

src/loaders/AudioLoader.d.ts

@@ -5,10 +5,10 @@ export class AudioLoader {
 	constructor( manager?: LoadingManager );
 
 	load(
-    url: string,
-    onLoad: Function,
-    onPrgress: Function,
-    onError: Function
-  ): void;
+		url: string,
+		onLoad: Function,
+		onPrgress: Function,
+		onError: Function
+	): void;
 
 }