lint d.ts files

examples/jsm/WebGL.d.ts

@@ -1,9 +1,9 @@
 export namespace WEBGL {
 
-  export function isWebGLAvailable(): boolean;
-  export function isWebGL2Available(): boolean;
-  export function getWebGLErrorMessage(): HTMLElement;
-  export function getWebGL2ErrorMessage(): HTMLElement;
-  export function getErrorMessage(version: number): HTMLElement;
+	export function isWebGLAvailable(): boolean;
+	export function isWebGL2Available(): boolean;
+	export function getWebGLErrorMessage(): HTMLElement;
+	export function getWebGL2ErrorMessage(): HTMLElement;
+	export function getErrorMessage( version: number ): HTMLElement;
 
 }

examples/jsm/animation/AnimationClipCreator.d.ts

@@ -1,16 +1,17 @@
 import {
-  AnimationClip,
-  Vector3
+	AnimationClip,
+	Vector3
 } from '../../../src/Three';
 
-export class AnimationClipCreator  {
-  constructor();
+export class AnimationClipCreator {
 
-  static CreateRotationAnimation(period: number, axis: string): AnimationClip;
-  static CreateScaleAxisAnimation(period: number, axis: string): AnimationClip;
-  static CreateShakeAnimation(duration: number, shakeScale: Vector3): AnimationClip;
-  static CreatePulsationAnimation(duration: number, pulseScale: number): AnimationClip;
-  static CreateVisibilityAnimation(duration: number): AnimationClip;
-  static CreateMaterialColorAnimation(duration: number, colors: number[]): AnimationClip;
+	constructor();
+
+	static CreateRotationAnimation( period: number, axis: string ): AnimationClip;
+	static CreateScaleAxisAnimation( period: number, axis: string ): AnimationClip;
+	static CreateShakeAnimation( duration: number, shakeScale: Vector3 ): AnimationClip;
+	static CreatePulsationAnimation( duration: number, pulseScale: number ): AnimationClip;
+	static CreateVisibilityAnimation( duration: number ): AnimationClip;
+	static CreateMaterialColorAnimation( duration: number, colors: number[] ): AnimationClip;
 
 }

examples/jsm/animation/CCDIKSolver.d.ts

@@ -1,25 +1,29 @@
 import {
-  SkinnedMesh,
+	SkinnedMesh,
 } from '../../../src/Three';
 
 export interface IKS {
-  effector: number;
-  iteration: number;
-  links: {
-    enabled: boolean;
-    index: number;
-  }
-  maxAngle: number;
-  target: number;
+	effector: number;
+	iteration: number;
+	links: {
+		enabled: boolean;
+		index: number;
+	}
+	maxAngle: number;
+	target: number;
 }
 
 export class CCDIKSolver {
-  constructor(mesh: SkinnedMesh, iks: IKS[]);
 
-  update(): this;
-  createHelper(): CCDIKHelper;
+	constructor( mesh: SkinnedMesh, iks: IKS[] );
+
+	update(): this;
+	createHelper(): CCDIKHelper;
+
 }
 
 export class CCDIKHelper {
-  constructor(mesh: SkinnedMesh, iks: IKS[]);
+
+	constructor( mesh: SkinnedMesh, iks: IKS[] );
+
 }

examples/jsm/animation/MMDAnimationHelper.d.ts

@@ -1,85 +1,91 @@
 import {
-  AnimationClip,
-  Audio,
-  Camera,
-  Mesh,
-  Object3D,
-  SkinnedMesh
+	AnimationClip,
+	Audio,
+	Camera,
+	Mesh,
+	Object3D,
+	SkinnedMesh
 } from '../../../src/Three';
 
 export interface MMDAnimationHelperParameter {
-  sync?: boolean;
-  afterglow?: number;
-  resetPhysicsOnLoop?: boolean;
+	sync?: boolean;
+	afterglow?: number;
+	resetPhysicsOnLoop?: boolean;
 }
 
 export interface MMDAnimationHelperAddParameter {
-  animation?: AnimationClip | AnimationClip[];
-  physics?: boolean;
-  warmup?: number;
-  unitStep?: number;
-  maxStepNum?: number;
-  gravity?: number;
-  delayTime?: number;
+	animation?: AnimationClip | AnimationClip[];
+	physics?: boolean;
+	warmup?: number;
+	unitStep?: number;
+	maxStepNum?: number;
+	gravity?: number;
+	delayTime?: number;
 }
 
 export interface MMDAnimationHelperPoseParameter {
-  resetPose?: boolean;
-  ik?: boolean;
-  grant?: boolean;
+	resetPose?: boolean;
+	ik?: boolean;
+	grant?: boolean;
 }
 
 export class MMDAnimationHelper {
-  constructor(params?: MMDAnimationHelperParameter);
-  meshes: Mesh[];
-  camera: Camera | null;
-  cameraTarget: Object3D;
-  audio: Audio;
-  audioManager: AudioManager;
-  configuration: {
-    sync: boolean;
-    afterglow: number;
-    resetPhysicsOnLoop: boolean;
-  };
-  enabled: {
-    animation: boolean;
-    ik: boolean;
-    grant: boolean;
-    physics: boolean;
-    cameraAnimation: boolean;
-  };
-  onBeforePhysics: (mesh: SkinnedMesh) => void;
-  sharedPhysics: boolean;
-  masterPhysics: null;
-
-  add(object: SkinnedMesh | Camera | Audio, params?: MMDAnimationHelperAddParameter): this;
-  remove(object: SkinnedMesh | Camera | Audio): this;
-  update(delta: number): this;
-  pose(mesh: SkinnedMesh, vpd: object, params?: MMDAnimationHelperPoseParameter): this;
-  enable(key: string, enabled: boolean): this;
-  createGrantSolver(mesh: SkinnedMesh): GrantSolver;
+
+	constructor( params?: MMDAnimationHelperParameter );
+	meshes: Mesh[];
+	camera: Camera | null;
+	cameraTarget: Object3D;
+	audio: Audio;
+	audioManager: AudioManager;
+	configuration: {
+		sync: boolean;
+		afterglow: number;
+		resetPhysicsOnLoop: boolean;
+	};
+	enabled: {
+		animation: boolean;
+		ik: boolean;
+		grant: boolean;
+		physics: boolean;
+		cameraAnimation: boolean;
+	};
+	onBeforePhysics: ( mesh: SkinnedMesh ) => void;
+	sharedPhysics: boolean;
+	masterPhysics: null;
+
+	add( object: SkinnedMesh | Camera | Audio, params?: MMDAnimationHelperAddParameter ): this;
+	remove( object: SkinnedMesh | Camera | Audio ): this;
+	update( delta: number ): this;
+	pose( mesh: SkinnedMesh, vpd: object, params?: MMDAnimationHelperPoseParameter ): this;
+	enable( key: string, enabled: boolean ): this;
+	createGrantSolver( mesh: SkinnedMesh ): GrantSolver;
+
 }
 
 export interface AudioManagerParameter {
-  delayTime?: number;
+	delayTime?: number;
 }
 
 export class AudioManager {
-  constructor(audio: Audio, params?: AudioManagerParameter);
-  audio: Audio;
-  elapsedTime: number;
-  currentTime: number;
-  delayTime: number;
-  audioDuration: number;
-  duration: number;
-
-  control(delta: number): this;
+
+	constructor( audio: Audio, params?: AudioManagerParameter );
+	audio: Audio;
+	elapsedTime: number;
+	currentTime: number;
+	delayTime: number;
+	audioDuration: number;
+	duration: number;
+
+	control( delta: number ): this;
+
 }
 
 export class GrantSolver {
-  constructor(mesh: SkinnedMesh, grants: object[]);
-  mesh: SkinnedMesh;
-  grants: object[];
 
-  update(): this;
+	constructor( mesh: SkinnedMesh, grants: object[] );
+	mesh: SkinnedMesh;
+	grants: object[];
+
+	update(): this;
+
 }

examples/jsm/animation/MMDPhysics.d.ts

@@ -1,109 +1,118 @@
 import {
-  Bone,
-  Euler,
-  Matrix4,
-  Object3D,
-  Quaternion,
-  SkinnedMesh,
-  Vector3
+	Bone,
+	Euler,
+	Matrix4,
+	Object3D,
+	Quaternion,
+	SkinnedMesh,
+	Vector3
 } from '../../../src/Three';
 
 export interface MMDPhysicsParameter {
-  unitStep?: number;
-  maxStepNum?: number;
-  gravity?: Vector3;
+	unitStep?: number;
+	maxStepNum?: number;
+	gravity?: Vector3;
 }
 
 export class MMDPhysics {
-  constructor(mesh: SkinnedMesh, rigidBodyParams: object[], constraintParams?: object[], params?: MMDPhysicsParameter);
-  manager: ResourceManager;
-  mesh: SkinnedMesh;
-  unitStep: number;
-  maxStepNum: number;
-  gravity: Vector3;
-  world: null;
-  bodies: RigidBody[];
-  constraints: Constraint[];
-
-  update(delta: number): this;
-  reset(): this;
-  warmup(cycles: number): this;
-  setGravity(gravity: Vector3): this;
-  createHelper(): MMDPhysicsHelper;
+
+	constructor( mesh: SkinnedMesh, rigidBodyParams: object[], constraintParams?: object[], params?: MMDPhysicsParameter );
+	manager: ResourceManager;
+	mesh: SkinnedMesh;
+	unitStep: number;
+	maxStepNum: number;
+	gravity: Vector3;
+	world: null;
+	bodies: RigidBody[];
+	constraints: Constraint[];
+
+	update( delta: number ): this;
+	reset(): this;
+	warmup( cycles: number ): this;
+	setGravity( gravity: Vector3 ): this;
+	createHelper(): MMDPhysicsHelper;
+
 }
 
-export class ResourceManager{
-  constructor();
-  threeVector3s: Vector3[];
-  threeMatrix4s: Matrix4[];
-  threeQuaternions: Quaternion[];
-  threeEulers: Euler[];
-  transforms: object[];
-  quaternions: object[];
-  vector3s: object[];
-
-  allocThreeVector3(): void;
-  freeThreeVector3(v: Vector3): void;
-  allocThreeMatrix4(): void;
-  freeThreeMatrix4(m: Matrix4): void;
-  allocThreeQuaternion(): void;
-  freeThreeQuaternion(q: Quaternion): void;
-  allocThreeEuler(): void;
-  freeThreeEuler(e: Euler): void;
-  allocTransform(): void;
-  freeTransform(t: object): void;
-  allocQuaternion(): void;
-  freeQuaternion(q: object): void;
-  allocVector3(): void;
-  freeVector3(v: object): void;
-  setIdentity(): void;
-  getBasis(t: object): object;
-  getBasisAsMatrix3(t: object): object;
-  getOrigin(t: object): object;
-  setOrigin(t: object, v: object): void;
-  copyOrigin(t1: object, t2: object): void;
-  setBasis(t: object, q: object): void;
-  setBasisFromMatrix3(t: object, m: object): void;
-  setOriginFromArray3(t: object, a: number[]): void;
-  setOriginFromThreeVector3(t: object, v: Vector3): void;
-  setBasisFromArray3(t: object, a: number[]): void;
-  setBasisFromThreeQuaternion(t: object, a: Quaternion): void;
-  multiplyTransforms(t1: object, t2: object): object;
-  inverseTransform(t: object): object;
-  multiplyMatrices3(m1: object, m2: object): object;
-  addVector3(v1: object, v2: object): object;
-  dotVectors3(v1: object, v2: object): number;
-  rowOfMatrix3(m: object, i: number): object;
-  columnOfMatrix3(m: object, i: number): object;
-  negativeVector3(v: object): object;
-  multiplyMatrix3ByVector3(m: object, v: object): object;
-  transposeMatrix3(m: object): object;
-  quaternionToMatrix3(q: object): object;
-  matrix3ToQuaternion(m: object): object;
+export class ResourceManager {
+
+	constructor();
+	threeVector3s: Vector3[];
+	threeMatrix4s: Matrix4[];
+	threeQuaternions: Quaternion[];
+	threeEulers: Euler[];
+	transforms: object[];
+	quaternions: object[];
+	vector3s: object[];
+
+	allocThreeVector3(): void;
+	freeThreeVector3( v: Vector3 ): void;
+	allocThreeMatrix4(): void;
+	freeThreeMatrix4( m: Matrix4 ): void;
+	allocThreeQuaternion(): void;
+	freeThreeQuaternion( q: Quaternion ): void;
+	allocThreeEuler(): void;
+	freeThreeEuler( e: Euler ): void;
+	allocTransform(): void;
+	freeTransform( t: object ): void;
+	allocQuaternion(): void;
+	freeQuaternion( q: object ): void;
+	allocVector3(): void;
+	freeVector3( v: object ): void;
+	setIdentity(): void;
+	getBasis( t: object ): object;
+	getBasisAsMatrix3( t: object ): object;
+	getOrigin( t: object ): object;
+	setOrigin( t: object, v: object ): void;
+	copyOrigin( t1: object, t2: object ): void;
+	setBasis( t: object, q: object ): void;
+	setBasisFromMatrix3( t: object, m: object ): void;
+	setOriginFromArray3( t: object, a: number[] ): void;
+	setOriginFromThreeVector3( t: object, v: Vector3 ): void;
+	setBasisFromArray3( t: object, a: number[] ): void;
+	setBasisFromThreeQuaternion( t: object, a: Quaternion ): void;
+	multiplyTransforms( t1: object, t2: object ): object;
+	inverseTransform( t: object ): object;
+	multiplyMatrices3( m1: object, m2: object ): object;
+	addVector3( v1: object, v2: object ): object;
+	dotVectors3( v1: object, v2: object ): number;
+	rowOfMatrix3( m: object, i: number ): object;
+	columnOfMatrix3( m: object, i: number ): object;
+	negativeVector3( v: object ): object;
+	multiplyMatrix3ByVector3( m: object, v: object ): object;
+	transposeMatrix3( m: object ): object;
+	quaternionToMatrix3( q: object ): object;
+	matrix3ToQuaternion( m: object ): object;
+
 }
 
-export class RigidBody{
-  constructor(mesh: SkinnedMesh, world: object, params: object, manager: ResourceManager);
-  mesh: SkinnedMesh;
-  world: object;
-  params: object;
-  manager: ResourceManager;
-
-  body: object;
-  bone: Bone;
-  boneOffsetForm: object;
-  boneOffsetFormInverse: object;
-
-  reset(): this;
-  updateFromBone(): this;
-  updateBone(): this;
+export class RigidBody {
+
+	constructor( mesh: SkinnedMesh, world: object, params: object, manager: ResourceManager );
+	mesh: SkinnedMesh;
+	world: object;
+	params: object;
+	manager: ResourceManager;
+
+	body: object;
+	bone: Bone;
+	boneOffsetForm: object;
+	boneOffsetFormInverse: object;
+
+	reset(): this;
+	updateFromBone(): this;
+	updateBone(): this;
+
 }
 
-export class Constraint{
-  constructor(mesh: SkinnedMesh, world: object, bodyA: RigidBody, bodyB: RigidBody, params: object, manager: ResourceManager);
+export class Constraint {
+
+	constructor( mesh: SkinnedMesh, world: object, bodyA: RigidBody, bodyB: RigidBody, params: object, manager: ResourceManager );
 
 }
 
 export class MMDPhysicsHelper extends Object3D {
-  constructor();
+
+	constructor();
+
 }

examples/jsm/animation/TimelinerController.d.ts

@@ -1,20 +1,22 @@
 import {
-  AnimationClip,
-  Scene,
-  Vector3
+	AnimationClip,
+	Scene,
+	Vector3
 } from '../../../src/Three';
 
-export class TimelinerController  {
-  constructor(scene: Scene, trackInfo: object[], onUpdate: () => void);
+export class TimelinerController {
+
+	constructor( scene: Scene, trackInfo: object[], onUpdate: () => void );
+
+	delKeyframe( channelName: string, time: number ): void;
+	deserialize( structs: object ): void;
+	getChannelKeyTimes(): number[];
+	getChannelNames(): string[];
+	init(): void;
+	moveKeyframe( channelName: string, time: number, delta: number, moveRemaining: boolean ): void;
+	serialize(): object;
+	setDisplayTime( time: number ): void;
+	setDuration( duration: number ): void;
+	setKeyframe( channelName: string, time: number ): void;
 
-  delKeyframe(channelName: string, time: number): void;
-  deserialize(structs: object): void;
-  getChannelKeyTimes(): number[];
-  getChannelNames(): string[];
-  init(): void;
-  moveKeyframe(channelName: string, time: number, delta: number, moveRemaining: boolean): void;
-  serialize(): object;
-  setDisplayTime(time: number): void;
-  setDuration(duration: number): void;
-  setKeyframe(channelName: string, time: number): void;
 }

examples/jsm/cameras/CinematicCamera.d.ts

@@ -1,32 +1,33 @@
 import {
-  PerspectiveCamera,
-  ShaderMaterial,
-  Scene,
-  WebGLRenderer
+	PerspectiveCamera,
+	ShaderMaterial,
+	Scene,
+	WebGLRenderer
 } from '../../../src/Three';
 
 export class CinematicCamera extends PerspectiveCamera {
-  constructor(fov: number, aspect: number, near: number, far: number);
 
-  postprocessing: {
-    enabled: boolean;
-  };
-  shaderSettings: {
-    rings: number;
-    samples: number;
-  };
-  materialDepth: ShaderMaterial;
-  coc: number;
-  aperture: number;
-  fNumber: number;
-  hyperFocal: number;
-  filmGauge: number;
+	constructor( fov: number, aspect: number, near: number, far: number );
 
-  linearize(depth: number): number;
-  smoothstep(near: number, far: number, depth: number): number;
-  saturate(x: number): number;
-  focusAt(focusDistance: number): void;
-  initPostProcessing(): void;
-  renderCinematic(scene: Scene, renderer: WebGLRenderer): void;
+	postprocessing: {
+		enabled: boolean;
+	};
+	shaderSettings: {
+		rings: number;
+		samples: number;
+	};
+	materialDepth: ShaderMaterial;
+	coc: number;
+	aperture: number;
+	fNumber: number;
+	hyperFocal: number;
+	filmGauge: number;
+
+	linearize( depth: number ): number;
+	smoothstep( near: number, far: number, depth: number ): number;
+	saturate( x: number ): number;
+	focusAt( focusDistance: number ): void;
+	initPostProcessing(): void;
+	renderCinematic( scene: Scene, renderer: WebGLRenderer ): void;
 
 }

examples/jsm/controls/DeviceOrientationControls.d.ts

@@ -1,22 +1,23 @@
 import {
-  Camera
+	Camera
 } from '../../../src/Three';
 
 export class DeviceOrientationControls {
-  constructor(object: Camera);
 
-  object: Camera;
+	constructor( object: Camera );
 
-  // API
+	object: Camera;
 
-  alphaOffset: number;
-  deviceOrientation: any;
-  enabled: boolean;
-  screenOrientation: number;
+	// API
 
-  connect(): void;
-  disconnect(): void;
-  dispose(): void;
-  update(): void;
+	alphaOffset: number;
+	deviceOrientation: any;
+	enabled: boolean;
+	screenOrientation: number;
+
+	connect(): void;
+	disconnect(): void;
+	dispose(): void;
+	update(): void;
 
 }

examples/jsm/controls/DragControls.d.ts

@@ -1,20 +1,21 @@
 import {
-  Camera,
-  EventDispatcher,
-  Object3D
+	Camera,
+	EventDispatcher,
+	Object3D
 } from '../../../src/Three';
 
 export class DragControls extends EventDispatcher {
-  constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement);
 
-  object: Camera;
+	constructor( objects: Object3D[], camera: Camera, domElement?: HTMLElement );
 
-  // API
+	object: Camera;
 
-  enabled: boolean;
+	// API
 
-  activate(): void;
-  deactivate(): void;
-  dispose(): void;
+	enabled: boolean;
+
+	activate(): void;
+	deactivate(): void;
+	dispose(): void;
 
 }

examples/jsm/controls/FirstPersonControls.d.ts

@@ -1,32 +1,33 @@
 import {
-  Camera,
-  Vector3
+	Camera,
+	Vector3
 } from '../../../src/Three';
 
 export class FirstPersonControls {
-  constructor(object: Camera, domElement?: HTMLElement);
 
-  object: Camera;
-  domElement: HTMLElement | HTMLDocument;
+	constructor( object: Camera, domElement?: HTMLElement );
 
-  enabled: boolean;
-  movementSpeed: number;
-  lookSpeed: number;
-  lookVertical: boolean;
-  autoForward: boolean;
-  activeLook: boolean;
-  heightSpeed: boolean;
-  heightCoef: number;
-  heightMin: number;
-  heightMax: number;
-  constrainVertical: boolean;
-  verticalMin: number;
-  verticalMax: number;
+	object: Camera;
+	domElement: HTMLElement | HTMLDocument;
+
+	enabled: boolean;
+	movementSpeed: number;
+	lookSpeed: number;
+	lookVertical: boolean;
+	autoForward: boolean;
+	activeLook: boolean;
+	heightSpeed: boolean;
+	heightCoef: number;
+	heightMin: number;
+	heightMax: number;
+	constrainVertical: boolean;
+	verticalMin: number;
+	verticalMax: number;
 	mouseDragOn: boolean;
 
-  handleResize(): void;
-  lookAt(x: number | Vector3, y: number, z: number): this;
-  update(delta: number): this;
-  dispose(): void;
+	handleResize(): void;
+	lookAt( x: number | Vector3, y: number, z: number ): this;
+	update( delta: number ): this;
+	dispose(): void;
 
 }

examples/jsm/controls/FlyControls.d.ts

@@ -1,19 +1,20 @@
 import {
-  Camera
+	Camera
 } from '../../../src/Three';
 
 export class FlyControls {
-  constructor(object: Camera, domElement?: HTMLElement);
 
-  object: Camera;
-  domElement: HTMLElement | HTMLDocument;
+	constructor( object: Camera, domElement?: HTMLElement );
 
-  movementSpeed: number;
-  rollSpeed: number;
-  dragToLook: boolean;
-  autoForward: boolean;
+	object: Camera;
+	domElement: HTMLElement | HTMLDocument;
 
-  update(delta: number): void;
-  dispose(): void;
+	movementSpeed: number;
+	rollSpeed: number;
+	dragToLook: boolean;
+	autoForward: boolean;
+
+	update( delta: number ): void;
+	dispose(): void;
 
 }

examples/jsm/controls/OrbitControls.d.ts

@@ -1,7 +1,8 @@
 import { Camera, MOUSE, Object3D, TOUCH, Vector3 } from '../../../src/Three';
 
 export class OrbitControls {
-	constructor(object: Camera, domElement?: HTMLElement);
+
+	constructor( object: Camera, domElement?: HTMLElement );
 
 	object: Camera;
 	domElement: HTMLElement | HTMLDocument;
@@ -44,22 +45,22 @@ export class OrbitControls {
 
 	enableKeys: boolean;
 	keys: { LEFT: number; UP: number; RIGHT: number; BOTTOM: number; };
-	mouseButtons: { LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE;  };
+	mouseButtons: { LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE; };
 	touches: { ONE: TOUCH; TWO: TOUCH };
 
-	rotateLeft(angle?: number): void;
+	rotateLeft( angle?: number ): void;
 
-	rotateUp(angle?: number): void;
+	rotateUp( angle?: number ): void;
 
-	panLeft(distance?: number): void;
+	panLeft( distance?: number ): void;
 
-	panUp(distance?: number): void;
+	panUp( distance?: number ): void;
 
-	pan(deltaX: number, deltaY: number): void;
+	pan( deltaX: number, deltaY: number ): void;
 
-	dollyIn(dollyScale: number): void;
+	dollyIn( dollyScale: number ): void;
 
-	dollyOut(dollyScale: number): void;
+	dollyOut( dollyScale: number ): void;
 
 	update(): boolean;
 
@@ -74,15 +75,18 @@ export class OrbitControls {
 	getAzimuthalAngle(): number;
 
 	// EventDispatcher mixins
-	addEventListener(type: string, listener: (event: any) => void): void;
+	addEventListener( type: string, listener: ( event: any ) => void ): void;
+
+	hasEventListener( type: string, listener: ( event: any ) => void ): boolean;
 
-	hasEventListener(type: string, listener: (event: any) => void): boolean;
+	removeEventListener( type: string, listener: ( event: any ) => void ): void;
 
-	removeEventListener(type: string, listener: (event: any) => void): void;
+	dispatchEvent( event: { type: string; target: any; } ): void;
 
-	dispatchEvent(event: { type: string; target: any; }): void;
 }
 
 export class MapControls extends OrbitControls {
-	constructor(object: Camera, domElement?: HTMLElement);
+
+	constructor( object: Camera, domElement?: HTMLElement );
+
 }

examples/jsm/controls/PointerLockControls.d.ts

@@ -1,26 +1,27 @@
 import {
-  Camera,
-  EventDispatcher,
-  Vector3
+	Camera,
+	EventDispatcher,
+	Vector3
 } from '../../../src/Three';
 
 export class PointerLockControls extends EventDispatcher {
-  constructor(camera: Camera, domElement?: HTMLElement);
 
-  domElement: HTMLElement;
+	constructor( camera: Camera, domElement?: HTMLElement );
 
-  // API
+	domElement: HTMLElement;
 
-  isLocked: boolean;
+	// API
 
-  connect(): void;
-  disconnect(): void;
-  dispose(): void;
-  getObject(): Camera;
-  getDirection(v: Vector3): Vector3;
-  moveForward(distance: number): void;
-  moveRight(distance: number): void;
-  lock(): void;
-  unlock(): void;
+	isLocked: boolean;
+
+	connect(): void;
+	disconnect(): void;
+	dispose(): void;
+	getObject(): Camera;
+	getDirection( v: Vector3 ): Vector3;
+	moveForward( distance: number ): void;
+	moveRight( distance: number ): void;
+	lock(): void;
+	unlock(): void;
 
 }

examples/jsm/controls/TrackballControls.d.ts

@@ -1,45 +1,47 @@
 import { Camera, EventDispatcher, Vector3 } from '../../../src/Three';
 
 export class TrackballControls extends EventDispatcher {
-  constructor(object: Camera, domElement?: HTMLElement);
 
-  object: Camera;
-  domElement: HTMLElement;
+	constructor( object: Camera, domElement?: HTMLElement );
 
-  // API
-  enabled: boolean;
-  screen: {left: number; top: number; width: number; height: number};
-  rotateSpeed: number;
-  zoomSpeed: number;
-  panSpeed: number;
-  noRotate: boolean;
-  noZoom: boolean;
-  noPan: boolean;
-  noRoll: boolean;
-  staticMoving: boolean;
-  dynamicDampingFactor: number;
-  minDistance: number;
-  maxDistance: number;
-  keys: number[];
+	object: Camera;
+	domElement: HTMLElement;
 
-  target: Vector3;
-  position0: Vector3;
-  target0: Vector3;
-  up0: Vector3;
+	// API
+	enabled: boolean;
+	screen: {left: number; top: number; width: number; height: number};
+	rotateSpeed: number;
+	zoomSpeed: number;
+	panSpeed: number;
+	noRotate: boolean;
+	noZoom: boolean;
+	noPan: boolean;
+	noRoll: boolean;
+	staticMoving: boolean;
+	dynamicDampingFactor: number;
+	minDistance: number;
+	maxDistance: number;
+	keys: number[];
 
-  update(): void;
+	target: Vector3;
+	position0: Vector3;
+	target0: Vector3;
+	up0: Vector3;
 
-  reset(): void;
+	update(): void;
 
-  dispose(): void;
+	reset(): void;
 
-  checkDistances(): void;
+	dispose(): void;
 
-  zoomCamera(): void;
+	checkDistances(): void;
 
-  panCamera(): void;
+	zoomCamera(): void;
 
-  rotateCamera(): void;
+	panCamera(): void;
+
+	rotateCamera(): void;
+
+	handleResize(): void;
 
-  handleResize(): void;
 }

examples/jsm/controls/TransformControls.d.ts

@@ -1,46 +1,47 @@
 import {
-  Object3D,
-  Camera,
-  Vector3,
-  Euler,
-  MOUSE
+	Object3D,
+	Camera,
+	Vector3,
+	Euler,
+	MOUSE
 } from '../../../src/Three';
 
 export class TransformControls extends Object3D {
-  constructor(object: Camera, domElement?: HTMLElement);
 
-  domElement: HTMLElement;
+	constructor( object: Camera, domElement?: HTMLElement );
 
-  // API
+	domElement: HTMLElement;
 
-  camera: Camera;
-  object: Object3D | undefined;
-  enabled: boolean;
-  axis: string | null;
-  mode: string;
-  translationSnap: number | null;
-  rotationSnap: number | null;
-  space: string;
-  size: number;
-  dragging: boolean;
-  showX: boolean;
-  showY: boolean;
-  showZ: boolean;
-  isTransformControls: boolean;
-  mouseButtons: {
-    LEFT: MOUSE;
-    MIDDLE: MOUSE;
-    RIGHT: MOUSE;
-  };
+	// API
 
-  attach(object: Object3D): this;
-  detach(): this;
-  getMode(): string;
-  setMode(mode: string): void;
-  setTranslationSnap(translationSnap: Number | null): void;
-  setRotationSnap(rotationSnap: Number | null): void;
-  setSize(size: number): void;
-  setSpace(space: string): void;
-  dispose(): void;
+	camera: Camera;
+	object: Object3D | undefined;
+	enabled: boolean;
+	axis: string | null;
+	mode: string;
+	translationSnap: number | null;
+	rotationSnap: number | null;
+	space: string;
+	size: number;
+	dragging: boolean;
+	showX: boolean;
+	showY: boolean;
+	showZ: boolean;
+	isTransformControls: boolean;
+	mouseButtons: {
+		LEFT: MOUSE;
+		MIDDLE: MOUSE;
+		RIGHT: MOUSE;
+	};
+
+	attach( object: Object3D ): this;
+	detach(): this;
+	getMode(): string;
+	setMode( mode: string ): void;
+	setTranslationSnap( translationSnap: Number | null ): void;
+	setRotationSnap( rotationSnap: Number | null ): void;
+	setSize( size: number ): void;
+	setSpace( space: string ): void;
+	dispose(): void;
 
 }

examples/jsm/curves/CurveExtras.d.ts

@@ -1,76 +1,104 @@
 import {
-  Curve,
-  Vector3
+	Curve,
+	Vector3
 } from '../../../src/Three';
 
 
 export namespace Curves {
 
-  export class GrannyKnot extends Curve<Vector3> {
-    constructor();
-  }
-
-  export class HeartCurve extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class VivianiCurve extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class KnotCurve extends Curve<Vector3> {
-    constructor();
-  }
-
-  export class HelixCurve extends Curve<Vector3> {
-    constructor();
-  }
-
-  export class TrefoilKnot extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class TorusKnot extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class CinquefoilKnot extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class TrefoilPolynomialKnot extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class FigureEightPolynomialKnot extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class DecoratedTorusKnot4a extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class DecoratedTorusKnot4b extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class DecoratedTorusKnot5a extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
-
-  export class DecoratedTorusKnot5c extends Curve<Vector3> {
-    constructor(scale?: number);
-    scale: number;
-  }
+	export class GrannyKnot extends Curve<Vector3> {
+
+  	constructor();
+
+	}
+
+	export class HeartCurve extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class VivianiCurve extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class KnotCurve extends Curve<Vector3> {
+
+  	constructor();
+
+	}
+
+	export class HelixCurve extends Curve<Vector3> {
+
+  	constructor();
+
+	}
+
+	export class TrefoilKnot extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class TorusKnot extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class CinquefoilKnot extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class TrefoilPolynomialKnot extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class FigureEightPolynomialKnot extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class DecoratedTorusKnot4a extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class DecoratedTorusKnot4b extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class DecoratedTorusKnot5a extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
+
+	export class DecoratedTorusKnot5c extends Curve<Vector3> {
+
+  	constructor( scale?: number );
+		scale: number;
+
+	}
 
 }

examples/jsm/curves/NURBSCurve.d.ts

@@ -1,10 +1,12 @@
 import {
-  Curve,
-  Vector2,
-  Vector3,
-  Vector4
+	Curve,
+	Vector2,
+	Vector3,
+	Vector4
 } from '../../../src/Three';
 
 export class NURBSCurve extends Curve<Vector3> {
-  constructor(degree: number, knots: number[], controlPoints: Vector2[] | Vector3[] | Vector4[], startKnot: number, endKnot: number);
+
+	constructor( degree: number, knots: number[], controlPoints: Vector2[] | Vector3[] | Vector4[], startKnot: number, endKnot: number );
+
 }

examples/jsm/curves/NURBSSurface.d.ts

@@ -1,11 +1,13 @@
 import {
-  Vector2,
-  Vector3,
-  Vector4
+	Vector2,
+	Vector3,
+	Vector4
 } from '../../../src/Three';
 
 export class NURBSSurface {
-  constructor(degree1: number, degree2: number, knots1: number[], knots2: number[], controlPoints: Vector2[][] | Vector3[][] | Vector4[][]);
 
-  getPoint(t1: number, t2: number, target: Vector3): void;
+	constructor( degree1: number, degree2: number, knots1: number[], knots2: number[], controlPoints: Vector2[][] | Vector3[][] | Vector4[][] );
+
+	getPoint( t1: number, t2: number, target: Vector3 ): void;
+
 }

examples/jsm/curves/NURBSUtils.d.ts

@@ -1,18 +1,18 @@
 import {
-  Vector3,
-  Vector4
+	Vector3,
+	Vector4
 } from '../../../src/Three';
 
 export namespace NURBSUtils {
 
-  export function findSpan(p: number, u: number, U: number[]): number;
-  export function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[];
-  export function calcBSplinePoint(p: number, U: number[], P: Vector4[], u: number): Vector4;
-  export function calcBasisFunctionDerivatives(span: number,u: number, p: number, n: number, U: number[]): number[][];
-  export function calcBSplineDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector4[];
-  export function calcKoverI(k: number, i: number): number;
-  export function calcRationalCurveDerivatives(Pders: Vector4[]): Vector3[];
-  export function calcNURBSDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector3[];
-  export function calcSurfacePoint(p: number, q: number, U: number[], V: number[], P: Vector4[], u: number, v: number, target: Vector3): Vector3;
+	export function findSpan( p: number, u: number, U: number[] ): number;
+	export function calcBasisFunctions( span: number, u: number, p: number, U: number[] ): number[];
+	export function calcBSplinePoint( p: number, U: number[], P: Vector4[], u: number ): Vector4;
+	export function calcBasisFunctionDerivatives( span: number, u: number, p: number, n: number, U: number[] ): number[][];
+	export function calcBSplineDerivatives( p: number, U: number[], P: Vector4[], u: number, nd: number ): Vector4[];
+	export function calcKoverI( k: number, i: number ): number;
+	export function calcRationalCurveDerivatives( Pders: Vector4[] ): Vector3[];
+	export function calcNURBSDerivatives( p: number, U: number[], P: Vector4[], u: number, nd: number ): Vector3[];
+	export function calcSurfacePoint( p: number, q: number, U: number[], V: number[], P: Vector4[], u: number, v: number, target: Vector3 ): Vector3;
 
 }

examples/jsm/effects/AnaglyphEffect.d.ts

@@ -1,16 +1,18 @@
 import {
-  Camera,
-  Matrix3,
-  Scene,
-  WebGLRenderer
+	Camera,
+	Matrix3,
+	Scene,
+	WebGLRenderer
 } from '../../../src/Three';
 
 export class AnaglyphEffect {
-  constructor(renderer: WebGLRenderer, width?: number, height?: number);
-  colorMatrixLeft: Matrix3;
-  colorMatrixRight: Matrix3;
 
-  dispose(): void;
-  render(scene: Scene, camera: Camera): void;
-  setSize(width: number, height: number): void;
+	constructor( renderer: WebGLRenderer, width?: number, height?: number );
+	colorMatrixLeft: Matrix3;
+	colorMatrixRight: Matrix3;
+
+	dispose(): void;
+	render( scene: Scene, camera: Camera ): void;
+	setSize( width: number, height: number ): void;
+
 }

examples/jsm/effects/AsciiEffect.d.ts

@@ -1,22 +1,24 @@
 import {
-  Camera,
-  Scene,
-  WebGLRenderer
+	Camera,
+	Scene,
+	WebGLRenderer
 } from '../../../src/Three';
 
 export interface AsciiEffectOptions {
-  resolution?: number;
-  scale?: number;
-  color?: boolean;
-  alpha?: boolean;
-  block?: boolean;
-  invert?: boolean;
+	resolution?: number;
+	scale?: number;
+	color?: boolean;
+	alpha?: boolean;
+	block?: boolean;
+	invert?: boolean;
 }
 
 export class AsciiEffect {
-  constructor(renderer: WebGLRenderer, charSet?: string, options?: AsciiEffectOptions);
-  domElement: HTMLElement;
 
-  render(scene: Scene, camera: Camera): void;
-  setSize(width: number, height: number): void;
+	constructor( renderer: WebGLRenderer, charSet?: string, options?: AsciiEffectOptions );
+	domElement: HTMLElement;
+
+	render( scene: Scene, camera: Camera ): void;
+	setSize( width: number, height: number ): void;
+
 }

examples/jsm/effects/OutlineEffect.d.ts

@@ -1,36 +1,38 @@
 import {
-  Camera,
-  Scene,
-  Vector2,
-  Vector4,
-  WebGLRenderer,
-  WebGLRenderTarget,
-  WebGLShadowMap
+	Camera,
+	Scene,
+	Vector2,
+	Vector4,
+	WebGLRenderer,
+	WebGLRenderTarget,
+	WebGLShadowMap
 } from '../../../src/Three';
 
 export interface OutlineEffectParameters {
-  defaultThickness?: number;
-  defaultColor?: number[];
-  defaultAlpha?: number;
-  defaultKeepAlive?: boolean;
+	defaultThickness?: number;
+	defaultColor?: number[];
+	defaultAlpha?: number;
+	defaultKeepAlive?: boolean;
 }
 
 export class OutlineEffect {
-  constructor(renderer: WebGLRenderer, parameters: OutlineEffectParameters);
-  enabled: boolean;
-  autoClear: boolean;
-  domElement: HTMLElement;
-  shadowMap: WebGLShadowMap;
 
-  clear(color?: boolean, depth?: boolean, stencil?: boolean): void;
-  getPixelRatio(): number;
-  getSize(target: Vector2): Vector2;
-  render(scene: Scene, camera: Camera): void;
-  renderOutline(scene: Scene, camera: Camera): void;
-  setRenderTarget(renderTarget: WebGLRenderTarget | null): void;
-  setPixelRatio(value: number): void;
-  setScissor(x: Vector4 | number, y?: number, width?: number, height?: number): void;
-  setScissorTest(enable: boolean): void;
-  setSize(width: number, height: number, updateStyle?: boolean): void;
-  setViewport(x: Vector4 | number, y?: number, width?: number, height?: number): void;
+	constructor( renderer: WebGLRenderer, parameters: OutlineEffectParameters );
+	enabled: boolean;
+	autoClear: boolean;
+	domElement: HTMLElement;
+	shadowMap: WebGLShadowMap;
+
+	clear( color?: boolean, depth?: boolean, stencil?: boolean ): void;
+	getPixelRatio(): number;
+	getSize( target: Vector2 ): Vector2;
+	render( scene: Scene, camera: Camera ): void;
+	renderOutline( scene: Scene, camera: Camera ): void;
+	setRenderTarget( renderTarget: WebGLRenderTarget | null ): void;
+	setPixelRatio( value: number ): void;
+	setScissor( x: Vector4 | number, y?: number, width?: number, height?: number ): void;
+	setScissorTest( enable: boolean ): void;
+	setSize( width: number, height: number, updateStyle?: boolean ): void;
+	setViewport( x: Vector4 | number, y?: number, width?: number, height?: number ): void;
+
 }

examples/jsm/effects/ParallaxBarrierEffect.d.ts

@@ -1,12 +1,14 @@
 import {
-  Camera,
-  Scene,
-  WebGLRenderer
+	Camera,
+	Scene,
+	WebGLRenderer
 } from '../../../src/Three';
 
 export class ParallaxBarrierEffect {
-  constructor(renderer: WebGLRenderer);
 
-  render(scene: Scene, camera: Camera): void;
-  setSize(width: number, height: number): void;
+	constructor( renderer: WebGLRenderer );
+
+	render( scene: Scene, camera: Camera ): void;
+	setSize( width: number, height: number ): void;
+
 }

examples/jsm/effects/PeppersGhostEffect.d.ts

@@ -1,14 +1,16 @@
 import {
-  Camera,
-  Scene,
-  WebGLRenderer
+	Camera,
+	Scene,
+	WebGLRenderer
 } from '../../../src/Three';
 
 export class PeppersGhostEffect {
-  constructor(renderer: WebGLRenderer);
-  cameraDistance: number;
-  reflectFromAbove: boolean;
 
-  render(scene: Scene, camera: Camera): void;
-  setSize(width: number, height: number): void;
+	constructor( renderer: WebGLRenderer );
+	cameraDistance: number;
+	reflectFromAbove: boolean;
+
+	render( scene: Scene, camera: Camera ): void;
+	setSize( width: number, height: number ): void;
+
 }

examples/jsm/effects/StereoEffect.d.ts

@@ -1,13 +1,15 @@
 import {
-  Camera,
-  Scene,
-  WebGLRenderer
+	Camera,
+	Scene,
+	WebGLRenderer
 } from '../../../src/Three';
 
 export class StereoEffect {
-  constructor(renderer: WebGLRenderer);
 
-  setEyeSeparation(eyeSep: number): void;
-  render(scene: Scene, camera: Camera): void;
-  setSize(width: number, height: number): void;
+	constructor( renderer: WebGLRenderer );
+
+	setEyeSeparation( eyeSep: number ): void;
+	render( scene: Scene, camera: Camera ): void;
+	setSize( width: number, height: number ): void;
+
 }

examples/jsm/exporters/ColladaExporter.d.ts

@@ -1,18 +1,20 @@
 import { Object3D } from '../../../src/Three';
 
 export interface ColladaExporterOptions {
-  author?: string;
-  textureDirectory?: string;
-  version?: string;
+	author?: string;
+	textureDirectory?: string;
+	version?: string;
 }
 
 export interface ColladaExporterResult {
-  data: string;
-  textures: object[];
+	data: string;
+	textures: object[];
 }
 
 export class ColladaExporter {
-  constructor();
-  
-  parse(object: Object3D, onDone: (res: ColladaExporterResult) => void, options: ColladaExporterOptions): ColladaExporterResult | null;
+
+	constructor();
+
+	parse( object: Object3D, onDone: ( res: ColladaExporterResult ) => void, options: ColladaExporterOptions ): ColladaExporterResult | null;
+
 }

examples/jsm/exporters/DRACOExporter.d.ts

@@ -1,20 +1,22 @@
 import {
-  BufferGeometry,
-  Geometry
+	BufferGeometry,
+	Geometry
 } from '../../../src/Three';
 
 export interface DRACOExporterOptions {
-  decodeSpeed?: number;
-  encodeSpeed?: number;
-  encoderMethod?: number;
-  quantization?: number[];
-  exportUvs?: boolean;
-  exportNormals?: boolean;
-  exportColor?: boolean;
+	decodeSpeed?: number;
+	encodeSpeed?: number;
+	encoderMethod?: number;
+	quantization?: number[];
+	exportUvs?: boolean;
+	exportNormals?: boolean;
+	exportColor?: boolean;
 }
 
 export class DRACOExporter {
-  constructor();
 
-  parse(geometry: BufferGeometry | Geometry, options: DRACOExporterOptions): Int8Array;
+	constructor();
+
+	parse( geometry: BufferGeometry | Geometry, options: DRACOExporterOptions ): Int8Array;
+
 }

examples/jsm/exporters/GLTFExporter.d.ts

@@ -1,22 +1,24 @@
 import {
-  Object3D,
-  AnimationClip
+	Object3D,
+	AnimationClip
 } from '../../../src/Three';
 
 export interface GLTFExporterOptions {
-  binary?: boolean;
-  trs?: boolean;
-  onlyVisible?: boolean;
-  truncateDrawRange?: boolean;
-  embedImages?: boolean;
-  animations?: AnimationClip[];
-  forceIndices?: boolean;
-  forcePowerOfTwoTextures?: boolean;
-  includeCustomExtensions?: boolean;
+	binary?: boolean;
+	trs?: boolean;
+	onlyVisible?: boolean;
+	truncateDrawRange?: boolean;
+	embedImages?: boolean;
+	animations?: AnimationClip[];
+	forceIndices?: boolean;
+	forcePowerOfTwoTextures?: boolean;
+	includeCustomExtensions?: boolean;
 }
 
 export class GLTFExporter {
-  constructor();
 
-  parse(input: Object3D, onCompleted: (gltf: object) => void, options: GLTFExporterOptions): void;
+	constructor();
+
+	parse( input: Object3D, onCompleted: ( gltf: object ) => void, options: GLTFExporterOptions ): void;
+
 }

examples/jsm/exporters/MMDExporter.d.ts

@@ -1,7 +1,9 @@
 import { Object3D } from '../../../src/Three';
 
 export class MMDExporter {
+
 	constructor();
 
-	parseVpd(skin: Object3D, outputShiftJis: boolean, useOriginalBones: boolean): [] | Uint8Array
+	parseVpd( skin: Object3D, outputShiftJis: boolean, useOriginalBones: boolean ): [] | Uint8Array
+
 }

examples/jsm/exporters/OBJExporter.d.ts

@@ -1,7 +1,9 @@
 import { Object3D } from '../../../src/Three';
 
 export class OBJExporter {
+
 	constructor();
 
-	parse(object: Object3D): string;
+	parse( object: Object3D ): string;
+
 }

examples/jsm/exporters/PLYExporter.d.ts

@@ -1,12 +1,14 @@
 import { Object3D } from '../../../src/Three';
 
 export interface PLYExporterOptions {
-  binary?: boolean;
-  excludeAttributes?: string[];
+	binary?: boolean;
+	excludeAttributes?: string[];
 }
 
 export class PLYExporter {
-  constructor();
 
-  parse(object: Object3D, onDone: (res: string) => void, options: PLYExporterOptions): string | null;
+	constructor();
+
+	parse( object: Object3D, onDone: ( res: string ) => void, options: PLYExporterOptions ): string | null;
+
 }

examples/jsm/exporters/STLExporter.d.ts

@@ -1,11 +1,13 @@
 import { Object3D } from '../../../src/Three';
 
 export interface STLExporterOptions {
-  binary?: boolean;
+	binary?: boolean;
 }
 
 export class STLExporter {
-  constructor();
 
-  parse(scene: Object3D, options?: STLExporterOptions): string;
+	constructor();
+
+	parse( scene: Object3D, options?: STLExporterOptions ): string;
+
 }

examples/jsm/exporters/TypedGeometryExporter.d.ts

@@ -1,7 +1,9 @@
 import { Object3D } from '../../../src/Three';
 
 export class TypedGeometryExporterD {
+
 	constructor();
 
-	parse(scene: Object3D, options: {}): DataView | string;
+	parse( scene: Object3D, options: {} ): DataView | string;
+
 }

examples/jsm/geometries/BoxLineGeometry.d.ts

@@ -1,7 +1,9 @@
 import {
-  BufferGeometry
+	BufferGeometry
 } from '../../../src/Three';
 
 export class BoxLineGeometry extends BufferGeometry {
-  constructor(width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number);
+
+	constructor( width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number );
+
 }

examples/jsm/geometries/ConvexGeometry.d.ts

@@ -1,13 +1,17 @@
 import {
-  BufferGeometry,
-  Geometry,
-  Vector3
+	BufferGeometry,
+	Geometry,
+	Vector3
 } from '../../../src/Three';
 
 export class ConvexGeometry extends Geometry {
-  constructor(points: Vector3[]);
+
+	constructor( points: Vector3[] );
+
 }
 
 export class ConvexBufferGeometry extends BufferGeometry {
-  constructor(points: Vector3[]);
+
+	constructor( points: Vector3[] );
+
 }

examples/jsm/geometries/DecalGeometry.d.ts

@@ -1,15 +1,19 @@
 import {
-  BufferGeometry,
-  Euler,
-  Mesh,
-  Vector3
+	BufferGeometry,
+	Euler,
+	Mesh,
+	Vector3
 } from '../../../src/Three';
 
 export class DecalGeometry extends BufferGeometry {
-  constructor(mesh: Mesh, position: Vector3, orientation: Euler, size: Vector3);
+
+	constructor( mesh: Mesh, position: Vector3, orientation: Euler, size: Vector3 );
+
 }
 
 export class DecalVertex {
-  constructor(position: Vector3, normal: Vector3);
-  clone(): DecalVertex;
+
+	constructor( position: Vector3, normal: Vector3 );
+	clone(): DecalVertex;
+
 }

examples/jsm/geometries/LightningStrike.d.ts

@@ -1,105 +1,107 @@
 import {
-  Vector3
+	Vector3
 } from '../../../src/Three';
 
 export interface RandomGenerator {
-  random(): number;
-  getSeed(): number;
-  setSeed(seed: number): void;
+	random(): number;
+	getSeed(): number;
+	setSeed( seed: number ): void;
 }
 
 export interface LightningSegment {
-  iteration: number;
-  pos0: Vector3;
-  pos1: Vector3;
-  linPos0: Vector3;
-  linPos1: Vector3;
-  up0: Vector3;
-  up1: Vector3;
-  radius0: number;
-  radius1: number;
-  fraction0: number;
-  fraction1: number;
-  positionVariationFactor: number;
+	iteration: number;
+	pos0: Vector3;
+	pos1: Vector3;
+	linPos0: Vector3;
+	linPos1: Vector3;
+	up0: Vector3;
+	up1: Vector3;
+	radius0: number;
+	radius1: number;
+	fraction0: number;
+	fraction1: number;
+	positionVariationFactor: number;
 }
 
 export interface LightningSubray {
-  seed: number;
-  maxIterations: number;
-  recursion: number;
-  pos0: Vector3;
-  pos1: Vector3;
-  linPos0: Vector3;
-  linPos1: Vector3;
-  up0: Vector3;
-  up1: Vector3;
-  radius0: number;
-  radius1: number;
-  birthTime: number;
-  deathTime: number;
-  timeScale: number;
-  roughness: number;
-  straightness: number;
-  propagationTimeFactor: number;
-  vanishingTimeFactor: number;
-  endPropagationTime: number;
-  beginVanishingTime: number;
+	seed: number;
+	maxIterations: number;
+	recursion: number;
+	pos0: Vector3;
+	pos1: Vector3;
+	linPos0: Vector3;
+	linPos1: Vector3;
+	up0: Vector3;
+	up1: Vector3;
+	radius0: number;
+	radius1: number;
+	birthTime: number;
+	deathTime: number;
+	timeScale: number;
+	roughness: number;
+	straightness: number;
+	propagationTimeFactor: number;
+	vanishingTimeFactor: number;
+	endPropagationTime: number;
+	beginVanishingTime: number;
 }
 
 export interface RayParameters {
-  sourceOffset?: Vector3;
-  destOffset?: Vector3;
-
-  timeScale?: number;
-  roughness?: number;
-  straightness?: number;
-
-  up0?: Vector3;
-  up1?: Vector3;
-  radius0?: number;
-  radius1?: number;
-  radius0Factor? : number;
-  radius1Factor? : number;
-  minRadius? : number;
-
-  isEternal?: boolean;
-  birthTime?: number;
-  deathTime?: number;
-  propagationTimeFactor?: number;
-  vanishingTimeFactor?: number;
-  subrayPeriod?: number;
-  subrayDutyCycle?: number;
-
-  maxIterations?: number;
-  isStatic?: boolean;
-  ramification?: number;
-  maxSubrayRecursion?: number;
-  recursionProbability?: number;
-  generateUVs?: boolean;
-
-  randomGenerator?: RandomGenerator;
-  noiseSeed?: number;
-
-  onDecideSubrayCreation?: (segment: LightningSegment, lightningStrike: LightningStrike) => void;
-  onSubrayCreation?: (segment: LightningSegment, parentSubray: LightningSubray, childSubray: LightningSubray, lightningStrike: LightningStrike) => void;
+	sourceOffset?: Vector3;
+	destOffset?: Vector3;
+
+	timeScale?: number;
+	roughness?: number;
+	straightness?: number;
+
+	up0?: Vector3;
+	up1?: Vector3;
+	radius0?: number;
+	radius1?: number;
+	radius0Factor? : number;
+	radius1Factor? : number;
+	minRadius? : number;
+
+	isEternal?: boolean;
+	birthTime?: number;
+	deathTime?: number;
+	propagationTimeFactor?: number;
+	vanishingTimeFactor?: number;
+	subrayPeriod?: number;
+	subrayDutyCycle?: number;
+
+	maxIterations?: number;
+	isStatic?: boolean;
+	ramification?: number;
+	maxSubrayRecursion?: number;
+	recursionProbability?: number;
+	generateUVs?: boolean;
+
+	randomGenerator?: RandomGenerator;
+	noiseSeed?: number;
+
+	onDecideSubrayCreation?: ( segment: LightningSegment, lightningStrike: LightningStrike ) => void;
+	onSubrayCreation?: ( segment: LightningSegment, parentSubray: LightningSubray, childSubray: LightningSubray, lightningStrike: LightningStrike ) => void;
 }
 
 export class LightningStrike {
-  constructor(rayParameters?: RayParameters);
-  copyParameters( dest?: RayParameters, source?: RayParameters): RayParameters;
 
-  // Ray states
-  static readonly RAY_INITIALIZED: number;
-  static readonly RAY_UNBORN: number;
-  static readonly RAY_PROPAGATING: number;
-  static readonly RAY_STEADY: number;
-  static readonly RAY_VANISHING: number;
-  static readonly RAY_EXTINGUISHED: number;
+	constructor( rayParameters?: RayParameters );
+	copyParameters( dest?: RayParameters, source?: RayParameters ): RayParameters;
+
+	// Ray states
+	static readonly RAY_INITIALIZED: number;
+	static readonly RAY_UNBORN: number;
+	static readonly RAY_PROPAGATING: number;
+	static readonly RAY_STEADY: number;
+	static readonly RAY_VANISHING: number;
+	static readonly RAY_EXTINGUISHED: number;
+
+	state: number;
 
-  state: number;
+	update( time: number ): void;
 
-  update(time: number): void;
+	copy( source: LightningStrike ): LightningStrike;
+	clone(): LightningStrike;
 
-  copy(source: LightningStrike): LightningStrike;
-  clone(): LightningStrike;
 }

examples/jsm/geometries/ParametricGeometries.d.ts

@@ -1,27 +1,35 @@
 import {
-  Curve,
-  Vector3
+	Curve,
+	Vector3
 } from '../../../src/Three';
 
-export namespace ParametricGeometries  {
-  export function klein(v: number, u: number, target: Vector3): Vector3;
-  export function plane(width: number, height: number, target: Vector3): Vector3;
-  export function mobius(u: number, t: number, target: Vector3): Vector3;
-  export function mobius3d(u: number, t: number, target: Vector3): Vector3;
+export namespace ParametricGeometries {
+	export function klein( v: number, u: number, target: Vector3 ): Vector3;
+	export function plane( width: number, height: number, target: Vector3 ): Vector3;
+	export function mobius( u: number, t: number, target: Vector3 ): Vector3;
+	export function mobius3d( u: number, t: number, target: Vector3 ): Vector3;
 
-  export class TubeGeometry {
-    constructor(path: Curve<Vector3>, segments?: number, radius?: number, segmentsRadius?: number, closed?: boolean, debug?: boolean);
-  }
+	export class TubeGeometry {
 
-  export class TorusKnotGeometry {
-    constructor(radius?: number, tube?: number, segmentsT?: number, segmentsR?: number, p?: number, q?: number);
-  }
+  	constructor( path: Curve<Vector3>, segments?: number, radius?: number, segmentsRadius?: number, closed?: boolean, debug?: boolean );
 
-  export class SphereGeometry {
-    constructor(size: number, u: number, v);
-  }
+	}
 
-  export class PlaneGeometry {
-    constructor(width: number, depth: number, segmentsWidth: number, segmentsDepth: number);
-  }
+	export class TorusKnotGeometry {
+
+  	constructor( radius?: number, tube?: number, segmentsT?: number, segmentsR?: number, p?: number, q?: number );
+
+	}
+
+	export class SphereGeometry {
+
+  	constructor( size: number, u: number, v );
+
+	}
+
+	export class PlaneGeometry {
+
+  	constructor( width: number, depth: number, segmentsWidth: number, segmentsDepth: number );
+
+	}
 }

examples/jsm/geometries/TeapotBufferGeometry.d.ts

@@ -1,7 +1,9 @@
 import {
-  BufferGeometry
+	BufferGeometry
 } from '../../../src/Three';
 
 export class TeapotBufferGeometry extends BufferGeometry {
-  constructor(size?: number, segments?: number, bottom?: boolean, lid?: boolean, body?: boolean, fitLid?: boolean, blinn?: number);
+
+	constructor( size?: number, segments?: number, bottom?: boolean, lid?: boolean, body?: boolean, fitLid?: boolean, blinn?: number );
+
 }

examples/jsm/interactive/SelectionBox.d.ts

@@ -1,22 +1,24 @@
 import {
-  Camera,
-  Frustum,
-  Mesh,
-  Object3D,
-  Scene,
-  Vector3
+	Camera,
+	Frustum,
+	Mesh,
+	Object3D,
+	Scene,
+	Vector3
 } from '../../../src/Three';
 
-export class SelectionBox  {
-  constructor(camera: Camera, scene: Scene, deep?: number);
-  camera: Camera;
-  collection: Mesh[];
-  deep: number;
-  endPoint: Vector3;
-  scene: Scene;
-  startPoint: Vector3;
+export class SelectionBox {
+
+	constructor( camera: Camera, scene: Scene, deep?: number );
+	camera: Camera;
+	collection: Mesh[];
+	deep: number;
+	endPoint: Vector3;
+	scene: Scene;
+	startPoint: Vector3;
+
+	select( startPoint: Vector3, endPoint: Vector3 ): Mesh[];
+	updateFrustum( startPoint: Vector3, endPoint: Vector3 ): void;
+	searchChildInFrustum( frustum: Frustum, object: Object3D ): void;
 
-  select(startPoint: Vector3, endPoint: Vector3): Mesh[];
-  updateFrustum(startPoint: Vector3, endPoint: Vector3): void;
-  searchChildInFrustum(frustum: Frustum, object: Object3D): void;
 }

examples/jsm/interactive/SelectionHelper.d.ts

@@ -1,20 +1,22 @@
 import {
-  WebGLRenderer,
-  Vector2
+	WebGLRenderer,
+	Vector2
 } from '../../../src/Three';
 
 import { SelectionBox } from './SelectionBox';
 
 export class SelectionHelper {
-  constructor(selectionBox: SelectionBox, renderer: WebGLRenderer, cssClassName: string);
-  element: HTMLElement;
-  isDown: boolean;
-  pointBottomRight: Vector2;
-  pointTopLeft: Vector2;
-  renderer: WebGLRenderer;
-  startPoint: Vector2;
 
-  onSelectStart(event: Event): void;
-  onSelectMove(event: Event): void;
-  onSelectOver(event: Event): void;
+	constructor( selectionBox: SelectionBox, renderer: WebGLRenderer, cssClassName: string );
+	element: HTMLElement;
+	isDown: boolean;
+	pointBottomRight: Vector2;
+	pointTopLeft: Vector2;
+	renderer: WebGLRenderer;
+	startPoint: Vector2;
+
+	onSelectStart( event: Event ): void;
+	onSelectMove( event: Event ): void;
+	onSelectOver( event: Event ): void;
+
 }

examples/jsm/lights/LightProbeGenerator.d.ts

@@ -1,10 +1,10 @@
 import {
-  CubeTexture,
-  LightProbe
+	CubeTexture,
+	LightProbe
 } from '../../../src/Three';
 
 export namespace LightProbeGenerator {
 
-  export function fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
+	export function fromCubeTexture( cubeTexture: CubeTexture ): LightProbe;
 
 }

examples/jsm/lights/RectAreaLightUniformsLib.d.ts

@@ -1,5 +1,5 @@
 export namespace RectAreaLightUniformsLib {
 
-  export function init(): void;
+	export function init(): void;
 
 }

examples/jsm/lines/Line2.d.ts

@@ -3,6 +3,8 @@ import { LineSegments2 } from './LineSegments2';
 import { LineMaterial } from './LineMaterial';
 
 export class Line2 extends LineSegments2 {
-  constructor(geometry?: LineGeometry, material?: LineMaterial);
-  isLine2: boolean;
+
+	constructor( geometry?: LineGeometry, material?: LineMaterial );
+	isLine2: boolean;
+
 }

examples/jsm/lines/LineGeometry.d.ts

@@ -1,12 +1,14 @@
 import {
-  Line
+	Line
 } from '../../../src/Three';
 
 import { LineSegmentsGeometry } from './LineSegmentsGeometry';
 
 export class LineGeometry extends LineSegmentsGeometry {
-  constructor();
-  isLineGeometry: boolean;
 
-  fromLine(line: Line): this;
+	constructor();
+	isLineGeometry: boolean;
+
+	fromLine( line: Line ): this;
+
 }

examples/jsm/lines/LineMaterial.d.ts

@@ -1,28 +1,30 @@
 import {
-  Color,
-  MaterialParameters,
-  ShaderMaterial,
-  Vector2
+	Color,
+	MaterialParameters,
+	ShaderMaterial,
+	Vector2
 } from '../../../src/Three';
 
 export interface LineMaterialParameters extends MaterialParameters {
-  color?: number;
-  dashed?: boolean;
-  dashScale?: number;
-  dashSize?: number;
-  gapSize?: number;
-  linewidth?: number;
-  resolution?: Vector2;
+	color?: number;
+	dashed?: boolean;
+	dashScale?: number;
+	dashSize?: number;
+	gapSize?: number;
+	linewidth?: number;
+	resolution?: Vector2;
 }
 
 export class LineMaterial extends ShaderMaterial {
-  constructor(parameters?: LineMaterialParameters);
-  color: Color;
-  dashed: boolean;
-  dashScale: number;
-  dashSize: number;
-  gapSize: number;
-  isLineMaterial: boolean;
-  linewidth: number;
-  resolution: Vector2;
+
+	constructor( parameters?: LineMaterialParameters );
+	color: Color;
+	dashed: boolean;
+	dashScale: number;
+	dashSize: number;
+	gapSize: number;
+	isLineMaterial: boolean;
+	linewidth: number;
+	resolution: Vector2;
+
 }

examples/jsm/lines/LineSegments2.d.ts

@@ -1,13 +1,15 @@
 import {
-  Mesh,
+	Mesh,
 } from '../../../src/Three';
 
 import { LineMaterial } from './LineMaterial';
 import { LineSegmentsGeometry } from './LineSegmentsGeometry';
 
 export class LineSegments2 extends Mesh {
-  constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
-  isLineSegments2: boolean;
 
-  computeLineDistances(): this;
+	constructor( geometry?: LineSegmentsGeometry, material?: LineMaterial );
+	isLineSegments2: boolean;
+
+	computeLineDistances(): this;
+
 }

examples/jsm/lines/LineSegmentsGeometry.d.ts

@@ -1,23 +1,25 @@
 import {
-  EdgesGeometry,
-  InstancedBufferGeometry,
-  LineSegments,
-  Matrix4,
-  Mesh,
-  WireframeGeometry
+	EdgesGeometry,
+	InstancedBufferGeometry,
+	LineSegments,
+	Matrix4,
+	Mesh,
+	WireframeGeometry
 } from '../../../src/Three';
 
 export class LineSegmentsGeometry extends InstancedBufferGeometry {
-  constructor();
-  isLineSegmentsGeometry: boolean;
 
-  applyMatrix(matrix: Matrix4): this;
-  computeBoundingBox(): void;
-  computeBoundingSphere(): void;
-  fromEdgesGeometry(geometry: WireframeGeometry): this;
-  fromLineSegements(lineSegments: LineSegments): this;
-  fromMesh(mesh: Mesh): this;
-  fromWireframeGeometry(geometry: EdgesGeometry): this;
-  setColors(array: number[] | Float32Array): this;
-  setPositions(array: number[] | Float32Array): this;
+	constructor();
+	isLineSegmentsGeometry: boolean;
+
+	applyMatrix( matrix: Matrix4 ): this;
+	computeBoundingBox(): void;
+	computeBoundingSphere(): void;
+	fromEdgesGeometry( geometry: WireframeGeometry ): this;
+	fromLineSegements( lineSegments: LineSegments ): this;
+	fromMesh( mesh: Mesh ): this;
+	fromWireframeGeometry( geometry: EdgesGeometry ): this;
+	setColors( array: number[] | Float32Array ): this;
+	setPositions( array: number[] | Float32Array ): this;
+
 }

examples/jsm/lines/Wireframe.d.ts

@@ -1,13 +1,15 @@
 import {
-  Mesh,
+	Mesh,
 } from '../../../src/Three';
 
 import { LineMaterial } from './LineMaterial';
 import { LineSegmentsGeometry } from './LineSegmentsGeometry';
 
 export class Wireframe extends Mesh {
-  constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
-  isWireframe: boolean;
 
-  computeLineDistances(): this;
+	constructor( geometry?: LineSegmentsGeometry, material?: LineMaterial );
+	isWireframe: boolean;
+
+	computeLineDistances(): this;
+
 }

examples/jsm/lines/WireframeGeometry2.d.ts

@@ -1,11 +1,13 @@
 import {
-  BufferGeometry,
-  Geometry
+	BufferGeometry,
+	Geometry
 } from '../../../src/Three';
 
 import { LineSegmentsGeometry } from './LineSegmentsGeometry';
 
 export class WireframeGeometry2 extends LineSegmentsGeometry {
-  constructor(geometry: Geometry | BufferGeometry);
-  isWireframeGeometry2: boolean;
+
+	constructor( geometry: Geometry | BufferGeometry );
+	isWireframeGeometry2: boolean;
+
 }

examples/jsm/loaders/3MFLoader.d.ts

@@ -1,14 +1,16 @@
 import {
-  Loader,
-  LoadingManager,
-  Group
+	Loader,
+	LoadingManager,
+	Group
 } from '../../../src/Three';
 
 export class ThreeMFLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  availableExtensions: object[];
 
-  load(url: string, onLoad: (object: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: ArrayBuffer): Group;
-  addExtension(extension: object):void
+	constructor( manager?: LoadingManager );
+	availableExtensions: object[];
+
+	load( url: string, onLoad: ( object: Group ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: ArrayBuffer ): Group;
+	addExtension( extension: object ):void
+
 }

examples/jsm/loaders/AMFLoader.d.ts

@@ -1,12 +1,14 @@
 import {
-  Loader,
-  LoadingManager,
-  Group
+	Loader,
+	LoadingManager,
+	Group
 } from '../../../src/Three';
 
 export class AMFLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (object: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: ArrayBuffer): Group;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( object: Group ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: ArrayBuffer ): Group;
+
 }

examples/jsm/loaders/AWDLoader.d.ts

@@ -1,49 +1,51 @@
 import {
-  Bone,
-  BufferGeometry,
-  Loader,
-  LoadingManager,
-  Material,
-  Matrix4,
-  Mesh,
-  Object3D,
-  Texture
+	Bone,
+	BufferGeometry,
+	Loader,
+	LoadingManager,
+	Material,
+	Matrix4,
+	Mesh,
+	Object3D,
+	Texture
 } from '../../../src/Three';
 
 export class AWDLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  materialFactory: any;
-  path: string;
-  trunk: Object3D;
 
-  getBlock(id: number): any;
-  load(url: string, onLoad: (result: Object3D) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  loadTexture(url: string): Texture;
-  parse(data: ArrayBuffer): Object3D;
-  parseAnimatorSet(): object;
-  parseAttrValue(type: number, value: number): any;
-  parseContainer(): Object3D;
-  parseMaterial(): Material;
-  parseMatrix4(): Matrix4;
-  parseMeshData(): BufferGeometry[];
-  parseMeshInstance(): Mesh;
-  parseMeshPoseAnimation(poseOnly: boolean): null;
-  parseNextBlock(): void;
-  parseProperties(expected: object): object;
-  parseSkeleton(): Bone[];
-  parseSkeletonAnimation(): object[];
-  parseSkeletonPose(): Matrix4[];
-  parseTexture(): Texture;
-  parseUserAttributes(): null;
-  parseVertexAnimationSet(): object[];
-  readU8(): number;
-  readI8(): number;
-  readU16(): number;
-  readI16(): number;
-  readU32(): number;
-  readI32(): number;
-  readF32(): number;
-  readF64(): number;
-  readUTF(): string;
-  readUTFBytes(len: number): string;
+	constructor( manager?: LoadingManager );
+	materialFactory: any;
+	path: string;
+	trunk: Object3D;
+
+	getBlock( id: number ): any;
+	load( url: string, onLoad: ( result: Object3D ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	loadTexture( url: string ): Texture;
+	parse( data: ArrayBuffer ): Object3D;
+	parseAnimatorSet(): object;
+	parseAttrValue( type: number, value: number ): any;
+	parseContainer(): Object3D;
+	parseMaterial(): Material;
+	parseMatrix4(): Matrix4;
+	parseMeshData(): BufferGeometry[];
+	parseMeshInstance(): Mesh;
+	parseMeshPoseAnimation( poseOnly: boolean ): null;
+	parseNextBlock(): void;
+	parseProperties( expected: object ): object;
+	parseSkeleton(): Bone[];
+	parseSkeletonAnimation(): object[];
+	parseSkeletonPose(): Matrix4[];
+	parseTexture(): Texture;
+	parseUserAttributes(): null;
+	parseVertexAnimationSet(): object[];
+	readU8(): number;
+	readI8(): number;
+	readU16(): number;
+	readI16(): number;
+	readU32(): number;
+	readI32(): number;
+	readF32(): number;
+	readF64(): number;
+	readUTF(): string;
+	readUTFBytes( len: number ): string;
+
 }

examples/jsm/loaders/AssimpJSONLoader.d.ts

@@ -1,12 +1,14 @@
 import {
-  Object3D,
-  Loader,
-  LoadingManager
+	Object3D,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class AssimpJSONLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (object: Object3D) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(json: object, path: string) : Object3D;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( object: Object3D ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( json: object, path: string ) : Object3D;
+
 }

examples/jsm/loaders/AssimpLoader.d.ts

@@ -1,18 +1,20 @@
 import {
-  Object3D,
-  Loader,
-  LoadingManager
+	Object3D,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 
 export interface Assimp {
-  animation: any;
-  object: Object3D;
+	animation: any;
+	object: Object3D;
 }
 
 export class AssimpLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (result: Assimp) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(buffer: ArrayBuffer, path: string) : Assimp;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( result: Assimp ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( buffer: ArrayBuffer, path: string ) : Assimp;
+
 }

examples/jsm/loaders/BVHLoader.d.ts

@@ -1,21 +1,23 @@
 import {
-  AnimationClip,
-  Skeleton,
-  Loader,
-  LoadingManager
+	AnimationClip,
+	Skeleton,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 
 export interface BVH {
-  clip: AnimationClip;
-  skeleton: Skeleton;
+	clip: AnimationClip;
+	skeleton: Skeleton;
 }
 
 export class BVHLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  animateBonePositions: boolean;
-  animateBoneRotations: boolean;
 
-  load(url: string, onLoad: (bvh: BVH) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(text: string) : BVH;
+	constructor( manager?: LoadingManager );
+	animateBonePositions: boolean;
+	animateBoneRotations: boolean;
+
+	load( url: string, onLoad: ( bvh: BVH ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( text: string ) : BVH;
+
 }

examples/jsm/loaders/BasisTextureLoader.d.ts

@@ -1,30 +1,32 @@
 import {
-  CompressedTexture,
-  Loader,
-  LoadingManager,
-  WebGLRenderer
+	CompressedTexture,
+	Loader,
+	LoadingManager,
+	WebGLRenderer
 } from '../../../src/Three';
 
 export class BasisTextureLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  transcoderBinary: ArrayBuffer | null;
-  transcoderPath: string;
-  transcoderPending: Promise<void> | null;
 
-  workerConfig: {
-    format: number;
-    etcSupported: boolean;
-    dxtSupported: boolean;
-    pvrtcSupported: boolean;
-  }
-  workerLimit: number;
-  workerNextTaskID: number;
-  workerPool: object[];
-  workerSourceURL: string;
+	constructor( manager?: LoadingManager );
+	transcoderBinary: ArrayBuffer | null;
+	transcoderPath: string;
+	transcoderPending: Promise<void> | null;
+
+	workerConfig: {
+		format: number;
+		etcSupported: boolean;
+		dxtSupported: boolean;
+		pvrtcSupported: boolean;
+	}
+	workerLimit: number;
+	workerNextTaskID: number;
+	workerPool: object[];
+	workerSourceURL: string;
+
+	detectSupport( renderer: WebGLRenderer ): this;
+	dispose(): void;
+	load( url: string, onLoad: ( texture: CompressedTexture ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	setTranscoderPath( path: string ): this;
+	setWorkerLimit( workerLimit: number ): this;
 
-  detectSupport(renderer: WebGLRenderer): this;
-  dispose(): void;
-  load(url: string, onLoad: (texture: CompressedTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  setTranscoderPath(path: string): this;
-  setWorkerLimit(workerLimit: number): this;
 }

examples/jsm/loaders/ColladaLoader.d.ts

@@ -1,21 +1,23 @@
 import {
-  AnimationClip,
-  Loader,
-  LoadingManager,
-  Scene
+	AnimationClip,
+	Loader,
+	LoadingManager,
+	Scene
 } from '../../../src/Three';
 
 
 export interface Collada {
-  animations: AnimationClip[];
-  kinematics: object;
-  library: object;
-  scene: Scene;
+	animations: AnimationClip[];
+	kinematics: object;
+	library: object;
+	scene: Scene;
 }
 
 export class ColladaLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (collada: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(text: string, path: string) : Collada;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( collada: Collada ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( text: string, path: string ) : Collada;
+
 }

examples/jsm/loaders/DDSLoader.d.ts

@@ -1,21 +1,23 @@
 import {
-  LoadingManager,
-  CompressedTextureLoader,
-  PixelFormat,
-  CompressedPixelFormat
+	LoadingManager,
+	CompressedTextureLoader,
+	PixelFormat,
+	CompressedPixelFormat
 } from '../../../src/Three';
 
 export interface DDS {
-  mipmaps: object[];
-  width: number;
-  height: number;
-  format: PixelFormat | CompressedPixelFormat;
-  mipmapCount: number;
-  isCubemap: boolean;
+	mipmaps: object[];
+	width: number;
+	height: number;
+	format: PixelFormat | CompressedPixelFormat;
+	mipmapCount: number;
+	isCubemap: boolean;
 }
 
 export class DDSLoader extends CompressedTextureLoader {
-  constructor(manager?: LoadingManager);
 
-  parse(buffer: ArrayBuffer, loadMipmaps: boolean) : DDS;
+	constructor( manager?: LoadingManager );
+
+	parse( buffer: ArrayBuffer, loadMipmaps: boolean ) : DDS;
+
 }

examples/jsm/loaders/DRACOLoader.d.ts

@@ -1,15 +1,17 @@
 import {
-  Loader,
-  LoadingManager,
-  BufferGeometry
+	Loader,
+	LoadingManager,
+	BufferGeometry
 } from '../../../src/Three';
 
 export class DRACOLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  setDecoderPath(path: string): DRACOLoader;
-  setDecoderConfig(config: object): DRACOLoader;
-  setWorkerLimit(workerLimit: number): DRACOLoader;
-  dispose(): DRACOLoader;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( geometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	setDecoderPath( path: string ): DRACOLoader;
+	setDecoderConfig( config: object ): DRACOLoader;
+	setWorkerLimit( workerLimit: number ): DRACOLoader;
+	dispose(): DRACOLoader;
+
 }

examples/jsm/loaders/EXRLoader.d.ts

@@ -1,23 +1,25 @@
 import {
-  LoadingManager,
-  DataTextureLoader,
-  TextureDataType,
-  PixelFormat
+	LoadingManager,
+	DataTextureLoader,
+	TextureDataType,
+	PixelFormat
 } from '../../../src/Three';
 
 export interface EXR {
-  header: object;
-  width: number;
-  height: number;
-  data: Float32Array;
-  format: PixelFormat;
-  type: TextureDataType;
+	header: object;
+	width: number;
+	height: number;
+	data: Float32Array;
+	format: PixelFormat;
+	type: TextureDataType;
 }
 
 export class EXRLoader extends DataTextureLoader {
-  constructor(manager?: LoadingManager);
-  type: TextureDataType;
 
-  parse(buffer: ArrayBuffer) : EXR;
-  setDataType(type: TextureDataType): this;
+	constructor( manager?: LoadingManager );
+	type: TextureDataType;
+
+	parse( buffer: ArrayBuffer ) : EXR;
+	setDataType( type: TextureDataType ): this;
+
 }

examples/jsm/loaders/EquirectangularToCubeGenerator.d.ts

@@ -1,34 +1,38 @@
 import {
-  PixelFormat,
-  Texture,
-  TextureDataType,
-  TextureFilter,
-  WebGLRenderer,
-  WebGLRenderTargetCube
+	PixelFormat,
+	Texture,
+	TextureDataType,
+	TextureFilter,
+	WebGLRenderer,
+	WebGLRenderTargetCube
 } from '../../../src/Three';
 
 export interface CubemapGeneratorOptions {
-  resolution?: number;
-  generateMipmaps?: boolean;
-  magFilter?: TextureFilter;
-  minFilter?: TextureFilter;
+	resolution?: number;
+	generateMipmaps?: boolean;
+	magFilter?: TextureFilter;
+	minFilter?: TextureFilter;
 }
 
 export interface EquirectangularToCubeGeneratorOptions {
-  resolution?: number;
-  format?: PixelFormat;
-  type?: TextureDataType;
+	resolution?: number;
+	format?: PixelFormat;
+	type?: TextureDataType;
 }
 
 export class CubemapGenerator {
-  constructor(renderer: WebGLRenderer);
 
-  fromEquirectangular(texture: Texture, options?: CubemapGeneratorOptions): WebGLRenderTargetCube;
+	constructor( renderer: WebGLRenderer );
+
+	fromEquirectangular( texture: Texture, options?: CubemapGeneratorOptions ): WebGLRenderTargetCube;
+
 }
 
 export class EquirectangularToCubeGenerator {
-  constructor(sourceTexture: Texture, options?: EquirectangularToCubeGeneratorOptions);
 
-  dispose(): void;
-  update(renderer: WebGLRenderer): Texture;
+	constructor( sourceTexture: Texture, options?: EquirectangularToCubeGeneratorOptions );
+
+	dispose(): void;
+	update( renderer: WebGLRenderer ): Texture;
+
 }

examples/jsm/loaders/FBXLoader.d.ts

@@ -1,12 +1,14 @@
 import {
-  Group,
-  Loader,
-  LoadingManager
+	Group,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class FBXLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (object: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(FBXBuffer: ArrayBuffer | string, path: string) : Group;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( object: Group ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( FBXBuffer: ArrayBuffer | string, path: string ) : Group;
+
 }

examples/jsm/loaders/GCodeLoader.d.ts

@@ -1,13 +1,15 @@
 import {
-  Group,
-  Loader,
-  LoadingManager
+	Group,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class GCodeLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  splitLayer: boolean;
 
-  load(url: string, onLoad: (object: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(data: string) : Group;
+	constructor( manager?: LoadingManager );
+	splitLayer: boolean;
+
+	load( url: string, onLoad: ( object: Group ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( data: string ) : Group;
+
 }

examples/jsm/loaders/GLTFLoader.d.ts

@@ -1,29 +1,31 @@
 import {
-  AnimationClip,
-  Camera,
-  Loader,
-  LoadingManager,
-  Scene
+	AnimationClip,
+	Camera,
+	Loader,
+	LoadingManager,
+	Scene
 } from '../../../src/Three';
 
 import { DRACOLoader } from './DRACOLoader';
 import { DDSLoader } from './DDSLoader';
 
 export interface GLTF {
-  animations: AnimationClip[];
-  scene: Scene;
-  scenes: Scene[];
-  cameras: Camera[];
-  asset: object;
+	animations: AnimationClip[];
+	scene: Scene;
+	scenes: Scene[];
+	cameras: Camera[];
+	asset: object;
 }
 
 export class GLTFLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  dracoLoader: DRACOLoader | null;
-  ddsLoader: DDSLoader | null;
 
-  load(url: string, onLoad: (gltf: GLTF) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader;
-  setDDSLoader(ddsLoader: DDSLoader): GLTFLoader;
-  parse(data: ArrayBuffer | string, path: string, onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void) : void;
+	constructor( manager?: LoadingManager );
+	dracoLoader: DRACOLoader | null;
+	ddsLoader: DDSLoader | null;
+
+	load( url: string, onLoad: ( gltf: GLTF ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	setDRACOLoader( dracoLoader: DRACOLoader ): GLTFLoader;
+	setDDSLoader( ddsLoader: DDSLoader ): GLTFLoader;
+	parse( data: ArrayBuffer | string, path: string, onLoad: ( gltf: GLTF ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+
 }

examples/jsm/loaders/HDRCubeTextureLoader.d.ts

@@ -1,17 +1,19 @@
 import {
-  CubeTexture,
-  Loader,
-  LoadingManager,
-  TextureDataType
+	CubeTexture,
+	Loader,
+	LoadingManager,
+	TextureDataType
 } from '../../../src/Three';
 
 import { RGBELoader } from './RGBELoader';
 
 export class HDRCubeTextureLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  hdrLoader: RGBELoader;
-  type: TextureDataType;
 
-  load(urls: string[], onLoad: (texture: CubeTexture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  setDataType(type: TextureDataType): this;
+	constructor( manager?: LoadingManager );
+	hdrLoader: RGBELoader;
+	type: TextureDataType;
+
+	load( urls: string[], onLoad: ( texture: CubeTexture ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	setDataType( type: TextureDataType ): this;
+
 }

examples/jsm/loaders/KMZLoader.d.ts

@@ -1,13 +1,15 @@
 import {
-  Loader,
-  LoadingManager
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 import { Collada } from './ColladaLoader';
 
 export class KMZLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (kmz: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: ArrayBuffer): Collada;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( kmz: Collada ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: ArrayBuffer ): Collada;
+
 }

examples/jsm/loaders/KTXLoader.d.ts

@@ -1,21 +1,23 @@
 import {
-  LoadingManager,
-  CompressedTextureLoader,
-  PixelFormat,
-  CompressedPixelFormat
+	LoadingManager,
+	CompressedTextureLoader,
+	PixelFormat,
+	CompressedPixelFormat
 } from '../../../src/Three';
 
 export interface KTX {
-  mipmaps: object[];
-  width: number;
-  height: number;
-  format: PixelFormat | CompressedPixelFormat;
-  mipmapCount: number;
-  isCubemap: boolean;
+	mipmaps: object[];
+	width: number;
+	height: number;
+	format: PixelFormat | CompressedPixelFormat;
+	mipmapCount: number;
+	isCubemap: boolean;
 }
 
 export class KTXLoader extends CompressedTextureLoader {
-  constructor(manager?: LoadingManager);
 
-  parse(buffer: ArrayBuffer, loadMipmaps: boolean) : KTX;
+	constructor( manager?: LoadingManager );
+
+	parse( buffer: ArrayBuffer, loadMipmaps: boolean ) : KTX;
+
 }

examples/jsm/loaders/LDrawLoader.d.ts

@@ -6,14 +6,16 @@ import {
 } from '../../../src/Three';
 
 export class LDrawLoader extends Loader {
-	constructor(manager?: LoadingManager);
 
-	load(url: string, onLoad: (data: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-	setFileMap(fileMap: Record<string, string>): void;
-	setMaterials(materials: Material[]): void;
+	constructor( manager?: LoadingManager );
 
-	parse(text: string, path: string, onLoad: (data: Group) => void): void;
+	load( url: string, onLoad: ( data: Group ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	setFileMap( fileMap: Record<string, string> ): void;
+	setMaterials( materials: Material[] ): void;
+
+	parse( text: string, path: string, onLoad: ( data: Group ) => void ): void;
+
+	addMaterial( material: Material ): void;
+	getMaterial( colourCode: string ): Material | null;
 
-	addMaterial(material: Material ): void;
-	getMaterial(colourCode: string): Material | null;
 }

examples/jsm/loaders/LWOLoader.d.ts

@@ -20,8 +20,10 @@ export interface LWOLoaderParameters {
 }
 
 export class LWOLoader extends Loader {
-	constructor(manager?: LoadingManager, parameters?: LWOLoaderParameters);
 
-	load(url: string, onLoad: (lwo: LWO) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-	parse(data: ArrayBuffer, path: string, modelName: string): LWO;
+	constructor( manager?: LoadingManager, parameters?: LWOLoaderParameters );
+
+	load( url: string, onLoad: ( lwo: LWO ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( data: ArrayBuffer, path: string, modelName: string ): LWO;
+
 }

examples/jsm/loaders/MD2Loader.d.ts

@@ -1,12 +1,14 @@
 import {
-  BufferGeometry,
-  Loader,
-  LoadingManager
+	BufferGeometry,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class MD2Loader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: ArrayBuffer): BufferGeometry;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( geometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: ArrayBuffer ): BufferGeometry;
+
 }

examples/jsm/loaders/MMDLoader.d.ts

@@ -1,30 +1,32 @@
 import {
-  AnimationClip,
-  FileLoader,
-  Loader,
-  LoadingManager,
-  SkinnedMesh
+	AnimationClip,
+	FileLoader,
+	Loader,
+	LoadingManager,
+	SkinnedMesh
 } from '../../../src/Three';
 
 export interface MMDLoaderAnimationObject {
-  animation: AnimationClip;
-  mesh: SkinnedMesh;
+	animation: AnimationClip;
+	mesh: SkinnedMesh;
 }
 
 export class MMDLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  animationBuilder: object;
-  animationPath: string;
-  loader: FileLoader;
-  meshBuilder: object;
-  parser: object | null;
 
-  load(url: string, onLoad: (mesh: SkinnedMesh) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  loadAnimation(url: string, object: SkinnedMesh | THREE.Camera, onLoad: (object: SkinnedMesh | AnimationClip) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  loadPMD(url: string, onLoad: (object: object) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  loadPMX(url: string, onLoad: (object: object) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  loadVMD(url: string, onLoad: (object: object) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  loadVPD(url: string, isUnicode: boolean, onLoad: (object: object) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  loadWithAnimation(url: string, vmdUrl: string | string[], onLoad: (object: MMDLoaderAnimationObject) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  setAnimationPath(animationPath: string): this;
+	constructor( manager?: LoadingManager );
+	animationBuilder: object;
+	animationPath: string;
+	loader: FileLoader;
+	meshBuilder: object;
+	parser: object | null;
+
+	load( url: string, onLoad: ( mesh: SkinnedMesh ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	loadAnimation( url: string, object: SkinnedMesh | THREE.Camera, onLoad: ( object: SkinnedMesh | AnimationClip ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	loadPMD( url: string, onLoad: ( object: object ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	loadPMX( url: string, onLoad: ( object: object ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	loadVMD( url: string, onLoad: ( object: object ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	loadVPD( url: string, isUnicode: boolean, onLoad: ( object: object ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	loadWithAnimation( url: string, vmdUrl: string | string[], onLoad: ( object: MMDLoaderAnimationObject ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	setAnimationPath( animationPath: string ): this;
+
 }

examples/jsm/loaders/MTLLoader.d.ts

@@ -1,96 +1,100 @@
 import {
-  Material,
-  LoadingManager,
-  Mapping,
-  Loader,
-  BufferGeometry,
-  Side,
-  Texture,
-  Vector2,
-  Wrapping
+	Material,
+	LoadingManager,
+	Mapping,
+	Loader,
+	BufferGeometry,
+	Side,
+	Texture,
+	Vector2,
+	Wrapping
 } from '../../../src/Three';
 
 export interface MaterialCreatorOptions {
-  /**
+	/**
    * side: Which side to apply the material
    * THREE.FrontSide (default), THREE.BackSide, THREE.DoubleSide
    */
-  side?: Side;
-  /*
+	side?: Side;
+	/*
    * wrap: What type of wrapping to apply for textures
    * THREE.RepeatWrapping (default), THREE.ClampToEdgeWrapping, THREE.MirroredRepeatWrapping
    */
-  wrap?: Wrapping;
-  /*
+	wrap?: Wrapping;
+	/*
    * normalizeRGB: RGBs need to be normalized to 0-1 from 0-255
    * Default: false, assumed to be already normalized
    */
-  normalizeRGB?: boolean;
-  /*
+	normalizeRGB?: boolean;
+	/*
    * ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's
    * Default: false
    */
-  ignoreZeroRGBs?: boolean;
-  /*
+	ignoreZeroRGBs?: boolean;
+	/*
    * invertTrProperty: Use values 1 of Tr field for fully opaque. This option is useful for obj
    * exported from 3ds MAX, vcglib or meshlab.
    * Default: false
    */
-  invertTrProperty?: boolean;
+	invertTrProperty?: boolean;
 }
 
 export class MTLLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  materialOptions: MaterialCreatorOptions;
 
-  load(url: string, onLoad: (materialCreator: MaterialCreator) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(text: string) : MaterialCreator;
-  setMaterialOptions(value: MaterialCreatorOptions) : void;
+	constructor( manager?: LoadingManager );
+	materialOptions: MaterialCreatorOptions;
+
+	load( url: string, onLoad: ( materialCreator: MaterialCreator ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( text: string ) : MaterialCreator;
+	setMaterialOptions( value: MaterialCreatorOptions ) : void;
+
 }
 
 export interface MaterialInfo {
-  ks?: number[];
-  kd?: number[];
-  ke?: number[];
-  map_kd?: string;
-  map_ks?: string;
-  map_ke?: string;
-  norm?: string;
-  map_bump?: string;
-  bump?: string;
-  map_d?: string;
-  ns?: number;
-  d?: number;
-  tr?: number;
+	ks?: number[];
+	kd?: number[];
+	ke?: number[];
+	map_kd?: string;
+	map_ks?: string;
+	map_ke?: string;
+	norm?: string;
+	map_bump?: string;
+	bump?: string;
+	map_d?: string;
+	ns?: number;
+	d?: number;
+	tr?: number;
 }
 
 export interface TexParams {
-  scale: Vector2;
-  offset: Vector2;
-  url: string;
+	scale: Vector2;
+	offset: Vector2;
+	url: string;
 }
 
 export class MaterialCreator {
-  constructor(baseUrl?: string, options?: MaterialCreatorOptions);
 
-  baseUrl : string;
-  options : MaterialCreatorOptions;
-  materialsInfo : {[key: string]: MaterialInfo};
-  materials : {[key: string]: Material};
-  private materialsArray : Material[];
-  nameLookup : {[key: string]: number};
-  side : Side;
-  wrap : Wrapping;
+	constructor( baseUrl?: string, options?: MaterialCreatorOptions );
+
+	baseUrl : string;
+	options : MaterialCreatorOptions;
+	materialsInfo : {[key: string]: MaterialInfo};
+	materials : {[key: string]: Material};
+	private materialsArray : Material[];
+	nameLookup : {[key: string]: number};
+	side : Side;
+	wrap : Wrapping;
+
+	setCrossOrigin( value: boolean ) : void;
+	setManager( value: LoadingManager ) : void;
+	setMaterials( materialsInfo: {[key: string]: MaterialInfo} ) : void;
+	convert( materialsInfo: {[key: string]: MaterialInfo} ) : {[key: string]: MaterialInfo};
+	preload() : void;
+	getIndex( materialName: string ) : Material;
+	getAsArray() : Material[];
+	create( materialName: string ) : Material;
+	createMaterial_( materialName: string ) : Material;
+	getTextureParams( value: string, matParams: any ) : TexParams;
+	loadTexture( url: string, mapping?: Mapping, onLoad?: ( bufferGeometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): Texture;
 
-  setCrossOrigin( value: boolean ) : void;
-  setManager( value: LoadingManager ) : void;
-  setMaterials( materialsInfo: {[key: string]: MaterialInfo} ) : void;
-  convert( materialsInfo: {[key: string]: MaterialInfo} ) : {[key: string]: MaterialInfo};
-  preload() : void;
-  getIndex( materialName: string ) : Material;
-  getAsArray() : Material[];
-  create( materialName: string ) : Material;
-  createMaterial_( materialName: string ) : Material;
-  getTextureParams( value: string, matParams: any ) : TexParams;
-  loadTexture(url: string, mapping?: Mapping, onLoad?: (bufferGeometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): Texture;
 }

examples/jsm/loaders/NRRDLoader.d.ts

@@ -1,23 +1,24 @@
 import {
-  Material,
-  LoadingManager,
-  Group
+	Material,
+	LoadingManager,
+	Group
 } from '../../../src/Three';
 
 import {
-  Volume
+	Volume
 } from '../misc/Volume';
 
 export class NRRDLoader {
-  constructor(manager?: LoadingManager);
-  manager: LoadingManager;
-  path: string;
 
-  fieldFunctions: object;
+	constructor( manager?: LoadingManager );
+	manager: LoadingManager;
+	path: string;
 
-  load(url: string, onLoad: (group: Volume) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: string) : Volume;
-  parseChars(array: number[], start?: number, end?: number) : string;
-  setPath(value: string) : this;
+	fieldFunctions: object;
+
+	load( url: string, onLoad: ( group: Volume ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: string ) : Volume;
+	parseChars( array: number[], start?: number, end?: number ) : string;
+	setPath( value: string ) : this;
 
 }

examples/jsm/loaders/OBJLoader.d.ts

@@ -1,18 +1,20 @@
 import {
-  Material,
-  Loader,
-  LoadingManager,
-  Group
+	Material,
+	Loader,
+	LoadingManager,
+	Group
 } from '../../../src/Three';
 import {
-  MaterialCreator
+	MaterialCreator
 } from './MTLLoader';
 
 export class OBJLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  materials: MaterialCreator;
 
-  load(url: string, onLoad: (group: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: string) : Group;
-  setMaterials(materials: MaterialCreator) : this;
+	constructor( manager?: LoadingManager );
+	materials: MaterialCreator;
+
+	load( url: string, onLoad: ( group: Group ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: string ) : Group;
+	setMaterials( materials: MaterialCreator ) : this;
+
 }

examples/jsm/loaders/OBJLoader2.d.ts

@@ -6,38 +6,40 @@ import {
 
 import { OBJLoader2Parser } from './obj2/worker/parallel/OBJLoader2Parser';
 import { MaterialHandler } from './obj2/shared/MaterialHandler';
-import { MeshReceiver} from './obj2/shared/MeshReceiver';
+import { MeshReceiver } from './obj2/shared/MeshReceiver';
 
 export class OBJLoader2 extends Loader {
-  constructor(manager?: LoadingManager);
-  parser: OBJLoader2Parser;
-  modelName: string;
-  instanceNo: number;
-  path: string;
-  resourcePath: string;
-  baseObject3d: Object3D;
-  materialHandler: MaterialHandler;
-  meshReceiver: MeshReceiver;
-
-  setLogging(enabled: boolean, debug: boolean): this;
-  setMaterialPerSmoothingGroup(materialPerSmoothingGroup: boolean): this;
-  setUseOAsMesh(useOAsMesh: boolean): this;
-  setUseIndices(useIndices: boolean): this;
-  setDisregardNormals(disregardNormals: boolean): this;
-
-  setModelName(modelName: string): this;
-  setPath(path: string): this;
-  setResourcePath(path: string): this;
-  setBaseObject3d(baseObject3d: Object3D): this;
-  addMaterials(materials: object): this;
-
-  setCallbackOnAssetAvailable(onAssetAvailable: Function): this;
-  setCallbackOnProgress(onProgress: Function): this;
-  setCallbackOnError(onError: Function): this;
-  setCallbackOnLoad(onLoad: Function): this;
-  setCallbackOnMeshAlter(onMeshAlter: Function): this;
-  setCallbackOnLoadMaterials(onLoadMaterials: Function): this;
-
-  load(url: string, onLoad: (object3d: Object3D) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void, onMeshAlter?: (meshData: object) => void): void;
-  parse(content: ArrayBuffer | string): Object3D;
+
+	constructor( manager?: LoadingManager );
+	parser: OBJLoader2Parser;
+	modelName: string;
+	instanceNo: number;
+	path: string;
+	resourcePath: string;
+	baseObject3d: Object3D;
+	materialHandler: MaterialHandler;
+	meshReceiver: MeshReceiver;
+
+	setLogging( enabled: boolean, debug: boolean ): this;
+	setMaterialPerSmoothingGroup( materialPerSmoothingGroup: boolean ): this;
+	setUseOAsMesh( useOAsMesh: boolean ): this;
+	setUseIndices( useIndices: boolean ): this;
+	setDisregardNormals( disregardNormals: boolean ): this;
+
+	setModelName( modelName: string ): this;
+	setPath( path: string ): this;
+	setResourcePath( path: string ): this;
+	setBaseObject3d( baseObject3d: Object3D ): this;
+	addMaterials( materials: object ): this;
+
+	setCallbackOnAssetAvailable( onAssetAvailable: Function ): this;
+	setCallbackOnProgress( onProgress: Function ): this;
+	setCallbackOnError( onError: Function ): this;
+	setCallbackOnLoad( onLoad: Function ): this;
+	setCallbackOnMeshAlter( onMeshAlter: Function ): this;
+	setCallbackOnLoadMaterials( onLoadMaterials: Function ): this;
+
+	load( url: string, onLoad: ( object3d: Object3D ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void, onMeshAlter?: ( meshData: object ) => void ): void;
+	parse( content: ArrayBuffer | string ): Object3D;
+
 }

examples/jsm/loaders/OBJLoader2Parallel.d.ts

@@ -1,21 +1,23 @@
 import {
-  LoadingManager
+	LoadingManager
 } from '../../../src/Three';
 import { OBJLoader2 } from './OBJLoader2';
 
-import { WorkerExecutionSupport} from './obj2/worker/main/WorkerExecutionSupport';
+import { WorkerExecutionSupport } from './obj2/worker/main/WorkerExecutionSupport';
 
 export class OBJLoader2Parallel extends OBJLoader2 {
-  constructor(manager?: LoadingManager);
-  preferJsmWorker: boolean;
-  executeParallel: boolean;
-  workerExecutionSupport: WorkerExecutionSupport;
 
-  setPreferJsmWorker(preferJsmWorker: boolean): this;
-  setExecuteParallel(executeParallel: boolean): this;
-  getWorkerExecutionSupport(): object;
-  buildWorkerCode(): object;
+	constructor( manager?: LoadingManager );
+	preferJsmWorker: boolean;
+	executeParallel: boolean;
+	workerExecutionSupport: WorkerExecutionSupport;
+
+	setPreferJsmWorker( preferJsmWorker: boolean ): this;
+	setExecuteParallel( executeParallel: boolean ): this;
+	getWorkerExecutionSupport(): object;
+	buildWorkerCode(): object;
+
+	// @ts-ignore
+	parse( content: ArrayBuffer ): void;
 
-  // @ts-ignore
-  parse(content: ArrayBuffer): void;
 }

examples/jsm/loaders/PCDLoader.d.ts

@@ -1,14 +1,16 @@
 import {
-  Points,
-  Loader,
-  LoadingManager
+	Points,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 
 export class PCDLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  littleEndian: boolean;
 
-  load(url: string, onLoad: (points: Points) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(data: ArrayBuffer | string, url: string) : Points;
+	constructor( manager?: LoadingManager );
+	littleEndian: boolean;
+
+	load( url: string, onLoad: ( points: Points ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( data: ArrayBuffer | string, url: string ) : Points;
+
 }

examples/jsm/loaders/PDBLoader.d.ts

@@ -1,22 +1,24 @@
 import {
-  BufferGeometry,
-  Loader,
-  LoadingManager
+	BufferGeometry,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export interface PDB {
-  geometryAtoms: BufferGeometry;
-  geometryBonds: BufferGeometry;
-  json: {
-    atoms: any[][],
-    bonds: number[][]
-  }
+	geometryAtoms: BufferGeometry;
+	geometryBonds: BufferGeometry;
+	json: {
+		atoms: any[][],
+		bonds: number[][]
+	}
 }
 
 
 export class PDBLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (pdb: PDB) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(text: string) : PDB;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( pdb: PDB ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( text: string ) : PDB;
+
 }

examples/jsm/loaders/PLYLoader.d.ts

@@ -1,15 +1,17 @@
 import {
-  BufferGeometry,
-  Loader,
-  LoadingManager
+	BufferGeometry,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 
 export class PLYLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  propertyNameMapping: object;
 
-  load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  setPropertyNameMapping(mapping: object) : void;
-  parse(data: ArrayBuffer | string) : BufferGeometry;
+	constructor( manager?: LoadingManager );
+	propertyNameMapping: object;
+
+	load( url: string, onLoad: ( geometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	setPropertyNameMapping( mapping: object ) : void;
+	parse( data: ArrayBuffer | string ) : BufferGeometry;
+
 }

examples/jsm/loaders/PRWMLoader.d.ts

@@ -1,15 +1,17 @@
 import {
-  BufferGeometry,
-  Loader,
-  LoadingManager
+	BufferGeometry,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 
 export class PRWMLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(data: ArrayBuffer) : BufferGeometry;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( geometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( data: ArrayBuffer ) : BufferGeometry;
+
+	static isBigEndianPlatform(): boolean;
 
-  static isBigEndianPlatform(): boolean;
 }

examples/jsm/loaders/PVRLoader.d.ts

@@ -1,20 +1,22 @@
 import {
-  LoadingManager,
-  CompressedTextureLoader,
-  CompressedPixelFormat
+	LoadingManager,
+	CompressedTextureLoader,
+	CompressedPixelFormat
 } from '../../../src/Three';
 
 export interface PVR {
-  mipmaps: object[];
-  width: number;
-  height: number;
-  format: CompressedPixelFormat;
-  mipmapCount: number;
-  isCubemap: boolean;
+	mipmaps: object[];
+	width: number;
+	height: number;
+	format: CompressedPixelFormat;
+	mipmapCount: number;
+	isCubemap: boolean;
 }
 
 export class PVRLoader extends CompressedTextureLoader {
-  constructor(manager?: LoadingManager);
 
-  parse(buffer: ArrayBuffer, loadMipmaps: boolean): PVR;
+	constructor( manager?: LoadingManager );
+
+	parse( buffer: ArrayBuffer, loadMipmaps: boolean ): PVR;
+
 }

examples/jsm/loaders/RGBELoader.d.ts

@@ -1,25 +1,27 @@
 import {
-  LoadingManager,
-  DataTextureLoader,
-  TextureDataType,
-  PixelFormat
+	LoadingManager,
+	DataTextureLoader,
+	TextureDataType,
+	PixelFormat
 } from '../../../src/Three';
 
 export interface RGBE {
-  width: number;
-  height: number;
-  data: Float32Array | Uint8Array;
-  header: string;
-  gamma: number;
-  exposure: number;
-  format: PixelFormat;
-  type: TextureDataType;
+	width: number;
+	height: number;
+	data: Float32Array | Uint8Array;
+	header: string;
+	gamma: number;
+	exposure: number;
+	format: PixelFormat;
+	type: TextureDataType;
 }
 
 export class RGBELoader extends DataTextureLoader {
-  constructor(manager?: LoadingManager);
-  type: TextureDataType;
 
-  parse(buffer: ArrayBuffer): RGBE;
-  setDataType(type: TextureDataType): this;
+	constructor( manager?: LoadingManager );
+	type: TextureDataType;
+
+	parse( buffer: ArrayBuffer ): RGBE;
+	setDataType( type: TextureDataType ): this;
+
 }

examples/jsm/loaders/STLLoader.d.ts

@@ -1,13 +1,15 @@
 import {
-  BufferGeometry,
-  Loader,
-  LoadingManager
+	BufferGeometry,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 
 export class STLLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(data: ArrayBuffer | string) : BufferGeometry;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( geometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( data: ArrayBuffer | string ) : BufferGeometry;
+
 }

examples/jsm/loaders/SVGLoader.d.ts

@@ -1,31 +1,33 @@
 import {
-  Loader,
-  LoadingManager,
-  ShapePath,
-  BufferGeometry,
-  Vector3
+	Loader,
+	LoadingManager,
+	ShapePath,
+	BufferGeometry,
+	Vector3
 } from '../../../src/Three';
 
 export interface SVGResult {
-  paths: ShapePath[];
-  xml: XMLDocument;
+	paths: ShapePath[];
+	xml: XMLDocument;
 }
 
 export interface StrokeStyle {
-  strokeColor: string;
-  strokeWidth: number;
-  strokeLineJoin: string;
-  strokeLineCap: string;
-  strokeMiterLimit: number;
+	strokeColor: string;
+	strokeWidth: number;
+	strokeLineJoin: string;
+	strokeLineCap: string;
+	strokeMiterLimit: number;
 }
 
 export class SVGLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (data: SVGResult) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(text: string) : SVGResult;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( data: SVGResult ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( text: string ) : SVGResult;
+
+	static getStrokeStyle( width: number, color: string, lineJoin: string, lineCap: string, miterLimit: number ): StrokeStyle;
+	static pointsToStroke( points: Vector3[], style: StrokeStyle, arcDivisions: number, minDistance: number ): BufferGeometry;
+	static pointsToStrokeWithBuffers( points: Vector3[], style: StrokeStyle, arcDivisions: number, minDistance: number, vertices: number[], normals: number[], uvs: number[], vertexOffset: number ): number;
 
-  static getStrokeStyle(width: number, color: string, lineJoin: string, lineCap: string, miterLimit: number): StrokeStyle;
-  static pointsToStroke(points: Vector3[], style: StrokeStyle, arcDivisions: number, minDistance: number ): BufferGeometry;
-  static pointsToStrokeWithBuffers(points: Vector3[], style: StrokeStyle, arcDivisions: number, minDistance: number, vertices: number[], normals: number[], uvs: number[], vertexOffset: number): number;
 }

examples/jsm/loaders/TDSLoader.d.ts

@@ -1,44 +1,46 @@
 import {
-  Color,
-  Group,
-  Loader,
-  LoadingManager,
-  Material,
-  Mesh,
-  Texture
+	Color,
+	Group,
+	Loader,
+	LoadingManager,
+	Material,
+	Mesh,
+	Texture
 } from '../../../src/Three';
 
 export class TDSLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  debug: boolean;
-  group: Group;
-  manager: LoadingManager;
-  materials: Material[];
-  meshes: Mesh[];
-  position: number;
 
-  load(url: string, onLoad: (object: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(arraybuffer: ArrayBuffer, path: string): Group;
+	constructor( manager?: LoadingManager );
+	debug: boolean;
+	group: Group;
+	manager: LoadingManager;
+	materials: Material[];
+	meshes: Mesh[];
+	position: number;
+
+	load( url: string, onLoad: ( object: Group ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( arraybuffer: ArrayBuffer, path: string ): Group;
+
+	debugMessage( message: object ): void;
+	endChunk( chunk: object ): void;
+	nextChunk( data: DataView, chunk: object ): void;
+	readByte( data: DataView ): number;
+	readChunk( data: DataView ): object;
+	readColor( data: DataView ): Color;
+	readDWord( data: DataView ): number;
+	readFaceArray( data: DataView, mesh: Mesh ): void;
+	readFile( arraybuffer: ArrayBuffer, path: string ): void;
+	readFloat( data: DataView ): number;
+	readInt( data: DataView ): number;
+	readMap( data: DataView, path: string ): Texture;
+	readMesh( data: DataView ): Mesh;
+	readMeshData( data: DataView, path: string ): void;
+	readMaterialEntry( data: DataView, path: string ): void;
+	readMaterialGroup( data: DataView ): object;
+	readNamedObject( data: DataView ): void;
+	readShort( data: DataView ): number;
+	readString( data: DataView, maxLength: number ): string;
+	readWord( data: DataView ): number;
+	resetPosition(): void;
 
-  debugMessage(message: object): void;
-  endChunk(chunk: object): void;
-  nextChunk(data: DataView, chunk: object): void;
-  readByte(data: DataView): number;
-  readChunk(data: DataView): object;
-  readColor(data: DataView): Color;
-  readDWord(data: DataView): number;
-  readFaceArray(data: DataView, mesh: Mesh): void;
-  readFile(arraybuffer: ArrayBuffer, path: string): void;
-  readFloat(data: DataView): number;
-  readInt(data: DataView): number;
-  readMap(data: DataView, path: string): Texture;
-  readMesh(data: DataView): Mesh;
-  readMeshData(data: DataView, path: string): void;
-  readMaterialEntry(data: DataView, path: string): void;
-  readMaterialGroup(data: DataView): object;
-  readNamedObject(data: DataView): void;
-  readShort(data: DataView): number;
-  readString(data: DataView, maxLength: number): string;
-  readWord(data: DataView): number;
-  resetPosition(): void;
 }

examples/jsm/loaders/TGALoader.d.ts

@@ -1,12 +1,14 @@
 import {
-  Texture,
-  Loader,
-  LoadingManager
+	Texture,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class TGALoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (texture: Texture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(data: ArrayBuffer) : Texture;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( texture: Texture ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( data: ArrayBuffer ) : Texture;
+
 }

examples/jsm/loaders/TTFLoader.d.ts

@@ -1,13 +1,15 @@
 import {
-  BufferGeometry,
-  Loader,
-  LoadingManager
+	BufferGeometry,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class TTFLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  reversed: boolean;
 
-  load(url: string, onLoad: (json: object) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(arraybuffer: ArrayBuffer): object;
+	constructor( manager?: LoadingManager );
+	reversed: boolean;
+
+	load( url: string, onLoad: ( json: object ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( arraybuffer: ArrayBuffer ): object;
+
 }

examples/jsm/loaders/VRMLLoader.d.ts

@@ -1,12 +1,14 @@
 import {
-  Scene,
-  Loader,
-  LoadingManager
+	Scene,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class VRMLLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (scene: Scene) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(data: string, path: string) : Scene;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( scene: Scene ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( data: string, path: string ) : Scene;
+
 }

examples/jsm/loaders/VRMLoader.d.ts

@@ -1,16 +1,18 @@
 import {
-  Loader,
-  LoadingManager
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 import { GLTFLoader, GLTF } from './GLTFLoader';
 import { DRACOLoader } from './DRACOLoader';
 
 export class VRMLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  gltfLoader: GLTFLoader;
 
-  load(url: string, onLoad: (scene: GLTF) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) : void;
-  parse(gltf: GLTF, onLoad: (scene: GLTF) => void): void;
-  setDRACOLoader(dracoLoader: DRACOLoader): this;
+	constructor( manager?: LoadingManager );
+	gltfLoader: GLTFLoader;
+
+	load( url: string, onLoad: ( scene: GLTF ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ) : void;
+	parse( gltf: GLTF, onLoad: ( scene: GLTF ) => void ): void;
+	setDRACOLoader( dracoLoader: DRACOLoader ): this;
+
 }

examples/jsm/loaders/VTKLoader.d.ts

@@ -1,12 +1,14 @@
 import {
-  BufferGeometry,
-  Loader,
-  LoadingManager
+	BufferGeometry,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export class VTKLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: ArrayBuffer | string, path: string): BufferGeometry;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( geometry: BufferGeometry ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: ArrayBuffer | string, path: string ): BufferGeometry;
+
 }

examples/jsm/loaders/XLoader.d.ts

@@ -1,17 +1,19 @@
 import {
-  Mesh,
-  Loader,
-  LoadingManager
+	Mesh,
+	Loader,
+	LoadingManager
 } from '../../../src/Three';
 
 export interface XResult {
-  animations: object[];
-  models: Mesh[];
+	animations: object[];
+	models: Mesh[];
 }
 
 export class XLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (object: XResult) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: ArrayBuffer | string, onLoad: (object: object) => void): object;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( object: XResult ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: ArrayBuffer | string, onLoad: ( object: object ) => void ): object;
+
 }

examples/jsm/loaders/deprecated/LegacyGLTFLoader.d.ts

@@ -1,21 +1,23 @@
 import {
-  AnimationClip,
-  Camera,
-  Loader,
-  LoadingManager,
-  Scene
+	AnimationClip,
+	Camera,
+	Loader,
+	LoadingManager,
+	Scene
 } from '../../../../src/Three';
 
 export interface GLTF {
-  animations: AnimationClip[];
-  scene: Scene;
-  scenes: Scene[];
-  cameras: Camera[];
+	animations: AnimationClip[];
+	scene: Scene;
+	scenes: Scene[];
+	cameras: Camera[];
 }
 
 export class LegacyGLTFLoader extends Loader {
-  constructor(manager?: LoadingManager);
 
-  load(url: string, onLoad: (gltf: GLTF) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(data: ArrayBuffer | string, path: string, callback: (gltf: GLTF) => void): void;
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( gltf: GLTF ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( data: ArrayBuffer | string, path: string, callback: ( gltf: GLTF ) => void ): void;
+
 }

examples/jsm/loaders/deprecated/LegacyJSONLoader.d.ts

@@ -1,19 +1,21 @@
 import {
-  Geometry,
-  Loader,
-  LoadingManager,
-  Material
+	Geometry,
+	Loader,
+	LoadingManager,
+	Material
 } from '../../../../src/Three';
 
 export interface LegacyJSONLoaderResult {
-  geometry: Geometry;
-  materials: Material[];
+	geometry: Geometry;
+	materials: Material[];
 }
 
 export class LegacyJSONLoader extends Loader {
-  constructor(manager?: LoadingManager);
-  withCredentials: boolean;
 
-  load(url: string, onLoad: (geometry: Geometry, materials: Material[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
-  parse(json: object, path: string): LegacyJSONLoaderResult;
+	constructor( manager?: LoadingManager );
+	withCredentials: boolean;
+
+	load( url: string, onLoad: ( geometry: Geometry, materials: Material[] ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	parse( json: object, path: string ): LegacyJSONLoaderResult;
+
 }

examples/jsm/loaders/obj2/bridge/MtlObjBridge.d.ts

@@ -1,8 +1,8 @@
 import {
-  MaterialCreator
+	MaterialCreator
 } from '../../MTLLoader';
 
 export namespace MtlObjBridge {
-  export function link(processResult: object, assetLoader: object): void;
-  export function addMaterialsFromMtlLoader(materialCreator: MaterialCreator): object;
+	export function link( processResult: object, assetLoader: object ): void;
+	export function addMaterialsFromMtlLoader( materialCreator: MaterialCreator ): object;
 }

examples/jsm/loaders/obj2/shared/MaterialHandler.d.ts

@@ -1,24 +1,26 @@
 import {
-  Material
+	Material
 } from '../../../../../src/Three';
 
 export class MaterialHandler {
-  constructor();
-  logging: {
-    enabled: boolean;
-    debug: boolean;
-  };
-  callbacks: {
-    onLoadMaterials: Function;
-  };
-  materials: object;
 
-  createDefaultMaterials(overrideExisting: boolean): void;
-  addMaterials(materials: object, overrideExisting: boolean, newMaterials: object): object;
-  addPayloadMaterials(materialPayload: object): object;
-  setLogging(enabled: boolean, debug: boolean): void;
-  getMaterials(): object;
-  getMaterial(materialName: string): Material;
-  getMaterialsJSON(): object;
-  clearMaterials(): void;
+	constructor();
+	logging: {
+		enabled: boolean;
+		debug: boolean;
+	};
+	callbacks: {
+		onLoadMaterials: Function;
+	};
+	materials: object;
+
+	createDefaultMaterials( overrideExisting: boolean ): void;
+	addMaterials( materials: object, overrideExisting: boolean, newMaterials: object ): object;
+	addPayloadMaterials( materialPayload: object ): object;
+	setLogging( enabled: boolean, debug: boolean ): void;
+	getMaterials(): object;
+	getMaterial( materialName: string ): Material;
+	getMaterialsJSON(): object;
+	clearMaterials(): void;
+
 }

examples/jsm/loaders/obj2/shared/MeshReceiver.d.ts

@@ -1,22 +1,23 @@
 import {
-  Mesh
+	Mesh
 } from '../../../../../src/Three';
 
-import { MaterialHandler } from './MaterialHandler'
+import { MaterialHandler } from './MaterialHandler';
 
 export class MeshReceiver {
-  constructor(materialHandler: MaterialHandler);
-  logging: {
-    enabled: boolean;
-    debug: boolean;
-  };
-  callbacks: {
-    onParseProgress: Function;
-    onMeshAlter: Function;
-  };
-  materialHandler: MaterialHandler;
 
-  buildMeshes(meshPayload: object): Mesh[];
-  setLogging(enabled: boolean, debug: boolean): void;
+	constructor( materialHandler: MaterialHandler );
+	logging: {
+		enabled: boolean;
+		debug: boolean;
+	};
+	callbacks: {
+		onParseProgress: Function;
+		onMeshAlter: Function;
+	};
+	materialHandler: MaterialHandler;
+
+	buildMeshes( meshPayload: object ): Mesh[];
+	setLogging( enabled: boolean, debug: boolean ): void;
 
 }

examples/jsm/loaders/obj2/utils/CodeSerializer.d.ts

@@ -1,10 +1,11 @@
 export namespace CodeSerializer {
-  export function serializeObject(fullName: string, serializationTarget: object): string;
-  export function serializeClass(fullObjectName: string, serializationTarget: object, basePrototypeName?: string, overrideFunctions?: CodeSerializationInstruction[]): string;
+	export function serializeObject( fullName: string, serializationTarget: object ): string;
+	export function serializeClass( fullObjectName: string, serializationTarget: object, basePrototypeName?: string, overrideFunctions?: CodeSerializationInstruction[] ): string;
 }
 
 export class CodeSerializationInstruction {
-	constructor(name: string, fullName: string);
+
+	constructor( name: string, fullName: string );
 	name: string;
 	fullName: string;
 	code: string;
@@ -12,8 +13,9 @@ export class CodeSerializationInstruction {
 
 	getName(): string;
 	getFullName(): string;
-	setCode(code: string): this;
+	setCode( code: string ): this;
 	getCode(): string;
-	setRemoveCode(removeCode: boolean): this;
+	setRemoveCode( removeCode: boolean ): this;
 	isRemoveCode(): boolean;
+
 }

examples/jsm/loaders/obj2/utils/ObjectManipulator.d.ts

@@ -1,3 +1,3 @@
 export namespace ObjectManipulator {
-  export function applyProperties(objToAlter: object, params: object, forceCreation: boolean): void;
+	export function applyProperties( objToAlter: object, params: object, forceCreation: boolean ): void;
 }

examples/jsm/loaders/obj2/worker/main/WorkerExecutionSupport.d.ts

@@ -1,59 +1,63 @@
 export class CodeBuilderInstructions {
-  constructor(supportsStandardWorker: boolean, supportsJsmWorker: boolean, preferJsmWorker: boolean);
-  supportsStandardWorker: boolean;
-  supportsJsmWorker: boolean;
-  preferJsmWorker: boolean;
-  startCode: string;
-  codeFragments: string[];
-  importStatements: string[];
-  jsmWorkerFile: string;
-  defaultGeometryType: number;
-
-  isSupportsStandardWorker(): boolean;
-  isSupportsJsmWorker(): boolean;
-  isPreferJsmWorker(): boolean;
-  setJsmWorkerFile(jsmWorkerFile: string): void;
-  addStartCode(startCode: string): void;
-  addCodeFragment(code: string): void;
-  addLibraryImport(libraryPath: string): void;
-  getImportStatements(): string[];
-  getCodeFragments(): string[];
-  getStartCode(): string;
+
+	constructor( supportsStandardWorker: boolean, supportsJsmWorker: boolean, preferJsmWorker: boolean );
+	supportsStandardWorker: boolean;
+	supportsJsmWorker: boolean;
+	preferJsmWorker: boolean;
+	startCode: string;
+	codeFragments: string[];
+	importStatements: string[];
+	jsmWorkerFile: string;
+	defaultGeometryType: number;
+
+	isSupportsStandardWorker(): boolean;
+	isSupportsJsmWorker(): boolean;
+	isPreferJsmWorker(): boolean;
+	setJsmWorkerFile( jsmWorkerFile: string ): void;
+	addStartCode( startCode: string ): void;
+	addCodeFragment( code: string ): void;
+	addLibraryImport( libraryPath: string ): void;
+	getImportStatements(): string[];
+	getCodeFragments(): string[];
+	getStartCode(): string;
+
 }
 
 export class WorkerExecutionSupport {
-  constructor();
-
-  logging: {
-    enabled: boolean;
-    debug: boolean;
-  };
-
-  worker: {
-    native: Worker;
-    jsmWorker: boolean;
-    logging: boolean;
-    workerRunner: {
-      name: string;
-      usesMeshDisassembler: boolean;
-      defaultGeometryType: number;
-    };
-    terminateWorkerOnLoad: boolean;
-    forceWorkerDataCopy: boolean;
-    started: boolean;
-    queuedMessage: object;
-    callbacks: {
-      onAssetAvailable: Function;
-      onLoad: Function;
-      terminate: Function;
-    };
-  };
-
-  setLogging(enabled: boolean, debug: boolean): this;
-  setForceWorkerDataCopy(forceWorkerDataCopy: boolean): this;
-  setTerminateWorkerOnLoad(terminateWorkerOnLoad: boolean): this;
-  updateCallbacks(onAssetAvailable: Function, onLoad: Function): void;
-  buildWorker(codeBuilderInstructions: CodeBuilderInstructions): void;
-  isWorkerLoaded(requireJsmWorker: boolean): boolean;
-  executeParallel(payload:object, transferables?: object[]);
+
+	constructor();
+
+	logging: {
+		enabled: boolean;
+		debug: boolean;
+	};
+
+	worker: {
+		native: Worker;
+		jsmWorker: boolean;
+		logging: boolean;
+		workerRunner: {
+			name: string;
+			usesMeshDisassembler: boolean;
+			defaultGeometryType: number;
+		};
+		terminateWorkerOnLoad: boolean;
+		forceWorkerDataCopy: boolean;
+		started: boolean;
+		queuedMessage: object;
+		callbacks: {
+			onAssetAvailable: Function;
+			onLoad: Function;
+			terminate: Function;
+		};
+	};
+
+	setLogging( enabled: boolean, debug: boolean ): this;
+	setForceWorkerDataCopy( forceWorkerDataCopy: boolean ): this;
+	setTerminateWorkerOnLoad( terminateWorkerOnLoad: boolean ): this;
+	updateCallbacks( onAssetAvailable: Function, onLoad: Function ): void;
+	buildWorker( codeBuilderInstructions: CodeBuilderInstructions ): void;
+	isWorkerLoaded( requireJsmWorker: boolean ): boolean;
+	executeParallel( payload:object, transferables?: object[] );
+
 }